MeshLib::VtkMeshConverter Class Reference

Detailed Description

Converter for VtkUnstructured Grids to OGS meshes.

Definition at line 38 of file VtkMeshConverter.h.

#include <VtkMeshConverter.h>

Static Public Member Functions
static MeshLib::Mesh *	convertUnstructuredGrid (vtkUnstructuredGrid *grid, bool const compute_element_neighbors=false, std::string const &mesh_name="vtkUnstructuredGrid")
	Converts a vtkUnstructuredGrid object to a Mesh.

Static Private Member Functions
static void	convertScalarArrays (vtkUnstructuredGrid &grid, MeshLib::Mesh &mesh)
static std::vector< MeshLib::Node * >	createNodeVector (std::vector< double > const &elevation, std::vector< int > &node_idx_map, GeoLib::RasterHeader const &header, bool use_elevation)
static std::vector< MeshLib::Element * >	createElementVector (std::vector< double > const &pix_val, std::vector< bool > const &pix_vis, std::vector< MeshLib::Node * > const &nodes, std::vector< int > const &node_idx_map, std::size_t const imgHeight, std::size_t const imgWidth, MeshElemType elem_type)
	Creates a mesh element vector based on image data.
template<typename T >
static void	fillPropertyVector (MeshLib::PropertyVector< T > &prop_vec, std::vector< double > const &pix_val, std::vector< bool > const &pix_vis, const std::size_t &imgHeight, const std::size_t &imgWidth, MeshElemType elem_type)
	Creates a scalar array/mesh property based on pixel values.
static void	convertArray (vtkDataArray &array, MeshLib::Properties &properties, MeshLib::MeshItemType type)
template<typename T >
static void	convertTypedArray (vtkDataArray &array, MeshLib::Properties &properties, MeshLib::MeshItemType type)

Member Function Documentation

convertArray()

void MeshLib::VtkMeshConverter::convertArray ( vtkDataArray & array, MeshLib::Properties & properties, MeshLib::MeshItemType type )

staticprivate

Definition at line 277 of file VtkMeshConverter.cpp.

{
    if (vtkDoubleArray::SafeDownCast(&array))
    {
        VtkMeshConverter::convertTypedArray<double>(array, properties, type);
        return;
    }
 
    if (vtkFloatArray::SafeDownCast(&array))
    {
        VtkMeshConverter::convertTypedArray<float>(array, properties, type);
        return;
    }
 
    if (vtkBitArray::SafeDownCast(&array))
    {
        VtkMeshConverter::convertTypedArray<bool>(array, properties, type);
        return;
    }
 
    // This also covers the vtkTypeInt8Array type, which is derived from the
    // vtkCharArray type.
    if (vtkCharArray::SafeDownCast(&array) ||
        vtkSignedCharArray::SafeDownCast(&array))
    {
        if constexpr (sizeof(std::int8_t) != sizeof(char))
        {
            OGS_FATAL(
                "Array '{:s}' in VTU file uses unsupported data type '{:s}' "
                "not convertible to char.",
                array.GetName(), array.GetDataTypeAsString());
        }
        VtkMeshConverter::convertTypedArray<char>(array, properties, type);
        return;
    }
 
    // This also covers the vtkTypeInt16Array type, which is derived from the
    // vtkShortArray type.
    if (vtkShortArray::SafeDownCast(&array))
    {
        if constexpr (sizeof(std::int16_t) != sizeof(short))
        {
            OGS_FATAL(
                "Array '{:s}' in VTU file uses unsupported data type '{:s}' "
                "not convertible to short.",
                array.GetName(), array.GetDataTypeAsString());
        }
        VtkMeshConverter::convertTypedArray<short>(array, properties, type);
        return;
    }
 
    // This also covers the vtkTypeInt32Array type, which is derived from the
    // vtkIntArray type.
    if (vtkIntArray::SafeDownCast(&array))
    {
        if constexpr (sizeof(std::int32_t) != sizeof(int))
        {
            OGS_FATAL(
                "Array '{:s}' in VTU file uses unsupported data type '{:s}' "
                "not convertible to int.",
                array.GetName(), array.GetDataTypeAsString());
        }
        VtkMeshConverter::convertTypedArray<int>(array, properties, type);
        return;
    }
 
    // This is not a unique conversion depending on the sizes of int, long, and
    // long long. Converting to the apparently smaller type.
    if (vtkLongArray::SafeDownCast(&array))
    {
        if constexpr (sizeof(long) == sizeof(int))
        {
            VtkMeshConverter::convertTypedArray<int>(array, properties, type);
            return;
        }
        if constexpr (sizeof(long long) == sizeof(long))
        {
            VtkMeshConverter::convertTypedArray<long>(array, properties, type);
            return;
        }
 
        OGS_FATAL(
            "Array '{:s}' in VTU file uses unsupported data type '{:s}' ({:d}) "
            "not convertible to int ({:d}), or long ({:d}) types.",
            array.GetName(), array.GetDataTypeAsString(),
            array.GetDataTypeSize(), sizeof(int), sizeof(long));
    }
 
    // Ensure, vtkTypeInt64Array and vtkLongLongArray are using the same type.
    static_assert(sizeof(std::int64_t) == sizeof(long long));
 
    // This also covers the vtkTypeInt64Array type, which is derived from the
    // vtkLongLongArray type.
    // Converting to the apparently smaller type.
    if (vtkLongLongArray::SafeDownCast(&array))
    {
        if constexpr (sizeof(long long) == sizeof(long))
        {
            VtkMeshConverter::convertTypedArray<long>(array, properties, type);
            return;
        }
        else  // ll > l. Other cases are not possible because ll >= l in c++.
        {
            VtkMeshConverter::convertTypedArray<long long>(array, properties,
                                                           type);
            return;
        }
    }
 
    // This also covers the vtkTypeUInt8Array type, which is derived from the
    // vtkUnsignedCharArray type.
    if (vtkUnsignedCharArray::SafeDownCast(&array))
    {
        if constexpr (sizeof(std::uint8_t) != sizeof(unsigned char))
        {
            OGS_FATAL(
                "Array '{:s}' in VTU file uses unsupported data type '{:s}' "
                "not convertible to unsigned char.",
                array.GetName(), array.GetDataTypeAsString());
        }
        VtkMeshConverter::convertTypedArray<unsigned char>(array, properties,
                                                           type);
        return;
    }
 
    // This also covers the vtkTypeUInt16Array type, which is derived from the
    // vtkUnsignedShortArray type.
    if (vtkUnsignedShortArray::SafeDownCast(&array))
    {
        if constexpr (sizeof(std::uint16_t) != sizeof(unsigned short))
        {
            OGS_FATAL(
                "Array '{:s}' in VTU file uses unsupported data type '{:s}' "
                "not convertible to unsigned short.",
                array.GetName(), array.GetDataTypeAsString());
        }
        VtkMeshConverter::convertTypedArray<unsigned short>(array, properties,
                                                            type);
        return;
    }
 
    // This also covers the vtkTypeUInt32Array type, which is derived from the
    // vtkUnsignedIntArray type.
    if (vtkUnsignedIntArray::SafeDownCast(&array))
    {
        if constexpr (sizeof(std::uint32_t) != sizeof(unsigned))
        {
            OGS_FATAL(
                "Array '{:s}' in VTU file uses unsupported data type '{:s}' "
                "not convertible to unsigned.",
                array.GetName(), array.GetDataTypeAsString());
        }
 
        // MaterialIDs are assumed to be integers
        if (std::strncmp(array.GetName(), "MaterialIDs", 11) == 0)
        {
            VtkMeshConverter::convertTypedArray<int>(array, properties, type);
        }
        else
        {
            VtkMeshConverter::convertTypedArray<unsigned>(array, properties,
                                                          type);
        }
 
        return;
    }
 
    // This is not a unique conversion depending on the sizes of unsigned,
    // unsigned long, and unsigned long long. Converting to the apparently
    // smaller type.
    if (vtkUnsignedLongArray::SafeDownCast(&array))
    {
        if constexpr (sizeof(unsigned long) == sizeof(unsigned))
        {
            VtkMeshConverter::convertTypedArray<unsigned>(array, properties,
                                                          type);
            return;
        }
        if constexpr (sizeof(unsigned long long) == sizeof(unsigned long))
        {
            VtkMeshConverter::convertTypedArray<unsigned long>(
                array, properties, type);
            return;
        }
 
        OGS_FATAL(
            "Array '{:s}' in VTU file uses unsupported data type '{:s}' ({:d}) "
            "not convertible to unsigned ({:d}), or unsigned long ({:d}) "
            "types.",
            array.GetName(), array.GetDataTypeAsString(),
            array.GetDataTypeSize(), sizeof(unsigned), sizeof(unsigned long));
    }
 
    // Ensure, vtkTypeUInt64Array and vtkUnsignedLongLongArray are using the
    // same type.
    static_assert(sizeof(std::uint64_t) == sizeof(unsigned long long));
 
    // This also covers the vtkTypeUInt64Array type, which is derived from the
    // vtkUnsignedLongLongArray type.
    // Converting to the apparently smaller type.
    if (vtkUnsignedLongLongArray::SafeDownCast(&array))
    {
        if constexpr (sizeof(unsigned long long) == sizeof(unsigned long))
        {
            VtkMeshConverter::convertTypedArray<unsigned long>(
                array, properties, type);
            return;
        }
        else  // ull > ul. Other cases are not possible because ull >= ul in
              // c++.
        {
            VtkMeshConverter::convertTypedArray<unsigned long long>(
                array, properties, type);
            return;
        }
    }
 
    if (vtkIdTypeArray::SafeDownCast(&array))
    {
        // Bulk node ids and bulk element ids are std::size_t in OGS but
        // sometimes vtkIdType is used in the input (e.g. as result of a vtk
        // filter).
        using namespace std::literals;
        if (array.GetName() == "bulk_element_ids"sv ||
            array.GetName() == "bulk_node_ids"sv)
        {
            VtkMeshConverter::convertTypedArray<std::size_t>(array, properties,
                                                             type);
        }
        else
        {
            VtkMeshConverter::convertTypedArray<vtkIdType>(array, properties,
                                                           type);
        }
        return;
    }
 
    WARN(
        "Array '{:s}' in VTU file uses unsupported data type '{:s}' of size "
        "{:d}. The data array will not be available.",
        array.GetName(), array.GetDataTypeAsString(), array.GetDataTypeSize());
}

References convertTypedArray(), OGS_FATAL, and WARN().

Referenced by convertScalarArrays().

convertScalarArrays()

void MeshLib::VtkMeshConverter::convertScalarArrays ( vtkUnstructuredGrid & grid, MeshLib::Mesh & mesh )

staticprivate

Definition at line 242 of file VtkMeshConverter.cpp.

{
    vtkPointData* point_data = grid.GetPointData();
    auto const n_point_arrays =
        static_cast<unsigned>(point_data->GetNumberOfArrays());
    for (unsigned i = 0; i < n_point_arrays; ++i)
    {
        convertArray(*point_data->GetArray(i),
                     mesh.getProperties(),
                     MeshLib::MeshItemType::Node);
    }
 
    vtkCellData* cell_data = grid.GetCellData();
    auto const n_cell_arrays =
        static_cast<unsigned>(cell_data->GetNumberOfArrays());
    for (unsigned i = 0; i < n_cell_arrays; ++i)
    {
        convertArray(*cell_data->GetArray(i),
                     mesh.getProperties(),
                     MeshLib::MeshItemType::Cell);
    }
 
    vtkFieldData* field_data = grid.GetFieldData();
    auto const n_field_arrays =
        static_cast<unsigned>(field_data->GetNumberOfArrays());
    for (unsigned i = 0; i < n_field_arrays; ++i)
    {
        convertArray(
            *vtkDataArray::SafeDownCast(field_data->GetAbstractArray(i)),
            mesh.getProperties(),
            MeshLib::MeshItemType::IntegrationPoint);
    }
}

References MeshLib::Cell, convertArray(), MeshLib::Mesh::getProperties(), MeshLib::IntegrationPoint, and MeshLib::Node.

Referenced by convertUnstructuredGrid().

convertTypedArray()

template<typename T >

static void MeshLib::VtkMeshConverter::convertTypedArray ( vtkDataArray & array, MeshLib::Properties & properties, MeshLib::MeshItemType type )

inlinestaticprivate

Definition at line 103 of file VtkMeshConverter.h.

    {
        // Keep for debugging purposes, since the vtk array type and the end
        // type T are not always the same.
        // DBUG(
        //    "Converting a vtk array '{:s}' with data type '{:s}' of "
        //    "size {:d} to a type '{:s}' of size {:d}.",
        //    array.GetName(), array.GetDataTypeAsString(),
        //    array.GetDataTypeSize(), typeid(T).name(), sizeof(T));
 
        if (sizeof(T) != array.GetDataTypeSize())
        {
            OGS_FATAL(
                "Trying to convert a vtk array '{:s}' with data type '{:s}' of "
                "size {:d} to a different sized type '{:s}' of size {:d}.",
                array.GetName(), array.GetDataTypeAsString(),
                array.GetDataTypeSize(), typeid(T).name(), sizeof(T));
        }
 
        vtkIdType const nTuples(array.GetNumberOfTuples());
        int const nComponents(array.GetNumberOfComponents());
        char const* const array_name(array.GetName());
 
        auto* const vec = properties.createNewPropertyVector<T>(
            array_name, type, nComponents);
        if (!vec)
        {
            WARN("Array {:s} could not be converted to PropertyVector.",
                 array_name);
            return;
        }
        vec->reserve(nTuples * nComponents);
        auto* data_array = static_cast<T*>(array.GetVoidPointer(0));
        std::copy(&data_array[0],
                  &data_array[nTuples * nComponents],
                  std::back_inserter(*vec));
        return;
    }

References MeshLib::Properties::createNewPropertyVector(), OGS_FATAL, and WARN().

Referenced by convertArray().

convertUnstructuredGrid()

MeshLib::Mesh * MeshLib::VtkMeshConverter::convertUnstructuredGrid ( vtkUnstructuredGrid * grid, bool const compute_element_neighbors = false, std::string const & mesh_name = "vtkUnstructuredGrid" )

static

Converts a vtkUnstructuredGrid object to a Mesh.

Definition at line 66 of file VtkMeshConverter.cpp.

{
    if (!grid)
    {
        return nullptr;
    }
 
    // set mesh nodes
    const std::size_t nNodes = grid->GetPoints()->GetNumberOfPoints();
    std::vector<MeshLib::Node*> nodes(nNodes);
    double* coords = nullptr;
    for (std::size_t i = 0; i < nNodes; i++)
    {
        coords = grid->GetPoints()->GetPoint(i);
        nodes[i] = new MeshLib::Node(coords[0], coords[1], coords[2], i);
    }
 
    // set mesh elements
    const std::size_t nElems = grid->GetNumberOfCells();
    std::vector<MeshLib::Element*> elements;
    elements.reserve(nElems);
    auto node_ids = vtkSmartPointer<vtkIdList>::New();
    for (std::size_t i = 0; i < nElems; i++)
    {
        MeshLib::Element* elem;
        grid->GetCellPoints(i, node_ids);
 
        int cell_type = grid->GetCellType(i);
        switch (cell_type)
        {
            case VTK_VERTEX:
            {
                elem = detail::createElementWithSameNodeOrder<MeshLib::Point>(
                    nodes, node_ids, i);
                break;
            }
            case VTK_LINE:
            {
                elem = detail::createElementWithSameNodeOrder<MeshLib::Line>(
                    nodes, node_ids, i);
                break;
            }
            case VTK_TRIANGLE:
            {
                elem = detail::createElementWithSameNodeOrder<MeshLib::Tri>(
                    nodes, node_ids, i);
                break;
            }
            case VTK_QUAD:
            {
                elem = detail::createElementWithSameNodeOrder<MeshLib::Quad>(
                    nodes, node_ids, i);
                break;
            }
            case VTK_PIXEL:
            {
                auto** quad_nodes = new MeshLib::Node*[4];
                quad_nodes[0] = nodes[node_ids->GetId(0)];
                quad_nodes[1] = nodes[node_ids->GetId(1)];
                quad_nodes[2] = nodes[node_ids->GetId(3)];
                quad_nodes[3] = nodes[node_ids->GetId(2)];
                elem = new MeshLib::Quad(quad_nodes, i);
                break;
            }
            case VTK_TETRA:
            {
                elem = detail::createElementWithSameNodeOrder<MeshLib::Tet>(
                    nodes, node_ids, i);
                break;
            }
            case VTK_HEXAHEDRON:
            {
                elem = detail::createElementWithSameNodeOrder<MeshLib::Hex>(
                    nodes, node_ids, i);
                break;
            }
            case VTK_VOXEL:
            {
                auto** voxel_nodes = new MeshLib::Node*[8];
                voxel_nodes[0] = nodes[node_ids->GetId(0)];
                voxel_nodes[1] = nodes[node_ids->GetId(1)];
                voxel_nodes[2] = nodes[node_ids->GetId(3)];
                voxel_nodes[3] = nodes[node_ids->GetId(2)];
                voxel_nodes[4] = nodes[node_ids->GetId(4)];
                voxel_nodes[5] = nodes[node_ids->GetId(5)];
                voxel_nodes[6] = nodes[node_ids->GetId(7)];
                voxel_nodes[7] = nodes[node_ids->GetId(6)];
                elem = new MeshLib::Hex(voxel_nodes, i);
                break;
            }
            case VTK_PYRAMID:
            {
                elem = detail::createElementWithSameNodeOrder<MeshLib::Pyramid>(
                    nodes, node_ids, i);
                break;
            }
            case VTK_WEDGE:
            {
                auto** prism_nodes = new MeshLib::Node*[6];
                for (unsigned j = 0; j < 3; ++j)
                {
                    prism_nodes[j] = nodes[node_ids->GetId(j + 3)];
                    prism_nodes[j + 3] = nodes[node_ids->GetId(j)];
                }
                elem = new MeshLib::Prism(prism_nodes, i);
                break;
            }
            case VTK_QUADRATIC_EDGE:
            {
                elem = detail::createElementWithSameNodeOrder<MeshLib::Line3>(
                    nodes, node_ids, i);
                break;
            }
            case VTK_QUADRATIC_TRIANGLE:
            {
                elem = detail::createElementWithSameNodeOrder<MeshLib::Tri6>(
                    nodes, node_ids, i);
                break;
            }
            case VTK_QUADRATIC_QUAD:
            {
                elem = detail::createElementWithSameNodeOrder<MeshLib::Quad8>(
                    nodes, node_ids, i);
                break;
            }
            case VTK_BIQUADRATIC_QUAD:
            {
                elem = detail::createElementWithSameNodeOrder<MeshLib::Quad9>(
                    nodes, node_ids, i);
                break;
            }
            case VTK_QUADRATIC_TETRA:
            {
                elem = detail::createElementWithSameNodeOrder<MeshLib::Tet10>(
                    nodes, node_ids, i);
                break;
            }
            case VTK_QUADRATIC_HEXAHEDRON:
            {
                elem = detail::createElementWithSameNodeOrder<MeshLib::Hex20>(
                    nodes, node_ids, i);
                break;
            }
            case VTK_QUADRATIC_PYRAMID:
            {
                elem =
                    detail::createElementWithSameNodeOrder<MeshLib::Pyramid13>(
                        nodes, node_ids, i);
                break;
            }
            case VTK_QUADRATIC_WEDGE:
            {
                elem = detail::createElementWithSameNodeOrder<MeshLib::Prism15>(
                    nodes, node_ids, i);
 
                break;
            }
            default:
                ERR("VtkMeshConverter::convertUnstructuredGrid(): Unknown mesh "
                    "element type '{:d}'.",
                    cell_type);
                return nullptr;
        }
 
        elements.push_back(elem);
    }
 
    MeshLib::Mesh* mesh = new MeshLib::Mesh(mesh_name, nodes, elements,
                                            compute_element_neighbors);
    convertScalarArrays(*grid, *mesh);
 
    return mesh;
}

References convertScalarArrays(), MeshLib::detail::createElementWithSameNodeOrder(), ERR(), and MeshLib::Node.

Referenced by ApplicationUtils::computeNaturalCoords(), VtkVisPipelineView::convertVTKToOGSMesh(), MeshLib::IO::VtuInterface::readVTKFile(), and MeshLib::IO::VtuInterface::readVTUFile().

createElementVector()

static std::vector< MeshLib::Element * > MeshLib::VtkMeshConverter::createElementVector ( std::vector< double > const & pix_val, std::vector< bool > const & pix_vis, std::vector< MeshLib::Node * > const & nodes, std::vector< int > const & node_idx_map, std::size_t const imgHeight, std::size_t const imgWidth, MeshElemType elem_type )

staticprivate

Creates a mesh element vector based on image data.

createNodeVector()

static std::vector< MeshLib::Node * > MeshLib::VtkMeshConverter::createNodeVector ( std::vector< double > const & elevation, std::vector< int > & node_idx_map, GeoLib::RasterHeader const & header, bool use_elevation )

staticprivate

fillPropertyVector()

template<typename T >

static void MeshLib::VtkMeshConverter::fillPropertyVector ( MeshLib::PropertyVector< T > & prop_vec, std::vector< double > const & pix_val, std::vector< bool > const & pix_vis, const std::size_t & imgHeight, const std::size_t & imgWidth, MeshElemType elem_type )

inlinestaticprivate

Creates a scalar array/mesh property based on pixel values.

Definition at line 69 of file VtkMeshConverter.h.

    {
        for (std::size_t i = 0; i < imgHeight; i++)
        {
            for (std::size_t j = 0; j < imgWidth; j++)
            {
                if (!pix_vis[i * imgWidth + j])
                {
                    continue;
                }
                T val(static_cast<T>(pix_val[i * (imgWidth + 1) + j]));
                if (elem_type == MeshElemType::TRIANGLE)
                {
                    prop_vec.push_back(val);
                    prop_vec.push_back(val);
                }
                else if (elem_type == MeshElemType::QUAD)
                {
                    prop_vec.push_back(val);
                }
            }
        }
    }

References MeshLib::QUAD, and MeshLib::TRIANGLE.

---

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

• MeshLib/IO/VtkIO/VtkMeshConverter.h
• MeshLib/IO/VtkIO/VtkMeshConverter.cpp