CellShape.h File Reference

#include <viskores/StaticAssert.h>
#include <viskores/Types.h>
#include <lcl/Polygon.h>
#include <lcl/Shapes.h>

Go to the source code of this file.

Classes
struct	viskores::CellShapeIdToTag< Id >
	A traits-like class to get an CellShapeId known at compile time to a tag. More...
struct	viskores::CellShapeTagEmpty
struct	viskores::CellShapeIdToTag< viskores::CELL_SHAPE_EMPTY >
struct	viskores::CellShapeTagVertex
struct	viskores::CellShapeIdToTag< viskores::CELL_SHAPE_VERTEX >
struct	viskores::CellShapeTagLine
struct	viskores::CellShapeIdToTag< viskores::CELL_SHAPE_LINE >
struct	viskores::CellShapeTagPolyLine
struct	viskores::CellShapeIdToTag< viskores::CELL_SHAPE_POLY_LINE >
struct	viskores::CellShapeTagTriangle
struct	viskores::CellShapeIdToTag< viskores::CELL_SHAPE_TRIANGLE >
struct	viskores::CellShapeTagPolygon
struct	viskores::CellShapeIdToTag< viskores::CELL_SHAPE_POLYGON >
struct	viskores::CellShapeTagQuad
struct	viskores::CellShapeIdToTag< viskores::CELL_SHAPE_QUAD >
struct	viskores::CellShapeTagTetra
struct	viskores::CellShapeIdToTag< viskores::CELL_SHAPE_TETRA >
struct	viskores::CellShapeTagHexahedron
struct	viskores::CellShapeIdToTag< viskores::CELL_SHAPE_HEXAHEDRON >
struct	viskores::CellShapeTagWedge
struct	viskores::CellShapeIdToTag< viskores::CELL_SHAPE_WEDGE >
struct	viskores::CellShapeTagPyramid
struct	viskores::CellShapeIdToTag< viskores::CELL_SHAPE_PYRAMID >
struct	viskores::CellShapeTagGeneric
	A special cell shape tag that holds a cell shape that is not known at compile time. More...

Namespaces
	lcl
	viskores
	Groups connected points that have the same field value.

Macros
#define	VISKORES_IS_CELL_SHAPE_TAG(tag)
	Checks that the argument is a proper cell shape tag. More...
#define	VISKORES_DEFINE_CELL_TAG(name, idname)
#define	viskoresGenericCellShapeMacroCase(cellShapeId, call)
#define	viskoresGenericCellShapeMacro(call)
	A macro used in a switch statement to determine cell shape. More...

Enumerations
enum	viskores::CellShapeIdEnum {   viskores::CELL_SHAPE_EMPTY = lcl::ShapeId::EMPTY, viskores::CELL_SHAPE_VERTEX = lcl::ShapeId::VERTEX, viskores::CELL_SHAPE_LINE = lcl::ShapeId::LINE, viskores::CELL_SHAPE_POLY_LINE = 4,   viskores::CELL_SHAPE_TRIANGLE = lcl::ShapeId::TRIANGLE, viskores::CELL_SHAPE_POLYGON = lcl::ShapeId::POLYGON, viskores::CELL_SHAPE_QUAD = lcl::ShapeId::QUAD, viskores::CELL_SHAPE_TETRA = lcl::ShapeId::TETRA,   viskores::CELL_SHAPE_HEXAHEDRON = lcl::ShapeId::HEXAHEDRON, viskores::CELL_SHAPE_WEDGE = lcl::ShapeId::WEDGE, viskores::CELL_SHAPE_PYRAMID = lcl::ShapeId::PYRAMID, viskores::NUMBER_OF_CELL_SHAPES }
	CellShapeId identifies the type of each cell. More...

Macro Definition Documentation

VISKORES_DEFINE_CELL_TAG

#define VISKORES_DEFINE_CELL_TAG	(		name,
			idname
	)

Value:

  struct CellShapeTag##name                                                                   \
  {                                                                                           \
    static constexpr viskores::UInt8 Id = viskores::idname;                                   \
  };                                                                                          \
  namespace internal                                                                          \
  {                                                                                           \
  template <>                                                                                 \
  struct CellShapeTagCheck<viskores::CellShapeTag##name> : std::true_type                     \
  {                                                                                           \
  };                                                                                          \
  template <>                                                                                 \
  struct CellShapeTagViskoresToVtkc<viskores::CellShapeTag##name>                             \
  {                                                                                           \
    using Type = lcl::name;                                                                   \
  };                                                                                          \
  }                                                                                           \
  static inline VISKORES_EXEC_CONT const char* GetCellShapeName(viskores::CellShapeTag##name) \
  {                                                                                           \
    return #name;                                                                             \
  }                                                                                           \
  template <>                                                                                 \
  struct CellShapeIdToTag<viskores::idname>                                                   \
  {                                                                                           \
    using valid = std::true_type;                                                             \
    using Tag = viskores::CellShapeTag##name;                                                 \
  }

VISKORES_IS_CELL_SHAPE_TAG

#define VISKORES_IS_CELL_SHAPE_TAG

(

tag

)

Value:

  VISKORES_STATIC_ASSERT_MSG(::viskores::internal::CellShapeTagCheck<tag>::value, \
                             "Provided type is not a valid Viskores cell shape tag.")

Checks that the argument is a proper cell shape tag.

This is a handy concept check to make sure that a template argument is a proper cell shape tag.

viskoresGenericCellShapeMacro

#define viskoresGenericCellShapeMacro

(

call

)

Value:

  viskoresGenericCellShapeMacroCase(CELL_SHAPE_EMPTY, call);      \
  viskoresGenericCellShapeMacroCase(CELL_SHAPE_VERTEX, call);     \
  viskoresGenericCellShapeMacroCase(CELL_SHAPE_LINE, call);       \
  viskoresGenericCellShapeMacroCase(CELL_SHAPE_POLY_LINE, call);  \
  viskoresGenericCellShapeMacroCase(CELL_SHAPE_TRIANGLE, call);   \
  viskoresGenericCellShapeMacroCase(CELL_SHAPE_POLYGON, call);    \
  viskoresGenericCellShapeMacroCase(CELL_SHAPE_QUAD, call);       \
  viskoresGenericCellShapeMacroCase(CELL_SHAPE_TETRA, call);      \
  viskoresGenericCellShapeMacroCase(CELL_SHAPE_HEXAHEDRON, call); \
  viskoresGenericCellShapeMacroCase(CELL_SHAPE_WEDGE, call);      \
  viskoresGenericCellShapeMacroCase(CELL_SHAPE_PYRAMID, call)

A macro used in a switch statement to determine cell shape.

The viskoresGenericCellShapeMacro is a series of case statements for all of the cell shapes supported by Viskores. This macro is intended to be used inside of a switch statement on a cell type. For each cell shape condition, a CellShapeTag typedef is created and the given call is executed.

A typical use case of this class is to create the specialization of a function overloaded on a cell shape tag for the generic cell shape like as following.

template<typename WorkletType>
VISKORES_EXEC
void MyCellOperation(viskores::CellShapeTagGeneric cellShape,
                     const viskores::exec::FunctorBase &worklet)
{
  switch(cellShape.CellShapeId)
  {
    viskoresGenericCellShapeMacro(
      MyCellOperation(CellShapeTag())
      );
    default: worklet.RaiseError("Encountered unknown cell shape."); break
  }
}

Note that viskoresGenericCellShapeMacro does not have a default case. You should consider adding one that gives a

viskoresGenericCellShapeMacroCase

#define viskoresGenericCellShapeMacroCase	(		cellShapeId,
			call
	)

Value:

  case viskores::cellShapeId:                                                    \
  {                                                                              \
    using CellShapeTag = viskores::CellShapeIdToTag<viskores::cellShapeId>::Tag; \
    call;                                                                        \
  }                                                                              \
  break