Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-20 11:05:44 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity
6ea55f838b
vtk-m/vtkm/worklet/SplitSharpEdges.h
Kenneth Moreland 2e426ad547 Run the update-control-signature-tags.sh script
2019-01-11 12:23:10 -07:00

566 lines
24 KiB
C++
Raw Blame History

//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//
// Copyright 2017 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
// Copyright 2017 UT-Battelle, LLC.
// Copyright 2017 Los Alamos National Security.
//
// Under the terms of Contract DE-NA0003525 with NTESS,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_worklet_SplitSharpEdges_h
#define vtk_m_worklet_SplitSharpEdges_h
#include <map>
#include <vtkm/worklet/CellDeepCopy.h>
#include <vtkm/worklet/DispatcherMapTopology.h>
#include <vtkm/worklet/WorkletMapTopology.h>
#include <vtkm/Bitset.h>
#include <vtkm/CellTraits.h>
#include <vtkm/TypeTraits.h>
#include <vtkm/VectorAnalysis.h>
#include <vtkm/cont/Algorithm.h>
#include <vtkm/cont/ArrayCopy.h>
#include <vtkm/cont/ArrayHandlePermutation.h>
#include <vtkm/exec/CellEdge.h>
namespace vtkm
{
namespace worklet
{
namespace internal
{
// Given a cell and a point on the cell, find the two edges that are
// associated with this point in canonical index
template <typename PointFromCellSetType>
VTKM_EXEC void FindRelatedEdges(const vtkm::Id& pointIndex,
const vtkm::Id& cellIndexG,
const PointFromCellSetType& pFromCellSet,
vtkm::Id2& edge0G,
vtkm::Id2& edge1G,
const vtkm::exec::FunctorBase& worklet)
{
typename PointFromCellSetType::CellShapeTag cellShape = pFromCellSet.GetCellShape(cellIndexG);
typename PointFromCellSetType::IndicesType cellConnections = pFromCellSet.GetIndices(cellIndexG);
vtkm::IdComponent numPointsInCell = pFromCellSet.GetNumberOfIndices(cellIndexG);
vtkm::IdComponent numEdges =
vtkm::exec::CellEdgeNumberOfEdges(numPointsInCell, cellShape, worklet);
vtkm::IdComponent edgeIndex = -1;
// Find the two edges with the pointIndex
while (true)
{
++edgeIndex;
if (edgeIndex >= numEdges)
{
worklet.RaiseError("Bad cell. Could not find two incident edges.");
return;
}
vtkm::Id2 canonicalEdgeId(cellConnections[vtkm::exec::CellEdgeLocalIndex(
numPointsInCell, 0, edgeIndex, cellShape, worklet)],
cellConnections[vtkm::exec::CellEdgeLocalIndex(
numPointsInCell, 1, edgeIndex, cellShape, worklet)]);
if (canonicalEdgeId[0] == pointIndex || canonicalEdgeId[1] == pointIndex)
{ // Assign value to edge0 first
if ((edge0G[0] == -1) && (edge0G[1] == -1))
{
edge0G = canonicalEdgeId;
}
else
{
edge1G = canonicalEdgeId;
break;
}
}
}
}
// TODO: We should replace this expensive lookup with a WholeCellSetIn<Edge, Cell> map.
// Given an edge on a cell, it would find the neighboring
// cell of this edge in local index. If it's a non manifold edge, -1 would be returned.
template <typename PointFromCellSetType, typename IncidentCellVecType>
VTKM_EXEC int FindNeighborCellInLocalIndex(const vtkm::Id2& eOI,
const PointFromCellSetType& pFromCellSet,
const IncidentCellVecType& incidentCells,
const vtkm::Id currentCellLocalIndex,
const vtkm::exec::FunctorBase& worklet)
{
int neighboringCellIndex = -1;
vtkm::IdComponent numberOfIncidentCells = incidentCells.GetNumberOfComponents();
size_t neighboringCellsCount = 0;
for (vtkm::IdComponent incidentCellIndex = 0; incidentCellIndex < numberOfIncidentCells;
incidentCellIndex++)
{
if (currentCellLocalIndex == incidentCellIndex)
{
continue; // No need to check the current interested cell
}
vtkm::Id cellIndexG = incidentCells[incidentCellIndex]; // Global cell index
typename PointFromCellSetType::CellShapeTag cellShape = pFromCellSet.GetCellShape(cellIndexG);
typename PointFromCellSetType::IndicesType cellConnections =
pFromCellSet.GetIndices(cellIndexG);
vtkm::IdComponent numPointsInCell = pFromCellSet.GetNumberOfIndices(cellIndexG);
vtkm::IdComponent numEdges =
vtkm::exec::CellEdgeNumberOfEdges(numPointsInCell, cellShape, worklet);
vtkm::IdComponent edgeIndex = -1;
// Check if this cell has edge of interest
while (true)
{
++edgeIndex;
if (edgeIndex >= numEdges)
{
break;
}
vtkm::Id2 canonicalEdgeId(cellConnections[vtkm::exec::CellEdgeLocalIndex(
numPointsInCell, 0, edgeIndex, cellShape, worklet)],
cellConnections[vtkm::exec::CellEdgeLocalIndex(
numPointsInCell, 1, edgeIndex, cellShape, worklet)]);
if ((canonicalEdgeId[0] == eOI[0] && canonicalEdgeId[1] == eOI[1]) ||
(canonicalEdgeId[0] == eOI[1] && canonicalEdgeId[1] == eOI[0]))
{
neighboringCellIndex = incidentCellIndex;
neighboringCellsCount++;
break;
}
}
}
return neighboringCellIndex;
}
} // internal namespace
// Split sharp manifold edges where the feature angle between the
// adjacent surfaces are larger than the threshold value
class SplitSharpEdges
{
public:
// This worklet would calculate the needed space for splitting sharp edges.
// For each point, it would have two values as numberOfNewPoint(how many
// times this point needs to be duplicated) and numberOfCellsNeedsUpdate
// (how many neighboring cells need to update connectivity).
// For example, Given a unit cube and feature angle
// as 89 degree, each point would be duplicated twice and there are two cells
// need connectivity update. There is no guarantee on which cell would get which
// new point.
class ClassifyPoint : public vtkm::worklet::WorkletMapCellToPoint
{
public:
ClassifyPoint(vtkm::FloatDefault cosfeatureAngle)
: CosFeatureAngle(cosfeatureAngle)
{
}
using ControlSignature = void(CellSetIn intputCells,
WholeCellSetIn<Point, Cell>, // Query points from cell
FieldInCell faceNormals,
FieldOutPoint newPointNum,
FieldOutPoint cellNum);
using ExecutionSignature = void(CellIndices incidentCells,
InputIndex pointIndex,
_2 pFromCellSet,
_3 faceNormals,
_4 newPointNum,
_5 cellNum);
using InputDomain = _1;
template <typename IncidentCellVecType,
typename PointFromCellSetType,
typename FaceNormalVecType>
VTKM_EXEC void operator()(const IncidentCellVecType& incidentCells,
vtkm::Id pointIndex,
const PointFromCellSetType& pFromCellSet,
const FaceNormalVecType& faceNormals,
vtkm::Id& newPointNum,
vtkm::Id& cellNum) const
{
vtkm::IdComponent numberOfIncidentCells = incidentCells.GetNumberOfComponents();
VTKM_ASSERT(numberOfIncidentCells < 64);
if (numberOfIncidentCells <= 1)
{
return; // Not enought cells to compare
}
// Initialize a global cell mask to avoid confusion. globalCellIndex->status
// 0 means not visited yet 1 means visited.
vtkm::Bitset<vtkm::UInt64> visitedCells;
vtkm::Id visitedCellsRegionIndex[64] = { 0 };
// Reallocate memory for visitedCellsGroup if needed
int regionIndex = 0;
// Loop through each cell
for (vtkm::IdComponent incidentCellIndex = 0; incidentCellIndex < numberOfIncidentCells;
incidentCellIndex++)
{
vtkm::Id cellIndexG = incidentCells[incidentCellIndex]; // cell index in global order
// If not visited
if (!visitedCells.test(incidentCellIndex))
{
// Mark the cell and track the region
visitedCells.set(incidentCellIndex);
visitedCellsRegionIndex[incidentCellIndex] = regionIndex;
// Find two edges containing the current point in canonial index
vtkm::Id2 edge0G(-1, -1), edge1G(-1, -1);
internal::FindRelatedEdges(pointIndex, cellIndexG, pFromCellSet, edge0G, edge1G, *this);
// Grow the area along each edge
for (size_t i = 0; i < 2; i++)
{ // Reset these two values for each grow operation
vtkm::Id2 currentEdgeG = i == 0 ? edge0G : edge1G;
vtkm::IdComponent currentTestingCellIndex = incidentCellIndex;
while (currentTestingCellIndex >= 0)
{
// Find the neighbor cell of the current cell edge in local index
int neighboringCellIndexQuery = internal::FindNeighborCellInLocalIndex(
currentEdgeG, pFromCellSet, incidentCells, currentTestingCellIndex, *this);
// The edge should be manifold and the neighboring cell should
// have not been visited
if (neighboringCellIndexQuery != -1 && !visitedCells.test(neighboringCellIndexQuery))
{
vtkm::IdComponent neighborCellIndex =
static_cast<vtkm::IdComponent>(neighboringCellIndexQuery);
auto thisNormal = faceNormals[currentTestingCellIndex];
//neighborNormal
auto neighborNormal = faceNormals[neighborCellIndex];
// Try to grow the area
if (vtkm::dot(thisNormal, neighborNormal) > this->CosFeatureAngle)
{ // No need to split.
visitedCells.set(neighborCellIndex);
visitedCellsRegionIndex[neighborCellIndex] = regionIndex;
// Move to examine next cell
currentTestingCellIndex = neighborCellIndex;
vtkm::Id2 neighborCellEdge0G(-1, -1), neighborCellEdge1G(-1, -1);
internal::FindRelatedEdges(pointIndex,
incidentCells[currentTestingCellIndex],
pFromCellSet,
neighborCellEdge0G,
neighborCellEdge1G,
*this);
// Update currentEdgeG
if ((currentEdgeG == neighborCellEdge0G) ||
currentEdgeG == vtkm::Id2(neighborCellEdge0G[1], neighborCellEdge0G[0]))
{
currentEdgeG = neighborCellEdge1G;
}
else
{
currentEdgeG = neighborCellEdge0G;
}
}
else
{
currentTestingCellIndex = -1;
}
}
else
{
currentTestingCellIndex =
-1; // Either seperated by previous visit, boundary or non-manifold
}
// cells is smaller than the thresold and the nighboring cell has not been visited
}
}
regionIndex++;
}
}
// For each new region you need a new point
newPointNum = regionIndex - 1;
vtkm::Id numberOfCellsNeedUpdate = 0;
for (vtkm::IdComponent i = 0; i < numberOfIncidentCells; i++)
{
if (visitedCellsRegionIndex[i] > 0)
{
numberOfCellsNeedUpdate++;
}
}
cellNum = numberOfCellsNeedUpdate;
}
private:
vtkm::FloatDefault CosFeatureAngle; // Cos value of the feature angle
};
// This worklet split the sharp edges and populate the
// cellTopologyUpdateTuples as (cellGlobalId, oldPointId, newPointId).
class SplitSharpEdge : public vtkm::worklet::WorkletMapCellToPoint
{
public:
SplitSharpEdge(vtkm::FloatDefault cosfeatureAngle, vtkm::Id numberOfOldPoints)
: CosFeatureAngle(cosfeatureAngle)
, NumberOfOldPoints(numberOfOldPoints)
{
}
using ControlSignature = void(CellSetIn intputCells,
WholeCellSetIn<Point, Cell>, // Query points from cell
FieldInCell faceNormals,
FieldInPoint newPointStartingIndex,
FieldInPoint pointCellsStartingIndex,
WholeArrayOut cellTopologyUpdateTuples);
using ExecutionSignature = void(CellIndices incidentCells,
InputIndex pointIndex,
_2 pFromCellSet,
_3 faceNormals,
_4 newPointStartingIndex,
_5 pointCellsStartingIndex,
_6 cellTopologyUpdateTuples);
using InputDomain = _1;
template <typename IncidentCellVecType,
typename PointFromCellSetType,
typename FaceNormalVecType,
typename CellTopologyUpdateTuples>
VTKM_EXEC void operator()(const IncidentCellVecType& incidentCells,
vtkm::Id pointIndex,
const PointFromCellSetType& pFromCellSet,
const FaceNormalVecType& faceNormals,
const vtkm::Id& newPointStartingIndex,
const vtkm::Id& pointCellsStartingIndex,
CellTopologyUpdateTuples& cellTopologyUpdateTuples) const
{
vtkm::IdComponent numberOfIncidentCells = incidentCells.GetNumberOfComponents();
if (numberOfIncidentCells <= 1)
{
return; // Not enought cells to compare
}
// Initialize a global cell mask to avoid confusion. globalCellIndex->status
// 0 means not visited yet 1 means visited.
vtkm::Bitset<vtkm::UInt64> visitedCells;
vtkm::Id visitedCellsRegionIndex[64] = { 0 };
// Reallocate memory for visitedCellsGroup if needed
int regionIndex = 0;
// Loop through each cell
for (vtkm::IdComponent incidentCellIndex = 0; incidentCellIndex < numberOfIncidentCells;
incidentCellIndex++)
{
vtkm::Id cellIndexG = incidentCells[incidentCellIndex]; // cell index in global order
// If not visited
if (!visitedCells.test(incidentCellIndex))
{
// Mark the cell and track the region
visitedCells.set(incidentCellIndex);
visitedCellsRegionIndex[incidentCellIndex] = regionIndex;
// Find two edges containing the current point in canonial index
vtkm::Id2 edge0G(-1, -1), edge1G(-1, -1);
internal::FindRelatedEdges(pointIndex, cellIndexG, pFromCellSet, edge0G, edge1G, *this);
// Grow the area along each edge
for (size_t i = 0; i < 2; i++)
{ // Reset these two values for each grow operation
vtkm::Id2 currentEdgeG = i == 0 ? edge0G : edge1G;
vtkm::IdComponent currentTestingCellIndex = incidentCellIndex;
while (currentTestingCellIndex >= 0)
{
// Find the neighbor of the current cell edge in local index
int neighboringCellIndexQuery = internal::FindNeighborCellInLocalIndex(
currentEdgeG, pFromCellSet, incidentCells, currentTestingCellIndex, *this);
// The edge should be manifold and the neighboring cell should
// have not been visited
if (neighboringCellIndexQuery != -1 && !visitedCells.test(neighboringCellIndexQuery))
{
vtkm::IdComponent neighborCellIndex =
static_cast<vtkm::IdComponent>(neighboringCellIndexQuery);
// Try to grow the area if the feature angle between current neighbor
auto thisNormal = faceNormals[currentTestingCellIndex];
//neighborNormal
auto neighborNormal = faceNormals[neighborCellIndex];
if (vtkm::dot(thisNormal, neighborNormal) > this->CosFeatureAngle)
{ // No need to split.
visitedCells.set(neighborCellIndex);
// Move to examine next cell
currentTestingCellIndex = neighborCellIndex;
vtkm::Id2 neighborCellEdge0G(-1, -1), neighborCellEdge1G(-1, -1);
internal::FindRelatedEdges(pointIndex,
incidentCells[currentTestingCellIndex],
pFromCellSet,
neighborCellEdge0G,
neighborCellEdge1G,
*this);
// Update currentEdgeG
if ((currentEdgeG == neighborCellEdge0G) ||
currentEdgeG == vtkm::Id2(neighborCellEdge0G[1], neighborCellEdge0G[0]))
{
currentEdgeG = neighborCellEdge1G;
}
else
{
currentEdgeG = neighborCellEdge0G;
}
}
else
{
currentTestingCellIndex = -1;
}
}
else
{
currentTestingCellIndex =
-1; // Either seperated by previous visit, boundary or non-manifold
}
// cells is smaller than the thresold and the nighboring cell has not been visited
}
}
regionIndex++;
}
}
// For each new region you need a new point
// Initialize the offset in the global cellTopologyUpdateTuples;
vtkm::Id cellTopologyUpdateTuplesIndex = pointCellsStartingIndex;
for (vtkm::Id i = 0; i < numberOfIncidentCells; i++)
{
if (visitedCellsRegionIndex[i])
{ // New region generated. Need to update the topology
vtkm::Id replacementPointId =
NumberOfOldPoints + newPointStartingIndex + visitedCellsRegionIndex[i] - 1;
vtkm::Id globalCellId = incidentCells[static_cast<vtkm::IdComponent>(i)];
// (cellGlobalIndex, oldPointId, replacementPointId)
vtkm::Vec<vtkm::Id, 3> tuple =
vtkm::make_Vec(globalCellId, pointIndex, replacementPointId);
cellTopologyUpdateTuples.Set(cellTopologyUpdateTuplesIndex, tuple);
cellTopologyUpdateTuplesIndex++;
}
}
}
private:
vtkm::FloatDefault CosFeatureAngle; // Cos value of the feature angle
vtkm::Id NumberOfOldPoints;
};
template <typename CellSetType,
typename FaceNormalsType,
typename CoordsComType,
typename CoordsInStorageType,
typename CoordsOutStorageType,
typename NewCellSetType>
void Run(
const CellSetType& oldCellset,
const vtkm::FloatDefault featureAngle,
const FaceNormalsType& faceNormals,
const vtkm::cont::ArrayHandle<vtkm::Vec<CoordsComType, 3>, CoordsInStorageType>& oldCoords,
vtkm::cont::ArrayHandle<vtkm::Vec<CoordsComType, 3>, CoordsOutStorageType>& newCoords,
NewCellSetType& newCellset)
{
vtkm::FloatDefault featureAngleR =
featureAngle / static_cast<vtkm::FloatDefault>(180.0) * vtkm::Pi<vtkm::FloatDefault>();
ClassifyPoint classifyPoint(vtkm::Cos(featureAngleR));
vtkm::worklet::DispatcherMapTopology<ClassifyPoint> cpDispatcher(classifyPoint);
// Array of newPointNums and cellNeedUpdateNums
vtkm::cont::ArrayHandle<vtkm::Id> newPointNums, cellNeedUpdateNums;
cpDispatcher.Invoke(oldCellset, oldCellset, faceNormals, newPointNums, cellNeedUpdateNums);
vtkm::Id totalNewPointsNum =
vtkm::cont::Algorithm::Reduce(newPointNums, vtkm::Id(0), vtkm::Add());
// Allocate the size for the updateCellTopologyArray
vtkm::Id cellsNeedUpdateNum =
vtkm::cont::Algorithm::Reduce(cellNeedUpdateNums, vtkm::Id(0), vtkm::Add());
vtkm::cont::ArrayHandle<vtkm::Id3> cellTopologyUpdateTuples;
cellTopologyUpdateTuples.Allocate(cellsNeedUpdateNum);
vtkm::cont::ArrayHandle<vtkm::Id> newpointStartingIndexs, pointCellsStartingIndexs;
vtkm::cont::Algorithm::ScanExclusive(newPointNums, newpointStartingIndexs);
vtkm::cont::Algorithm::ScanExclusive(cellNeedUpdateNums, pointCellsStartingIndexs);
SplitSharpEdge splitSharpEdge(vtkm::Cos(featureAngleR), oldCoords.GetNumberOfValues());
vtkm::worklet::DispatcherMapTopology<SplitSharpEdge> sseDispatcher(splitSharpEdge);
sseDispatcher.Invoke(oldCellset,
oldCellset,
faceNormals,
newpointStartingIndexs,
pointCellsStartingIndexs,
cellTopologyUpdateTuples);
auto ctutPortal = cellTopologyUpdateTuples.GetPortalConstControl();
// Create the new point coordinate system and update NewPointsIdArray to
// process point field
this->NewPointsIdArray.Allocate(oldCoords.GetNumberOfValues() + totalNewPointsNum);
auto newPointsIdArrayPortal = this->NewPointsIdArray.GetPortalControl();
for (vtkm::Id i = 0; i < newPointNums.GetNumberOfValues(); i++)
{
newPointsIdArrayPortal.Set(i, i);
}
newCoords.Allocate(oldCoords.GetNumberOfValues() + totalNewPointsNum);
vtkm::cont::Algorithm::CopySubRange(oldCoords, 0, oldCoords.GetNumberOfValues(), newCoords);
vtkm::Id newCoordsIndex = oldCoords.GetNumberOfValues();
auto oldCoordsPortal = oldCoords.GetPortalConstControl();
auto newCoordsPortal = newCoords.GetPortalControl();
auto newPointNumsPortal = newPointNums.GetPortalControl();
for (vtkm::Id i = 0; i < newPointNums.GetNumberOfValues(); i++)
{ // Find out for each new point, how many times it should be added
for (vtkm::Id j = 0; j < newPointNumsPortal.Get(i); j++)
{
newPointsIdArrayPortal.Set(newCoordsIndex, i);
newCoordsPortal.Set(newCoordsIndex++, oldCoordsPortal.Get(i));
}
}
// Create the new cellset
CellDeepCopy::Run(oldCellset, newCellset);
// FIXME: Since the non const get array function is not in CellSetExplict.h,
// here I just get a non-const copy of the array handle.
auto connectivityArrayHandle = newCellset.GetConnectivityArray(vtkm::TopologyElementTagPoint(),
vtkm::TopologyElementTagCell());
auto connectivityArrayHandleP = connectivityArrayHandle.GetPortalControl();
auto offsetArrayHandle = newCellset.GetIndexOffsetArray(vtkm::TopologyElementTagPoint(),
vtkm::TopologyElementTagCell());
auto offsetArrayHandleP = offsetArrayHandle.GetPortalControl();
for (vtkm::Id i = 0; i < cellTopologyUpdateTuples.GetNumberOfValues(); i++)
{
vtkm::Id cellId(ctutPortal.Get(i)[0]), oldPointId(ctutPortal.Get(i)[1]),
newPointId(ctutPortal.Get(i)[2]);
vtkm::Id bound = (cellId + 1 == offsetArrayHandle.GetNumberOfValues())
? connectivityArrayHandle.GetNumberOfValues()
: offsetArrayHandleP.Get(cellId + 1);
vtkm::Id k = 0;
for (vtkm::Id j = offsetArrayHandleP.Get(cellId); j < bound; j++, k++)
{
if (connectivityArrayHandleP.Get(j) == oldPointId)
{
connectivityArrayHandleP.Set(j, newPointId);
}
}
}
}
template <typename ValueType, typename StorageTag>
vtkm::cont::ArrayHandle<ValueType> ProcessPointField(
const vtkm::cont::ArrayHandle<ValueType, StorageTag> in) const
{
// Use a temporary permutation array to simplify the mapping:
auto tmp = vtkm::cont::make_ArrayHandlePermutation(this->NewPointsIdArray, in);
// Copy into an array with default storage:
vtkm::cont::ArrayHandle<ValueType> result;
vtkm::cont::ArrayCopy(tmp, result);
return result;
}
private:
vtkm::cont::ArrayHandle<vtkm::Id> NewPointsIdArray;
};
}
} // vtkm::worklet
#endif // vtk_m_worklet_SplitSharpEdges_h
Reference in New Issue View Git Blame Copy Permalink