MeshToolsLib::MeshGenerator::VoxelGridFromMesh Namespace Reference

Functions
std::array< std::size_t, 3 >	getNumberOfVoxelPerDimension (std::array< double, 3 > const &ranges, std::array< double, 3 > const &cellsize)
std::vector< int >	assignCellIds (vtkSmartPointer< vtkUnstructuredGrid > const &mesh, MathLib::Point3d const &min, std::array< std::size_t, 3 > const &dims, std::array< double, 3 > const &cellsize)
bool	removeUnusedGridCells (vtkSmartPointer< vtkUnstructuredGrid > const &mesh, std::unique_ptr< MeshLib::Mesh > &grid)
template<typename T , typename VTK_TYPE >
void	mapArray (MeshLib::Mesh &grid, VTK_TYPE vtk_arr, std::string const &name)
template<typename T >
bool	checkDyncast (MeshLib::Mesh &mesh, vtkSmartPointer< vtkCellData > const cell_data, char const *const name)
void	mapMeshArraysOntoGrid (vtkSmartPointer< vtkUnstructuredGrid > const &mesh, std::unique_ptr< MeshLib::Mesh > const &grid)

Variables
static std::string const	cell_id_name = "CellIds"

Function Documentation

assignCellIds()

std::vector< int > MeshToolsLib::MeshGenerator::VoxelGridFromMesh::assignCellIds	(	vtkSmartPointer< vtkUnstructuredGrid > const &	mesh,
		MathLib::Point3d const &	min,
		std::array< std::size_t, 3 > const &	dims,
		std::array< double, 3 > const &	cellsize )

Definition at line 57 of file VoxelGridFromMesh.cpp.

{
    vtkSmartPointer<vtkCellLocator> locator =
        vtkSmartPointer<vtkCellLocator>::New();
    locator->SetDataSet(mesh);
    locator->Update();
 
    std::vector<int> cell_ids;
    cell_ids.reserve(dims[0] * dims[1] * dims[2]);
    std::array<double, 3> const grid_max = {min[0] + dims[0] * cellsize[0],
                                            min[1] + dims[1] * cellsize[1],
                                            min[2] + dims[2] * cellsize[2]};
 
    double const start[3] = {min[0] + cellsize[0] / 2.,
                             min[1] + cellsize[1] / 2.,
                             min[2] + cellsize[2] / 2.};
    double pnt[3];
    for (pnt[2] = start[2]; pnt[2] < grid_max[2]; pnt[2] += cellsize[2])
    {
        for (pnt[1] = start[1]; pnt[1] < grid_max[1]; pnt[1] += cellsize[1])
        {
            for (pnt[0] = start[0]; pnt[0] < grid_max[0]; pnt[0] += cellsize[0])
            {
                cell_ids.push_back(static_cast<int>(locator->FindCell(pnt)));
            }
        }
    }
    return cell_ids;
}

checkDyncast()

template<typename T >

bool MeshToolsLib::MeshGenerator::VoxelGridFromMesh::checkDyncast	(	MeshLib::Mesh &	mesh,
		vtkSmartPointer< vtkCellData > const	cell_data,
		char const *const	name )

Definition at line 135 of file VoxelGridFromMesh.cpp.

{
    using DataArrayType = vtkAOSDataArrayTemplate<T>;
    vtkSmartPointer<DataArrayType> const arr =
        dynamic_cast<DataArrayType*>(cell_data->GetArray(name));
    if (!arr)
    {
        return false;
    }
    mapArray<T, vtkSmartPointer<DataArrayType>>(mesh, arr, name);
    return true;
}

References mapArray().

Referenced by mapMeshArraysOntoGrid().

getNumberOfVoxelPerDimension()

std::array< std::size_t, 3 > MeshToolsLib::MeshGenerator::VoxelGridFromMesh::getNumberOfVoxelPerDimension	(	std::array< double, 3 > const &	ranges,
		std::array< double, 3 > const &	cellsize )

getNumberOfVoxelPerDimension is used to calculate how many voxel fit into a bounding box. For this calculation the difference of min and max point of the bounding box is divided by the cell size, for every dimension. The calculation is restricted to work only with positive values for the cell size. If the difference between min and max is zero, we assign one voxel for the respective dimension.

Definition at line 32 of file VoxelGridFromMesh.cpp.

{
    if (cellsize[0] <= 0 || cellsize[1] <= 0 || cellsize[2] <= 0)
    {
        OGS_FATAL("A cellsize ({},{},{}) is not allowed to be <= 0",
                  cellsize[0], cellsize[1], cellsize[2]);
    }
    std::array<double, 3> numberOfVoxel = {ranges[0] / cellsize[0],
                                           ranges[1] / cellsize[1],
                                           ranges[2] / cellsize[2]};
 
    if (ranges[0] < 0 || ranges[1] < 0 || ranges[2] < 0)
    {
        OGS_FATAL(
            "The difference of max-min ({},{},{}) is not allowed to be < 0",
            ranges[0], ranges[1], ranges[2]);
    }
    std::replace(numberOfVoxel.begin(), numberOfVoxel.end(), 0, 1);
 
    return {static_cast<std::size_t>(std::lround(numberOfVoxel[0])),
            static_cast<std::size_t>(std::lround(numberOfVoxel[1])),
            static_cast<std::size_t>(std::lround(numberOfVoxel[2]))};
}

References OGS_FATAL.

mapArray()

template<typename T , typename VTK_TYPE >

void MeshToolsLib::MeshGenerator::VoxelGridFromMesh::mapArray	(	MeshLib::Mesh &	grid,
		VTK_TYPE	vtk_arr,
		std::string const &	name )

Definition at line 113 of file VoxelGridFromMesh.cpp.

{
    auto const* cell_ids = grid.getProperties().getPropertyVector<int>(
        cell_id_name, MeshLib::MeshItemType::Cell, 1);
    if (cell_ids == nullptr)
    {
        // Error message
        return;
    }
    std::size_t const n_elems = cell_ids->size();
    auto& arr = *grid.getProperties().createNewPropertyVector<T>(
        name, MeshLib::MeshItemType::Cell, n_elems,
        vtk_arr->GetNumberOfComponents());
    for (std::size_t j = 0; j < n_elems; ++j)
    {
        arr[j] = vtk_arr->GetValue((*cell_ids)[j]);
    }
}

References MeshLib::Cell, cell_id_name, MeshLib::Properties::createNewPropertyVector(), MeshLib::Mesh::getProperties(), and MeshLib::Properties::getPropertyVector().

Referenced by checkDyncast().

mapMeshArraysOntoGrid()

void MeshToolsLib::MeshGenerator::VoxelGridFromMesh::mapMeshArraysOntoGrid	(	vtkSmartPointer< vtkUnstructuredGrid > const &	mesh,
		std::unique_ptr< MeshLib::Mesh > const &	grid )

Definition at line 150 of file VoxelGridFromMesh.cpp.

{
    assert(mesh != nullptr);
    assert(grid != nullptr);
    vtkSmartPointer<vtkCellData> const cell_data = mesh->GetCellData();
    for (int i = 0; i < cell_data->GetNumberOfArrays(); ++i)
    {
        auto const name = cell_data->GetArrayName(i);
 
        if (!(checkDyncast<double>(*grid, cell_data, name) ||
              checkDyncast<long>(*grid, cell_data, name) ||
              checkDyncast<long long>(*grid, cell_data, name) ||
              checkDyncast<int>(*grid, cell_data, name)))
        {
            WARN("Ignoring array '{:s}', array type {:s} not implemented...",
                 name,
                 cell_data->GetArray(name)->GetDataTypeAsString());
        }
    }
}

References checkDyncast(), and WARN().

removeUnusedGridCells()

bool MeshToolsLib::MeshGenerator::VoxelGridFromMesh::removeUnusedGridCells	(	vtkSmartPointer< vtkUnstructuredGrid > const &	mesh,
		std::unique_ptr< MeshLib::Mesh > &	grid )

Definition at line 90 of file VoxelGridFromMesh.cpp.

{
    MeshLib::ElementSearch search(*grid);
    std::size_t const n_elems_marked = search.searchByPropertyValueRange<int>(
        cell_id_name, 0, static_cast<int>(mesh->GetNumberOfCells()), true);
 
    if (n_elems_marked == grid->getNumberOfElements())
    {
        ERR("No valid elements found. Aborting...");
        return false;
    }
 
    if (n_elems_marked)
    {
        grid.reset(MeshToolsLib::removeElements(
            *grid, search.getSearchedElementIDs(), "trimmed_grid"));
    }
    return true;
}

References cell_id_name, ERR(), MeshLib::ElementSearch::getSearchedElementIDs(), MeshToolsLib::removeElements(), and MeshLib::ElementSearch::searchByPropertyValueRange().

Variable Documentation

cell_id_name

std::string const MeshToolsLib::MeshGenerator::VoxelGridFromMesh::cell_id_name = "CellIds"

static

Definition at line 30 of file VoxelGridFromMesh.h.

Referenced by mapArray(), and removeUnusedGridCells().