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 56 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;
}

Referenced by Vtu2GridDialog::accept(), and main().

◆ checkDyncast()

template<typename T>

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

Definition at line 134 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 31 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.

Referenced by Vtu2GridDialog::accept(), and main().

◆ 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 112 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(), MeshLib::Properties::getPropertyVector(), and MeshLib::PropertyVector< PROP_VAL_TYPE >::size().

Referenced by checkDyncast().

◆ mapMeshArraysOntoGrid()

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

Definition at line 149 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().

Referenced by Vtu2GridDialog::accept(), and main().

◆ removeUnusedGridCells()

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

Definition at line 89 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;
}