Viskores  1.0
StreamLineUniformGrid.h
Go to the documentation of this file.
1 //============================================================================
2 // The contents of this file are covered by the Viskores license. See
3 // LICENSE.txt for details.
4 //
5 // By contributing to this file, all contributors agree to the Developer
6 // Certificate of Origin Version 1.1 (DCO 1.1) as stated in DCO.txt.
7 //============================================================================
8 
9 //============================================================================
10 // Copyright (c) Kitware, Inc.
11 // All rights reserved.
12 // See LICENSE.txt for details.
13 //
14 // This software is distributed WITHOUT ANY WARRANTY; without even
15 // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
16 // PURPOSE. See the above copyright notice for more information.
17 //============================================================================
18 
19 #ifndef viskores_worklet_StreamLineUniformGrid_h
20 #define viskores_worklet_StreamLineUniformGrid_h
21 
22 #include <viskores/cont/Algorithm.h>
23 #include <viskores/cont/ArrayHandle.h>
24 #include <viskores/cont/ArrayHandleCounting.h>
25 #include <viskores/cont/CellSetExplicit.h>
26 #include <viskores/cont/CellSetStructured.h>
27 #include <viskores/cont/ConvertNumComponentsToOffsets.h>
28 #include <viskores/cont/DataSet.h>
29 #include <viskores/cont/DeviceAdapter.h>
30 #include <viskores/cont/Field.h>
31 #include <viskores/cont/Invoker.h>
32 
33 #include <viskores/worklet/ScatterUniform.h>
34 #include <viskores/worklet/WorkletMapField.h>
35 
36 namespace viskores
37 {
38 namespace worklet
39 {
40 namespace streamline
41 {
42 // Take this out when defined in CellShape.h
43 const viskores::UInt8 CELL_SHAPE_POLY_LINE = 4;
44 
45 enum StreamLineMode
46 {
47  FORWARD = 0,
48  BACKWARD = 1,
49  BOTH = 2
50 };
51 
52 // Trilinear interpolation to calculate vector data at position
53 template <typename FieldType, typename PortalType>
54 VISKORES_EXEC viskores::Vec<FieldType, 3> VecDataAtPos(viskores::Vec<FieldType, 3> pos,
55  const viskores::Id3& vdims,
56  const viskores::Id& planesize,
57  const viskores::Id& rowsize,
58  const PortalType& vecdata)
59 {
60  // Adjust initial position to be within bounding box of grid
61  for (viskores::IdComponent d = 0; d < 3; d++)
62  {
63  if (pos[d] < 0.0f)
64  pos[d] = 0.0f;
65  if (pos[d] > static_cast<FieldType>(vdims[d] - 1))
66  pos[d] = static_cast<FieldType>(vdims[d] - 1);
67  }
68 
69  // Set the eight corner indices with no wraparound
70  viskores::Id3 idx000, idx001, idx010, idx011, idx100, idx101, idx110, idx111;
71  idx000[0] = static_cast<viskores::Id>(floor(pos[0]));
72  idx000[1] = static_cast<viskores::Id>(floor(pos[1]));
73  idx000[2] = static_cast<viskores::Id>(floor(pos[2]));
74 
75  idx001 = idx000;
76  idx001[0] = (idx001[0] + 1) <= vdims[0] - 1 ? idx001[0] + 1 : vdims[0] - 1;
77  idx010 = idx000;
78  idx010[1] = (idx010[1] + 1) <= vdims[1] - 1 ? idx010[1] + 1 : vdims[1] - 1;
79  idx011 = idx010;
80  idx011[0] = (idx011[0] + 1) <= vdims[0] - 1 ? idx011[0] + 1 : vdims[0] - 1;
81  idx100 = idx000;
82  idx100[2] = (idx100[2] + 1) <= vdims[2] - 1 ? idx100[2] + 1 : vdims[2] - 1;
83  idx101 = idx100;
84  idx101[0] = (idx101[0] + 1) <= vdims[0] - 1 ? idx101[0] + 1 : vdims[0] - 1;
85  idx110 = idx100;
86  idx110[1] = (idx110[1] + 1) <= vdims[1] - 1 ? idx110[1] + 1 : vdims[1] - 1;
87  idx111 = idx110;
88  idx111[0] = (idx111[0] + 1) <= vdims[0] - 1 ? idx111[0] + 1 : vdims[0] - 1;
89 
90  // Get the vecdata at the eight corners
91  viskores::Vec<FieldType, 3> v000, v001, v010, v011, v100, v101, v110, v111;
92  v000 = vecdata.Get(idx000[2] * planesize + idx000[1] * rowsize + idx000[0]);
93  v001 = vecdata.Get(idx001[2] * planesize + idx001[1] * rowsize + idx001[0]);
94  v010 = vecdata.Get(idx010[2] * planesize + idx010[1] * rowsize + idx010[0]);
95  v011 = vecdata.Get(idx011[2] * planesize + idx011[1] * rowsize + idx011[0]);
96  v100 = vecdata.Get(idx100[2] * planesize + idx100[1] * rowsize + idx100[0]);
97  v101 = vecdata.Get(idx101[2] * planesize + idx101[1] * rowsize + idx101[0]);
98  v110 = vecdata.Get(idx110[2] * planesize + idx110[1] * rowsize + idx110[0]);
99  v111 = vecdata.Get(idx111[2] * planesize + idx111[1] * rowsize + idx111[0]);
100 
101  // Interpolation in X
102  viskores::Vec<FieldType, 3> v00, v01, v10, v11;
103  FieldType a = pos[0] - static_cast<FieldType>(floor(pos[0]));
104  v00[0] = (1.0f - a) * v000[0] + a * v001[0];
105  v00[1] = (1.0f - a) * v000[1] + a * v001[1];
106  v00[2] = (1.0f - a) * v000[2] + a * v001[2];
107 
108  v01[0] = (1.0f - a) * v010[0] + a * v011[0];
109  v01[1] = (1.0f - a) * v010[1] + a * v011[1];
110  v01[2] = (1.0f - a) * v010[2] + a * v011[2];
111 
112  v10[0] = (1.0f - a) * v100[0] + a * v101[0];
113  v10[1] = (1.0f - a) * v100[1] + a * v101[1];
114  v10[2] = (1.0f - a) * v100[2] + a * v101[2];
115 
116  v11[0] = (1.0f - a) * v110[0] + a * v111[0];
117  v11[1] = (1.0f - a) * v110[1] + a * v111[1];
118  v11[2] = (1.0f - a) * v110[2] + a * v111[2];
119 
120  // Interpolation in Y
121  viskores::Vec<FieldType, 3> v0, v1;
122  a = pos[1] - static_cast<FieldType>(floor(pos[1]));
123  v0[0] = (1.0f - a) * v00[0] + a * v01[0];
124  v0[1] = (1.0f - a) * v00[1] + a * v01[1];
125  v0[2] = (1.0f - a) * v00[2] + a * v01[2];
126 
127  v1[0] = (1.0f - a) * v10[0] + a * v11[0];
128  v1[1] = (1.0f - a) * v10[1] + a * v11[1];
129  v1[2] = (1.0f - a) * v10[2] + a * v11[2];
130 
131  // Interpolation in Z
132  viskores::Vec<FieldType, 3> v;
133  a = pos[2] - static_cast<FieldType>(floor(pos[2]));
134  v[0] = (1.0f - a) * v0[0] + v1[0];
135  v[1] = (1.0f - a) * v0[1] + v1[1];
136  v[2] = (1.0f - a) * v0[2] + v1[2];
137  return v;
138 }
139 
140 struct IsUnity
141 {
142  template <typename T>
143  VISKORES_EXEC_CONT bool operator()(const T& x) const
144  {
145  return x == T(1);
146  }
147 };
148 
149 template <typename FieldType>
150 class MakeStreamLines : public viskores::worklet::WorkletMapField
151 {
152 public:
153  using ControlSignature = void(WholeArrayIn field,
154  FieldIn seedId,
155  FieldIn position,
156  WholeArrayOut numIndices,
157  WholeArrayOut validPoint,
158  WholeArrayOut streamLines);
159  using ExecutionSignature = void(_1, _2, _3, _4, _5, _6, VisitIndex);
160  using InputDomain = _2;
161 
162  using ScatterType = viskores::worklet::ScatterUniform<2>;
163 
164  const viskores::Id3 vdims;
165  const viskores::Id maxsteps;
166  const FieldType timestep;
167  const viskores::Id planesize;
168  const viskores::Id rowsize;
169  const viskores::Id streammode;
170 
171  VISKORES_CONT
172  MakeStreamLines() {}
173 
174  VISKORES_CONT
175  MakeStreamLines(const FieldType tStep,
176  const viskores::Id sMode,
177  const viskores::Id nSteps,
178  const viskores::Id3 dims)
179  : vdims(dims)
180  , maxsteps(nSteps)
181  , timestep(tStep)
182  , planesize(dims[0] * dims[1])
183  , rowsize(dims[0])
184  , streammode(sMode)
185  {
186  }
187 
188  template <typename FieldPortalType, typename IdComponentPortalType, typename FieldVec3PortalType>
189  VISKORES_EXEC void operator()(const FieldPortalType& field,
190  viskores::Id& seedId,
191  viskores::Vec<FieldType, 3>& seedPos,
192  IdComponentPortalType& numIndices,
193  IdComponentPortalType& validPoint,
194  FieldVec3PortalType& slLists,
195  viskores::IdComponent visitIndex) const
196  {
197  // Set initial offset into the output streams array
198  viskores::Vec<FieldType, 3> pos = seedPos;
199  viskores::Vec<FieldType, 3> pre_pos = seedPos;
200 
201  // Forward tracing
202  if (visitIndex == 0 && (streammode == FORWARD || streammode == BOTH))
203  {
204  viskores::Id index = (seedId * 2) * maxsteps;
205  bool done = false;
206  viskores::Id step = 0;
207  validPoint.Set(index, 1);
208  slLists.Set(index++, pos);
209 
210  while (done != true && step < maxsteps)
211  {
212  viskores::Vec<FieldType, 3> vdata, adata, bdata, cdata, ddata;
213  vdata = VecDataAtPos(pos, vdims, planesize, rowsize, field);
214  for (viskores::IdComponent d = 0; d < 3; d++)
215  {
216  adata[d] = timestep * vdata[d];
217  pos[d] += adata[d] / 2.0f;
218  }
219 
220  vdata = VecDataAtPos(pos, vdims, planesize, rowsize, field);
221  for (viskores::IdComponent d = 0; d < 3; d++)
222  {
223  bdata[d] = timestep * vdata[d];
224  pos[d] += bdata[d] / 2.0f;
225  }
226 
227  vdata = VecDataAtPos(pos, vdims, planesize, rowsize, field);
228  for (viskores::IdComponent d = 0; d < 3; d++)
229  {
230  cdata[d] = timestep * vdata[d];
231  pos[d] += cdata[d] / 2.0f;
232  }
233 
234  vdata = VecDataAtPos(pos, vdims, planesize, rowsize, field);
235  for (viskores::IdComponent d = 0; d < 3; d++)
236  {
237  ddata[d] = timestep * vdata[d];
238  pos[d] += (adata[d] + (2.0f * bdata[d]) + (2.0f * cdata[d]) + ddata[d]) / 6.0f;
239  }
240 
241  if (pos[0] < 0.0f || pos[0] > static_cast<FieldType>(vdims[0]) || pos[1] < 0.0f ||
242  pos[1] > static_cast<FieldType>(vdims[1]) || pos[2] < 0.0f ||
243  pos[2] > static_cast<FieldType>(vdims[2]))
244  {
245  pos = pre_pos;
246  done = true;
247  }
248  else
249  {
250  validPoint.Set(index, 1);
251  slLists.Set(index++, pos);
252  pre_pos = pos;
253  }
254  step++;
255  }
256  numIndices.Set(seedId * 2, static_cast<viskores::IdComponent>(step));
257  }
258 
259  // Backward tracing
260  if (visitIndex == 1 && (streammode == BACKWARD || streammode == BOTH))
261  {
262  viskores::Id index = (seedId * 2 + 1) * maxsteps;
263  bool done = false;
264  viskores::Id step = 0;
265  validPoint.Set(index, 1);
266  slLists.Set(index++, pos);
267 
268  while (done != true && step < maxsteps)
269  {
270  viskores::Vec<FieldType, 3> vdata, adata, bdata, cdata, ddata;
271  vdata = VecDataAtPos(pos, vdims, planesize, rowsize, field);
272  for (viskores::IdComponent d = 0; d < 3; d++)
273  {
274  adata[d] = timestep * (0.0f - vdata[d]);
275  pos[d] += adata[d] / 2.0f;
276  }
277 
278  vdata = VecDataAtPos(pos, vdims, planesize, rowsize, field);
279  for (viskores::IdComponent d = 0; d < 3; d++)
280  {
281  bdata[d] = timestep * (0.0f - vdata[d]);
282  pos[d] += bdata[d] / 2.0f;
283  }
284 
285  vdata = VecDataAtPos(pos, vdims, planesize, rowsize, field);
286  for (viskores::IdComponent d = 0; d < 3; d++)
287  {
288  cdata[d] = timestep * (0.0f - vdata[d]);
289  pos[d] += cdata[d] / 2.0f;
290  }
291 
292  vdata = VecDataAtPos(pos, vdims, planesize, rowsize, field);
293  for (viskores::IdComponent d = 0; d < 3; d++)
294  {
295  ddata[d] = timestep * (0.0f - vdata[d]);
296  pos[d] += (adata[d] + (2.0f * bdata[d]) + (2.0f * cdata[d]) + ddata[d]) / 6.0f;
297  }
298 
299  if (pos[0] < 0.0f || pos[0] > static_cast<FieldType>(vdims[0]) || pos[1] < 0.0f ||
300  pos[1] > static_cast<FieldType>(vdims[1]) || pos[2] < 0.0f ||
301  pos[2] > static_cast<FieldType>(vdims[2]))
302  {
303  pos = pre_pos;
304  done = true;
305  }
306  else
307  {
308  validPoint.Set(index, 1);
309  slLists.Set(index++, pos);
310  pre_pos = pos;
311  }
312  step++;
313  }
314  numIndices.Set((seedId * 2) + 1, static_cast<viskores::IdComponent>(step));
315  }
316  }
317 };
318 
319 
320 } // namespace streamline
321 
323 template <typename FieldType>
324 class StreamLineFilterUniformGrid
325 {
326 public:
327  StreamLineFilterUniformGrid() {}
328 
329  viskores::cont::DataSet Run(const viskores::cont::DataSet& InDataSet,
330  viskores::Id streamMode,
331  viskores::Id numSeeds,
332  viskores::Id maxSteps,
333  FieldType timeStep)
334  {
335  using Algorithm = viskores::cont::Algorithm;
336 
337  // Get information from input dataset
338  viskores::cont::CellSetStructured<3> inCellSet;
339  InDataSet.GetCellSet().AsCellSet(inCellSet);
340  viskores::Id3 vdims = inCellSet.GetSchedulingRange(viskores::TopologyElementTagPoint());
341 
342  viskores::cont::ArrayHandle<viskores::Vec<FieldType, 3>> fieldArray;
343  InDataSet.GetField("vecData").GetData().AsArrayHandle(fieldArray);
344 
345  // Generate random seeds for starting streamlines
346  viskores::cont::ArrayHandle<viskores::Vec<FieldType, 3>> seedPosArray;
347  seedPosArray.Allocate(numSeeds);
348  {
349  auto seedPosPortal = seedPosArray.WritePortal();
350  for (viskores::Id i = 0; i < numSeeds; i++)
351  {
352  viskores::Vec<FieldType, 3> seed;
353  seed[0] = static_cast<FieldType>(rand() % vdims[0]);
354  seed[1] = static_cast<FieldType>(rand() % vdims[1]);
355  seed[2] = static_cast<FieldType>(rand() % vdims[2]);
356  seedPosPortal.Set(i, seed);
357  }
358  }
359  viskores::cont::ArrayHandleIndex seedIdArray(numSeeds);
360 
361  // Number of streams * number of steps * [forward, backward]
362  viskores::Id numCells = numSeeds * 2;
363  viskores::Id maxConnectivityLen = numCells * maxSteps;
364 
365  // Stream array at max size will be filled with stream coordinates
366  viskores::cont::ArrayHandle<viskores::Vec<FieldType, 3>> streamArray;
367  streamArray.Allocate(maxConnectivityLen);
368 
369  // NumIndices per polyline cell filled in by MakeStreamLines
370  viskores::cont::ArrayHandle<viskores::IdComponent> numIndices;
371  numIndices.Allocate(numCells);
372 
373  // All cells are polylines
374  viskores::cont::ArrayHandle<viskores::UInt8> cellTypes;
375  cellTypes.Allocate(numCells);
376  viskores::cont::ArrayHandleConstant<viskores::UInt8> polyLineShape(
377  streamline::CELL_SHAPE_POLY_LINE, numCells);
378  Algorithm::Copy(polyLineShape, cellTypes);
379 
380  // Possible maxSteps points but if less use stencil
381  viskores::cont::ArrayHandle<viskores::IdComponent> validPoint;
382  viskores::cont::ArrayHandleConstant<viskores::Id> zeros(0, maxConnectivityLen);
383  validPoint.Allocate(maxConnectivityLen);
384  Algorithm::Copy(zeros, validPoint);
385 
386  // Worklet to make the streamlines
387  streamline::MakeStreamLines<FieldType> makeStreamLines(timeStep, streamMode, maxSteps, vdims);
388 
389  viskores::cont::Invoker{}(
390  makeStreamLines, fieldArray, seedIdArray, seedPosArray, numIndices, validPoint, streamArray);
391 
392  // Size of connectivity based on size of returned streamlines
393  viskores::Id connectivityLen;
394  auto offsets = viskores::cont::ConvertNumComponentsToOffsets(numIndices, connectivityLen);
395 
396  // Connectivity is sequential
397  viskores::cont::ArrayHandleCounting<viskores::Id> connCount(0, 1, connectivityLen);
398  viskores::cont::ArrayHandle<viskores::Id> connectivity;
399  Algorithm::Copy(connCount, connectivity);
400 
401  // Compact the stream array so it only has valid points
402  viskores::cont::ArrayHandle<viskores::Vec<FieldType, 3>> coordinates;
403  Algorithm::CopyIf(streamArray, validPoint, coordinates, streamline::IsUnity());
404 
405  // Create the output data set
406  viskores::cont::DataSet OutDataSet;
407  viskores::cont::CellSetExplicit<> outCellSet;
408 
409  outCellSet.Fill(coordinates.GetNumberOfValues(), cellTypes, connectivity, offsets);
410  OutDataSet.SetCellSet(outCellSet);
411  OutDataSet.AddCoordinateSystem(viskores::cont::CoordinateSystem("coordinates", coordinates));
412 
413  return OutDataSet;
414  }
415 };
416 }
417 }
418 
419 #endif // viskores_worklet_StreamLineUniformGrid_h
ArrayHandle.h
viskores::cont::DataSet
Contains and manages the geometric data structures that Viskores operates on.
Definition: DataSet.h:66
viskores::worklet::streamline::MakeStreamLines::vdims
const viskores::Id3 vdims
Definition: StreamLineUniformGrid.h:164
viskores::worklet::StreamLineFilterUniformGrid::Run
viskores::cont::DataSet Run(const viskores::cont::DataSet &InDataSet, viskores::Id streamMode, viskores::Id numSeeds, viskores::Id maxSteps, FieldType timeStep)
Definition: StreamLineUniformGrid.h:329
WorkletMapField.h
CellSetExplicit.h
ScatterUniform.h
viskores::worklet::streamline::VecDataAtPos
viskores::Vec< FieldType, 3 > VecDataAtPos(viskores::Vec< FieldType, 3 > pos, const viskores::Id3 &vdims, const viskores::Id &planesize, const viskores::Id &rowsize, const PortalType &vecdata)
Definition: StreamLineUniformGrid.h:54
viskores::worklet::WorkletMapField::FieldIn
A control signature tag for input fields.
Definition: WorkletMapField.h:68
viskores::worklet::streamline::IsUnity::operator()
bool operator()(const T &x) const
Definition: StreamLineUniformGrid.h:143
viskores::cont::Algorithm
Definition: Algorithm.h:397
viskores::worklet::StreamLineFilterUniformGrid::StreamLineFilterUniformGrid
StreamLineFilterUniformGrid()
Definition: StreamLineUniformGrid.h:327
viskores::cont::Field::GetData
const viskores::cont::UnknownArrayHandle & GetData() const
Get the array of the data for the field.
viskores::cont::ArrayHandle
Manages an array-worth of data.
Definition: ArrayHandle.h:313
viskores::cont::CoordinateSystem
Manages a coordinate system for a DataSet.
Definition: CoordinateSystem.h:38
viskores::cont::DataSet::GetField
const viskores::cont::Field & GetField(viskores::Id index) const
Retrieves a field by index.
Definition: DataSet.h:117
Invoker.h
viskores::IdComponent
viskores::Int32 IdComponent
Base type to use to index small lists.
Definition: Types.h:202
VISKORES_EXEC_CONT
#define VISKORES_EXEC_CONT
Definition: ExportMacros.h:60
viskores::cont::CellSetStructured::GetSchedulingRange
SchedulingRangeType GetSchedulingRange(TopologyElement) const
Definition: CellSetStructured.h:140
viskores::worklet::streamline::MakeStreamLines::operator()
void operator()(const FieldPortalType &field, viskores::Id &seedId, viskores::Vec< FieldType, 3 > &seedPos, IdComponentPortalType &numIndices, IdComponentPortalType &validPoint, FieldVec3PortalType &slLists, viskores::IdComponent visitIndex) const
Definition: StreamLineUniformGrid.h:189
viskores::worklet::StreamLineFilterUniformGrid
Compute the streamline.
Definition: StreamLineUniformGrid.h:324
viskores::TopologyElementTagPoint
A tag used to identify the point elements in a topology.
Definition: TopologyElementTag.h:42
viskores::cont::DataSet::AddCoordinateSystem
viskores::IdComponent AddCoordinateSystem(const viskores::cont::CoordinateSystem &cs)
Adds the given CoordinateSystem to the DataSet.
viskores::worklet::streamline::IsUnity
Definition: StreamLineUniformGrid.h:140
DeviceAdapter.h
viskores::exec::arg::VisitIndex
The ExecutionSignature tag to use to get the visit index.
Definition: VisitIndex.h:54
viskores::worklet::streamline::BACKWARD
@ BACKWARD
Definition: StreamLineUniformGrid.h:48
viskores::Id
viskores::Int64 Id
Base type to use to index arrays.
Definition: Types.h:235
VISKORES_CONT
#define VISKORES_CONT
Definition: ExportMacros.h:65
viskores
Groups connected points that have the same field value.
Definition: Atomic.h:27
Algorithm.h
viskores::worklet::streamline::MakeStreamLines::MakeStreamLines
MakeStreamLines(const FieldType tStep, const viskores::Id sMode, const viskores::Id nSteps, const viskores::Id3 dims)
Definition: StreamLineUniformGrid.h:175
viskores::worklet::streamline::CELL_SHAPE_POLY_LINE
const viskores::UInt8 CELL_SHAPE_POLY_LINE
Definition: StreamLineUniformGrid.h:43
viskores::cont::ArrayHandleConstant
An array handle with a constant value.
Definition: ArrayHandleConstant.h:78
viskores::worklet::ScatterIdentity
A scatter that maps input directly to output.
Definition: ScatterIdentity.h:38
viskores::cont::ArrayHandle::Allocate
void Allocate(viskores::Id numberOfValues, viskores::CopyFlag preserve, viskores::cont::Token &token) const
Allocates an array large enough to hold the given number of values.
Definition: ArrayHandle.h:504
viskores::cont::CellSetExplicit
Defines an irregular collection of cells.
Definition: CastAndCall.h:44
viskores::cont::ArrayHandle::GetNumberOfValues
viskores::Id GetNumberOfValues() const
Returns the number of entries in the array.
Definition: ArrayHandle.h:482
viskores::cont::ArrayHandleCounting
ArrayHandleCounting is a specialization of ArrayHandle.
Definition: ArrayHandleCounting.h:140
Field.h
viskores::worklet::streamline::MakeStreamLines
Definition: StreamLineUniformGrid.h:150
viskores::cont::UnknownArrayHandle::AsArrayHandle
void AsArrayHandle(viskores::cont::ArrayHandle< T, S > &array) const
Returns this array cast appropriately and stored in the given ArrayHandle type.
Definition: UnknownArrayHandle.h:679
viskores::worklet::streamline::FORWARD
@ FORWARD
Definition: StreamLineUniformGrid.h:47
viskores::cont::CellSetExplicit::Fill
void Fill(viskores::Id numPoints, const viskores::cont::ArrayHandle< viskores::UInt8, ShapesStorageTag > &cellTypes, const viskores::cont::ArrayHandle< viskores::Id, ConnectivityStorageTag > &connectivity, const viskores::cont::ArrayHandle< viskores::Id, OffsetsStorageTag > &offsets)
Set all the cells of the mesh.
viskores::cont::ConvertNumComponentsToOffsets
void ConvertNumComponentsToOffsets(const viskores::cont::UnknownArrayHandle &numComponentsArray, viskores::cont::ArrayHandle< viskores::Id > &offsetsArray, viskores::Id &componentsArraySize, viskores::cont::DeviceAdapterId device=viskores::cont::DeviceAdapterTagAny{})
ConvertNumComponentsToOffsets takes an array of Vec sizes (i.e.
viskores::cont::ArrayHandle::WritePortal
WritePortalType WritePortal() const
Get an array portal that can be used in the control environment.
Definition: ArrayHandle.h:468
viskores::worklet::streamline::MakeStreamLines::MakeStreamLines
MakeStreamLines()
Definition: StreamLineUniformGrid.h:172
viskores::worklet::streamline::MakeStreamLines::ControlSignature
void(WholeArrayIn field, FieldIn seedId, FieldIn position, WholeArrayOut numIndices, WholeArrayOut validPoint, WholeArrayOut streamLines) ControlSignature
Definition: StreamLineUniformGrid.h:158
viskores::UInt8
uint8_t UInt8
Base type to use for 8-bit unsigned integer numbers.
Definition: Types.h:177
viskores::cont::CellSetStructured
Defines a 1-, 2-, or 3-dimensional structured grid of points.
Definition: CastAndCall.h:40
viskores::cont::DataSet::GetCellSet
const viskores::cont::UnknownCellSet & GetCellSet() const
Definition: DataSet.h:422
ConvertNumComponentsToOffsets.h
ArrayHandleCounting.h
viskores::worklet::streamline::StreamLineMode
StreamLineMode
Definition: StreamLineUniformGrid.h:45
viskores::worklet::streamline::MakeStreamLines::streammode
const viskores::Id streammode
Definition: StreamLineUniformGrid.h:169
CellSetStructured.h
viskores::worklet::streamline::MakeStreamLines::planesize
const viskores::Id planesize
Definition: StreamLineUniformGrid.h:167
viskores::worklet::streamline::BOTH
@ BOTH
Definition: StreamLineUniformGrid.h:49
viskores::cont::Invoker
Allows launching any worklet without a dispatcher.
Definition: Invoker.h:49
viskores::worklet::streamline::MakeStreamLines::maxsteps
const viskores::Id maxsteps
Definition: StreamLineUniformGrid.h:165
viskores::worklet::WorkletMapField
Base class for worklets that do a simple mapping of field arrays.
Definition: WorkletMapField.h:47
viskores::worklet::ScatterUniform
A scatter that maps input to some constant numbers of output.
Definition: ScatterUniform.h:61
viskores::Vec
A short fixed-length array.
Definition: Types.h:365
viskores::cont::UnknownCellSet::AsCellSet
void AsCellSet(CellSetType &cellSet) const
Get the cell set as a known type.
Definition: UnknownCellSet.h:189
VISKORES_EXEC
#define VISKORES_EXEC
Definition: ExportMacros.h:59
DataSet.h
viskores::cont::ArrayHandleIndex
An implicit array handle containing the its own indices.
Definition: ArrayHandleIndex.h:64
viskores::worklet::streamline::MakeStreamLines::rowsize
const viskores::Id rowsize
Definition: StreamLineUniformGrid.h:168
viskores::worklet::streamline::MakeStreamLines::timestep
const FieldType timestep
Definition: StreamLineUniformGrid.h:166
viskores::worklet::streamline::MakeStreamLines::ExecutionSignature
void(_1, _2, _3, _4, _5, _6, VisitIndex) ExecutionSignature
Definition: StreamLineUniformGrid.h:159
viskores::cont::DataSet::SetCellSet
void SetCellSet(const CellSetType &cellSet)
Definition: DataSet.h:415
Generated by   doxygen 1.8.17