NEM::MSH::dataSetRegionBoundaryFilter Class Reference

Like vtkDataSetRegionSurfaceFilter, this filter extracts boundaries of materials, including both interfaces and external boundaries. More...

Detailed Description

Unlike vtkDataSetRegionSurfaceFilter, can extract boundary edges for 2d data sets.

Output edges/faces are represented once for interfaces, with the orientation chosen by the input cell with lower material number. If input is a vtkPointSet, output points are shallow copy; otherwise, input points are deep copy - in either case, all points are copied, even those unused in output. Output point data is shallow copy of input point data; input cell data is not copied. Unlike vtkDataSetRegionSurfaceFilter, point ordering should match the edge/face described in OrigCellArrayName and CellSideArrayName arrays.

Definition at line 58 of file dataSetRegionBoundaryFilter.H.

Public Member Functions
	vtkTypeMacro (dataSetRegionBoundaryFilter, vtkPolyDataAlgorithm) vtkSetClampMacro(Dimension
	If 2-D, finds edges; if 3-D, finds faces. More...
	vtkGetMacro (Dimension, int)
	vtkSetMacro (MaterialArrayName, const std::string &)
	Input material/region array name. More...
	vtkGetMacro (MaterialArrayName, const std::string &)
	vtkSetMacro (BoundaryRegionArrayName, const std::string &)
	Output region array name. More...
	vtkGetMacro (BoundaryRegionArrayName, const std::string &)
	vtkSetMacro (RegionToMaterialArrayName, const std::string &)
	Output region to material array name. More...
	vtkGetMacro (RegionToMaterialArrayName, const std::string &)
	vtkSetMacro (OrigCellArrayName, const std::string &)
	Output original cell id array name. More...
	vtkGetMacro (OrigCellArrayName, const std::string &)
	vtkSetMacro (CellSideArrayName, const std::string &)
	Output original cell edge/face id array name. More...
	vtkGetMacro (CellSideArrayName, const std::string &)

Static Public Member Functions
static dataSetRegionBoundaryFilter *	New ()

Public Attributes
	int

Protected Member Functions
	dataSetRegionBoundaryFilter ()=default
int	RequestData (vtkInformation *request, vtkInformationVector **inputVector, vtkInformationVector *outputVector) override
int	FillInputPortInformation (int port, vtkInformation *info) override

Protected Attributes
int	Dimension {3}
std::string	MaterialArrayName {"Material"}
std::string	RegionToMaterialArrayName {"RegionToMaterial"}
std::string	OrigCellArrayName {"OrigCellIds"}
std::string	CellSideArrayName {"CellFaceIds"}
std::string	BoundaryRegionArrayName {"Region"}

Inherits vtkPolyDataAlgorithm.

Constructor & Destructor Documentation

dataSetRegionBoundaryFilter()

NEM::MSH::dataSetRegionBoundaryFilter::dataSetRegionBoundaryFilter ( )

protecteddefault

Member Function Documentation

FillInputPortInformation()

int NEM::MSH::dataSetRegionBoundaryFilter::FillInputPortInformation ( int  port, vtkInformation *  info  )

overrideprotected

New()

static dataSetRegionBoundaryFilter* NEM::MSH::dataSetRegionBoundaryFilter::New ( )

static

RequestData()

int NEM::MSH::dataSetRegionBoundaryFilter::RequestData ( vtkInformation *  request, vtkInformationVector **  inputVector, vtkInformationVector *  outputVector  )

overrideprotected

Definition at line 254 of file dataSetRegionBoundaryFilter.C.

References BoundaryCellSet, NEM::MSH::New(), and points.

                                        {
  // get the info objects
  vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
  vtkInformation *outInfo = outputVector->GetInformationObject(0);

  // get the input and output
  auto input =
      vtkDataSet::SafeDownCast(inInfo->Get(vtkDataObject::DATA_OBJECT()));
  auto output =
      vtkPolyData::SafeDownCast(outInfo->Get(vtkDataObject::DATA_OBJECT()));

  if (input->CheckAttributes()) {
    return 0;
  }

  const vtkIdType numCells = input->GetNumberOfCells();
  if (numCells == 0) {
    vtkDebugMacro(<< "Number of cells is zero, no data to process.");
    return 1;
  }
  vtkNew<vtkCellArray> newCells{};
  // Approximate
  newCells->Allocate(numCells);

  BoundaryCellSet boundaryCellSet(input->GetNumberOfPoints());
  auto regionArr = vtkArrayDownCast<vtkIntArray>(
      input->GetCellData()->GetAbstractArray(this->MaterialArrayName.c_str()));
  for (vtkIdType i = 0; i < numCells; ++i) {
    auto cell = input->GetCell(i);
    auto region = regionArr->GetTypedComponent(i, 0);

    if (cell->GetCellDimension() != this->GetDimension()) {
      continue;
    }

    if (this->GetDimension() == 2) {
      for (int j = 0; j < cell->GetNumberOfEdges(); ++j) {
        auto edge = cell->GetEdge(j);
        boundaryCellSet.insert(i, j, edge->GetPointIds(), 2, region);
      }
    } else {  // this->GetDimension() == 3
      switch (static_cast<VTKCellType>(cell->GetCellType())) {
        case VTK_TETRA:
        case VTK_QUADRATIC_TETRA:
        case VTK_HIGHER_ORDER_TETRAHEDRON:
        case VTK_LAGRANGE_TETRAHEDRON: {
          auto points = cell->GetPointIds()->GetPointer(0);
          boundaryCellSet.insertTetFaces(i, points, region);
          break;
        }
        case VTK_HEXAHEDRON:
        case VTK_QUADRATIC_HEXAHEDRON:
        case VTK_TRIQUADRATIC_HEXAHEDRON:
        case VTK_BIQUADRATIC_QUADRATIC_HEXAHEDRON:
        case VTK_HIGHER_ORDER_HEXAHEDRON:
        case VTK_LAGRANGE_HEXAHEDRON: {
          auto points = cell->GetPointIds()->GetPointer(0);
          boundaryCellSet.insertHexFaces(i, points, region);
          break;
        }
        case VTK_WEDGE:
        case VTK_QUADRATIC_WEDGE:
        case VTK_QUADRATIC_LINEAR_WEDGE:
        case VTK_BIQUADRATIC_QUADRATIC_WEDGE:
        case VTK_HIGHER_ORDER_WEDGE:
        case VTK_LAGRANGE_WEDGE: {
          auto points = cell->GetPointIds()->GetPointer(0);
          boundaryCellSet.insertWedgeFaces(i, points, region);
          break;
        }
        default: {
          for (int j = 0; j < cell->GetNumberOfFaces(); ++j) {
            auto face = cell->GetFace(j);
            // Treat non-linear faces as linear ones by only looking at
            // beginning of point id array. Number of edges should be equal to
            // number of vertices even for non-linear faces.
            boundaryCellSet.insert(i, j, face->GetPointIds(),
                                   face->GetNumberOfEdges(), region);
          }
          break;
        }
      }
    }
  }

  vtkSmartPointer<vtkIdTypeArray> origCellId{};
  vtkSmartPointer<vtkIntArray> cellSideId{}, surfRegionId{};
  if (!this->GetOrigCellArrayName().empty()) {
    origCellId = vtkSmartPointer<vtkIdTypeArray>::New();
    origCellId->SetName(this->GetOrigCellArrayName().c_str());
    origCellId->SetNumberOfComponents(2);
    origCellId->SetNumberOfTuples(boundaryCellSet.size());
  }
  if (!this->GetCellSideArrayName().empty()) {
    cellSideId = vtkSmartPointer<vtkIntArray>::New();
    cellSideId->SetName(this->GetCellSideArrayName().c_str());
    cellSideId->SetNumberOfComponents(2);
    cellSideId->SetNumberOfTuples(boundaryCellSet.size());
  }
  if (!this->GetBoundaryRegionArrayName().empty()) {
    surfRegionId = vtkSmartPointer<vtkIntArray>::New();
    surfRegionId->SetName(this->GetBoundaryRegionArrayName().c_str());
    surfRegionId->SetNumberOfTuples(boundaryCellSet.size());
  }

  // Map from regionArr to surfRegionId.
  std::map<std::array<int, 2>, int> oldRegions2SurfRegions{};
  for (const auto &boundaryCell : boundaryCellSet) {
    auto origCellToInsert = input->GetCell(boundaryCell.sources[0]);
    auto sideToInsert = this->GetDimension() == 2
                            ? origCellToInsert->GetEdge(boundaryCell.sides[0])
                            : origCellToInsert->GetFace(boundaryCell.sides[0]);
    auto sideIdx = newCells->InsertNextCell(
        this->GetDimension() == 2 ? 2 : sideToInsert->GetNumberOfEdges(),
        sideToInsert->GetPointIds()->GetPointer(0));
    if (origCellId) {
      origCellId->SetTypedTuple(sideIdx, boundaryCell.sources.data());
    }
    if (cellSideId) {
      cellSideId->SetTypedTuple(sideIdx, boundaryCell.sides.data());
    }
    auto surfRegionIter = oldRegions2SurfRegions.emplace(
        boundaryCell.regions, oldRegions2SurfRegions.size());
    if (surfRegionId) {
      surfRegionId->SetTypedComponent(sideIdx, 0, surfRegionIter.first->second);
    }
  }
  newCells->Squeeze();

  if (!this->GetRegionToMaterialArrayName().empty()) {
    vtkNew<vtkIntArray> region2MaterialId;
    region2MaterialId->SetName(this->GetRegionToMaterialArrayName().c_str());
    region2MaterialId->SetNumberOfComponents(2);
    region2MaterialId->SetNumberOfTuples(oldRegions2SurfRegions.size());
    for (const auto &old2newRegion : oldRegions2SurfRegions) {
      auto newRegion = old2newRegion.second;
      region2MaterialId->SetComponent(newRegion, 0, old2newRegion.first[0]);
      region2MaterialId->SetComponent(newRegion, 1, old2newRegion.first[1]);
    }
    output->GetFieldData()->AddArray(region2MaterialId);
  }

  if (auto pointSet = vtkPointSet::SafeDownCast(input)) {
    output->SetPoints(pointSet->GetPoints());
  } else if (auto rectGrid = vtkRectilinearGrid::SafeDownCast(input)) {
    rectGrid->GetPoints(output->GetPoints());
  } else {
    auto outPoints = output->GetPoints();
    outPoints->Initialize();
    outPoints->SetNumberOfPoints(input->GetNumberOfPoints());
    for (vtkIdType i = 0; i < input->GetNumberOfPoints(); ++i) {
      outPoints->SetPoint(i, input->GetPoint(i));
    }
  }
  output->GetPointData()->ShallowCopy(input->GetPointData());

  if (this->GetDimension() == 2) {
    output->SetLines(newCells);
  } else {  // this->GetDimension() == 3
    output->SetPolys(newCells);
  }

  vtkCellData *outputCD = output->GetCellData();
  outputCD->AddArray(origCellId);
  outputCD->AddArray(cellSideId);
  outputCD->AddArray(surfRegionId);

  if (output->CheckAttributes()) {
    return 0;
  } else {
    return 1;
  }
}

vtkGetMacro() [1/6]

NEM::MSH::dataSetRegionBoundaryFilter::vtkGetMacro	(	Dimension	,
		int
	)

vtkGetMacro() [2/6]

NEM::MSH::dataSetRegionBoundaryFilter::vtkGetMacro	(	MaterialArrayName	,
		const std::string &
	)

vtkGetMacro() [3/6]

NEM::MSH::dataSetRegionBoundaryFilter::vtkGetMacro	(	BoundaryRegionArrayName	,
		const std::string &
	)

vtkGetMacro() [4/6]

NEM::MSH::dataSetRegionBoundaryFilter::vtkGetMacro	(	RegionToMaterialArrayName	,
		const std::string &
	)

vtkGetMacro() [5/6]

NEM::MSH::dataSetRegionBoundaryFilter::vtkGetMacro	(	OrigCellArrayName	,
		const std::string &
	)

vtkGetMacro() [6/6]

NEM::MSH::dataSetRegionBoundaryFilter::vtkGetMacro	(	CellSideArrayName	,
		const std::string &
	)

vtkSetMacro() [1/5]

NEM::MSH::dataSetRegionBoundaryFilter::vtkSetMacro	(	MaterialArrayName	,
		const std::string &
	)

Default is "Material".

Assumed to be vtkIntArray in input cell data. Interfaces between materials are included in output. Should not use the value -1.

vtkSetMacro() [2/5]

NEM::MSH::dataSetRegionBoundaryFilter::vtkSetMacro	(	BoundaryRegionArrayName	,
		const std::string &
	)

Default is "Region".

If not empty, array will be added as vtkIntArray in output cell data. To recover relation to material, see RegionToMaterialArrayName

vtkSetMacro() [3/5]

NEM::MSH::dataSetRegionBoundaryFilter::vtkSetMacro	(	RegionToMaterialArrayName	,
		const std::string &
	)

Default is "RegionToMaterial".

If not empty, array will be added as vtkIntArray with two components in output field data. Indexed by region (value in BoundaryRegionArrayName array); value corresponds to material(s), with -1 corresponding to no material (for regions bounding only one material).

vtkSetMacro() [4/5]

NEM::MSH::dataSetRegionBoundaryFilter::vtkSetMacro	(	OrigCellArrayName	,
		const std::string &
	)

Default is "OrigCellIds".

If not empty, array will be added as vtkIdTypeArray with two components in output cell data. For each output edge/face, contains the index of the input cell. Second component is -1 if external edge/face.

vtkSetMacro() [5/5]

NEM::MSH::dataSetRegionBoundaryFilter::vtkSetMacro	(	CellSideArrayName	,
		const std::string &
	)

Default is "CellFaceIds".

If not empty, array will be added as vtkIntArray with two components in output cell data. For each output edge/face, contains the index of the corresponding edge/face of the cell given by the OrigCellArrayName array. Second component is -1 if external edge/face.

vtkTypeMacro()

NEM::MSH::dataSetRegionBoundaryFilter::vtkTypeMacro	(	dataSetRegionBoundaryFilter	,
		vtkPolyDataAlgorithm
	)

Default is 3.

Member Data Documentation

BoundaryRegionArrayName

std::string NEM::MSH::dataSetRegionBoundaryFilter::BoundaryRegionArrayName {"Region"}

protected

Definition at line 139 of file dataSetRegionBoundaryFilter.H.

CellSideArrayName

std::string NEM::MSH::dataSetRegionBoundaryFilter::CellSideArrayName {"CellFaceIds"}

protected

Definition at line 138 of file dataSetRegionBoundaryFilter.H.

Dimension

int NEM::MSH::dataSetRegionBoundaryFilter::Dimension {3}

protected

Definition at line 134 of file dataSetRegionBoundaryFilter.H.

int

NEM::MSH::dataSetRegionBoundaryFilter::int

Definition at line 67 of file dataSetRegionBoundaryFilter.H.

MaterialArrayName

std::string NEM::MSH::dataSetRegionBoundaryFilter::MaterialArrayName {"Material"}

protected

Definition at line 135 of file dataSetRegionBoundaryFilter.H.

OrigCellArrayName

std::string NEM::MSH::dataSetRegionBoundaryFilter::OrigCellArrayName {"OrigCellIds"}

protected

Definition at line 137 of file dataSetRegionBoundaryFilter.H.

RegionToMaterialArrayName

std::string NEM::MSH::dataSetRegionBoundaryFilter::RegionToMaterialArrayName {"RegionToMaterial"}

protected

Definition at line 136 of file dataSetRegionBoundaryFilter.H.

---

The documentation for this class was generated from the following files:

• dataSetRegionBoundaryFilter.H
• dataSetRegionBoundaryFilter.C