OGS
anonymous_namespace{NetCDFRasterReader.cpp} Namespace Reference

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 70 of file NetCDFRasterReader.cpp.

74{
75 // second read raster header values
76 std::vector<double> raster_data;
77 for (auto [variable_name, variable] : variables)
78 {
79 // uncomment for debugging
80 // DBUG("checking variable '{}'", variable_name);
81 if (variable_name == var_name)
82 {
83 auto const n_dims = variable.getDimCount();
84 if (n_dims == 0)
85 {
86 continue;
87 }
88 // DBUG("variable '{}' has {} dimensions", variable_name, n_dims);
89
90 std::vector<std::size_t> counts(n_dims, 1);
91 for (int i = 0; i < n_dims; ++i)
92 {
93 counts[i] = variable.getDim(i).getSize();
94 }
95 // DBUG("counts {}", fmt::join(counts, ", "));
96 std::vector<std::size_t> start(n_dims, 0);
97 if (dimension_number > counts[0])
98 {
99 OGS_FATAL(
100 "variable '{}' has {} dimensions, requested dimension "
101 "number is {}",
102 variable_name, counts[0], dimension_number);
103 }
104 // time dimension
105 start[0] = dimension_number; // number of time step
106 counts[0] = 1; // read one time step
107
108 // y dimension - netcdf dimension number 1
109 // With the counts[1] and cell_size the 'usual' lower y-coordinate
110 // of the origin is computed.
111 // DBUG("reset header.origin[1]: original y0: {}, new y0: {} ",
112 // header.origin[1],
113 // header.origin[1] - counts[1] * header.cell_size);
114 header.origin[1] -= counts[1] * header.cell_size;
115
116 counts[2] = static_cast<int>(
117 std::ceil((min_max_points.max[0] - min_max_points.min[0]) /
118 header.cell_size) +
119 1);
120 counts[1] = static_cast<int>(
121 std::ceil((min_max_points.max[1] - min_max_points.min[1]) /
122 header.cell_size) +
123 1);
124 // x dimension - netcdf dimension number 2
125 start[2] = static_cast<int>(std::floor(
126 (min_max_points.min[0] - header.origin[0]) / header.cell_size));
127 // y dimension - netcdf dimension number 1
128 start[1] = static_cast<int>(std::floor(
129 (min_max_points.min[1] - header.origin[1]) / header.cell_size));
130
131 // DBUG("cut-out raster: pixel in x dimension: {} ", counts[2]);
132 // DBUG("cut-out raster: pixel in y dimension: {} ", counts[1]);
133 // DBUG("cut-out raster: start index x dimension: {}", start[2]);
134 // DBUG("cut-out raster: start index y dimension: {}", start[1]);
135
136 header.n_cols = counts[2];
137 header.n_rows = counts[1];
138 header.origin[0] += start[2] * header.cell_size;
139 // reset header y origin for cut out raster
140 header.origin[1] += start[1] * header.cell_size;
141 std::size_t const total_length =
142 std::accumulate(counts.cbegin(), counts.cend(), 1,
143 std::multiplies<std::size_t>());
144 raster_data.resize(total_length);
145 variable.getVar(start, counts, raster_data.data());
146
147 std::replace(raster_data.begin(), raster_data.end(), header.no_data,
148 0.0);
149 }
150 }
151 return raster_data;
152}
OGS_FATAL
#define OGS_FATAL(...)
Definition Error.h:19
GeoLib::RasterHeader::origin
MathLib::Point3d origin
Definition Raster.h:22
GeoLib::RasterHeader::n_cols
std::size_t n_cols
Definition Raster.h:19
GeoLib::RasterHeader::n_rows
std::size_t n_rows
Definition Raster.h:20

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 23 of file NetCDFRasterReader.cpp.

25{
26 GeoLib::RasterHeader header;
27
28 // remark: netcdf raster starts in the left upper corner
29 double cell_size_y = 0;
30 // first read:
31 // - origin, cell_size from GeoTransform attribute
32 // - header.no_data from _FillValue attribute
33 for (auto [variable_name, variable] : variables)
34 {
35 if (variable.isNull())
36 {
37 OGS_FATAL("Variable '{}' not found in file.", variable_name);
38 }
39 auto const& attributes = variable.getAtts();
40 for (auto [name, attribute] : attributes)
41 {
42 if (name == "GeoTransform")
43 {
44 std::vector<char> attribute_values;
45 attribute_values.resize(attribute.getAttLength());
46 attribute.getValues(attribute_values.data());
47 std::string const str_attribute_values(attribute_values.begin(),
48 attribute_values.end());
49 auto const strings = BaseLib::splitString(str_attribute_values);
50 header.origin[0] = std::stod(strings[0]); // origin x
51 header.cell_size = std::stod(strings[1]); // cell size x
52 header.origin[1] = std::stod(strings[3]); // origin y
53 cell_size_y = std::stod(strings[5]); // cell size y
54 DBUG(
55 "GeoTransform attribute values: origin_x: {}, origin_y: "
56 "{}, cell_size_x: {}, cell_size_y: {}",
57 header.origin[0], header.origin[1], header.cell_size,
58 cell_size_y);
59 }
60 if (name == "_FillValue")
61 {
62 attribute.getValues(&header.no_data);
63 }
64 }
65 }
66
67 return header;
68}
DBUG
void DBUG(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:22
BaseLib::splitString
std::vector< std::string > splitString(std::string const &str)
Definition StringTools.cpp:18
GeoLib::RasterHeader
Contains the relevant information when storing a geoscientific raster data.
Definition Raster.h:18

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 154 of file NetCDFRasterReader.cpp.

159{
160 netCDF::NcFile dataset(filepath.string(), netCDF::NcFile::read);
161 if (dataset.isNull())
162 {
163 OGS_FATAL("Error opening file '{}'.", filepath.string());
164 }
165
166 auto const& variables = dataset.getVars();
167 GeoLib::RasterHeader header = readHeaderFromNetCDF(variables);
168 std::vector<double> raster_data = readDataFromNetCDF(
169 variables, var_name, dimension_number, min_max_points, header);
170
171 return std::make_unique<GeoLib::Raster>(header, raster_data.begin(),
172 raster_data.end());
173}
anonymous_namespace{NetCDFRasterReader.cpp}::readDataFromNetCDF
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)
Definition NetCDFRasterReader.cpp:70
anonymous_namespace{NetCDFRasterReader.cpp}::readHeaderFromNetCDF
GeoLib::RasterHeader readHeaderFromNetCDF(std::multimap< std::string, netCDF::NcVar > const &variables)
Definition NetCDFRasterReader.cpp:23

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 176 of file NetCDFRasterReader.cpp.

182{
183 INFO("readRasterFromFile: '{}/{}'", path.string(), filename.string());
184
185 if (filename.extension() == ".nc")
186 {
187#ifdef OGS_USE_NETCDF
188 auto raster = readNetCDF(path / filename, var_name, dimension_number,
189 min_max_points);
190
191 return GeoLib::NamedRaster{filename.replace_extension().string() + "_" +
192 var_name + "_" +
193 std::to_string(dimension_number),
194 std::move(raster)};
195#else
196 OGS_FATAL("OGS was not build with NetCDF support. Can not read {}",
197 (path / filename).string());
198#endif
199 }
200 auto raster = std::unique_ptr<GeoLib::Raster>(
201 FileIO::AsciiRasterInterface::readRaster((path / filename).string()));
202 if (raster == nullptr)
203 {
204 OGS_FATAL("Could not read raster from file '{}'.",
205 (path / filename).string());
206 }
207 return GeoLib::NamedRaster{filename.replace_extension().string() + "_" +
208 var_name + "_" +
209 std::to_string(dimension_number),
210 std::move(raster)};
211}
INFO
void INFO(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:28
FileIO::AsciiRasterInterface::readRaster
static GeoLib::Raster * readRaster(std::string const &fname)
Definition AsciiRasterInterface.cpp:16
anonymous_namespace{NetCDFRasterReader.cpp}::readNetCDF
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)
Definition NetCDFRasterReader.cpp:154

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