Rename vtkm::dot()
to vtkm::Dot()
.
This keeps the old name around but prepares it for removal in the next release.
This commit is contained in:
parent
dd7c17f776
commit
00c7905afb
6
docs/changelog/dot-product.md
Normal file
6
docs/changelog/dot-product.md
Normal file
@ -0,0 +1,6 @@
|
|||||||
|
# Dot product function name changed.
|
||||||
|
|
||||||
|
The free function `vtkm::dot()` has been renamed to `vtkm::Dot()`
|
||||||
|
to be consistent with other vtk-m function names.
|
||||||
|
Aliases are provided for backwards compatibility but will
|
||||||
|
be removed in the next release.
|
@ -388,8 +388,8 @@ public:
|
|||||||
VTKM_EXEC_CONT Scalar Value(const Vector& point) const override
|
VTKM_EXEC_CONT Scalar Value(const Vector& point) const override
|
||||||
{
|
{
|
||||||
Vector x2c = point - this->Center;
|
Vector x2c = point - this->Center;
|
||||||
FloatDefault proj = vtkm::dot(this->Axis, x2c);
|
FloatDefault proj = vtkm::Dot(this->Axis, x2c);
|
||||||
return vtkm::dot(x2c, x2c) - (proj * proj) - (this->Radius * this->Radius);
|
return vtkm::Dot(x2c, x2c) - (proj * proj) - (this->Radius * this->Radius);
|
||||||
}
|
}
|
||||||
|
|
||||||
VTKM_EXEC_CONT Vector Gradient(const Vector& point) const override
|
VTKM_EXEC_CONT Vector Gradient(const Vector& point) const override
|
||||||
@ -487,7 +487,7 @@ public:
|
|||||||
{
|
{
|
||||||
const Vector& p = this->Points[index];
|
const Vector& p = this->Points[index];
|
||||||
const Vector& n = this->Normals[index];
|
const Vector& n = this->Normals[index];
|
||||||
const Scalar val = vtkm::dot(point - p, n);
|
const Scalar val = vtkm::Dot(point - p, n);
|
||||||
maxVal = vtkm::Max(maxVal, val);
|
maxVal = vtkm::Max(maxVal, val);
|
||||||
}
|
}
|
||||||
return maxVal;
|
return maxVal;
|
||||||
@ -501,7 +501,7 @@ public:
|
|||||||
{
|
{
|
||||||
const Vector& p = this->Points[index];
|
const Vector& p = this->Points[index];
|
||||||
const Vector& n = this->Normals[index];
|
const Vector& n = this->Normals[index];
|
||||||
Scalar val = vtkm::dot(point - p, n);
|
Scalar val = vtkm::Dot(point - p, n);
|
||||||
if (val > maxVal)
|
if (val > maxVal)
|
||||||
{
|
{
|
||||||
maxVal = val;
|
maxVal = val;
|
||||||
@ -556,7 +556,7 @@ public:
|
|||||||
|
|
||||||
VTKM_EXEC_CONT Scalar Value(const Vector& point) const override
|
VTKM_EXEC_CONT Scalar Value(const Vector& point) const override
|
||||||
{
|
{
|
||||||
return vtkm::dot(point - this->Origin, this->Normal);
|
return vtkm::Dot(point - this->Origin, this->Normal);
|
||||||
}
|
}
|
||||||
|
|
||||||
VTKM_EXEC_CONT Vector Gradient(const Vector&) const override { return this->Normal; }
|
VTKM_EXEC_CONT Vector Gradient(const Vector&) const override { return this->Normal; }
|
||||||
|
@ -195,7 +195,7 @@ VTKM_EXEC_CONT vtkm::Vec<T, NumRow> MatrixMultiply(
|
|||||||
vtkm::Vec<T, NumRow> product;
|
vtkm::Vec<T, NumRow> product;
|
||||||
for (vtkm::IdComponent rowIndex = 0; rowIndex < NumRow; rowIndex++)
|
for (vtkm::IdComponent rowIndex = 0; rowIndex < NumRow; rowIndex++)
|
||||||
{
|
{
|
||||||
product[rowIndex] = vtkm::dot(vtkm::MatrixGetRow(leftFactor, rowIndex), rightFactor);
|
product[rowIndex] = vtkm::Dot(vtkm::MatrixGetRow(leftFactor, rowIndex), rightFactor);
|
||||||
}
|
}
|
||||||
return product;
|
return product;
|
||||||
}
|
}
|
||||||
@ -210,7 +210,7 @@ VTKM_EXEC_CONT vtkm::Vec<T, NumCol> MatrixMultiply(
|
|||||||
vtkm::Vec<T, NumCol> product;
|
vtkm::Vec<T, NumCol> product;
|
||||||
for (vtkm::IdComponent colIndex = 0; colIndex < NumCol; colIndex++)
|
for (vtkm::IdComponent colIndex = 0; colIndex < NumCol; colIndex++)
|
||||||
{
|
{
|
||||||
product[colIndex] = vtkm::dot(leftFactor, vtkm::MatrixGetColumn(rightFactor, colIndex));
|
product[colIndex] = vtkm::Dot(leftFactor, vtkm::MatrixGetColumn(rightFactor, colIndex));
|
||||||
}
|
}
|
||||||
return product;
|
return product;
|
||||||
}
|
}
|
||||||
|
@ -47,9 +47,9 @@ VTKM_EXEC_CONT vtkm::Vec<T, 3> Transform3DPoint(const vtkm::Matrix<T, 4, 4>& mat
|
|||||||
const vtkm::Vec<T, 3>& point)
|
const vtkm::Vec<T, 3>& point)
|
||||||
{
|
{
|
||||||
vtkm::Vec<T, 4> homogeneousPoint(point[0], point[1], point[2], T(1));
|
vtkm::Vec<T, 4> homogeneousPoint(point[0], point[1], point[2], T(1));
|
||||||
return vtkm::Vec<T, 3>(vtkm::dot(vtkm::MatrixGetRow(matrix, 0), homogeneousPoint),
|
return vtkm::Vec<T, 3>(vtkm::Dot(vtkm::MatrixGetRow(matrix, 0), homogeneousPoint),
|
||||||
vtkm::dot(vtkm::MatrixGetRow(matrix, 1), homogeneousPoint),
|
vtkm::Dot(vtkm::MatrixGetRow(matrix, 1), homogeneousPoint),
|
||||||
vtkm::dot(vtkm::MatrixGetRow(matrix, 2), homogeneousPoint));
|
vtkm::Dot(vtkm::MatrixGetRow(matrix, 2), homogeneousPoint));
|
||||||
}
|
}
|
||||||
|
|
||||||
/// \brief Transform a 3D point by a transformation matrix with perspective.
|
/// \brief Transform a 3D point by a transformation matrix with perspective.
|
||||||
@ -66,10 +66,10 @@ VTKM_EXEC_CONT vtkm::Vec<T, 3> Transform3DPointPerspective(const vtkm::Matrix<T,
|
|||||||
const vtkm::Vec<T, 3>& point)
|
const vtkm::Vec<T, 3>& point)
|
||||||
{
|
{
|
||||||
vtkm::Vec<T, 4> homogeneousPoint(point[0], point[1], point[2], T(1));
|
vtkm::Vec<T, 4> homogeneousPoint(point[0], point[1], point[2], T(1));
|
||||||
T inverseW = 1 / vtkm::dot(vtkm::MatrixGetRow(matrix, 3), homogeneousPoint);
|
T inverseW = 1 / vtkm::Dot(vtkm::MatrixGetRow(matrix, 3), homogeneousPoint);
|
||||||
return vtkm::Vec<T, 3>(vtkm::dot(vtkm::MatrixGetRow(matrix, 0), homogeneousPoint) * inverseW,
|
return vtkm::Vec<T, 3>(vtkm::Dot(vtkm::MatrixGetRow(matrix, 0), homogeneousPoint) * inverseW,
|
||||||
vtkm::dot(vtkm::MatrixGetRow(matrix, 1), homogeneousPoint) * inverseW,
|
vtkm::Dot(vtkm::MatrixGetRow(matrix, 1), homogeneousPoint) * inverseW,
|
||||||
vtkm::dot(vtkm::MatrixGetRow(matrix, 2), homogeneousPoint) * inverseW);
|
vtkm::Dot(vtkm::MatrixGetRow(matrix, 2), homogeneousPoint) * inverseW);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// \brief Transform a 3D vector by a transformation matrix.
|
/// \brief Transform a 3D vector by a transformation matrix.
|
||||||
|
40
vtkm/Types.h
40
vtkm/Types.h
@ -1226,24 +1226,24 @@ static inline VTKM_EXEC_CONT typename DotType<T>::type vec_dot(const vtkm::Vec<T
|
|||||||
}
|
}
|
||||||
|
|
||||||
template <typename T>
|
template <typename T>
|
||||||
static inline VTKM_EXEC_CONT auto dot(const T& a, const T& b) -> decltype(detail::vec_dot(a, b))
|
static inline VTKM_EXEC_CONT auto Dot(const T& a, const T& b) -> decltype(detail::vec_dot(a, b))
|
||||||
{
|
{
|
||||||
return detail::vec_dot(a, b);
|
return detail::vec_dot(a, b);
|
||||||
}
|
}
|
||||||
template <typename T>
|
template <typename T>
|
||||||
static inline VTKM_EXEC_CONT typename detail::DotType<T>::type dot(const vtkm::Vec<T, 2>& a,
|
static inline VTKM_EXEC_CONT typename detail::DotType<T>::type Dot(const vtkm::Vec<T, 2>& a,
|
||||||
const vtkm::Vec<T, 2>& b)
|
const vtkm::Vec<T, 2>& b)
|
||||||
{
|
{
|
||||||
return (a[0] * b[0]) + (a[1] * b[1]);
|
return (a[0] * b[0]) + (a[1] * b[1]);
|
||||||
}
|
}
|
||||||
template <typename T>
|
template <typename T>
|
||||||
static inline VTKM_EXEC_CONT typename detail::DotType<T>::type dot(const vtkm::Vec<T, 3>& a,
|
static inline VTKM_EXEC_CONT typename detail::DotType<T>::type Dot(const vtkm::Vec<T, 3>& a,
|
||||||
const vtkm::Vec<T, 3>& b)
|
const vtkm::Vec<T, 3>& b)
|
||||||
{
|
{
|
||||||
return (a[0] * b[0]) + (a[1] * b[1]) + (a[2] * b[2]);
|
return (a[0] * b[0]) + (a[1] * b[1]) + (a[2] * b[2]);
|
||||||
}
|
}
|
||||||
template <typename T>
|
template <typename T>
|
||||||
static inline VTKM_EXEC_CONT typename detail::DotType<T>::type dot(const vtkm::Vec<T, 4>& a,
|
static inline VTKM_EXEC_CONT typename detail::DotType<T>::type Dot(const vtkm::Vec<T, 4>& a,
|
||||||
const vtkm::Vec<T, 4>& b)
|
const vtkm::Vec<T, 4>& b)
|
||||||
{
|
{
|
||||||
return (a[0] * b[0]) + (a[1] * b[1]) + (a[2] * b[2]) + (a[3] * b[3]);
|
return (a[0] * b[0]) + (a[1] * b[1]) + (a[2] * b[2]) + (a[3] * b[3]);
|
||||||
@ -1251,7 +1251,11 @@ static inline VTKM_EXEC_CONT typename detail::DotType<T>::type dot(const vtkm::V
|
|||||||
// Integer types of a width less than an integer get implicitly casted to
|
// Integer types of a width less than an integer get implicitly casted to
|
||||||
// an integer when doing a multiplication.
|
// an integer when doing a multiplication.
|
||||||
#define VTK_M_SCALAR_DOT(stype) \
|
#define VTK_M_SCALAR_DOT(stype) \
|
||||||
static inline VTKM_EXEC_CONT detail::DotType<stype>::type dot(stype a, stype b) { return a * b; }
|
static inline VTKM_EXEC_CONT detail::DotType<stype>::type dot(stype a, stype b) \
|
||||||
|
{ \
|
||||||
|
return a * b; \
|
||||||
|
} /* LEGACY */ \
|
||||||
|
static inline VTKM_EXEC_CONT detail::DotType<stype>::type Dot(stype a, stype b) { return a * b; }
|
||||||
VTK_M_SCALAR_DOT(vtkm::Int8)
|
VTK_M_SCALAR_DOT(vtkm::Int8)
|
||||||
VTK_M_SCALAR_DOT(vtkm::UInt8)
|
VTK_M_SCALAR_DOT(vtkm::UInt8)
|
||||||
VTK_M_SCALAR_DOT(vtkm::Int16)
|
VTK_M_SCALAR_DOT(vtkm::Int16)
|
||||||
@ -1263,6 +1267,32 @@ VTK_M_SCALAR_DOT(vtkm::UInt64)
|
|||||||
VTK_M_SCALAR_DOT(vtkm::Float32)
|
VTK_M_SCALAR_DOT(vtkm::Float32)
|
||||||
VTK_M_SCALAR_DOT(vtkm::Float64)
|
VTK_M_SCALAR_DOT(vtkm::Float64)
|
||||||
|
|
||||||
|
// v============ LEGACY =============v
|
||||||
|
template <typename T>
|
||||||
|
static inline VTKM_EXEC_CONT auto dot(const T& a, const T& b) -> decltype(detail::vec_dot(a, b))
|
||||||
|
{
|
||||||
|
return vtkm::Dot(a, b);
|
||||||
|
}
|
||||||
|
template <typename T>
|
||||||
|
static inline VTKM_EXEC_CONT typename detail::DotType<T>::type dot(const vtkm::Vec<T, 2>& a,
|
||||||
|
const vtkm::Vec<T, 2>& b)
|
||||||
|
{
|
||||||
|
return vtkm::Dot(a, b);
|
||||||
|
}
|
||||||
|
template <typename T>
|
||||||
|
static inline VTKM_EXEC_CONT typename detail::DotType<T>::type dot(const vtkm::Vec<T, 3>& a,
|
||||||
|
const vtkm::Vec<T, 3>& b)
|
||||||
|
{
|
||||||
|
return vtkm::Dot(a, b);
|
||||||
|
}
|
||||||
|
template <typename T>
|
||||||
|
static inline VTKM_EXEC_CONT typename detail::DotType<T>::type dot(const vtkm::Vec<T, 4>& a,
|
||||||
|
const vtkm::Vec<T, 4>& b)
|
||||||
|
{
|
||||||
|
return vtkm::Dot(a, b);
|
||||||
|
}
|
||||||
|
// ^============ LEGACY =============^
|
||||||
|
|
||||||
template <typename T, vtkm::IdComponent Size>
|
template <typename T, vtkm::IdComponent Size>
|
||||||
inline VTKM_EXEC_CONT T ReduceSum(const vtkm::Vec<T, Size>& a)
|
inline VTKM_EXEC_CONT T ReduceSum(const vtkm::Vec<T, Size>& a)
|
||||||
{
|
{
|
||||||
|
@ -76,7 +76,7 @@ template <typename T>
|
|||||||
VTKM_EXEC_CONT typename detail::FloatingPointReturnType<T>::Type MagnitudeSquared(const T& x)
|
VTKM_EXEC_CONT typename detail::FloatingPointReturnType<T>::Type MagnitudeSquared(const T& x)
|
||||||
{
|
{
|
||||||
using U = typename detail::FloatingPointReturnType<T>::Type;
|
using U = typename detail::FloatingPointReturnType<T>::Type;
|
||||||
return static_cast<U>(vtkm::dot(x, x));
|
return static_cast<U>(vtkm::Dot(x, x));
|
||||||
}
|
}
|
||||||
|
|
||||||
// ----------------------------------------------------------------------------
|
// ----------------------------------------------------------------------------
|
||||||
|
@ -65,7 +65,7 @@ struct ValueSquared
|
|||||||
template <typename U>
|
template <typename U>
|
||||||
VTKM_EXEC_CONT ValueType operator()(U u) const
|
VTKM_EXEC_CONT ValueType operator()(U u) const
|
||||||
{
|
{
|
||||||
return vtkm::dot(u, u);
|
return vtkm::Dot(u, u);
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
|
@ -40,9 +40,9 @@ const vtkm::Id ARRAY_SIZE = 10;
|
|||||||
struct MySquare
|
struct MySquare
|
||||||
{
|
{
|
||||||
template <typename U>
|
template <typename U>
|
||||||
VTKM_EXEC auto operator()(U u) const -> decltype(vtkm::dot(u, u))
|
VTKM_EXEC auto operator()(U u) const -> decltype(vtkm::Dot(u, u))
|
||||||
{
|
{
|
||||||
return vtkm::dot(u, u);
|
return vtkm::Dot(u, u);
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
|
@ -635,19 +635,19 @@ VTKM_EXEC vtkm::Vec<ValueType, 3> TriangleDerivative(const vtkm::Vec<ValueType,
|
|||||||
// gradient g and scalar value s_origin, can be found with this set of 4
|
// gradient g and scalar value s_origin, can be found with this set of 4
|
||||||
// equations and 4 unknowns.
|
// equations and 4 unknowns.
|
||||||
//
|
//
|
||||||
// dot(p0, g) + s_origin = s0
|
// Dot(p0, g) + s_origin = s0
|
||||||
// dot(p1, g) + s_origin = s1
|
// Dot(p1, g) + s_origin = s1
|
||||||
// dot(p2, g) + s_origin = s2
|
// Dot(p2, g) + s_origin = s2
|
||||||
// dot(n, g) = 0
|
// Dot(n, g) = 0
|
||||||
//
|
//
|
||||||
// Where the p's are point coordinates and n is the normal vector. But we
|
// Where the p's are point coordinates and n is the normal vector. But we
|
||||||
// don't really care about s_origin. We just want to find the gradient g.
|
// don't really care about s_origin. We just want to find the gradient g.
|
||||||
// With some simple elimination we, we can get rid of s_origin and be left
|
// With some simple elimination we, we can get rid of s_origin and be left
|
||||||
// with 3 equations and 3 unknowns.
|
// with 3 equations and 3 unknowns.
|
||||||
//
|
//
|
||||||
// dot(p1-p0, g) = s1 - s0
|
// Dot(p1-p0, g) = s1 - s0
|
||||||
// dot(p2-p0, g) = s2 - s0
|
// Dot(p2-p0, g) = s2 - s0
|
||||||
// dot(n, g) = 0
|
// Dot(n, g) = 0
|
||||||
//
|
//
|
||||||
// We'll solve this by putting this in matrix form Ax = b where the rows of A
|
// We'll solve this by putting this in matrix form Ax = b where the rows of A
|
||||||
// are the differences in points and normal, b has the scalar differences,
|
// are the differences in points and normal, b has the scalar differences,
|
||||||
@ -937,19 +937,19 @@ VTKM_EXEC vtkm::Vec<ValueType, 3> TetraDerivative(const vtkm::Vec<ValueType, 4>&
|
|||||||
// gradient g and scalar value s_origin, can be found with this set of 4
|
// gradient g and scalar value s_origin, can be found with this set of 4
|
||||||
// equations and 4 unknowns.
|
// equations and 4 unknowns.
|
||||||
//
|
//
|
||||||
// dot(p0, g) + s_origin = s0
|
// Dot(p0, g) + s_origin = s0
|
||||||
// dot(p1, g) + s_origin = s1
|
// Dot(p1, g) + s_origin = s1
|
||||||
// dot(p2, g) + s_origin = s2
|
// Dot(p2, g) + s_origin = s2
|
||||||
// dot(p3, g) + s_origin = s3
|
// Dot(p3, g) + s_origin = s3
|
||||||
//
|
//
|
||||||
// Where the p's are point coordinates. But we don't really care about
|
// Where the p's are point coordinates. But we don't really care about
|
||||||
// s_origin. We just want to find the gradient g. With some simple
|
// s_origin. We just want to find the gradient g. With some simple
|
||||||
// elimination we, we can get rid of s_origin and be left with 3 equations
|
// elimination we, we can get rid of s_origin and be left with 3 equations
|
||||||
// and 3 unknowns.
|
// and 3 unknowns.
|
||||||
//
|
//
|
||||||
// dot(p1-p0, g) = s1 - s0
|
// Dot(p1-p0, g) = s1 - s0
|
||||||
// dot(p2-p0, g) = s2 - s0
|
// Dot(p2-p0, g) = s2 - s0
|
||||||
// dot(p3-p0, g) = s3 - s0
|
// Dot(p3-p0, g) = s3 - s0
|
||||||
//
|
//
|
||||||
// We'll solve this by putting this in matrix form Ax = b where the rows of A
|
// We'll solve this by putting this in matrix form Ax = b where the rows of A
|
||||||
// are the differences in points and normal, b has the scalar differences,
|
// are the differences in points and normal, b has the scalar differences,
|
||||||
|
@ -86,7 +86,7 @@ VTKM_EXEC typename WorldCoordVector::ComponentType ReverseInterpolateTriangle(
|
|||||||
//
|
//
|
||||||
// First, we define an implicit plane as:
|
// First, we define an implicit plane as:
|
||||||
//
|
//
|
||||||
// dot((p - wcoords), planeNormal) = 0
|
// Dot((p - wcoords), planeNormal) = 0
|
||||||
//
|
//
|
||||||
// where planeNormal is the normal to the plane (easily computed from the
|
// where planeNormal is the normal to the plane (easily computed from the
|
||||||
// triangle), and p is any point in the plane. Next, we define the parametric
|
// triangle), and p is any point in the plane. Next, we define the parametric
|
||||||
@ -103,7 +103,7 @@ VTKM_EXEC typename WorldCoordVector::ComponentType ReverseInterpolateTriangle(
|
|||||||
// definition of p(d) into p for the plane equation. With some basic algebra
|
// definition of p(d) into p for the plane equation. With some basic algebra
|
||||||
// you get:
|
// you get:
|
||||||
//
|
//
|
||||||
// d = dot((wcoords - p0), planeNormal)/dot((p1-p0), planeNormal)
|
// d = Dot((wcoords - p0), planeNormal)/Dot((p1-p0), planeNormal)
|
||||||
//
|
//
|
||||||
// From here, the u coordinate is simply d. The v coordinate follows
|
// From here, the u coordinate is simply d. The v coordinate follows
|
||||||
// similarly.
|
// similarly.
|
||||||
@ -122,7 +122,7 @@ VTKM_EXEC typename WorldCoordVector::ComponentType ReverseInterpolateTriangle(
|
|||||||
Vector3 p2 = pointWCoords[2 - dimension];
|
Vector3 p2 = pointWCoords[2 - dimension];
|
||||||
Vector3 planeNormal = vtkm::Cross(triangleNormal, p2 - p0);
|
Vector3 planeNormal = vtkm::Cross(triangleNormal, p2 - p0);
|
||||||
|
|
||||||
T d = vtkm::dot(wcoords - p0, planeNormal) / vtkm::dot(p1 - p0, planeNormal);
|
T d = vtkm::Dot(wcoords - p0, planeNormal) / vtkm::Dot(p1 - p0, planeNormal);
|
||||||
|
|
||||||
pcoords[dimension] = d;
|
pcoords[dimension] = d;
|
||||||
}
|
}
|
||||||
|
@ -123,8 +123,8 @@ VTKM_EXEC OutType CellMeasure(const vtkm::IdComponent& numPts,
|
|||||||
Normalize(unitCenterNormal);
|
Normalize(unitCenterNormal);
|
||||||
|
|
||||||
OutType area =
|
OutType area =
|
||||||
(dot(unitCenterNormal, cornerNormals[0]) + dot(unitCenterNormal, cornerNormals[1]) +
|
(Dot(unitCenterNormal, cornerNormals[0]) + Dot(unitCenterNormal, cornerNormals[1]) +
|
||||||
dot(unitCenterNormal, cornerNormals[2]) + dot(unitCenterNormal, cornerNormals[3])) *
|
Dot(unitCenterNormal, cornerNormals[2]) + Dot(unitCenterNormal, cornerNormals[3])) *
|
||||||
OutType(0.25);
|
OutType(0.25);
|
||||||
return area;
|
return area;
|
||||||
}
|
}
|
||||||
@ -157,7 +157,7 @@ VTKM_EXEC OutType CellMeasure(const vtkm::IdComponent& numPts,
|
|||||||
typename PointCoordVecType::ComponentType v1 = pts[1] - pts[0];
|
typename PointCoordVecType::ComponentType v1 = pts[1] - pts[0];
|
||||||
typename PointCoordVecType::ComponentType v2 = pts[2] - pts[0];
|
typename PointCoordVecType::ComponentType v2 = pts[2] - pts[0];
|
||||||
typename PointCoordVecType::ComponentType v3 = pts[3] - pts[0];
|
typename PointCoordVecType::ComponentType v3 = pts[3] - pts[0];
|
||||||
OutType volume = dot(Cross(v1, v2), v3) / OutType(6.0);
|
OutType volume = Dot(Cross(v1, v2), v3) / OutType(6.0);
|
||||||
return volume;
|
return volume;
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -201,7 +201,7 @@ VTKM_EXEC OutType CellMeasure(const vtkm::IdComponent& numPts,
|
|||||||
efg3 -= pts[2];
|
efg3 -= pts[2];
|
||||||
efg3 -= pts[3];
|
efg3 -= pts[3];
|
||||||
|
|
||||||
OutType volume = dot(Cross(efg2, efg3), efg1) / OutType(64.0);
|
OutType volume = Dot(Cross(efg2, efg3), efg1) / OutType(64.0);
|
||||||
return volume;
|
return volume;
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -221,17 +221,17 @@ VTKM_EXEC OutType CellMeasure(const vtkm::IdComponent& numPts,
|
|||||||
typename PointCoordVecType::ComponentType v0 = pts[1] - pts[0];
|
typename PointCoordVecType::ComponentType v0 = pts[1] - pts[0];
|
||||||
typename PointCoordVecType::ComponentType v1 = pts[2] - pts[0];
|
typename PointCoordVecType::ComponentType v1 = pts[2] - pts[0];
|
||||||
typename PointCoordVecType::ComponentType v2 = pts[3] - pts[0];
|
typename PointCoordVecType::ComponentType v2 = pts[3] - pts[0];
|
||||||
OutType volume = dot(Cross(v0, v1), v2) / OutType(6.0);
|
OutType volume = Dot(Cross(v0, v1), v2) / OutType(6.0);
|
||||||
|
|
||||||
typename PointCoordVecType::ComponentType v3 = pts[4] - pts[1];
|
typename PointCoordVecType::ComponentType v3 = pts[4] - pts[1];
|
||||||
typename PointCoordVecType::ComponentType v4 = pts[5] - pts[1];
|
typename PointCoordVecType::ComponentType v4 = pts[5] - pts[1];
|
||||||
typename PointCoordVecType::ComponentType v5 = pts[3] - pts[1];
|
typename PointCoordVecType::ComponentType v5 = pts[3] - pts[1];
|
||||||
volume += dot(Cross(v3, v4), v5) / OutType(6.0);
|
volume += Dot(Cross(v3, v4), v5) / OutType(6.0);
|
||||||
|
|
||||||
typename PointCoordVecType::ComponentType v6 = pts[5] - pts[1];
|
typename PointCoordVecType::ComponentType v6 = pts[5] - pts[1];
|
||||||
typename PointCoordVecType::ComponentType v7 = pts[2] - pts[1];
|
typename PointCoordVecType::ComponentType v7 = pts[2] - pts[1];
|
||||||
typename PointCoordVecType::ComponentType v8 = pts[3] - pts[1];
|
typename PointCoordVecType::ComponentType v8 = pts[3] - pts[1];
|
||||||
volume += dot(Cross(v6, v7), v8) / OutType(6.0);
|
volume += Dot(Cross(v6, v7), v8) / OutType(6.0);
|
||||||
|
|
||||||
return volume;
|
return volume;
|
||||||
}
|
}
|
||||||
@ -252,12 +252,12 @@ VTKM_EXEC OutType CellMeasure(const vtkm::IdComponent& numPts,
|
|||||||
typename PointCoordVecType::ComponentType v1 = pts[1] - pts[0];
|
typename PointCoordVecType::ComponentType v1 = pts[1] - pts[0];
|
||||||
typename PointCoordVecType::ComponentType v2 = pts[3] - pts[0];
|
typename PointCoordVecType::ComponentType v2 = pts[3] - pts[0];
|
||||||
typename PointCoordVecType::ComponentType v3 = pts[4] - pts[0];
|
typename PointCoordVecType::ComponentType v3 = pts[4] - pts[0];
|
||||||
OutType volume = dot(Cross(v1, v2), v3) / OutType(6.0);
|
OutType volume = Dot(Cross(v1, v2), v3) / OutType(6.0);
|
||||||
|
|
||||||
typename PointCoordVecType::ComponentType v4 = pts[1] - pts[2];
|
typename PointCoordVecType::ComponentType v4 = pts[1] - pts[2];
|
||||||
typename PointCoordVecType::ComponentType v5 = pts[3] - pts[2];
|
typename PointCoordVecType::ComponentType v5 = pts[3] - pts[2];
|
||||||
typename PointCoordVecType::ComponentType v6 = pts[4] - pts[2];
|
typename PointCoordVecType::ComponentType v6 = pts[4] - pts[2];
|
||||||
volume += dot(Cross(v5, v4), v6) / OutType(6.0);
|
volume += Dot(Cross(v5, v4), v6) / OutType(6.0);
|
||||||
|
|
||||||
return volume;
|
return volume;
|
||||||
}
|
}
|
||||||
|
@ -58,7 +58,7 @@ struct Space2D
|
|||||||
Vec2 ConvertCoordToSpace(const Vec3 coord) const
|
Vec2 ConvertCoordToSpace(const Vec3 coord) const
|
||||||
{
|
{
|
||||||
Vec3 vec = coord - this->Origin;
|
Vec3 vec = coord - this->Origin;
|
||||||
return Vec2(vtkm::dot(vec, this->Basis0), vtkm::dot(vec, this->Basis1));
|
return Vec2(vtkm::Dot(vec, this->Basis0), vtkm::Dot(vec, this->Basis1));
|
||||||
}
|
}
|
||||||
|
|
||||||
template <typename U>
|
template <typename U>
|
||||||
|
@ -628,17 +628,17 @@ WorldCoordinatesToParametricCoordinates(const WorldCoordVector& pointWCoords,
|
|||||||
// Because this is a line, there is only one valid parametric coordinate. Let
|
// Because this is a line, there is only one valid parametric coordinate. Let
|
||||||
// vec be the vector from the first point to the second point
|
// vec be the vector from the first point to the second point
|
||||||
// (pointWCoords[1] - pointWCoords[0]), which is the direction of the line.
|
// (pointWCoords[1] - pointWCoords[0]), which is the direction of the line.
|
||||||
// dot(vec,wcoords-pointWCoords[0])/mag(vec) is the orthoginal projection of
|
// Dot(vec,wcoords-pointWCoords[0])/mag(vec) is the orthoginal projection of
|
||||||
// wcoords on the line and represents the distance between the orthoginal
|
// wcoords on the line and represents the distance between the orthoginal
|
||||||
// projection and pointWCoords[0]. The parametric coordinate is the fraction
|
// projection and pointWCoords[0]. The parametric coordinate is the fraction
|
||||||
// of this over the length of the segment, which is mag(vec). Thus, the
|
// of this over the length of the segment, which is mag(vec). Thus, the
|
||||||
// parametric coordinate is dot(vec,wcoords-pointWCoords[0])/mag(vec)^2.
|
// parametric coordinate is Dot(vec,wcoords-pointWCoords[0])/mag(vec)^2.
|
||||||
|
|
||||||
using Vector3 = typename WorldCoordVector::ComponentType;
|
using Vector3 = typename WorldCoordVector::ComponentType;
|
||||||
using T = typename Vector3::ComponentType;
|
using T = typename Vector3::ComponentType;
|
||||||
|
|
||||||
Vector3 vec = pointWCoords[1] - pointWCoords[0];
|
Vector3 vec = pointWCoords[1] - pointWCoords[0];
|
||||||
T numerator = vtkm::dot(vec, wcoords - pointWCoords[0]);
|
T numerator = vtkm::Dot(vec, wcoords - pointWCoords[0]);
|
||||||
T denominator = vtkm::MagnitudeSquared(vec);
|
T denominator = vtkm::MagnitudeSquared(vec);
|
||||||
|
|
||||||
return Vector3(numerator / denominator, 0, 0);
|
return Vector3(numerator / denominator, 0, 0);
|
||||||
@ -848,8 +848,8 @@ WorldCoordinatesToParametricCoordinates(const WorldCoordVector& pointWCoords,
|
|||||||
{
|
{
|
||||||
WCoordType vecInPlane = pointWCoords[firstPointIndex] - wcoordCenter;
|
WCoordType vecInPlane = pointWCoords[firstPointIndex] - wcoordCenter;
|
||||||
WCoordType planeNormal = vtkm::Cross(polygonNormal, vecInPlane);
|
WCoordType planeNormal = vtkm::Cross(polygonNormal, vecInPlane);
|
||||||
typename WCoordType::ComponentType planeOffset = vtkm::dot(planeNormal, wcoordCenter);
|
typename WCoordType::ComponentType planeOffset = vtkm::Dot(planeNormal, wcoordCenter);
|
||||||
if (vtkm::dot(planeNormal, wcoords) < planeOffset)
|
if (vtkm::Dot(planeNormal, wcoords) < planeOffset)
|
||||||
{
|
{
|
||||||
// wcoords on wrong side of plane, thus outside of triangle
|
// wcoords on wrong side of plane, thus outside of triangle
|
||||||
continue;
|
continue;
|
||||||
@ -858,8 +858,8 @@ WorldCoordinatesToParametricCoordinates(const WorldCoordVector& pointWCoords,
|
|||||||
secondPointIndex = firstPointIndex + 1;
|
secondPointIndex = firstPointIndex + 1;
|
||||||
vecInPlane = pointWCoords[secondPointIndex] - wcoordCenter;
|
vecInPlane = pointWCoords[secondPointIndex] - wcoordCenter;
|
||||||
planeNormal = vtkm::Cross(polygonNormal, vecInPlane);
|
planeNormal = vtkm::Cross(polygonNormal, vecInPlane);
|
||||||
planeOffset = vtkm::dot(planeNormal, wcoordCenter);
|
planeOffset = vtkm::Dot(planeNormal, wcoordCenter);
|
||||||
if (vtkm::dot(planeNormal, wcoords) > planeOffset)
|
if (vtkm::Dot(planeNormal, wcoords) > planeOffset)
|
||||||
{
|
{
|
||||||
// wcoords on wrong side of plane, thus outside of triangle
|
// wcoords on wrong side of plane, thus outside of triangle
|
||||||
continue;
|
continue;
|
||||||
@ -931,7 +931,7 @@ WorldCoordinatesToParametricCoordinatesTetra(
|
|||||||
// from p0 to the adjacent point (which is itself the parametric coordinate
|
// from p0 to the adjacent point (which is itself the parametric coordinate
|
||||||
// we are after), we get the following definition for the intersection.
|
// we are after), we get the following definition for the intersection.
|
||||||
//
|
//
|
||||||
// d = dot((wcoords - p0), planeNormal)/dot((p1-p0), planeNormal)
|
// d = Dot((wcoords - p0), planeNormal)/Dot((p1-p0), planeNormal)
|
||||||
//
|
//
|
||||||
|
|
||||||
const auto vec0 = pointWCoords[1] - pointWCoords[0];
|
const auto vec0 = pointWCoords[1] - pointWCoords[0];
|
||||||
@ -941,13 +941,13 @@ WorldCoordinatesToParametricCoordinatesTetra(
|
|||||||
|
|
||||||
typename WorldCoordVector::ComponentType pcoords;
|
typename WorldCoordVector::ComponentType pcoords;
|
||||||
auto planeNormal = vtkm::Cross(vec1, vec2);
|
auto planeNormal = vtkm::Cross(vec1, vec2);
|
||||||
pcoords[0] = vtkm::dot(coordVec, planeNormal) / vtkm::dot(vec0, planeNormal);
|
pcoords[0] = vtkm::Dot(coordVec, planeNormal) / vtkm::Dot(vec0, planeNormal);
|
||||||
|
|
||||||
planeNormal = vtkm::Cross(vec0, vec2);
|
planeNormal = vtkm::Cross(vec0, vec2);
|
||||||
pcoords[1] = vtkm::dot(coordVec, planeNormal) / vtkm::dot(vec1, planeNormal);
|
pcoords[1] = vtkm::Dot(coordVec, planeNormal) / vtkm::Dot(vec1, planeNormal);
|
||||||
|
|
||||||
planeNormal = vtkm::Cross(vec0, vec1);
|
planeNormal = vtkm::Cross(vec0, vec1);
|
||||||
pcoords[2] = vtkm::dot(coordVec, planeNormal) / vtkm::dot(vec2, planeNormal);
|
pcoords[2] = vtkm::Dot(coordVec, planeNormal) / vtkm::Dot(vec2, planeNormal);
|
||||||
|
|
||||||
return pcoords;
|
return pcoords;
|
||||||
}
|
}
|
||||||
|
@ -225,7 +225,7 @@ struct TestWorkletProxy : vtkm::exec::FunctorBase
|
|||||||
const InputDomainType&,
|
const InputDomainType&,
|
||||||
const G& globalThreadIndexOffset) const
|
const G& globalThreadIndexOffset) const
|
||||||
{
|
{
|
||||||
const vtkm::Id index = vtkm::dot(threadIndex, vtkm::Id3(1, 8, 64));
|
const vtkm::Id index = vtkm::Dot(threadIndex, vtkm::Id3(1, 8, 64));
|
||||||
return vtkm::exec::arg::ThreadIndicesBasic(
|
return vtkm::exec::arg::ThreadIndicesBasic(
|
||||||
index, outToIn.Get(index), visit.Get(index), globalThreadIndexOffset);
|
index, outToIn.Get(index), visit.Get(index), globalThreadIndexOffset);
|
||||||
}
|
}
|
||||||
@ -265,7 +265,7 @@ struct TestWorkletErrorProxy : vtkm::exec::FunctorBase
|
|||||||
const InputDomainType&,
|
const InputDomainType&,
|
||||||
const G& globalThreadIndexOffset) const
|
const G& globalThreadIndexOffset) const
|
||||||
{
|
{
|
||||||
const vtkm::Id index = vtkm::dot(threadIndex, vtkm::Id3(1, 8, 64));
|
const vtkm::Id index = vtkm::Dot(threadIndex, vtkm::Id3(1, 8, 64));
|
||||||
return vtkm::exec::arg::ThreadIndicesBasic(
|
return vtkm::exec::arg::ThreadIndicesBasic(
|
||||||
index, outToIn.Get(index), visit.Get(index), globalThreadIndexOffset);
|
index, outToIn.Get(index), visit.Get(index), globalThreadIndexOffset);
|
||||||
}
|
}
|
||||||
|
@ -212,7 +212,7 @@ struct TestPCoordsFunctor
|
|||||||
numPoints, pointIndex, pcoords, CellShapeTag(), workletProxy);
|
numPoints, pointIndex, pcoords, CellShapeTag(), workletProxy);
|
||||||
VTKM_TEST_ASSERT(!errorMessage.IsErrorRaised(), messageBuffer);
|
VTKM_TEST_ASSERT(!errorMessage.IsErrorRaised(), messageBuffer);
|
||||||
|
|
||||||
Vector3 wCoords = Vector3(pcoords[0], pcoords[1], pcoords[2] + vtkm::dot(pcoords, sheerVec));
|
Vector3 wCoords = Vector3(pcoords[0], pcoords[1], pcoords[2] + vtkm::Dot(pcoords, sheerVec));
|
||||||
pointWCoords.Append(wCoords);
|
pointWCoords.Append(wCoords);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -111,14 +111,14 @@ void CheckResult(const vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::FloatDefault, 3>>
|
|||||||
//Make sure result is orthogonal each input vector. Need to normalize to compare with zero.
|
//Make sure result is orthogonal each input vector. Need to normalize to compare with zero.
|
||||||
vtkm::Vec<vtkm::FloatDefault, 3> v1N(vtkm::Normal(v1)), v2N(vtkm::Normal(v1)),
|
vtkm::Vec<vtkm::FloatDefault, 3> v1N(vtkm::Normal(v1)), v2N(vtkm::Normal(v1)),
|
||||||
resN(vtkm::Normal(res));
|
resN(vtkm::Normal(res));
|
||||||
VTKM_TEST_ASSERT(test_equal(vtkm::dot(resN, v1N), vtkm::FloatDefault(0.0)),
|
VTKM_TEST_ASSERT(test_equal(vtkm::Dot(resN, v1N), vtkm::FloatDefault(0.0)),
|
||||||
"Wrong result for cross product");
|
"Wrong result for cross product");
|
||||||
VTKM_TEST_ASSERT(test_equal(vtkm::dot(resN, v2N), vtkm::FloatDefault(0.0)),
|
VTKM_TEST_ASSERT(test_equal(vtkm::Dot(resN, v2N), vtkm::FloatDefault(0.0)),
|
||||||
"Wrong result for cross product");
|
"Wrong result for cross product");
|
||||||
|
|
||||||
vtkm::FloatDefault sinAngle =
|
vtkm::FloatDefault sinAngle =
|
||||||
vtkm::Magnitude(res) * vtkm::RMagnitude(v1) * vtkm::RMagnitude(v2);
|
vtkm::Magnitude(res) * vtkm::RMagnitude(v1) * vtkm::RMagnitude(v2);
|
||||||
vtkm::FloatDefault cosAngle = vtkm::dot(v1, v2) * vtkm::RMagnitude(v1) * vtkm::RMagnitude(v2);
|
vtkm::FloatDefault cosAngle = vtkm::Dot(v1, v2) * vtkm::RMagnitude(v1) * vtkm::RMagnitude(v2);
|
||||||
VTKM_TEST_ASSERT(test_equal(sinAngle * sinAngle + cosAngle * cosAngle, vtkm::FloatDefault(1.0)),
|
VTKM_TEST_ASSERT(test_equal(sinAngle * sinAngle + cosAngle * cosAngle, vtkm::FloatDefault(1.0)),
|
||||||
"Bad cross product length.");
|
"Bad cross product length.");
|
||||||
}
|
}
|
||||||
|
@ -108,7 +108,7 @@ void CheckResult(const vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::FloatDefault, 3>>
|
|||||||
vtkm::Vec<vtkm::FloatDefault, 3> v2 = v2Portal.Get(j);
|
vtkm::Vec<vtkm::FloatDefault, 3> v2 = v2Portal.Get(j);
|
||||||
vtkm::FloatDefault res = outPortal.Get(j);
|
vtkm::FloatDefault res = outPortal.Get(j);
|
||||||
|
|
||||||
VTKM_TEST_ASSERT(test_equal(vtkm::dot(v1, v2), res), "Wrong result for dot product");
|
VTKM_TEST_ASSERT(test_equal(vtkm::Dot(v1, v2), res), "Wrong result for dot product");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -294,7 +294,7 @@ private:
|
|||||||
|
|
||||||
// vtkm::FloatDefault magnitudeValue = GLReturneMags[pointIndex];
|
// vtkm::FloatDefault magnitudeValue = GLReturneMags[pointIndex];
|
||||||
// vtkm::FloatDefault magnitudeExpected =
|
// vtkm::FloatDefault magnitudeExpected =
|
||||||
// sqrt(vtkm::dot(pointCoordinateExpected, pointCoordinateExpected));
|
// sqrt(vtkm::Dot(pointCoordinateExpected, pointCoordinateExpected));
|
||||||
// VTKM_TEST_ASSERT(test_equal(magnitudeValue, magnitudeExpected),
|
// VTKM_TEST_ASSERT(test_equal(magnitudeValue, magnitudeExpected),
|
||||||
// "Got bad magnitude from OpenGL buffer.");
|
// "Got bad magnitude from OpenGL buffer.");
|
||||||
// }
|
// }
|
||||||
|
@ -77,9 +77,9 @@ struct MatrixHelpers
|
|||||||
matrix(2, 1) = viewDir[1];
|
matrix(2, 1) = viewDir[1];
|
||||||
matrix(2, 2) = viewDir[2];
|
matrix(2, 2) = viewDir[2];
|
||||||
|
|
||||||
matrix(0, 3) = -vtkm::dot(right, position);
|
matrix(0, 3) = -vtkm::Dot(right, position);
|
||||||
matrix(1, 3) = -vtkm::dot(ru, position);
|
matrix(1, 3) = -vtkm::Dot(ru, position);
|
||||||
matrix(2, 3) = -vtkm::dot(viewDir, position);
|
matrix(2, 3) = -vtkm::Dot(viewDir, position);
|
||||||
|
|
||||||
return matrix;
|
return matrix;
|
||||||
}
|
}
|
||||||
|
@ -121,7 +121,7 @@ public:
|
|||||||
ray_dir = nlook + delta_x * ((2.f * vtkm::Float32(i) - vtkm::Float32(w)) / 2.0f) +
|
ray_dir = nlook + delta_x * ((2.f * vtkm::Float32(i) - vtkm::Float32(w)) / 2.0f) +
|
||||||
delta_y * ((2.f * vtkm::Float32(j) - vtkm::Float32(h)) / 2.0f);
|
delta_y * ((2.f * vtkm::Float32(j) - vtkm::Float32(h)) / 2.0f);
|
||||||
|
|
||||||
vtkm::Float32 dot = vtkm::dot(ray_dir, ray_dir);
|
vtkm::Float32 dot = vtkm::Dot(ray_dir, ray_dir);
|
||||||
vtkm::Float32 sq_mag = vtkm::Sqrt(dot);
|
vtkm::Float32 sq_mag = vtkm::Sqrt(dot);
|
||||||
|
|
||||||
ray_dir[0] = ray_dir[0] / sq_mag;
|
ray_dir[0] = ray_dir[0] / sq_mag;
|
||||||
@ -338,7 +338,7 @@ public:
|
|||||||
if (ray_dir[d] == 0.f)
|
if (ray_dir[d] == 0.f)
|
||||||
ray_dir[d] += 0.0000001f;
|
ray_dir[d] += 0.0000001f;
|
||||||
}
|
}
|
||||||
Precision dot = vtkm::dot(ray_dir, ray_dir);
|
Precision dot = vtkm::Dot(ray_dir, ray_dir);
|
||||||
Precision sq_mag = vtkm::Sqrt(dot);
|
Precision sq_mag = vtkm::Sqrt(dot);
|
||||||
|
|
||||||
rayDirX = ray_dir[0] / sq_mag;
|
rayDirX = ray_dir[0] / sq_mag;
|
||||||
@ -1064,7 +1064,7 @@ void Camera::CreateDebugRayImp(vtkm::Vec<vtkm::Int32, 2> pixel, Ray<Precision>&
|
|||||||
ray_dir = nlook + delta_x * ((2.f * Precision(i) - Precision(this->Width)) / 2.0f) +
|
ray_dir = nlook + delta_x * ((2.f * Precision(i) - Precision(this->Width)) / 2.0f) +
|
||||||
delta_y * ((2.f * Precision(j) - Precision(this->Height)) / 2.0f);
|
delta_y * ((2.f * Precision(j) - Precision(this->Height)) / 2.0f);
|
||||||
|
|
||||||
Precision dot = vtkm::dot(ray_dir, ray_dir);
|
Precision dot = vtkm::Dot(ray_dir, ray_dir);
|
||||||
Precision sq_mag = vtkm::Sqrt(dot);
|
Precision sq_mag = vtkm::Sqrt(dot);
|
||||||
|
|
||||||
ray_dir[0] = ray_dir[0] / sq_mag;
|
ray_dir[0] = ray_dir[0] / sq_mag;
|
||||||
|
@ -279,7 +279,7 @@ public:
|
|||||||
vtkm::UInt32& mortonCode) const
|
vtkm::UInt32& mortonCode) const
|
||||||
{
|
{
|
||||||
vtkm::Vec<vtkm::Float32, 3> direction(xmax - xmin, ymax - ymin, zmax - zmin);
|
vtkm::Vec<vtkm::Float32, 3> direction(xmax - xmin, ymax - ymin, zmax - zmin);
|
||||||
vtkm::Float32 halfDistance = sqrtf(vtkm::dot(direction, direction)) * 0.5f;
|
vtkm::Float32 halfDistance = sqrtf(vtkm::Dot(direction, direction)) * 0.5f;
|
||||||
vtkm::Normalize(direction);
|
vtkm::Normalize(direction);
|
||||||
vtkm::Float32 centroidx = xmin + halfDistance * direction[0] - MinCoordinate[0];
|
vtkm::Float32 centroidx = xmin + halfDistance * direction[0] - MinCoordinate[0];
|
||||||
vtkm::Float32 centroidy = ymin + halfDistance * direction[1] - MinCoordinate[1];
|
vtkm::Float32 centroidy = ymin + halfDistance * direction[1] - MinCoordinate[1];
|
||||||
|
@ -122,7 +122,7 @@ public:
|
|||||||
vtkm::Normalize(normal);
|
vtkm::Normalize(normal);
|
||||||
|
|
||||||
//flip the normal if its pointing the wrong way
|
//flip the normal if its pointing the wrong way
|
||||||
if (vtkm::dot(normal, rayDir) > 0.f)
|
if (vtkm::Dot(normal, rayDir) > 0.f)
|
||||||
normal = -normal;
|
normal = -normal;
|
||||||
normalX = normal[0];
|
normalX = normal[0];
|
||||||
normalY = normal[1];
|
normalY = normal[1];
|
||||||
@ -338,15 +338,15 @@ public:
|
|||||||
vtkm::Normalize(lightDir);
|
vtkm::Normalize(lightDir);
|
||||||
vtkm::Normalize(viewDir);
|
vtkm::Normalize(viewDir);
|
||||||
//Diffuse lighting
|
//Diffuse lighting
|
||||||
Precision cosTheta = vtkm::dot(normal, lightDir);
|
Precision cosTheta = vtkm::Dot(normal, lightDir);
|
||||||
//clamp tp [0,1]
|
//clamp tp [0,1]
|
||||||
const Precision zero = 0.f;
|
const Precision zero = 0.f;
|
||||||
const Precision one = 1.f;
|
const Precision one = 1.f;
|
||||||
cosTheta = vtkm::Min(vtkm::Max(cosTheta, zero), one);
|
cosTheta = vtkm::Min(vtkm::Max(cosTheta, zero), one);
|
||||||
//Specular lighting
|
//Specular lighting
|
||||||
vtkm::Vec<Precision, 3> reflect = 2.f * vtkm::dot(lightDir, normal) * normal - lightDir;
|
vtkm::Vec<Precision, 3> reflect = 2.f * vtkm::Dot(lightDir, normal) * normal - lightDir;
|
||||||
vtkm::Normalize(reflect);
|
vtkm::Normalize(reflect);
|
||||||
Precision cosPhi = vtkm::dot(reflect, viewDir);
|
Precision cosPhi = vtkm::Dot(reflect, viewDir);
|
||||||
Precision specularConstant =
|
Precision specularConstant =
|
||||||
Precision(pow(vtkm::Max(cosPhi, zero), (Precision)SpecularExponent));
|
Precision(pow(vtkm::Max(cosPhi, zero), (Precision)SpecularExponent));
|
||||||
vtkm::Int32 colorIdx = vtkm::Int32(scalar * Precision(ColorMapSize - 1));
|
vtkm::Int32 colorIdx = vtkm::Int32(scalar * Precision(ColorMapSize - 1));
|
||||||
|
@ -145,7 +145,7 @@ struct MatrixTest
|
|||||||
{
|
{
|
||||||
vtkm::Vec<T, NUM_COLS> leftVector = vtkm::MatrixGetRow(leftFactor, row);
|
vtkm::Vec<T, NUM_COLS> leftVector = vtkm::MatrixGetRow(leftFactor, row);
|
||||||
vtkm::Vec<T, NUM_COLS> rightVector = vtkm::MatrixGetColumn(rightFactor, col);
|
vtkm::Vec<T, NUM_COLS> rightVector = vtkm::MatrixGetColumn(rightFactor, col);
|
||||||
VTKM_TEST_ASSERT(test_equal(product(row, col), vtkm::dot(leftVector, rightVector)),
|
VTKM_TEST_ASSERT(test_equal(product(row, col), vtkm::Dot(leftVector, rightVector)),
|
||||||
"Matrix multiple wrong.");
|
"Matrix multiple wrong.");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -189,13 +189,13 @@ void GeneralVecCTypeTest(const vtkm::Vec<ComponentType, Size>&)
|
|||||||
div = aSrc / b;
|
div = aSrc / b;
|
||||||
VTKM_TEST_ASSERT(test_equal(div, correct_div), "Tuples not divided correctly.");
|
VTKM_TEST_ASSERT(test_equal(div, correct_div), "Tuples not divided correctly.");
|
||||||
|
|
||||||
ComponentType d = static_cast<ComponentType>(vtkm::dot(a, b));
|
ComponentType d = static_cast<ComponentType>(vtkm::Dot(a, b));
|
||||||
ComponentType correct_d = 0;
|
ComponentType correct_d = 0;
|
||||||
for (vtkm::IdComponent i = 0; i < Size; ++i)
|
for (vtkm::IdComponent i = 0; i < Size; ++i)
|
||||||
{
|
{
|
||||||
correct_d = ComponentType(correct_d + a[i] * b[i]);
|
correct_d = ComponentType(correct_d + a[i] * b[i]);
|
||||||
}
|
}
|
||||||
VTKM_TEST_ASSERT(test_equal(d, correct_d), "dot(Tuple) wrong");
|
VTKM_TEST_ASSERT(test_equal(d, correct_d), "Dot(Tuple) wrong");
|
||||||
|
|
||||||
VTKM_TEST_ASSERT(!(a < b), "operator< wrong");
|
VTKM_TEST_ASSERT(!(a < b), "operator< wrong");
|
||||||
VTKM_TEST_ASSERT((b < a), "operator< wrong");
|
VTKM_TEST_ASSERT((b < a), "operator< wrong");
|
||||||
@ -286,13 +286,13 @@ void GeneralVecCConstTypeTest(const vtkm::Vec<ComponentType, Size>&)
|
|||||||
div = aSrc / b;
|
div = aSrc / b;
|
||||||
VTKM_TEST_ASSERT(test_equal(div, correct_div), "Tuples not divided correctly.");
|
VTKM_TEST_ASSERT(test_equal(div, correct_div), "Tuples not divided correctly.");
|
||||||
|
|
||||||
ComponentType d = static_cast<ComponentType>(vtkm::dot(a, b));
|
ComponentType d = static_cast<ComponentType>(vtkm::Dot(a, b));
|
||||||
ComponentType correct_d = 0;
|
ComponentType correct_d = 0;
|
||||||
for (vtkm::IdComponent i = 0; i < Size; ++i)
|
for (vtkm::IdComponent i = 0; i < Size; ++i)
|
||||||
{
|
{
|
||||||
correct_d = ComponentType(correct_d + a[i] * b[i]);
|
correct_d = ComponentType(correct_d + a[i] * b[i]);
|
||||||
}
|
}
|
||||||
VTKM_TEST_ASSERT(test_equal(d, correct_d), "dot(Tuple) wrong");
|
VTKM_TEST_ASSERT(test_equal(d, correct_d), "Dot(Tuple) wrong");
|
||||||
|
|
||||||
VTKM_TEST_ASSERT(!(a < b), "operator< wrong");
|
VTKM_TEST_ASSERT(!(a < b), "operator< wrong");
|
||||||
VTKM_TEST_ASSERT((b < a), "operator< wrong");
|
VTKM_TEST_ASSERT((b < a), "operator< wrong");
|
||||||
@ -403,13 +403,13 @@ void GeneralVecTypeTest(const vtkm::Vec<ComponentType, Size>&)
|
|||||||
div = a / ComponentType(2);
|
div = a / ComponentType(2);
|
||||||
VTKM_TEST_ASSERT(test_equal(div, b), "Tuple does not divide by Scalar correctly.");
|
VTKM_TEST_ASSERT(test_equal(div, b), "Tuple does not divide by Scalar correctly.");
|
||||||
|
|
||||||
ComponentType d = static_cast<ComponentType>(vtkm::dot(a, b));
|
ComponentType d = static_cast<ComponentType>(vtkm::Dot(a, b));
|
||||||
ComponentType correct_d = 0;
|
ComponentType correct_d = 0;
|
||||||
for (vtkm::IdComponent i = 0; i < T::NUM_COMPONENTS; ++i)
|
for (vtkm::IdComponent i = 0; i < T::NUM_COMPONENTS; ++i)
|
||||||
{
|
{
|
||||||
correct_d = ComponentType(correct_d + a[i] * b[i]);
|
correct_d = ComponentType(correct_d + a[i] * b[i]);
|
||||||
}
|
}
|
||||||
VTKM_TEST_ASSERT(test_equal(d, correct_d), "dot(Tuple) wrong");
|
VTKM_TEST_ASSERT(test_equal(d, correct_d), "Dot(Tuple) wrong");
|
||||||
|
|
||||||
VTKM_TEST_ASSERT(!(a < b), "operator< wrong");
|
VTKM_TEST_ASSERT(!(a < b), "operator< wrong");
|
||||||
VTKM_TEST_ASSERT((b < a), "operator< wrong");
|
VTKM_TEST_ASSERT((b < a), "operator< wrong");
|
||||||
@ -477,8 +477,8 @@ void TypeTest(const vtkm::Vec<Scalar, 2>&)
|
|||||||
VTKM_TEST_ASSERT(test_equal(div, vtkm::make_Vec(1, 2)),
|
VTKM_TEST_ASSERT(test_equal(div, vtkm::make_Vec(1, 2)),
|
||||||
"Vector does not divide by Scalar correctly.");
|
"Vector does not divide by Scalar correctly.");
|
||||||
|
|
||||||
Scalar d = static_cast<Scalar>(vtkm::dot(a, b));
|
Scalar d = static_cast<Scalar>(vtkm::Dot(a, b));
|
||||||
VTKM_TEST_ASSERT(test_equal(d, Scalar(10)), "dot(Vector2) wrong");
|
VTKM_TEST_ASSERT(test_equal(d, Scalar(10)), "Dot(Vector2) wrong");
|
||||||
|
|
||||||
VTKM_TEST_ASSERT(!(a < b), "operator< wrong");
|
VTKM_TEST_ASSERT(!(a < b), "operator< wrong");
|
||||||
VTKM_TEST_ASSERT((b < a), "operator< wrong");
|
VTKM_TEST_ASSERT((b < a), "operator< wrong");
|
||||||
@ -539,8 +539,8 @@ void TypeTest(const vtkm::Vec<Scalar, 3>&)
|
|||||||
div = a / Scalar(2);
|
div = a / Scalar(2);
|
||||||
VTKM_TEST_ASSERT(test_equal(div, b), "Vector does not divide by Scalar correctly.");
|
VTKM_TEST_ASSERT(test_equal(div, b), "Vector does not divide by Scalar correctly.");
|
||||||
|
|
||||||
Scalar d = static_cast<Scalar>(vtkm::dot(a, b));
|
Scalar d = static_cast<Scalar>(vtkm::Dot(a, b));
|
||||||
VTKM_TEST_ASSERT(test_equal(d, Scalar(28)), "dot(Vector3) wrong");
|
VTKM_TEST_ASSERT(test_equal(d, Scalar(28)), "Dot(Vector3) wrong");
|
||||||
|
|
||||||
VTKM_TEST_ASSERT(!(a < b), "operator< wrong");
|
VTKM_TEST_ASSERT(!(a < b), "operator< wrong");
|
||||||
VTKM_TEST_ASSERT((b < a), "operator< wrong");
|
VTKM_TEST_ASSERT((b < a), "operator< wrong");
|
||||||
@ -601,8 +601,8 @@ void TypeTest(const vtkm::Vec<Scalar, 4>&)
|
|||||||
div = a / Scalar(2);
|
div = a / Scalar(2);
|
||||||
VTKM_TEST_ASSERT(test_equal(div, b), "Vector does not divide by Scalar correctly.");
|
VTKM_TEST_ASSERT(test_equal(div, b), "Vector does not divide by Scalar correctly.");
|
||||||
|
|
||||||
Scalar d = static_cast<Scalar>(vtkm::dot(a, b));
|
Scalar d = static_cast<Scalar>(vtkm::Dot(a, b));
|
||||||
VTKM_TEST_ASSERT(test_equal(d, Scalar(60)), "dot(Vector4) wrong");
|
VTKM_TEST_ASSERT(test_equal(d, Scalar(60)), "Dot(Vector4) wrong");
|
||||||
|
|
||||||
VTKM_TEST_ASSERT(!(a < b), "operator< wrong");
|
VTKM_TEST_ASSERT(!(a < b), "operator< wrong");
|
||||||
VTKM_TEST_ASSERT((b < a), "operator< wrong");
|
VTKM_TEST_ASSERT((b < a), "operator< wrong");
|
||||||
@ -668,20 +668,20 @@ void TypeTest(Scalar)
|
|||||||
VTKM_TEST_FAIL("operator!= wrong");
|
VTKM_TEST_FAIL("operator!= wrong");
|
||||||
}
|
}
|
||||||
|
|
||||||
if (vtkm::dot(a, b) != 8)
|
if (vtkm::Dot(a, b) != 8)
|
||||||
{
|
{
|
||||||
VTKM_TEST_FAIL("dot(Scalar) wrong");
|
VTKM_TEST_FAIL("Dot(Scalar) wrong");
|
||||||
}
|
}
|
||||||
|
|
||||||
//verify we don't roll over
|
//verify we don't roll over
|
||||||
Scalar c = 128;
|
Scalar c = 128;
|
||||||
Scalar d = 32;
|
Scalar d = 32;
|
||||||
auto r = vtkm::dot(c, d);
|
auto r = vtkm::Dot(c, d);
|
||||||
VTKM_TEST_ASSERT((sizeof(r) >= sizeof(int)),
|
VTKM_TEST_ASSERT((sizeof(r) >= sizeof(int)),
|
||||||
"dot(Scalar) didn't promote smaller than 32bit types");
|
"Dot(Scalar) didn't promote smaller than 32bit types");
|
||||||
if (r != 4096)
|
if (r != 4096)
|
||||||
{
|
{
|
||||||
VTKM_TEST_FAIL("dot(Scalar) wrong");
|
VTKM_TEST_FAIL("Dot(Scalar) wrong");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -134,8 +134,8 @@ void TestCross(const vtkm::Vec<T, 3>& x, const vtkm::Vec<T, 3>& y)
|
|||||||
|
|
||||||
std::cout << " Orthogonality" << std::endl;
|
std::cout << " Orthogonality" << std::endl;
|
||||||
// The cross product result should be perpendicular to input vectors.
|
// The cross product result should be perpendicular to input vectors.
|
||||||
VTKM_TEST_ASSERT(test_equal(vtkm::dot(cross, x), T(0.0)), "Cross product not perpendicular.");
|
VTKM_TEST_ASSERT(test_equal(vtkm::Dot(cross, x), T(0.0)), "Cross product not perpendicular.");
|
||||||
VTKM_TEST_ASSERT(test_equal(vtkm::dot(cross, y), T(0.0)), "Cross product not perpendicular.");
|
VTKM_TEST_ASSERT(test_equal(vtkm::Dot(cross, y), T(0.0)), "Cross product not perpendicular.");
|
||||||
|
|
||||||
std::cout << " Length" << std::endl;
|
std::cout << " Length" << std::endl;
|
||||||
// The length of cross product should be the lengths of the input vectors
|
// The length of cross product should be the lengths of the input vectors
|
||||||
@ -144,7 +144,7 @@ void TestCross(const vtkm::Vec<T, 3>& x, const vtkm::Vec<T, 3>& y)
|
|||||||
|
|
||||||
// The dot product is likewise the lengths of the input vectors times the
|
// The dot product is likewise the lengths of the input vectors times the
|
||||||
// cos of the angle between them.
|
// cos of the angle between them.
|
||||||
T cosAngle = vtkm::dot(x, y) * vtkm::RMagnitude(x) * vtkm::RMagnitude(y);
|
T cosAngle = vtkm::Dot(x, y) * vtkm::RMagnitude(x) * vtkm::RMagnitude(y);
|
||||||
|
|
||||||
// Test that these are the actual sin and cos of the same angle with a
|
// Test that these are the actual sin and cos of the same angle with a
|
||||||
// basic trigonometric identity.
|
// basic trigonometric identity.
|
||||||
@ -154,7 +154,7 @@ void TestCross(const vtkm::Vec<T, 3>& x, const vtkm::Vec<T, 3>& y)
|
|||||||
std::cout << " Triangle normal" << std::endl;
|
std::cout << " Triangle normal" << std::endl;
|
||||||
// Test finding the normal to a triangle (similar to cross product).
|
// Test finding the normal to a triangle (similar to cross product).
|
||||||
Vec3 normal = vtkm::TriangleNormal(x, y, Vec3(0, 0, 0));
|
Vec3 normal = vtkm::TriangleNormal(x, y, Vec3(0, 0, 0));
|
||||||
VTKM_TEST_ASSERT(test_equal(vtkm::dot(normal, x - y), T(0.0)),
|
VTKM_TEST_ASSERT(test_equal(vtkm::Dot(normal, x - y), T(0.0)),
|
||||||
"Triangle normal is not really normal.");
|
"Triangle normal is not really normal.");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -148,7 +148,7 @@ static void TestVecTypeImpl(const typename std::remove_const<T>::type& inVector,
|
|||||||
VTKM_TEST_ASSERT(test_equal(vectorCopy, inVector), "CopyInto does not work.");
|
VTKM_TEST_ASSERT(test_equal(vectorCopy, inVector), "CopyInto does not work.");
|
||||||
|
|
||||||
{
|
{
|
||||||
auto expected = vtkm::dot(vectorCopy, vectorCopy);
|
auto expected = vtkm::Dot(vectorCopy, vectorCopy);
|
||||||
decltype(expected) result = 0;
|
decltype(expected) result = 0;
|
||||||
for (vtkm::IdComponent i = 0; i < NUM_COMPONENTS; i++)
|
for (vtkm::IdComponent i = 0; i < NUM_COMPONENTS; i++)
|
||||||
{
|
{
|
||||||
|
@ -40,7 +40,7 @@ public:
|
|||||||
const vtkm::Vec<T, Size>& v2,
|
const vtkm::Vec<T, Size>& v2,
|
||||||
T& outValue) const
|
T& outValue) const
|
||||||
{
|
{
|
||||||
outValue = vtkm::dot(v1, v2);
|
outValue = vtkm::Dot(v1, v2);
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
@ -340,7 +340,7 @@ struct KernelSplatterFilterUniformGrid
|
|||||||
PointType dist = vtkm::make_Vec((splatPoint[0] - voxel[0]) * spacing_[0],
|
PointType dist = vtkm::make_Vec((splatPoint[0] - voxel[0]) * spacing_[0],
|
||||||
(splatPoint[1] - voxel[1]) * spacing_[0],
|
(splatPoint[1] - voxel[1]) * spacing_[0],
|
||||||
(splatPoint[2] - voxel[2]) * spacing_[0]);
|
(splatPoint[2] - voxel[2]) * spacing_[0]);
|
||||||
vtkm::Float64 dist2 = vtkm::dot(dist, dist);
|
vtkm::Float64 dist2 = vtkm::Dot(dist, dist);
|
||||||
|
|
||||||
// Compute splat value using the kernel distance_squared function
|
// Compute splat value using the kernel distance_squared function
|
||||||
splatValue = scale * kernel.w2(kernel_H, dist2);
|
splatValue = scale * kernel.w2(kernel_H, dist2);
|
||||||
|
@ -72,9 +72,9 @@ public:
|
|||||||
vtkm::Float64 operator()(const vtkm::Vec<vtkm::Float64, 3>& vec) const
|
vtkm::Float64 operator()(const vtkm::Vec<vtkm::Float64, 3>& vec) const
|
||||||
{
|
{
|
||||||
vtkm::Vec<vtkm::Float64, 3> direction = this->HighPoint - this->LowPoint;
|
vtkm::Vec<vtkm::Float64, 3> direction = this->HighPoint - this->LowPoint;
|
||||||
vtkm::Float64 lengthSqr = vtkm::dot(direction, direction);
|
vtkm::Float64 lengthSqr = vtkm::Dot(direction, direction);
|
||||||
vtkm::Float64 rangeLength = this->RangeHigh - this->RangeLow;
|
vtkm::Float64 rangeLength = this->RangeHigh - this->RangeLow;
|
||||||
vtkm::Float64 s = vtkm::dot(vec - this->LowPoint, direction) / lengthSqr;
|
vtkm::Float64 s = vtkm::Dot(vec - this->LowPoint, direction) / lengthSqr;
|
||||||
s = internal::clamp(s, 0.0, 1.0);
|
s = internal::clamp(s, 0.0, 1.0);
|
||||||
return this->RangeLow + (s * rangeLength);
|
return this->RangeLow + (s * rangeLength);
|
||||||
}
|
}
|
||||||
|
@ -146,7 +146,7 @@ void TestCellGradientUniform3DWithVectorField()
|
|||||||
|
|
||||||
//compute QCriterion
|
//compute QCriterion
|
||||||
vtkm::Float64 qcriterion =
|
vtkm::Float64 qcriterion =
|
||||||
((vtkm::dot(v, v) / 2.0f) - (vtkm::dot(d, d) + (vtkm::dot(s, s) / 2.0f))) / 2.0f;
|
((vtkm::Dot(v, v) / 2.0f) - (vtkm::Dot(d, d) + (vtkm::Dot(s, s) / 2.0f))) / 2.0f;
|
||||||
|
|
||||||
vtkm::Float64 q = extraOutput.QCriterion.GetPortalConstControl().Get(i);
|
vtkm::Float64 q = extraOutput.QCriterion.GetPortalConstControl().Get(i);
|
||||||
|
|
||||||
|
@ -106,11 +106,11 @@ void TestCrossProduct()
|
|||||||
|
|
||||||
//Make sure result is orthogonal each input vector. Need to normalize to compare with zero.
|
//Make sure result is orthogonal each input vector. Need to normalize to compare with zero.
|
||||||
vtkm::Vec<T, 3> v1N(vtkm::Normal(v1)), v2N(vtkm::Normal(v1)), resN(vtkm::Normal(res));
|
vtkm::Vec<T, 3> v1N(vtkm::Normal(v1)), v2N(vtkm::Normal(v1)), resN(vtkm::Normal(res));
|
||||||
VTKM_TEST_ASSERT(test_equal(vtkm::dot(resN, v1N), T(0.0)), "Wrong result for cross product");
|
VTKM_TEST_ASSERT(test_equal(vtkm::Dot(resN, v1N), T(0.0)), "Wrong result for cross product");
|
||||||
VTKM_TEST_ASSERT(test_equal(vtkm::dot(resN, v2N), T(0.0)), "Wrong result for cross product");
|
VTKM_TEST_ASSERT(test_equal(vtkm::Dot(resN, v2N), T(0.0)), "Wrong result for cross product");
|
||||||
|
|
||||||
T sinAngle = vtkm::Magnitude(res) * vtkm::RMagnitude(v1) * vtkm::RMagnitude(v2);
|
T sinAngle = vtkm::Magnitude(res) * vtkm::RMagnitude(v1) * vtkm::RMagnitude(v2);
|
||||||
T cosAngle = vtkm::dot(v1, v2) * vtkm::RMagnitude(v1) * vtkm::RMagnitude(v2);
|
T cosAngle = vtkm::Dot(v1, v2) * vtkm::RMagnitude(v1) * vtkm::RMagnitude(v2);
|
||||||
VTKM_TEST_ASSERT(test_equal(sinAngle * sinAngle + cosAngle * cosAngle, T(1.0)),
|
VTKM_TEST_ASSERT(test_equal(sinAngle * sinAngle + cosAngle * cosAngle, T(1.0)),
|
||||||
"Bad cross product length.");
|
"Bad cross product length.");
|
||||||
}
|
}
|
||||||
|
@ -97,7 +97,7 @@ void TestDotProduct()
|
|||||||
vtkm::Vec<T, 3> v2 = inputArray2.GetPortalConstControl().Get(i);
|
vtkm::Vec<T, 3> v2 = inputArray2.GetPortalConstControl().Get(i);
|
||||||
T ans = answer[static_cast<std::size_t>(i)];
|
T ans = answer[static_cast<std::size_t>(i)];
|
||||||
|
|
||||||
VTKM_TEST_ASSERT(test_equal(ans, vtkm::dot(v1, v2)), "Wrong result for dot product");
|
VTKM_TEST_ASSERT(test_equal(ans, vtkm::Dot(v1, v2)), "Wrong result for dot product");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -190,7 +190,7 @@ void TestPointGradientUniform3DWithVectorField2()
|
|||||||
|
|
||||||
//compute QCriterion
|
//compute QCriterion
|
||||||
vtkm::Float64 qcriterion =
|
vtkm::Float64 qcriterion =
|
||||||
((vtkm::dot(ev, ev) / 2.0f) - (vtkm::dot(ed, ed) + (vtkm::dot(es, es) / 2.0f))) / 2.0f;
|
((vtkm::Dot(ev, ev) / 2.0f) - (vtkm::Dot(ed, ed) + (vtkm::Dot(es, es) / 2.0f))) / 2.0f;
|
||||||
|
|
||||||
vtkm::Float64 q = extraOutput.QCriterion.GetPortalConstControl().Get(i);
|
vtkm::Float64 q = extraOutput.QCriterion.GetPortalConstControl().Get(i);
|
||||||
|
|
||||||
|
@ -33,7 +33,7 @@ namespace
|
|||||||
template <typename T>
|
template <typename T>
|
||||||
VTKM_EXEC_CONT vtkm::Vec<T, 3> Normalize(vtkm::Vec<T, 3> v)
|
VTKM_EXEC_CONT vtkm::Vec<T, 3> Normalize(vtkm::Vec<T, 3> v)
|
||||||
{
|
{
|
||||||
T magnitude = static_cast<T>(sqrt(vtkm::dot(v, v)));
|
T magnitude = static_cast<T>(sqrt(vtkm::Dot(v, v)));
|
||||||
T zero = static_cast<T>(0.0);
|
T zero = static_cast<T>(0.0);
|
||||||
T one = static_cast<T>(1.0);
|
T one = static_cast<T>(1.0);
|
||||||
if (magnitude == zero)
|
if (magnitude == zero)
|
||||||
|
Loading…
Reference in New Issue
Block a user