RasterToMesh.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include "GeoLib/Raster.h"
#include "MeshLib/MeshEnums.h"
#include "MeshLib/Properties.h"
 
class vtkImageData;  // For conversion from Image to QuadMesh
 
namespace MeshLib
{
 
class Mesh;
class Node;
class Element;
template <typename T>
class PropertyVector;
}  // namespace MeshLib
 
namespace MeshToolsLib
{

class RasterToMesh
{
public:
    static std::unique_ptr<MeshLib::Mesh> convert(
        GeoLib::Raster const& raster,
        MeshLib::MeshElemType elem_type,
        MeshLib::UseIntensityAs intensity_type,
        std::string const& array_name = "Colour");

    static std::unique_ptr<MeshLib::Mesh> convert(
        vtkImageData* img,
        const double origin[3],
        const double scalingFactor,
        MeshLib::MeshElemType elem_type,
        MeshLib::UseIntensityAs intensity_type,
        std::string const& array_name = "Colour");

    static std::unique_ptr<MeshLib::Mesh> convert(
        const double* const img,
        GeoLib::RasterHeader const& header,
        MeshLib::MeshElemType elem_type,
        MeshLib::UseIntensityAs intensity_type,
        std::string const& array_name = "Colour");
 
private:
    template <typename T>
    static void fillPropertyVector(MeshLib::PropertyVector<T>& prop_vec,
                                   double const* const img,
                                   GeoLib::RasterHeader const& header,
                                   MeshLib::MeshElemType elem_type)
    {
        for (std::size_t k = 0; k < header.n_depth; k++)
        {
            std::size_t const layer_idx = (k * header.n_rows * header.n_cols);
            for (std::size_t i = 0; i < header.n_cols; i++)
            {
                std::size_t idx(i * header.n_rows + layer_idx);
                for (std::size_t j = 0; j < header.n_rows; j++)
                {
                    auto val(static_cast<T>(img[idx + j]));
                    prop_vec.push_back(val);
                    if (elem_type == MeshLib::MeshElemType::TRIANGLE ||
                        elem_type == MeshLib::MeshElemType::PRISM)
                    {
                        prop_vec.push_back(val);  // because each pixel is
                                                  // represented by two cells
                    }
                }
            }
        }
    }
};
 
}  // namespace MeshToolsLib