isce3 0.25.0
Loading...
Searching...
No Matches
TopoLayers.h
1#pragma once
2
3#include "forward.h"
4
5#include <string>
6#include <valarray>
7
8#include <isce3/io/Raster.h>
9
10class isce3::geometry::TopoLayers {
11
12 public:
13 // Constructors
14 TopoLayers(const std::string & outdir, const size_t length,
15 const size_t width, const size_t linesPerBlock,
16 const bool computeMask);
17
18 TopoLayers(const size_t linesPerBlock,
19 isce3::io::Raster * xRaster = nullptr,
20 isce3::io::Raster * yRaster = nullptr,
21 isce3::io::Raster * zRaster = nullptr,
22 isce3::io::Raster * incRaster = nullptr,
23 isce3::io::Raster * hdgRaster = nullptr,
24 isce3::io::Raster * localIncRaster = nullptr,
25 isce3::io::Raster * localPsiRaster = nullptr,
26 isce3::io::Raster * simRaster = nullptr,
27 isce3::io::Raster * maskRaster = nullptr,
28 isce3::io::Raster * groundToSatEastRaster = nullptr,
29 isce3::io::Raster * groundToSatNorthRaster = nullptr);
30
31 // Destructor
32 ~TopoLayers() {
33 if (_haveOwnRasters) {
34 delete _xRaster;
35 delete _yRaster;
36 delete _zRaster;
37 delete _incRaster;
38 delete _hdgRaster;
39 delete _localIncRaster;
40 delete _localPsiRaster;
41 delete _simRaster;
42 delete _groundToSatEastRaster;
43 delete _groundToSatNorthRaster;
44 if (_maskRaster) {
45 delete _maskRaster;
46 }
47 }
48 }
49
50 // Set new block sizes
51 void setBlockSize(size_t length, size_t width);
52
53 // Get sizes
54 inline size_t length() const { return _length; }
55 inline size_t width() const { return _width; }
56
57 // Get array references
58 std::valarray<double> & x() { return _x; }
59 std::valarray<double> & y() { return _y; }
60 std::valarray<double> & z() { return _z; }
61 std::valarray<float> & inc() { return _inc; }
62 std::valarray<float> & hdg() { return _hdg; }
63 std::valarray<float> & localInc() { return _localInc; }
64 std::valarray<float> & localPsi() { return _localPsi; }
65 std::valarray<float> & sim() { return _sim; }
66 std::valarray<short> & mask() { return _mask; }
67 std::valarray<double> & crossTrack() { return _crossTrack; }
68 std::valarray<float> & groundToSatEast() { return _groundToSatEast; }
69 std::valarray<float> & groundToSatNorth() { return _groundToSatNorth; }
70
71 inline bool hasXRaster() const { return _xRaster != nullptr; }
72 inline bool hasYRaster() const { return _yRaster != nullptr; }
73 inline bool hasZRaster() const { return _zRaster != nullptr; }
74 inline bool hasIncRaster() const { return _incRaster != nullptr; }
75 inline bool hasHdgRaster() const { return _hdgRaster != nullptr; }
76 inline bool hasLocalIncRaster() const { return _localIncRaster != nullptr; }
77 inline bool hasLocalPsiRaster() const { return _localPsiRaster != nullptr; }
78 inline bool hasSimRaster() const { return _simRaster != nullptr; }
79 inline bool hasMaskRaster() const { return _maskRaster != nullptr; }
80 inline bool hasGroundToSatEastRaster() const {
81 return _groundToSatEastRaster != nullptr; }
82 inline bool hasGroundToSatNorthRaster() const {
83 return _groundToSatNorthRaster != nullptr; }
84
85 /*
86 Set values for a single index.
87 Values are only set if memory has been allocated for that layer.
88 */
89 inline void x(size_t row, size_t col, double value) {
90 if (_x.size() == 0) {
91 return;
92 }
93 _x[row*_width+col] = value;
94 }
95
96 inline void y(size_t row, size_t col, double value) {
97 if (_y.size() == 0) {
98 return;
99 }
100 _y[row*_width + col] = value;
101 }
102
103 inline void z(size_t row, size_t col, double value) {
104 if (_z.size() == 0) {
105 return;
106 }
107 _z[row*_width + col] = value;
108 }
109
110 inline void inc(size_t row, size_t col, float value) {
111 if (_inc.size() == 0) {
112 return;
113 }
114 _inc[row*_width + col] = value;
115 }
116
117 inline void hdg(size_t row, size_t col, float value) {
118 if (_hdg.size() == 0) {
119 return;
120 }
121 _hdg[row*_width + col] = value;
122 }
123
124 inline void localInc(size_t row, size_t col, float value) {
125 if (_localInc.size() == 0) {
126 return;
127 }
128 _localInc[row*_width + col] = value;
129 }
130
131 inline void localPsi(size_t row, size_t col, float value) {
132 if (_localPsi.size() == 0) {
133 return;
134 }
135 _localPsi[row*_width + col] = value;
136 }
137
138 inline void sim(size_t row, size_t col, float value) {
139 if (_sim.size() == 0) {
140 return;
141 }
142 _sim[row*_width + col] = value;
143 }
144
145 inline void mask(size_t row, size_t col, short value) {
146 if (_mask.size() == 0) {
147 return;
148 }
149 _mask[row*_width + col] = value;
150 }
151
152 inline void crossTrack(size_t row, size_t col, double value) {
153 if (_crossTrack.size() == 0) {
154 return;
155 }
156 _crossTrack[row*_width + col] = value;
157 }
158
159 inline void groundToSatEast(size_t row, size_t col, float value) {
160 if (hasGroundToSatEastRaster()) {
161 _groundToSatEast[row*_width + col] = value;
162 }
163 }
164
165 inline void groundToSatNorth(size_t row, size_t col, float value) {
166 if (hasGroundToSatNorthRaster()) {
167 _groundToSatNorth[row*_width + col] = value;
168 }
169 }
170
171 // Get values for a single index
172 double x(size_t row, size_t col) const {
173 if (_x.size() == 0 || row > _length - 1 || col > _width - 1) {
174 return std::numeric_limits<double>::quiet_NaN();
175 }
176 return _x[row*_width+col];
177 }
178
179 double y(size_t row, size_t col) const {
180 if (_y.size() == 0 || row > _length - 1 || col > _width - 1) {
181 return std::numeric_limits<double>::quiet_NaN();
182 }
183 return _y[row*_width + col];
184 }
185
186 double z(size_t row, size_t col) const {
187 if (_z.size() == 0 || row > _length - 1 || col > _width - 1) {
188 return std::numeric_limits<double>::quiet_NaN();
189 }
190 return _z[row*_width + col];
191 }
192
193 float inc(size_t row, size_t col) const {
194 if (_inc.size() == 0 || row > _length - 1 || col > _width - 1) {
195 return std::numeric_limits<float>::quiet_NaN();
196 }
197 return _inc[row*_width + col];
198 }
199
200 float hdg(size_t row, size_t col) const {
201 if (_hdg.size() == 0 || row > _length - 1 || col > _width - 1) {
202 return std::numeric_limits<float>::quiet_NaN();
203 }
204 return _hdg[row*_width + col];
205 }
206
207 float localInc(size_t row, size_t col) const {
208 if (_localInc.size() == 0 || row > _length - 1 || col > _width - 1) {
209 return std::numeric_limits<float>::quiet_NaN();
210 }
211 return _localInc[row*_width + col];
212 }
213
214 float localPsi(size_t row, size_t col) const {
215 if (_localPsi.size() == 0 || row > _length - 1 || col > _width - 1) {
216 return std::numeric_limits<float>::quiet_NaN();
217 }
218 return _localPsi[row*_width + col];
219 }
220
221 float sim(size_t row, size_t col) const {
222 if (_sim.size() == 0 || row > _length - 1 || col > _width - 1) {
223 return std::numeric_limits<float>::quiet_NaN();
224 }
225 return _sim[row*_width + col];
226 }
227
228 short mask(size_t row, size_t col) const {
229 if (_mask.size() == 0 || row > _length - 1 || col > _width - 1) {
230 return 0;
231 }
232 return _mask[row*_width + col];
233 }
234
235 double crossTrack(size_t row, size_t col) const {
236 if (_crossTrack.size() == 0 || row > _length - 1 || col > _width - 1) {
237 return std::numeric_limits<double>::quiet_NaN();
238 }
239 return _crossTrack[row*_width + col];
240 }
241
242 float groundToSatEast(size_t row, size_t col) const {
243 if (!hasGroundToSatEastRaster() || row > _length - 1 || col > _width -1) {
244 return std::numeric_limits<float>::quiet_NaN();
245 }
246 return _groundToSatEast[row*_width + col];
247 }
248
249 float groundToSatNorth(size_t row, size_t col) const {
250 if (!hasGroundToSatNorthRaster() || row > _length - 1 || col > _width -1) {
251 return std::numeric_limits<float>::quiet_NaN();
252 }
253 return _groundToSatNorth[row*_width + col];
254 }
255
256 // Write data with rasters
257 void writeData(size_t xidx, size_t yidx);
258
259 private:
260 // The valarrays for the actual data
261 std::valarray<double> _x;
262 std::valarray<double> _y;
263 std::valarray<double> _z;
264 std::valarray<float> _inc;
265 std::valarray<float> _hdg;
266 std::valarray<float> _localInc;
267 std::valarray<float> _localPsi;
268 std::valarray<float> _sim;
269 std::valarray<short> _mask;
270 std::valarray<double> _crossTrack; // internal usage only; not saved to Raster
271 std::valarray<float> _groundToSatEast;
272 std::valarray<float> _groundToSatNorth;
273
274 // Raster pointers for each layer
275 isce3::io::Raster * _xRaster = nullptr;
276 isce3::io::Raster * _yRaster = nullptr;
277 isce3::io::Raster * _zRaster = nullptr;
278 isce3::io::Raster * _incRaster = nullptr;
279 isce3::io::Raster * _hdgRaster = nullptr;
280 isce3::io::Raster * _localIncRaster = nullptr;
281 isce3::io::Raster * _localPsiRaster = nullptr;
282 isce3::io::Raster * _simRaster = nullptr;
283 isce3::io::Raster * _maskRaster = nullptr;
284 isce3::io::Raster * _groundToSatEastRaster = nullptr;
285 isce3::io::Raster * _groundToSatNorthRaster = nullptr;
286
287 // Dimensions
288 size_t _length, _width;
289
290 // Directory for placing rasters
291 std::string _topodir;
292
293 // Flag indicates if the Class owns the Rasters
294 // Should be True when initRasters is called
295 // Should be false when the Rasters are passed
296 // from outside and setRaster method is called
297 bool _haveOwnRasters;
298};
isce3::geometry::TopoLayers
Definition TopoLayers.h:10
isce3::io::Raster
Data structure meant to handle Raster I/O operations.
Definition Raster.h:32
Generated for ISCE3.0 by doxygen 1.13.2.