Functions
GeoLib::RasterHeader	readHeaderFromNetCDF (std::multimap< std::string, netCDF::NcVar > const &variables)

std::vector< double >	readDataFromNetCDF (std::multimap< std::string, netCDF::NcVar > const &variables, std::string_view const var_name, std::size_t const dimension_number, GeoLib::MinMaxPoints const &min_max_points, GeoLib::RasterHeader &header)

std::unique_ptr< GeoLib::Raster >	readNetCDF (std::filesystem::path const &filepath, std::string_view const var_name, std::size_t const dimension_number, GeoLib::MinMaxPoints const &min_max_points)

GeoLib::NamedRaster	readRasterFromFile (std::filesystem::path const &path, std::filesystem::path filename, std::string const &var_name, std::size_t const dimension_number, GeoLib::MinMaxPoints const &min_max_points)

Function Documentation

◆ readDataFromNetCDF()

std::vector< double > anonymous_namespace{NetCDFRasterReader.cpp}::readDataFromNetCDF	(	std::multimap< std::string, netCDF::NcVar > const &	variables,
		std::string_view const	var_name,
		std::size_t const	dimension_number,
		GeoLib::MinMaxPoints const &	min_max_points,
		GeoLib::RasterHeader &	header )

Definition at line 76 of file NetCDFRasterReader.cpp.

{
    // second read raster header values
    std::vector<double> raster_data;
    for (auto [variable_name, variable] : variables)
    {
        // uncomment for debugging
        // DBUG("checking variable '{}'", variable_name);
        if (variable_name == var_name)
        {
            auto const n_dims = variable.getDimCount();
            if (n_dims == 0)
            {
                continue;
            }
            // DBUG("variable '{}' has {} dimensions", variable_name, n_dims);
 
            std::vector<std::size_t> counts(n_dims, 1);
            for (int i = 0; i < n_dims; ++i)
            {
                counts[i] = variable.getDim(i).getSize();
            }
            // DBUG("counts {}", fmt::join(counts, ", "));
            std::vector<std::size_t> start(n_dims, 0);
            if (dimension_number > counts[0])
            {
                OGS_FATAL(
                    "variable '{}' has {} dimensions, requested dimension "
                    "number is {}",
                    variable_name, counts[0], dimension_number);
            }
            // time dimension
            start[0] = dimension_number;  // number of time step
            counts[0] = 1;                // read one time step
 
            // y dimension - netcdf dimension number 1
            // With the counts[1] and cell_size the 'usual' lower y-coordinate
            // of the origin is computed.
            // DBUG("reset header.origin[1]: original y0: {}, new y0: {} ",
            //     header.origin[1],
            //     header.origin[1] - counts[1] * header.cell_size);
            header.origin[1] -= counts[1] * header.cell_size;
 
            counts[2] = static_cast<int>(
                std::ceil((min_max_points.max[0] - min_max_points.min[0]) /
                          header.cell_size) +
                1);
            counts[1] = static_cast<int>(
                std::ceil((min_max_points.max[1] - min_max_points.min[1]) /
                          header.cell_size) +
                1);
            // x dimension - netcdf dimension number 2
            start[2] = static_cast<int>(std::floor(
                (min_max_points.min[0] - header.origin[0]) / header.cell_size));
            // y dimension - netcdf dimension number 1
            start[1] = static_cast<int>(std::floor(
                (min_max_points.min[1] - header.origin[1]) / header.cell_size));
 
            // DBUG("cut-out raster: pixel in x dimension: {} ", counts[2]);
            // DBUG("cut-out raster: pixel in y dimension: {} ", counts[1]);
            // DBUG("cut-out raster: start index x dimension: {}", start[2]);
            // DBUG("cut-out raster: start index y dimension: {}", start[1]);
 
            header.n_cols = counts[2];
            header.n_rows = counts[1];
            header.origin[0] += start[2] * header.cell_size;
            // reset header y origin for cut out raster
            header.origin[1] += start[1] * header.cell_size;
            std::size_t const total_length =
                std::accumulate(counts.cbegin(), counts.cend(), 1,
                                std::multiplies<std::size_t>());
            raster_data.resize(total_length);
            variable.getVar(start, counts, raster_data.data());
 
            std::replace(raster_data.begin(), raster_data.end(), header.no_data,
                         0.0);
        }
    }
    return raster_data;
}

References GeoLib::RasterHeader::cell_size, GeoLib::MinMaxPoints::max, GeoLib::MinMaxPoints::min, GeoLib::RasterHeader::n_cols, GeoLib::RasterHeader::n_rows, GeoLib::RasterHeader::no_data, OGS_FATAL, and GeoLib::RasterHeader::origin.

Referenced by readNetCDF().

◆ readHeaderFromNetCDF()

GeoLib::RasterHeader anonymous_namespace{NetCDFRasterReader.cpp}::readHeaderFromNetCDF ( std::multimap< std::string, netCDF::NcVar > const & variables )

Definition at line 29 of file NetCDFRasterReader.cpp.

{
    GeoLib::RasterHeader header;
 
    // remark: netcdf raster starts in the left upper corner
    double cell_size_y = 0;
    // first read:
    // - origin, cell_size from GeoTransform attribute
    // - header.no_data from _FillValue attribute
    for (auto [variable_name, variable] : variables)
    {
        if (variable.isNull())
        {
            OGS_FATAL("Variable '{}' not found in file.", variable_name);
        }
        auto const& attributes = variable.getAtts();
        for (auto [name, attribute] : attributes)
        {
            if (name == "GeoTransform")
            {
                std::vector<char> attribute_values;
                attribute_values.resize(attribute.getAttLength());
                attribute.getValues(attribute_values.data());
                std::string const str_attribute_values(attribute_values.begin(),
                                                       attribute_values.end());
                auto const strings = BaseLib::splitString(str_attribute_values);
                header.origin[0] = std::stod(strings[0]);  // origin x
                header.cell_size = std::stod(strings[1]);  // cell size x
                header.origin[1] = std::stod(strings[3]);  // origin y
                cell_size_y = std::stod(strings[5]);       // cell size y
                DBUG(
                    "GeoTransform attribute values: origin_x: {}, origin_y: "
                    "{}, cell_size_x: {}, cell_size_y: {}",
                    header.origin[0], header.origin[1], header.cell_size,
                    cell_size_y);
            }
            if (name == "_FillValue")
            {
                attribute.getValues(&header.no_data);
            }
        }
    }
 
    return header;
}

References GeoLib::RasterHeader::cell_size, DBUG(), GeoLib::RasterHeader::no_data, OGS_FATAL, GeoLib::RasterHeader::origin, and BaseLib::splitString().

Referenced by readNetCDF().

◆ readNetCDF()

std::unique_ptr< GeoLib::Raster > anonymous_namespace{NetCDFRasterReader.cpp}::readNetCDF	(	std::filesystem::path const &	filepath,
		std::string_view const	var_name,
		std::size_t const	dimension_number,
		GeoLib::MinMaxPoints const &	min_max_points )

Definition at line 160 of file NetCDFRasterReader.cpp.

{
    netCDF::NcFile dataset(filepath.string(), netCDF::NcFile::read);
    if (dataset.isNull())
    {
        OGS_FATAL("Error opening file '{}'.", filepath.string());
    }
 
    auto const& variables = dataset.getVars();
    GeoLib::RasterHeader header = readHeaderFromNetCDF(variables);
    std::vector<double> raster_data = readDataFromNetCDF(
        variables, var_name, dimension_number, min_max_points, header);
 
    return std::make_unique<GeoLib::Raster>(header, raster_data.begin(),
                                            raster_data.end());
}

References OGS_FATAL, readDataFromNetCDF(), and readHeaderFromNetCDF().

Referenced by readRasterFromFile().

◆ readRasterFromFile()

GeoLib::NamedRaster anonymous_namespace{NetCDFRasterReader.cpp}::readRasterFromFile	(	std::filesystem::path const &	path,
		std::filesystem::path	filename,
		std::string const &	var_name,
		std::size_t const	dimension_number,
		GeoLib::MinMaxPoints const &	min_max_points )

Definition at line 182 of file NetCDFRasterReader.cpp.

{
    INFO("readRasterFromFile: '{}/{}'", path.string(), filename.string());
 
    if (filename.extension() == ".nc")
    {
#ifdef OGS_USE_NETCDF
        auto raster = readNetCDF(path / filename, var_name, dimension_number,
                                 min_max_points);
 
        return GeoLib::NamedRaster{filename.replace_extension().string() + "_" +
                                       var_name + "_" +
                                       std::to_string(dimension_number),
                                   std::move(raster)};
#else
        OGS_FATAL("OGS was not build with NetCDF support. Can not read {}",
                  (path / filename).string());
#endif
    }
    auto raster = std::unique_ptr<GeoLib::Raster>(
        FileIO::AsciiRasterInterface::readRaster((path / filename).string()));
    if (raster == nullptr)
    {
        OGS_FATAL("Could not read raster from file '{}'.",
                  (path / filename).string());
    }
    return GeoLib::NamedRaster{filename.replace_extension().string() + "_" +
                                   var_name + "_" +
                                   std::to_string(dimension_number),
                               std::move(raster)};
}

References INFO(), OGS_FATAL, readNetCDF(), and FileIO::AsciiRasterInterface::readRaster().

Functions

Function Documentation

◆ readDataFromNetCDF()

◆ readHeaderFromNetCDF()

◆ readNetCDF()

◆ readRasterFromFile()