Line data Source code
1 : /******************************************************************************
2 : *
3 : * Project: GDAL Core
4 : * Purpose: Base class for format specific band class implementation. This
5 : * base class provides default implementation for many methods.
6 : * Author: Frank Warmerdam, warmerdam@pobox.com
7 : *
8 : ******************************************************************************
9 : * Copyright (c) 1998, Frank Warmerdam
10 : * Copyright (c) 2007-2016, Even Rouault <even dot rouault at spatialys dot com>
11 : *
12 : * SPDX-License-Identifier: MIT
13 : ****************************************************************************/
14 :
15 : #include "cpl_port.h"
16 : #include "cpl_float.h"
17 : #include "gdal_priv.h"
18 :
19 : #include <climits>
20 : #include <cmath>
21 : #include <cstdarg>
22 : #include <cstddef>
23 : #include <cstdio>
24 : #include <cstdlib>
25 : #include <cstring>
26 : #include <algorithm>
27 : #include <limits>
28 : #include <memory>
29 : #include <new>
30 : #include <type_traits>
31 :
32 : #include "cpl_conv.h"
33 : #include "cpl_error.h"
34 : #include "cpl_float.h"
35 : #include "cpl_progress.h"
36 : #include "cpl_string.h"
37 : #include "cpl_virtualmem.h"
38 : #include "cpl_vsi.h"
39 : #include "gdal.h"
40 : #include "gdal_rat.h"
41 : #include "gdal_priv_templates.hpp"
42 : #include "gdal_interpolateatpoint.h"
43 : #include "gdal_minmax_element.hpp"
44 :
45 : /************************************************************************/
46 : /* GDALRasterBand() */
47 : /************************************************************************/
48 :
49 : /*! Constructor. Applications should never create GDALRasterBands directly. */
50 :
51 1638870 : GDALRasterBand::GDALRasterBand()
52 : : GDALRasterBand(
53 1638870 : CPLTestBool(CPLGetConfigOption("GDAL_FORCE_CACHING", "NO")))
54 : {
55 1638700 : }
56 :
57 : /** Constructor. Applications should never create GDALRasterBands directly.
58 : * @param bForceCachedIOIn Whether cached IO should be forced.
59 : */
60 1910000 : GDALRasterBand::GDALRasterBand(int bForceCachedIOIn)
61 1910000 : : bForceCachedIO(bForceCachedIOIn)
62 :
63 : {
64 1909710 : }
65 :
66 : /************************************************************************/
67 : /* ~GDALRasterBand() */
68 : /************************************************************************/
69 :
70 : /*! Destructor. Applications should never destroy GDALRasterBands directly,
71 : instead destroy the GDALDataset. */
72 :
73 1909990 : GDALRasterBand::~GDALRasterBand()
74 :
75 : {
76 1910010 : if (poDS && poDS->IsMarkedSuppressOnClose())
77 : {
78 526 : if (poBandBlockCache)
79 461 : poBandBlockCache->DisableDirtyBlockWriting();
80 : }
81 1910010 : GDALRasterBand::FlushCache(true);
82 :
83 1909990 : delete poBandBlockCache;
84 :
85 1909990 : if (static_cast<GIntBig>(nBlockReads) >
86 1909990 : static_cast<GIntBig>(nBlocksPerRow) * nBlocksPerColumn &&
87 219 : nBand == 1 && poDS != nullptr)
88 : {
89 318 : CPLDebug(
90 : "GDAL", "%d block reads on " CPL_FRMT_GIB " block band 1 of %s.",
91 159 : nBlockReads, static_cast<GIntBig>(nBlocksPerRow) * nBlocksPerColumn,
92 159 : poDS->GetDescription());
93 : }
94 :
95 1909990 : InvalidateMaskBand();
96 1909990 : nBand = -nBand;
97 :
98 1909990 : delete m_poPointsCache;
99 1909990 : }
100 :
101 : /************************************************************************/
102 : /* RasterIO() */
103 : /************************************************************************/
104 :
105 : /**
106 : * \fn GDALRasterBand::IRasterIO( GDALRWFlag eRWFlag,
107 : * int nXOff, int nYOff, int nXSize, int nYSize,
108 : * void * pData, int nBufXSize, int nBufYSize,
109 : * GDALDataType eBufType,
110 : * GSpacing nPixelSpace,
111 : * GSpacing nLineSpace,
112 : * GDALRasterIOExtraArg* psExtraArg )
113 : * \brief Read/write a region of image data for this band.
114 : *
115 : * This method allows reading a region of a GDALRasterBand into a buffer,
116 : * or writing data from a buffer into a region of a GDALRasterBand. It
117 : * automatically takes care of data type translation if the data type
118 : * (eBufType) of the buffer is different than that of the GDALRasterBand.
119 : * The method also takes care of image decimation / replication if the
120 : * buffer size (nBufXSize x nBufYSize) is different than the size of the
121 : * region being accessed (nXSize x nYSize).
122 : *
123 : * The window of interest expressed by (nXOff, nYOff, nXSize, nYSize) should be
124 : * fully within the raster space, that is nXOff >= 0, nYOff >= 0,
125 : * nXOff + nXSize <= GetXSize() and nYOff + nYSize <= GetYSize().
126 : * If reads larger than the raster space are wished, GDALTranslate() might be used.
127 : * Or use nLineSpace and a possibly shifted pData value.
128 : *
129 : * The nPixelSpace and nLineSpace parameters allow reading into or
130 : * writing from unusually organized buffers. This is primarily used
131 : * for buffers containing more than one bands raster data in interleaved
132 : * format.
133 : *
134 : * Some formats may efficiently implement decimation into a buffer by
135 : * reading from lower resolution overview images. The logic of the default
136 : * implementation in the base class GDALRasterBand is the following one. It
137 : * computes a target_downscaling_factor from the window of interest and buffer
138 : * size which is min(nXSize/nBufXSize, nYSize/nBufYSize).
139 : * It then walks through overviews and will select the first one whose
140 : * downscaling factor is greater than target_downscaling_factor / 1.2.
141 : *
142 : * Let's assume we have overviews at downscaling factors 2, 4 and 8.
143 : * The relationship between target_downscaling_factor and the select overview
144 : * level is the following one:
145 : *
146 : * target_downscaling_factor | selected_overview
147 : * ------------------------- | -----------------
148 : * ]0, 2 / 1.2] | full resolution band
149 : * ]2 / 1.2, 4 / 1.2] | 2x downsampled band
150 : * ]4 / 1.2, 8 / 1.2] | 4x downsampled band
151 : * ]8 / 1.2, infinity[ | 8x downsampled band
152 : *
153 : * Note that starting with GDAL 3.9, this 1.2 oversampling factor can be
154 : * modified by setting the GDAL_OVERVIEW_OVERSAMPLING_THRESHOLD configuration
155 : * option. Also note that starting with GDAL 3.9, when the resampling algorithm
156 : * specified in psExtraArg->eResampleAlg is different from GRIORA_NearestNeighbour,
157 : * this oversampling threshold defaults to 1. Consequently if there are overviews
158 : * of downscaling factor 2, 4 and 8, and the desired downscaling factor is
159 : * 7.99, the overview of factor 4 will be selected for a non nearest resampling.
160 : *
161 : * For highest performance full resolution data access, read and write
162 : * on "block boundaries" as returned by GetBlockSize(), or use the
163 : * ReadBlock() and WriteBlock() methods.
164 : *
165 : * This method is the same as the C GDALRasterIO() or GDALRasterIOEx()
166 : * functions.
167 : *
168 : * @param eRWFlag Either GF_Read to read a region of data, or GF_Write to
169 : * write a region of data.
170 : *
171 : * @param nXOff The pixel offset to the top left corner of the region
172 : * of the band to be accessed. This would be zero to start from the left side.
173 : *
174 : * @param nYOff The line offset to the top left corner of the region
175 : * of the band to be accessed. This would be zero to start from the top.
176 : *
177 : * @param nXSize The width of the region of the band to be accessed in pixels.
178 : *
179 : * @param nYSize The height of the region of the band to be accessed in lines.
180 : *
181 : * @param pData The buffer into which the data should be read, or from which
182 : * it should be written. This buffer must contain at least nBufXSize *
183 : * nBufYSize words of type eBufType. It is organized in left to right,
184 : * top to bottom pixel order. Spacing is controlled by the nPixelSpace,
185 : * and nLineSpace parameters.
186 : * Note that even with eRWFlag==GF_Write, the content of the buffer might be
187 : * temporarily modified during the execution of this method (and eventually
188 : * restored back to its original content), so it is not safe to use a buffer
189 : * stored in a read-only section of the calling program.
190 : *
191 : * @param nBufXSize the width of the buffer image into which the desired region
192 : * is to be read, or from which it is to be written.
193 : *
194 : * @param nBufYSize the height of the buffer image into which the desired region
195 : * is to be read, or from which it is to be written.
196 : *
197 : * @param eBufType the type of the pixel values in the pData data buffer. The
198 : * pixel values will automatically be translated to/from the GDALRasterBand
199 : * data type as needed. Most driver implementations will use GDALCopyWords64()
200 : * to perform data type translation.
201 : *
202 : * @param nPixelSpace The byte offset from the start of one pixel value in
203 : * pData to the start of the next pixel value within a scanline. If defaulted
204 : * (0) the size of the datatype eBufType is used.
205 : *
206 : * @param nLineSpace The byte offset from the start of one scanline in
207 : * pData to the start of the next. If defaulted (0) the size of the datatype
208 : * eBufType * nBufXSize is used.
209 : *
210 : * @param psExtraArg (new in GDAL 2.0) pointer to a GDALRasterIOExtraArg
211 : * structure with additional arguments to specify resampling and progress
212 : * callback, or NULL for default behavior. The GDAL_RASTERIO_RESAMPLING
213 : * configuration option can also be defined to override the default resampling
214 : * to one of BILINEAR, CUBIC, CUBICSPLINE, LANCZOS, AVERAGE or MODE.
215 : *
216 : * @return CE_Failure if the access fails, otherwise CE_None.
217 : */
218 :
219 : /**
220 : * \brief Read/write a region of image data for this band.
221 : *
222 : * This method allows reading a region of a GDALRasterBand into a buffer,
223 : * or writing data from a buffer into a region of a GDALRasterBand. It
224 : * automatically takes care of data type translation if the data type
225 : * (eBufType) of the buffer is different than that of the GDALRasterBand.
226 : * The method also takes care of image decimation / replication if the
227 : * buffer size (nBufXSize x nBufYSize) is different than the size of the
228 : * region being accessed (nXSize x nYSize).
229 : *
230 : * The window of interest expressed by (nXOff, nYOff, nXSize, nYSize) should be
231 : * fully within the raster space, that is nXOff >= 0, nYOff >= 0,
232 : * nXOff + nXSize <= GetXSize() and nYOff + nYSize <= GetYSize().
233 : * If reads larger than the raster space are wished, GDALTranslate() might be used.
234 : * Or use nLineSpace and a possibly shifted pData value.
235 : *
236 : * The nPixelSpace and nLineSpace parameters allow reading into or
237 : * writing from unusually organized buffers. This is primarily used
238 : * for buffers containing more than one bands raster data in interleaved
239 : * format.
240 : *
241 : * Some formats may efficiently implement decimation into a buffer by
242 : * reading from lower resolution overview images. The logic of the default
243 : * implementation in the base class GDALRasterBand is the following one. It
244 : * computes a target_downscaling_factor from the window of interest and buffer
245 : * size which is min(nXSize/nBufXSize, nYSize/nBufYSize).
246 : * It then walks through overviews and will select the first one whose
247 : * downscaling factor is greater than target_downscaling_factor / 1.2.
248 : *
249 : * Let's assume we have overviews at downscaling factors 2, 4 and 8.
250 : * The relationship between target_downscaling_factor and the select overview
251 : * level is the following one:
252 : *
253 : * target_downscaling_factor | selected_overview
254 : * ------------------------- | -----------------
255 : * ]0, 2 / 1.2] | full resolution band
256 : * ]2 / 1.2, 4 / 1.2] | 2x downsampled band
257 : * ]4 / 1.2, 8 / 1.2] | 4x downsampled band
258 : * ]8 / 1.2, infinity[ | 8x downsampled band
259 : *
260 : * For highest performance full resolution data access, read and write
261 : * on "block boundaries" as returned by GetBlockSize(), or use the
262 : * ReadBlock() and WriteBlock() methods.
263 : *
264 : * This method is the same as the C GDALRasterIO() or GDALRasterIOEx()
265 : * functions.
266 : *
267 : * Starting with GDAL 3.10, the GDALRasterBand::ReadRaster() methods may be
268 : * more convenient to use for most common use cases.
269 : *
270 : * As nearly all GDAL methods, this method is *NOT* thread-safe, that is it cannot
271 : * be called on the same GDALRasterBand instance (or another GDALRasterBand
272 : * instance of this dataset) concurrently from several threads.
273 : *
274 : * @param eRWFlag Either GF_Read to read a region of data, or GF_Write to
275 : * write a region of data.
276 : *
277 : * @param nXOff The pixel offset to the top left corner of the region
278 : * of the band to be accessed. This would be zero to start from the left side.
279 : *
280 : * @param nYOff The line offset to the top left corner of the region
281 : * of the band to be accessed. This would be zero to start from the top.
282 : *
283 : * @param nXSize The width of the region of the band to be accessed in pixels.
284 : *
285 : * @param nYSize The height of the region of the band to be accessed in lines.
286 : *
287 : * @param[in,out] pData The buffer into which the data should be read, or from
288 : * which it should be written. This buffer must contain at least nBufXSize *
289 : * nBufYSize words of type eBufType. It is organized in left to right,
290 : * top to bottom pixel order. Spacing is controlled by the nPixelSpace,
291 : * and nLineSpace parameters.
292 : *
293 : * @param nBufXSize the width of the buffer image into which the desired region
294 : * is to be read, or from which it is to be written.
295 : *
296 : * @param nBufYSize the height of the buffer image into which the desired region
297 : * is to be read, or from which it is to be written.
298 : *
299 : * @param eBufType the type of the pixel values in the pData data buffer. The
300 : * pixel values will automatically be translated to/from the GDALRasterBand
301 : * data type as needed.
302 : *
303 : * @param nPixelSpace The byte offset from the start of one pixel value in
304 : * pData to the start of the next pixel value within a scanline. If defaulted
305 : * (0) the size of the datatype eBufType is used.
306 : *
307 : * @param nLineSpace The byte offset from the start of one scanline in
308 : * pData to the start of the next. If defaulted (0) the size of the datatype
309 : * eBufType * nBufXSize is used.
310 : *
311 : * @param[in] psExtraArg (new in GDAL 2.0) pointer to a GDALRasterIOExtraArg
312 : * structure with additional arguments to specify resampling and progress
313 : * callback, or NULL for default behavior. The GDAL_RASTERIO_RESAMPLING
314 : * configuration option can also be defined to override the default resampling
315 : * to one of BILINEAR, CUBIC, CUBICSPLINE, LANCZOS, AVERAGE or MODE.
316 : *
317 : * @return CE_Failure if the access fails, otherwise CE_None.
318 : *
319 : * @see GDALRasterBand::ReadRaster()
320 : */
321 :
322 4404220 : CPLErr GDALRasterBand::RasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
323 : int nXSize, int nYSize, void *pData,
324 : int nBufXSize, int nBufYSize,
325 : GDALDataType eBufType, GSpacing nPixelSpace,
326 : GSpacing nLineSpace,
327 : GDALRasterIOExtraArg *psExtraArg)
328 :
329 : {
330 : GDALRasterIOExtraArg sExtraArg;
331 4404220 : if (psExtraArg == nullptr)
332 : {
333 3806860 : INIT_RASTERIO_EXTRA_ARG(sExtraArg);
334 3806860 : psExtraArg = &sExtraArg;
335 : }
336 597361 : else if (CPL_UNLIKELY(psExtraArg->nVersion >
337 : RASTERIO_EXTRA_ARG_CURRENT_VERSION))
338 : {
339 0 : ReportError(CE_Failure, CPLE_AppDefined,
340 : "Unhandled version of GDALRasterIOExtraArg");
341 0 : return CE_Failure;
342 : }
343 :
344 4404220 : GDALRasterIOExtraArgSetResampleAlg(psExtraArg, nXSize, nYSize, nBufXSize,
345 : nBufYSize);
346 :
347 4405720 : if (CPL_UNLIKELY(nullptr == pData))
348 : {
349 0 : ReportError(CE_Failure, CPLE_AppDefined,
350 : "The buffer into which the data should be read is null");
351 0 : return CE_Failure;
352 : }
353 :
354 : /* -------------------------------------------------------------------- */
355 : /* Some size values are "noop". Lets just return to avoid */
356 : /* stressing lower level functions. */
357 : /* -------------------------------------------------------------------- */
358 4405720 : if (CPL_UNLIKELY(nXSize < 1 || nYSize < 1 || nBufXSize < 1 ||
359 : nBufYSize < 1))
360 : {
361 2 : CPLDebug("GDAL",
362 : "RasterIO() skipped for odd window or buffer size.\n"
363 : " Window = (%d,%d)x%dx%d\n"
364 : " Buffer = %dx%d\n",
365 : nXOff, nYOff, nXSize, nYSize, nBufXSize, nBufYSize);
366 :
367 2 : return CE_None;
368 : }
369 :
370 4405720 : if (eRWFlag == GF_Write)
371 : {
372 363028 : if (CPL_UNLIKELY(eFlushBlockErr != CE_None))
373 : {
374 0 : ReportError(eFlushBlockErr, CPLE_AppDefined,
375 : "An error occurred while writing a dirty block "
376 : "from GDALRasterBand::RasterIO");
377 0 : CPLErr eErr = eFlushBlockErr;
378 0 : eFlushBlockErr = CE_None;
379 0 : return eErr;
380 : }
381 363028 : if (EmitErrorMessageIfWriteNotSupported("GDALRasterBand::RasterIO()"))
382 : {
383 7 : return CE_Failure;
384 : }
385 : }
386 :
387 : /* -------------------------------------------------------------------- */
388 : /* If pixel and line spacing are defaulted assign reasonable */
389 : /* value assuming a packed buffer. */
390 : /* -------------------------------------------------------------------- */
391 4405730 : if (nPixelSpace == 0)
392 : {
393 4007710 : nPixelSpace = GDALGetDataTypeSizeBytes(eBufType);
394 : }
395 :
396 4404580 : if (nLineSpace == 0)
397 : {
398 3996930 : nLineSpace = nPixelSpace * nBufXSize;
399 : }
400 :
401 : /* -------------------------------------------------------------------- */
402 : /* Do some validation of parameters. */
403 : /* -------------------------------------------------------------------- */
404 4404580 : if (CPL_UNLIKELY(nXOff < 0 || nXOff > INT_MAX - nXSize ||
405 : nXOff + nXSize > nRasterXSize || nYOff < 0 ||
406 : nYOff > INT_MAX - nYSize || nYOff + nYSize > nRasterYSize))
407 : {
408 15 : ReportError(CE_Failure, CPLE_IllegalArg,
409 : "Access window out of range in RasterIO(). Requested\n"
410 : "(%d,%d) of size %dx%d on raster of %dx%d.",
411 : nXOff, nYOff, nXSize, nYSize, nRasterXSize, nRasterYSize);
412 15 : return CE_Failure;
413 : }
414 :
415 4404570 : if (CPL_UNLIKELY(eRWFlag != GF_Read && eRWFlag != GF_Write))
416 : {
417 0 : ReportError(
418 : CE_Failure, CPLE_IllegalArg,
419 : "eRWFlag = %d, only GF_Read (0) and GF_Write (1) are legal.",
420 : eRWFlag);
421 0 : return CE_Failure;
422 : }
423 4404570 : if (CPL_UNLIKELY(eBufType == GDT_Unknown || eBufType == GDT_TypeCount))
424 : {
425 2 : ReportError(CE_Failure, CPLE_IllegalArg,
426 : "Illegal GDT_Unknown/GDT_TypeCount argument");
427 2 : return CE_Failure;
428 : }
429 :
430 4404560 : return RasterIOInternal(eRWFlag, nXOff, nYOff, nXSize, nYSize, pData,
431 : nBufXSize, nBufYSize, eBufType, nPixelSpace,
432 4403390 : nLineSpace, psExtraArg);
433 : }
434 :
435 : /************************************************************************/
436 : /* RasterIOInternal() */
437 : /************************************************************************/
438 :
439 4403990 : CPLErr GDALRasterBand::RasterIOInternal(
440 : GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize,
441 : void *pData, int nBufXSize, int nBufYSize, GDALDataType eBufType,
442 : GSpacing nPixelSpace, GSpacing nLineSpace, GDALRasterIOExtraArg *psExtraArg)
443 : {
444 : /* -------------------------------------------------------------------- */
445 : /* Call the format specific function. */
446 : /* -------------------------------------------------------------------- */
447 :
448 4403990 : const bool bCallLeaveReadWrite = CPL_TO_BOOL(EnterReadWrite(eRWFlag));
449 :
450 : CPLErr eErr;
451 4402310 : if (bForceCachedIO)
452 23 : eErr = GDALRasterBand::IRasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize,
453 : pData, nBufXSize, nBufYSize, eBufType,
454 : nPixelSpace, nLineSpace, psExtraArg);
455 : else
456 : eErr =
457 4406400 : IRasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize,
458 4402280 : nBufYSize, eBufType, nPixelSpace, nLineSpace, psExtraArg);
459 :
460 4406420 : if (bCallLeaveReadWrite)
461 600155 : LeaveReadWrite();
462 :
463 4403510 : return eErr;
464 : }
465 :
466 : /************************************************************************/
467 : /* GDALRasterIO() */
468 : /************************************************************************/
469 :
470 : /**
471 : * \brief Read/write a region of image data for this band.
472 : *
473 : * Use GDALRasterIOEx() if 64 bit spacings or extra arguments (resampling
474 : * resolution, progress callback, etc. are needed)
475 : *
476 : * @see GDALRasterBand::RasterIO()
477 : */
478 :
479 3404220 : CPLErr CPL_STDCALL GDALRasterIO(GDALRasterBandH hBand, GDALRWFlag eRWFlag,
480 : int nXOff, int nYOff, int nXSize, int nYSize,
481 : void *pData, int nBufXSize, int nBufYSize,
482 : GDALDataType eBufType, int nPixelSpace,
483 : int nLineSpace)
484 :
485 : {
486 3404220 : VALIDATE_POINTER1(hBand, "GDALRasterIO", CE_Failure);
487 :
488 3404220 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
489 :
490 3405210 : return (poBand->RasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize, pData,
491 : nBufXSize, nBufYSize, eBufType, nPixelSpace,
492 3397980 : nLineSpace, nullptr));
493 : }
494 :
495 : /************************************************************************/
496 : /* GDALRasterIOEx() */
497 : /************************************************************************/
498 :
499 : /**
500 : * \brief Read/write a region of image data for this band.
501 : *
502 : * @see GDALRasterBand::RasterIO()
503 : * @since GDAL 2.0
504 : */
505 :
506 39074 : CPLErr CPL_STDCALL GDALRasterIOEx(GDALRasterBandH hBand, GDALRWFlag eRWFlag,
507 : int nXOff, int nYOff, int nXSize, int nYSize,
508 : void *pData, int nBufXSize, int nBufYSize,
509 : GDALDataType eBufType, GSpacing nPixelSpace,
510 : GSpacing nLineSpace,
511 : GDALRasterIOExtraArg *psExtraArg)
512 :
513 : {
514 39074 : VALIDATE_POINTER1(hBand, "GDALRasterIOEx", CE_Failure);
515 :
516 39074 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
517 :
518 39074 : return (poBand->RasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize, pData,
519 : nBufXSize, nBufYSize, eBufType, nPixelSpace,
520 39070 : nLineSpace, psExtraArg));
521 : }
522 :
523 : /************************************************************************/
524 : /* GetGDTFromCppType() */
525 : /************************************************************************/
526 :
527 : namespace
528 : {
529 : template <class T> struct GetGDTFromCppType;
530 :
531 : #define DEFINE_GetGDTFromCppType(T, eDT) \
532 : template <> struct GetGDTFromCppType<T> \
533 : { \
534 : static constexpr GDALDataType GDT = eDT; \
535 : }
536 :
537 : DEFINE_GetGDTFromCppType(uint8_t, GDT_Byte);
538 : DEFINE_GetGDTFromCppType(int8_t, GDT_Int8);
539 : DEFINE_GetGDTFromCppType(uint16_t, GDT_UInt16);
540 : DEFINE_GetGDTFromCppType(int16_t, GDT_Int16);
541 : DEFINE_GetGDTFromCppType(uint32_t, GDT_UInt32);
542 : DEFINE_GetGDTFromCppType(int32_t, GDT_Int32);
543 : DEFINE_GetGDTFromCppType(uint64_t, GDT_UInt64);
544 : DEFINE_GetGDTFromCppType(int64_t, GDT_Int64);
545 : DEFINE_GetGDTFromCppType(GFloat16, GDT_Float16);
546 : DEFINE_GetGDTFromCppType(float, GDT_Float32);
547 : DEFINE_GetGDTFromCppType(double, GDT_Float64);
548 : // Not allowed by C++ standard
549 : //DEFINE_GetGDTFromCppType(std::complex<int16_t>, GDT_CInt16);
550 : //DEFINE_GetGDTFromCppType(std::complex<int32_t>, GDT_CInt32);
551 : DEFINE_GetGDTFromCppType(std::complex<float>, GDT_CFloat32);
552 : DEFINE_GetGDTFromCppType(std::complex<double>, GDT_CFloat64);
553 : } // namespace
554 :
555 : /************************************************************************/
556 : /* ReadRaster() */
557 : /************************************************************************/
558 :
559 : // clang-format off
560 : /** Read a region of image data for this band.
561 : *
562 : * This is a slightly more convenient alternative to GDALRasterBand::RasterIO()
563 : * for common use cases, like reading a whole band.
564 : * It infers the GDAL data type of the buffer from the C/C++ type of the buffer.
565 : * This template is instantiated for the following types: [u?]int[8|16|32|64]_t,
566 : * float, double, std::complex<float|double>.
567 : *
568 : * When possible prefer the ReadRaster(std::vector<T>& vData, double dfXOff, double dfYOff, double dfXSize, double dfYSize, size_t nBufXSize, size_t nBufYSize, GDALRIOResampleAlg eResampleAlg, GDALProgressFunc pfnProgress, void *pProgressData) const variant that takes a std::vector<T>&,
569 : * and can allocate memory automatically.
570 : *
571 : * To read a whole band (assuming it fits into memory), as an array of double:
572 : *
573 : \code{.cpp}
574 : double* myArray = static_cast<double*>(
575 : VSI_MALLOC3_VERBOSE(sizeof(double), poBand->GetXSize(), poBand->GetYSize()));
576 : // TODO: check here that myArray != nullptr
577 : const size_t nArrayEltCount =
578 : static_cast<size_t>(poBand->GetXSize()) * poBand->GetYSize());
579 : if (poBand->ReadRaster(myArray, nArrayEltCount) == CE_None)
580 : {
581 : // do something
582 : }
583 : VSIFree(myArray)
584 : \endcode
585 : *
586 : * To read 128x128 pixels starting at (col=12, line=24) as an array of double:
587 : *
588 : \code{.cpp}
589 : double* myArray = static_cast<double*>(
590 : VSI_MALLOC3_VERBOSE(sizeof(double), 128, 128));
591 : // TODO: check here that myArray != nullptr
592 : const size_t nArrayEltCount = 128 * 128;
593 : if (poBand->ReadRaster(myArray, nArrayEltCount, 12, 24, 128, 128) == CE_None)
594 : {
595 : // do something
596 : }
597 : VSIFree(myArray)
598 : \endcode
599 : *
600 : * As nearly all GDAL methods, this method is *NOT* thread-safe, that is it cannot
601 : * be called on the same GDALRasterBand instance (or another GDALRasterBand
602 : * instance of this dataset) concurrently from several threads.
603 : *
604 : * The window of interest expressed by (dfXOff, dfYOff, dfXSize, dfYSize) should be
605 : * fully within the raster space, that is dfXOff >= 0, dfYOff >= 0,
606 : * dfXOff + dfXSize <= GetXSize() and dfYOff + dfYSize <= GetYSize().
607 : * If reads larger than the raster space are wished, GDALTranslate() might be used.
608 : * Or use nLineSpace and a possibly shifted pData value.
609 : *
610 : * @param[out] pData The buffer into which the data should be written.
611 : * This buffer must contain at least nBufXSize *
612 : * nBufYSize words of type T. It is organized in left to right,
613 : * top to bottom pixel order, and fully packed.
614 : * The type of the buffer does not need to be the one of GetDataType(). The
615 : * method will perform data type translation (with potential rounding, clamping)
616 : * if needed.
617 : *
618 : * @param nArrayEltCount Number of values of pData. If non zero, the method will
619 : * check that it is at least greater or equal to nBufXSize * nBufYSize, and
620 : * return in error if it is not. If set to zero, then pData is trusted to be
621 : * large enough.
622 : *
623 : * @param dfXOff The pixel offset to the top left corner of the region
624 : * of the band to be accessed. This would be zero to start from the left side.
625 : * Defaults to 0.
626 : *
627 : * @param dfYOff The line offset to the top left corner of the region
628 : * of the band to be accessed. This would be zero to start from the top.
629 : * Defaults to 0.
630 : *
631 : * @param dfXSize The width of the region of the band to be accessed in pixels.
632 : * If all of dfXOff, dfYOff, dfXSize and dfYSize are left to their zero default value,
633 : * dfXSize is set to the band width.
634 : *
635 : * @param dfYSize The height of the region of the band to be accessed in lines.
636 : * If all of dfXOff, dfYOff, dfXSize and dfYSize are left to their zero default value,
637 : * dfYSize is set to the band height.
638 : *
639 : * @param nBufXSize the width of the buffer image into which the desired region
640 : * is to be read. If set to zero, and both dfXSize and dfYSize are integer values,
641 : * then nBufXSize is initialized with dfXSize.
642 : *
643 : * @param nBufYSize the height of the buffer image into which the desired region
644 : * is to be read. If set to zero, and both dfXSize and dfYSize are integer values,
645 : * then nBufYSize is initialized with dfYSize.
646 : *
647 : * @param eResampleAlg Resampling algorithm. Defaults to GRIORA_NearestNeighbour.
648 : *
649 : * @param pfnProgress Progress function. May be nullptr.
650 : *
651 : * @param pProgressData User data of pfnProgress. May be nullptr.
652 : *
653 : * @return CE_Failure if the access fails, otherwise CE_None.
654 : *
655 : * @see GDALRasterBand::RasterIO()
656 : * @since GDAL 3.10
657 : */
658 : // clang-format on
659 :
660 : template <class T>
661 20 : CPLErr GDALRasterBand::ReadRaster(T *pData, size_t nArrayEltCount,
662 : double dfXOff, double dfYOff, double dfXSize,
663 : double dfYSize, size_t nBufXSize,
664 : size_t nBufYSize,
665 : GDALRIOResampleAlg eResampleAlg,
666 : GDALProgressFunc pfnProgress,
667 : void *pProgressData) const
668 : {
669 20 : if (((nBufXSize | nBufYSize) >> 31) != 0)
670 : {
671 2 : return CE_Failure;
672 : }
673 :
674 18 : if (dfXOff == 0 && dfYOff == 0 && dfXSize == 0 && dfYSize == 0)
675 : {
676 16 : dfXSize = nRasterXSize;
677 16 : dfYSize = nRasterYSize;
678 : }
679 2 : else if (!(dfXOff >= 0 && dfXOff <= INT_MAX) ||
680 2 : !(dfYOff >= 0 && dfYOff <= INT_MAX) || !(dfXSize >= 0) ||
681 2 : !(dfYSize >= 0) || dfXOff + dfXSize > INT_MAX ||
682 2 : dfYOff + dfYSize > INT_MAX)
683 : {
684 0 : return CE_Failure;
685 : }
686 :
687 : GDALRasterIOExtraArg sExtraArg;
688 18 : sExtraArg.nVersion = 1;
689 18 : sExtraArg.eResampleAlg = eResampleAlg;
690 18 : sExtraArg.pfnProgress = pfnProgress;
691 18 : sExtraArg.pProgressData = pProgressData;
692 18 : sExtraArg.bFloatingPointWindowValidity = true;
693 18 : sExtraArg.dfXOff = dfXOff;
694 18 : sExtraArg.dfYOff = dfYOff;
695 18 : sExtraArg.dfXSize = dfXSize;
696 18 : sExtraArg.dfYSize = dfYSize;
697 18 : const int nXOff = static_cast<int>(dfXOff);
698 18 : const int nYOff = static_cast<int>(dfYOff);
699 18 : const int nXSize = std::max(1, static_cast<int>(dfXSize + 0.5));
700 18 : const int nYSize = std::max(1, static_cast<int>(dfYSize + 0.5));
701 18 : if (nBufXSize == 0 && nBufYSize == 0)
702 : {
703 17 : if (static_cast<int>(dfXSize) == dfXSize &&
704 17 : static_cast<int>(dfYSize) == dfYSize)
705 : {
706 17 : nBufXSize = static_cast<int>(dfXSize);
707 17 : nBufYSize = static_cast<int>(dfYSize);
708 : }
709 : else
710 : {
711 0 : CPLError(CE_Failure, CPLE_AppDefined,
712 : "nBufXSize and nBufYSize must be provided if dfXSize or "
713 : "dfYSize is not an integer value");
714 0 : return CE_Failure;
715 : }
716 : }
717 18 : if (nBufXSize == 0 || nBufYSize == 0)
718 : {
719 0 : CPLDebug("GDAL",
720 : "RasterIO() skipped for odd window or buffer size.\n"
721 : " Window = (%d,%d)x%dx%d\n"
722 : " Buffer = %dx%d\n",
723 : nXOff, nYOff, nXSize, nYSize, static_cast<int>(nBufXSize),
724 : static_cast<int>(nBufYSize));
725 :
726 0 : return CE_None;
727 : }
728 :
729 18 : if (nArrayEltCount > 0 && nBufXSize > nArrayEltCount / nBufYSize)
730 : {
731 1 : CPLError(CE_Failure, CPLE_AppDefined,
732 : "Provided array is not large enough");
733 1 : return CE_Failure;
734 : }
735 :
736 17 : constexpr GSpacing nPixelSpace = sizeof(T);
737 17 : const GSpacing nLineSpace = nPixelSpace * nBufXSize;
738 17 : constexpr GDALDataType eBufType = GetGDTFromCppType<T>::GDT;
739 :
740 17 : GDALRasterBand *pThis = const_cast<GDALRasterBand *>(this);
741 :
742 : return pThis->RasterIOInternal(GF_Read, nXOff, nYOff, nXSize, nYSize, pData,
743 : static_cast<int>(nBufXSize),
744 : static_cast<int>(nBufYSize), eBufType,
745 17 : nPixelSpace, nLineSpace, &sExtraArg);
746 : }
747 :
748 : //! @cond Doxygen_Suppress
749 :
750 : #define INSTANTIATE_READ_RASTER(T) \
751 : template CPLErr CPL_DLL GDALRasterBand::ReadRaster( \
752 : T *vData, size_t nArrayEltCount, double dfXOff, double dfYOff, \
753 : double dfXSize, double dfYSize, size_t nBufXSize, size_t nBufYSize, \
754 : GDALRIOResampleAlg eResampleAlg, GDALProgressFunc pfnProgress, \
755 : void *pProgressData) const;
756 :
757 : INSTANTIATE_READ_RASTER(uint8_t)
758 : INSTANTIATE_READ_RASTER(int8_t)
759 : INSTANTIATE_READ_RASTER(uint16_t)
760 : INSTANTIATE_READ_RASTER(int16_t)
761 : INSTANTIATE_READ_RASTER(uint32_t)
762 : INSTANTIATE_READ_RASTER(int32_t)
763 : INSTANTIATE_READ_RASTER(uint64_t)
764 : INSTANTIATE_READ_RASTER(int64_t)
765 : INSTANTIATE_READ_RASTER(GFloat16)
766 : INSTANTIATE_READ_RASTER(float)
767 : INSTANTIATE_READ_RASTER(double)
768 : // Not allowed by C++ standard
769 : // INSTANTIATE_READ_RASTER(std::complex<int16_t>)
770 : // INSTANTIATE_READ_RASTER(std::complex<int32_t>)
771 : INSTANTIATE_READ_RASTER(std::complex<float>)
772 : INSTANTIATE_READ_RASTER(std::complex<double>)
773 :
774 : //! @endcond
775 :
776 : /************************************************************************/
777 : /* ReadRaster() */
778 : /************************************************************************/
779 :
780 : /** Read a region of image data for this band.
781 : *
782 : * This is a slightly more convenient alternative to GDALRasterBand::RasterIO()
783 : * for common use cases, like reading a whole band.
784 : * It infers the GDAL data type of the buffer from the C/C++ type of the buffer.
785 : * This template is instantiated for the following types: [u?]int[8|16|32|64]_t,
786 : * float, double, std::complex<float|double>.
787 : *
788 : * To read a whole band (assuming it fits into memory), as a vector of double:
789 : *
790 : \code
791 : std::vector<double> myArray;
792 : if (poBand->ReadRaster(myArray) == CE_None)
793 : {
794 : // do something
795 : }
796 : \endcode
797 : *
798 : * To read 128x128 pixels starting at (col=12, line=24) as a vector of double:
799 : *
800 : \code{.cpp}
801 : std::vector<double> myArray;
802 : if (poBand->ReadRaster(myArray, 12, 24, 128, 128) == CE_None)
803 : {
804 : // do something
805 : }
806 : \endcode
807 : *
808 : * As nearly all GDAL methods, this method is *NOT* thread-safe, that is it cannot
809 : * be called on the same GDALRasterBand instance (or another GDALRasterBand
810 : * instance of this dataset) concurrently from several threads.
811 : *
812 : * The window of interest expressed by (dfXOff, dfYOff, dfXSize, dfYSize) should be
813 : * fully within the raster space, that is dfXOff >= 0, dfYOff >= 0,
814 : * dfXOff + dfXSize <= GetXSize() and dfYOff + dfYSize <= GetYSize().
815 : * If reads larger than the raster space are wished, GDALTranslate() might be used.
816 : * Or use nLineSpace and a possibly shifted pData value.
817 : *
818 : * @param[out] vData The vector into which the data should be written.
819 : * The vector will be resized, if needed, to contain at least nBufXSize *
820 : * nBufYSize values. The values in the vector are organized in left to right,
821 : * top to bottom pixel order, and fully packed.
822 : * The type of the vector does not need to be the one of GetDataType(). The
823 : * method will perform data type translation (with potential rounding, clamping)
824 : * if needed.
825 : *
826 : * @param dfXOff The pixel offset to the top left corner of the region
827 : * of the band to be accessed. This would be zero to start from the left side.
828 : * Defaults to 0.
829 : *
830 : * @param dfYOff The line offset to the top left corner of the region
831 : * of the band to be accessed. This would be zero to start from the top.
832 : * Defaults to 0.
833 : *
834 : * @param dfXSize The width of the region of the band to be accessed in pixels.
835 : * If all of dfXOff, dfYOff, dfXSize and dfYSize are left to their zero default value,
836 : * dfXSize is set to the band width.
837 : *
838 : * @param dfYSize The height of the region of the band to be accessed in lines.
839 : * If all of dfXOff, dfYOff, dfXSize and dfYSize are left to their zero default value,
840 : * dfYSize is set to the band height.
841 : *
842 : * @param nBufXSize the width of the buffer image into which the desired region
843 : * is to be read. If set to zero, and both dfXSize and dfYSize are integer values,
844 : * then nBufXSize is initialized with dfXSize.
845 : *
846 : * @param nBufYSize the height of the buffer image into which the desired region
847 : * is to be read. If set to zero, and both dfXSize and dfYSize are integer values,
848 : * then nBufYSize is initialized with dfYSize.
849 : *
850 : * @param eResampleAlg Resampling algorithm. Defaults to GRIORA_NearestNeighbour.
851 : *
852 : * @param pfnProgress Progress function. May be nullptr.
853 : *
854 : * @param pProgressData User data of pfnProgress. May be nullptr.
855 : *
856 : * @return CE_Failure if the access fails, otherwise CE_None.
857 : *
858 : * @see GDALRasterBand::RasterIO()
859 : * @since GDAL 3.10
860 : */
861 : template <class T>
862 22 : CPLErr GDALRasterBand::ReadRaster(std::vector<T> &vData, double dfXOff,
863 : double dfYOff, double dfXSize, double dfYSize,
864 : size_t nBufXSize, size_t nBufYSize,
865 : GDALRIOResampleAlg eResampleAlg,
866 : GDALProgressFunc pfnProgress,
867 : void *pProgressData) const
868 : {
869 22 : if (((nBufXSize | nBufYSize) >> 31) != 0)
870 : {
871 2 : return CE_Failure;
872 : }
873 :
874 20 : if (dfXOff == 0 && dfYOff == 0 && dfXSize == 0 && dfYSize == 0)
875 : {
876 13 : dfXSize = nRasterXSize;
877 13 : dfYSize = nRasterYSize;
878 : }
879 7 : else if (!(dfXOff >= 0 && dfXOff <= INT_MAX) ||
880 7 : !(dfYOff >= 0 && dfYOff <= INT_MAX) || !(dfXSize >= 0) ||
881 7 : !(dfYSize >= 0) || dfXOff + dfXSize > INT_MAX ||
882 7 : dfYOff + dfYSize > INT_MAX)
883 : {
884 0 : return CE_Failure;
885 : }
886 :
887 : GDALRasterIOExtraArg sExtraArg;
888 20 : sExtraArg.nVersion = 1;
889 20 : sExtraArg.eResampleAlg = eResampleAlg;
890 20 : sExtraArg.pfnProgress = pfnProgress;
891 20 : sExtraArg.pProgressData = pProgressData;
892 20 : sExtraArg.bFloatingPointWindowValidity = true;
893 20 : sExtraArg.dfXOff = dfXOff;
894 20 : sExtraArg.dfYOff = dfYOff;
895 20 : sExtraArg.dfXSize = dfXSize;
896 20 : sExtraArg.dfYSize = dfYSize;
897 20 : const int nXOff = static_cast<int>(dfXOff);
898 20 : const int nYOff = static_cast<int>(dfYOff);
899 20 : const int nXSize = std::max(1, static_cast<int>(dfXSize + 0.5));
900 20 : const int nYSize = std::max(1, static_cast<int>(dfYSize + 0.5));
901 20 : if (nBufXSize == 0 && nBufYSize == 0)
902 : {
903 16 : if (static_cast<int>(dfXSize) == dfXSize &&
904 15 : static_cast<int>(dfYSize) == dfYSize)
905 : {
906 15 : nBufXSize = static_cast<int>(dfXSize);
907 15 : nBufYSize = static_cast<int>(dfYSize);
908 : }
909 : else
910 : {
911 1 : CPLError(CE_Failure, CPLE_AppDefined,
912 : "nBufXSize and nBufYSize must be provided if "
913 : "dfXSize or dfYSize is not an integer value");
914 1 : return CE_Failure;
915 : }
916 : }
917 19 : if (nBufXSize == 0 || nBufYSize == 0)
918 : {
919 0 : CPLDebug("GDAL",
920 : "RasterIO() skipped for odd window or buffer size.\n"
921 : " Window = (%d,%d)x%dx%d\n"
922 : " Buffer = %dx%d\n",
923 : nXOff, nYOff, nXSize, nYSize, static_cast<int>(nBufXSize),
924 : static_cast<int>(nBufYSize));
925 :
926 0 : return CE_None;
927 : }
928 :
929 : if constexpr (SIZEOF_VOIDP < 8)
930 : {
931 : if (nBufXSize > std::numeric_limits<size_t>::max() / nBufYSize)
932 : {
933 : CPLError(CE_Failure, CPLE_OutOfMemory, "Too large buffer");
934 : return CE_Failure;
935 : }
936 : }
937 :
938 19 : if (vData.size() < nBufXSize * nBufYSize)
939 : {
940 : try
941 : {
942 17 : vData.resize(nBufXSize * nBufYSize);
943 : }
944 1 : catch (const std::exception &)
945 : {
946 1 : CPLError(CE_Failure, CPLE_OutOfMemory, "Cannot resize array");
947 1 : return CE_Failure;
948 : }
949 : }
950 :
951 18 : constexpr GSpacing nPixelSpace = sizeof(T);
952 18 : const GSpacing nLineSpace = nPixelSpace * nBufXSize;
953 18 : constexpr GDALDataType eBufType = GetGDTFromCppType<T>::GDT;
954 :
955 18 : GDALRasterBand *pThis = const_cast<GDALRasterBand *>(this);
956 :
957 : return pThis->RasterIOInternal(GF_Read, nXOff, nYOff, nXSize, nYSize,
958 : vData.data(), static_cast<int>(nBufXSize),
959 : static_cast<int>(nBufYSize), eBufType,
960 18 : nPixelSpace, nLineSpace, &sExtraArg);
961 : }
962 :
963 : //! @cond Doxygen_Suppress
964 :
965 : #define INSTANTIATE_READ_RASTER_VECTOR(T) \
966 : template CPLErr CPL_DLL GDALRasterBand::ReadRaster( \
967 : std::vector<T> &vData, double dfXOff, double dfYOff, double dfXSize, \
968 : double dfYSize, size_t nBufXSize, size_t nBufYSize, \
969 : GDALRIOResampleAlg eResampleAlg, GDALProgressFunc pfnProgress, \
970 : void *pProgressData) const;
971 :
972 : INSTANTIATE_READ_RASTER_VECTOR(uint8_t)
973 : INSTANTIATE_READ_RASTER_VECTOR(int8_t)
974 : INSTANTIATE_READ_RASTER_VECTOR(uint16_t)
975 : INSTANTIATE_READ_RASTER_VECTOR(int16_t)
976 : INSTANTIATE_READ_RASTER_VECTOR(uint32_t)
977 : INSTANTIATE_READ_RASTER_VECTOR(int32_t)
978 : INSTANTIATE_READ_RASTER_VECTOR(uint64_t)
979 : INSTANTIATE_READ_RASTER_VECTOR(int64_t)
980 : INSTANTIATE_READ_RASTER_VECTOR(GFloat16)
981 : INSTANTIATE_READ_RASTER_VECTOR(float)
982 : INSTANTIATE_READ_RASTER_VECTOR(double)
983 : // Not allowed by C++ standard
984 : // INSTANTIATE_READ_RASTER_VECTOR(std::complex<int16_t>)
985 : // INSTANTIATE_READ_RASTER_VECTOR(std::complex<int32_t>)
986 : INSTANTIATE_READ_RASTER_VECTOR(std::complex<float>)
987 : INSTANTIATE_READ_RASTER_VECTOR(std::complex<double>)
988 :
989 : //! @endcond
990 :
991 : /************************************************************************/
992 : /* ReadBlock() */
993 : /************************************************************************/
994 :
995 : /**
996 : * \brief Read a block of image data efficiently.
997 : *
998 : * This method accesses a "natural" block from the raster band without
999 : * resampling, or data type conversion. For a more generalized, but
1000 : * potentially less efficient access use RasterIO().
1001 : *
1002 : * This method is the same as the C GDALReadBlock() function.
1003 : *
1004 : * See the GetLockedBlockRef() method for a way of accessing internally cached
1005 : * block oriented data without an extra copy into an application buffer.
1006 : *
1007 : * The following code would efficiently compute a histogram of eight bit
1008 : * raster data. Note that the final block may be partial ... data beyond
1009 : * the edge of the underlying raster band in these edge blocks is of an
1010 : * undetermined value.
1011 : *
1012 : \code{.cpp}
1013 : CPLErr GetHistogram( GDALRasterBand *poBand, GUIntBig *panHistogram )
1014 :
1015 : {
1016 : memset( panHistogram, 0, sizeof(GUIntBig) * 256 );
1017 :
1018 : CPLAssert( poBand->GetRasterDataType() == GDT_Byte );
1019 :
1020 : int nXBlockSize, nYBlockSize;
1021 :
1022 : poBand->GetBlockSize( &nXBlockSize, &nYBlockSize );
1023 : int nXBlocks = DIV_ROUND_UP(poBand->GetXSize(), nXBlockSize);
1024 : int nYBlocks = DIV_ROUND_UP(poBand->GetYSize(), nYBlockSize);
1025 :
1026 : GByte *pabyData = (GByte *) CPLMalloc(nXBlockSize * nYBlockSize);
1027 :
1028 : for( int iYBlock = 0; iYBlock < nYBlocks; iYBlock++ )
1029 : {
1030 : for( int iXBlock = 0; iXBlock < nXBlocks; iXBlock++ )
1031 : {
1032 : int nXValid, nYValid;
1033 :
1034 : poBand->ReadBlock( iXBlock, iYBlock, pabyData );
1035 :
1036 : // Compute the portion of the block that is valid
1037 : // for partial edge blocks.
1038 : poBand->GetActualBlockSize(iXBlock, iYBlock, &nXValid, &nYValid)
1039 :
1040 : // Collect the histogram counts.
1041 : for( int iY = 0; iY < nYValid; iY++ )
1042 : {
1043 : for( int iX = 0; iX < nXValid; iX++ )
1044 : {
1045 : panHistogram[pabyData[iX + iY * nXBlockSize]] += 1;
1046 : }
1047 : }
1048 : }
1049 : }
1050 : }
1051 : \endcode
1052 : *
1053 : * @param nXBlockOff the horizontal block offset, with zero indicating
1054 : * the left most block, 1 the next block and so forth.
1055 : *
1056 : * @param nYBlockOff the vertical block offset, with zero indicating
1057 : * the top most block, 1 the next block and so forth.
1058 : *
1059 : * @param pImage the buffer into which the data will be read. The buffer
1060 : * must be large enough to hold GetBlockXSize()*GetBlockYSize() words
1061 : * of type GetRasterDataType().
1062 : *
1063 : * @return CE_None on success or CE_Failure on an error.
1064 : */
1065 :
1066 879 : CPLErr GDALRasterBand::ReadBlock(int nXBlockOff, int nYBlockOff, void *pImage)
1067 :
1068 : {
1069 : /* -------------------------------------------------------------------- */
1070 : /* Validate arguments. */
1071 : /* -------------------------------------------------------------------- */
1072 879 : CPLAssert(pImage != nullptr);
1073 :
1074 879 : if (!InitBlockInfo())
1075 0 : return CE_Failure;
1076 :
1077 879 : if (nXBlockOff < 0 || nXBlockOff >= nBlocksPerRow)
1078 : {
1079 0 : ReportError(CE_Failure, CPLE_IllegalArg,
1080 : "Illegal nXBlockOff value (%d) in "
1081 : "GDALRasterBand::ReadBlock()\n",
1082 : nXBlockOff);
1083 :
1084 0 : return (CE_Failure);
1085 : }
1086 :
1087 879 : if (nYBlockOff < 0 || nYBlockOff >= nBlocksPerColumn)
1088 : {
1089 0 : ReportError(CE_Failure, CPLE_IllegalArg,
1090 : "Illegal nYBlockOff value (%d) in "
1091 : "GDALRasterBand::ReadBlock()\n",
1092 : nYBlockOff);
1093 :
1094 0 : return (CE_Failure);
1095 : }
1096 :
1097 : /* -------------------------------------------------------------------- */
1098 : /* Invoke underlying implementation method. */
1099 : /* -------------------------------------------------------------------- */
1100 :
1101 879 : int bCallLeaveReadWrite = EnterReadWrite(GF_Read);
1102 879 : CPLErr eErr = IReadBlock(nXBlockOff, nYBlockOff, pImage);
1103 879 : if (bCallLeaveReadWrite)
1104 4 : LeaveReadWrite();
1105 879 : return eErr;
1106 : }
1107 :
1108 : /************************************************************************/
1109 : /* GDALReadBlock() */
1110 : /************************************************************************/
1111 :
1112 : /**
1113 : * \brief Read a block of image data efficiently.
1114 : *
1115 : * @see GDALRasterBand::ReadBlock()
1116 : */
1117 :
1118 69 : CPLErr CPL_STDCALL GDALReadBlock(GDALRasterBandH hBand, int nXOff, int nYOff,
1119 : void *pData)
1120 :
1121 : {
1122 69 : VALIDATE_POINTER1(hBand, "GDALReadBlock", CE_Failure);
1123 :
1124 69 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
1125 69 : return (poBand->ReadBlock(nXOff, nYOff, pData));
1126 : }
1127 :
1128 : /************************************************************************/
1129 : /* IReadBlock() */
1130 : /************************************************************************/
1131 :
1132 : /** \fn GDALRasterBand::IReadBlock( int nBlockXOff, int nBlockYOff, void *pData
1133 : * ) \brief Read a block of data.
1134 : *
1135 : * Default internal implementation ... to be overridden by
1136 : * subclasses that support reading.
1137 : * @param nBlockXOff Block X Offset
1138 : * @param nBlockYOff Block Y Offset
1139 : * @param pData Pixel buffer into which to place read data.
1140 : * @return CE_None on success or CE_Failure on an error.
1141 : */
1142 :
1143 : /************************************************************************/
1144 : /* IWriteBlock() */
1145 : /************************************************************************/
1146 :
1147 : /**
1148 : * \fn GDALRasterBand::IWriteBlock(int, int, void*)
1149 : * Write a block of data.
1150 : *
1151 : * Default internal implementation ... to be overridden by
1152 : * subclasses that support writing.
1153 : * @param nBlockXOff Block X Offset
1154 : * @param nBlockYOff Block Y Offset
1155 : * @param pData Pixel buffer to write
1156 : * @return CE_None on success or CE_Failure on an error.
1157 : */
1158 :
1159 : /**/
1160 : /**/
1161 :
1162 0 : CPLErr GDALRasterBand::IWriteBlock(int /*nBlockXOff*/, int /*nBlockYOff*/,
1163 : void * /*pData*/)
1164 :
1165 : {
1166 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
1167 0 : ReportError(CE_Failure, CPLE_NotSupported,
1168 : "WriteBlock() not supported for this dataset.");
1169 :
1170 0 : return (CE_Failure);
1171 : }
1172 :
1173 : /************************************************************************/
1174 : /* WriteBlock() */
1175 : /************************************************************************/
1176 :
1177 : /**
1178 : * \brief Write a block of image data efficiently.
1179 : *
1180 : * This method accesses a "natural" block from the raster band without
1181 : * resampling, or data type conversion. For a more generalized, but
1182 : * potentially less efficient access use RasterIO().
1183 : *
1184 : * This method is the same as the C GDALWriteBlock() function.
1185 : *
1186 : * See ReadBlock() for an example of block oriented data access.
1187 : *
1188 : * @param nXBlockOff the horizontal block offset, with zero indicating
1189 : * the left most block, 1 the next block and so forth.
1190 : *
1191 : * @param nYBlockOff the vertical block offset, with zero indicating
1192 : * the left most block, 1 the next block and so forth.
1193 : *
1194 : * @param pImage the buffer from which the data will be written. The buffer
1195 : * must be large enough to hold GetBlockXSize()*GetBlockYSize() words
1196 : * of type GetRasterDataType(). Note that the content of the buffer might be
1197 : * temporarily modified during the execution of this method (and eventually
1198 : * restored back to its original content), so it is not safe to use a buffer
1199 : * stored in a read-only section of the calling program.
1200 : *
1201 : * @return CE_None on success or CE_Failure on an error.
1202 : */
1203 :
1204 4888 : CPLErr GDALRasterBand::WriteBlock(int nXBlockOff, int nYBlockOff, void *pImage)
1205 :
1206 : {
1207 : /* -------------------------------------------------------------------- */
1208 : /* Validate arguments. */
1209 : /* -------------------------------------------------------------------- */
1210 4888 : CPLAssert(pImage != nullptr);
1211 :
1212 4888 : if (!InitBlockInfo())
1213 0 : return CE_Failure;
1214 :
1215 4888 : if (nXBlockOff < 0 || nXBlockOff >= nBlocksPerRow)
1216 : {
1217 0 : ReportError(CE_Failure, CPLE_IllegalArg,
1218 : "Illegal nXBlockOff value (%d) in "
1219 : "GDALRasterBand::WriteBlock()\n",
1220 : nXBlockOff);
1221 :
1222 0 : return (CE_Failure);
1223 : }
1224 :
1225 4888 : if (nYBlockOff < 0 || nYBlockOff >= nBlocksPerColumn)
1226 : {
1227 0 : ReportError(CE_Failure, CPLE_IllegalArg,
1228 : "Illegal nYBlockOff value (%d) in "
1229 : "GDALRasterBand::WriteBlock()\n",
1230 : nYBlockOff);
1231 :
1232 0 : return (CE_Failure);
1233 : }
1234 :
1235 4888 : if (EmitErrorMessageIfWriteNotSupported("GDALRasterBand::WriteBlock()"))
1236 : {
1237 0 : return CE_Failure;
1238 : }
1239 :
1240 4888 : if (eFlushBlockErr != CE_None)
1241 : {
1242 0 : ReportError(eFlushBlockErr, CPLE_AppDefined,
1243 : "An error occurred while writing a dirty block "
1244 : "from GDALRasterBand::WriteBlock");
1245 0 : CPLErr eErr = eFlushBlockErr;
1246 0 : eFlushBlockErr = CE_None;
1247 0 : return eErr;
1248 : }
1249 :
1250 : /* -------------------------------------------------------------------- */
1251 : /* Invoke underlying implementation method. */
1252 : /* -------------------------------------------------------------------- */
1253 :
1254 4888 : const bool bCallLeaveReadWrite = CPL_TO_BOOL(EnterReadWrite(GF_Write));
1255 4888 : CPLErr eErr = IWriteBlock(nXBlockOff, nYBlockOff, pImage);
1256 4888 : if (bCallLeaveReadWrite)
1257 4888 : LeaveReadWrite();
1258 :
1259 4888 : return eErr;
1260 : }
1261 :
1262 : /************************************************************************/
1263 : /* GDALWriteBlock() */
1264 : /************************************************************************/
1265 :
1266 : /**
1267 : * \brief Write a block of image data efficiently.
1268 : *
1269 : * @see GDALRasterBand::WriteBlock()
1270 : */
1271 :
1272 0 : CPLErr CPL_STDCALL GDALWriteBlock(GDALRasterBandH hBand, int nXOff, int nYOff,
1273 : void *pData)
1274 :
1275 : {
1276 0 : VALIDATE_POINTER1(hBand, "GDALWriteBlock", CE_Failure);
1277 :
1278 0 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
1279 0 : return (poBand->WriteBlock(nXOff, nYOff, pData));
1280 : }
1281 :
1282 : /************************************************************************/
1283 : /* EmitErrorMessageIfWriteNotSupported() */
1284 : /************************************************************************/
1285 :
1286 : /**
1287 : * Emit an error message if a write operation to this band is not supported.
1288 : *
1289 : * The base implementation will emit an error message if the access mode is
1290 : * read-only. Derived classes may implement it to provide a custom message.
1291 : *
1292 : * @param pszCaller Calling function.
1293 : * @return true if an error message has been emitted.
1294 : */
1295 636152 : bool GDALRasterBand::EmitErrorMessageIfWriteNotSupported(
1296 : const char *pszCaller) const
1297 : {
1298 636152 : if (eAccess == GA_ReadOnly)
1299 : {
1300 4 : ReportError(CE_Failure, CPLE_NoWriteAccess,
1301 : "%s: attempt to write to dataset opened in read-only mode.",
1302 : pszCaller);
1303 :
1304 4 : return true;
1305 : }
1306 636148 : return false;
1307 : }
1308 :
1309 : /************************************************************************/
1310 : /* GetActualBlockSize() */
1311 : /************************************************************************/
1312 : /**
1313 : * \brief Fetch the actual block size for a given block offset.
1314 : *
1315 : * Handles partial blocks at the edges of the raster and returns the true
1316 : * number of pixels
1317 : *
1318 : * @param nXBlockOff the horizontal block offset for which to calculate the
1319 : * number of valid pixels, with zero indicating the left most block, 1 the next
1320 : * block and so forth.
1321 : *
1322 : * @param nYBlockOff the vertical block offset, with zero indicating
1323 : * the top most block, 1 the next block and so forth.
1324 : *
1325 : * @param pnXValid pointer to an integer in which the number of valid pixels in
1326 : * the x direction will be stored
1327 : *
1328 : * @param pnYValid pointer to an integer in which the number of valid pixels in
1329 : * the y direction will be stored
1330 : *
1331 : * @return CE_None if the input parameters are valid, CE_Failure otherwise
1332 : *
1333 : * @since GDAL 2.2
1334 : */
1335 50481 : CPLErr GDALRasterBand::GetActualBlockSize(int nXBlockOff, int nYBlockOff,
1336 : int *pnXValid, int *pnYValid) const
1337 : {
1338 100961 : if (nXBlockOff < 0 || nBlockXSize == 0 ||
1339 100959 : nXBlockOff >= DIV_ROUND_UP(nRasterXSize, nBlockXSize) ||
1340 100956 : nYBlockOff < 0 || nBlockYSize == 0 ||
1341 50478 : nYBlockOff >= DIV_ROUND_UP(nRasterYSize, nBlockYSize))
1342 : {
1343 4 : return CE_Failure;
1344 : }
1345 :
1346 50477 : const int nXPixelOff = nXBlockOff * nBlockXSize;
1347 50477 : const int nYPixelOff = nYBlockOff * nBlockYSize;
1348 :
1349 50477 : *pnXValid = nBlockXSize;
1350 50477 : *pnYValid = nBlockYSize;
1351 :
1352 50477 : if (nXPixelOff >= nRasterXSize - nBlockXSize)
1353 : {
1354 49089 : *pnXValid = nRasterXSize - nXPixelOff;
1355 : }
1356 :
1357 50477 : if (nYPixelOff >= nRasterYSize - nBlockYSize)
1358 : {
1359 3500 : *pnYValid = nRasterYSize - nYPixelOff;
1360 : }
1361 :
1362 50477 : return CE_None;
1363 : }
1364 :
1365 : /************************************************************************/
1366 : /* GDALGetActualBlockSize() */
1367 : /************************************************************************/
1368 :
1369 : /**
1370 : * \brief Retrieve the actual block size for a given block offset.
1371 : *
1372 : * @see GDALRasterBand::GetActualBlockSize()
1373 : */
1374 :
1375 6 : CPLErr CPL_STDCALL GDALGetActualBlockSize(GDALRasterBandH hBand, int nXBlockOff,
1376 : int nYBlockOff, int *pnXValid,
1377 : int *pnYValid)
1378 :
1379 : {
1380 6 : VALIDATE_POINTER1(hBand, "GDALGetActualBlockSize", CE_Failure);
1381 :
1382 6 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
1383 : return (
1384 6 : poBand->GetActualBlockSize(nXBlockOff, nYBlockOff, pnXValid, pnYValid));
1385 : }
1386 :
1387 : /************************************************************************/
1388 : /* GetSuggestedBlockAccessPattern() */
1389 : /************************************************************************/
1390 :
1391 : /**
1392 : * \brief Return the suggested/most efficient access pattern to blocks
1393 : * (for read operations).
1394 : *
1395 : * While all GDAL drivers have to expose a block size, not all can guarantee
1396 : * efficient random access (GSBAP_RANDOM) to any block.
1397 : * Some drivers for example decompress sequentially a compressed stream from
1398 : * top raster to bottom (GSBAP_TOP_TO_BOTTOM), in which
1399 : * case best performance will be achieved while reading blocks in that order.
1400 : * (accessing blocks in random access in such rasters typically causes the
1401 : * decoding to be re-initialized from the start if accessing blocks in
1402 : * a non-sequential order)
1403 : *
1404 : * The base implementation returns GSBAP_UNKNOWN, which can also be explicitly
1405 : * returned by drivers that expose a somewhat artificial block size, because
1406 : * they can extract any part of a raster, but in a rather inefficient way.
1407 : *
1408 : * The GSBAP_LARGEST_CHUNK_POSSIBLE value can be combined as a logical bitmask
1409 : * with other enumeration values (GSBAP_UNKNOWN, GSBAP_RANDOM,
1410 : * GSBAP_TOP_TO_BOTTOM, GSBAP_BOTTOM_TO_TOP). When a driver sets this flag, the
1411 : * most efficient strategy is to read as many pixels as possible in the less
1412 : * RasterIO() operations.
1413 : *
1414 : * The return of this method is for example used to determine the swath size
1415 : * used by GDALDatasetCopyWholeRaster() and GDALRasterBandCopyWholeRaster().
1416 : *
1417 : * @since GDAL 3.6
1418 : */
1419 :
1420 : GDALSuggestedBlockAccessPattern
1421 2355 : GDALRasterBand::GetSuggestedBlockAccessPattern() const
1422 : {
1423 2355 : return GSBAP_UNKNOWN;
1424 : }
1425 :
1426 : /************************************************************************/
1427 : /* GetRasterDataType() */
1428 : /************************************************************************/
1429 :
1430 : /**
1431 : * \brief Fetch the pixel data type for this band.
1432 : *
1433 : * This method is the same as the C function GDALGetRasterDataType().
1434 : *
1435 : * @return the data type of pixels for this band.
1436 : */
1437 :
1438 8986140 : GDALDataType GDALRasterBand::GetRasterDataType() const
1439 :
1440 : {
1441 8986140 : return eDataType;
1442 : }
1443 :
1444 : /************************************************************************/
1445 : /* GDALGetRasterDataType() */
1446 : /************************************************************************/
1447 :
1448 : /**
1449 : * \brief Fetch the pixel data type for this band.
1450 : *
1451 : * @see GDALRasterBand::GetRasterDataType()
1452 : */
1453 :
1454 903544 : GDALDataType CPL_STDCALL GDALGetRasterDataType(GDALRasterBandH hBand)
1455 :
1456 : {
1457 903544 : VALIDATE_POINTER1(hBand, "GDALGetRasterDataType", GDT_Unknown);
1458 :
1459 903544 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
1460 903544 : return poBand->GetRasterDataType();
1461 : }
1462 :
1463 : /************************************************************************/
1464 : /* GetBlockSize() */
1465 : /************************************************************************/
1466 :
1467 : /**
1468 : * \brief Fetch the "natural" block size of this band.
1469 : *
1470 : * GDAL contains a concept of the natural block size of rasters so that
1471 : * applications can organized data access efficiently for some file formats.
1472 : * The natural block size is the block size that is most efficient for
1473 : * accessing the format. For many formats this is simple a whole scanline
1474 : * in which case *pnXSize is set to GetXSize(), and *pnYSize is set to 1.
1475 : *
1476 : * However, for tiled images this will typically be the tile size.
1477 : *
1478 : * Note that the X and Y block sizes don't have to divide the image size
1479 : * evenly, meaning that right and bottom edge blocks may be incomplete.
1480 : * See ReadBlock() for an example of code dealing with these issues.
1481 : *
1482 : * This method is the same as the C function GDALGetBlockSize().
1483 : *
1484 : * @param pnXSize integer to put the X block size into or NULL.
1485 : *
1486 : * @param pnYSize integer to put the Y block size into or NULL.
1487 : */
1488 :
1489 5512020 : void GDALRasterBand::GetBlockSize(int *pnXSize, int *pnYSize) const
1490 :
1491 : {
1492 5512020 : if (nBlockXSize <= 0 || nBlockYSize <= 0)
1493 : {
1494 7413 : ReportError(CE_Failure, CPLE_AppDefined,
1495 7413 : "Invalid block dimension : %d * %d", nBlockXSize,
1496 7413 : nBlockYSize);
1497 0 : if (pnXSize != nullptr)
1498 0 : *pnXSize = 0;
1499 0 : if (pnYSize != nullptr)
1500 0 : *pnYSize = 0;
1501 : }
1502 : else
1503 : {
1504 5504610 : if (pnXSize != nullptr)
1505 5504270 : *pnXSize = nBlockXSize;
1506 5504610 : if (pnYSize != nullptr)
1507 5503130 : *pnYSize = nBlockYSize;
1508 : }
1509 5504610 : }
1510 :
1511 : /************************************************************************/
1512 : /* GDALGetBlockSize() */
1513 : /************************************************************************/
1514 :
1515 : /**
1516 : * \brief Fetch the "natural" block size of this band.
1517 : *
1518 : * @see GDALRasterBand::GetBlockSize()
1519 : */
1520 :
1521 41034 : void CPL_STDCALL GDALGetBlockSize(GDALRasterBandH hBand, int *pnXSize,
1522 : int *pnYSize)
1523 :
1524 : {
1525 41034 : VALIDATE_POINTER0(hBand, "GDALGetBlockSize");
1526 :
1527 41034 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
1528 41034 : poBand->GetBlockSize(pnXSize, pnYSize);
1529 : }
1530 :
1531 : /************************************************************************/
1532 : /* InitBlockInfo() */
1533 : /************************************************************************/
1534 :
1535 : //! @cond Doxygen_Suppress
1536 3639010 : int GDALRasterBand::InitBlockInfo()
1537 :
1538 : {
1539 3639010 : if (poBandBlockCache != nullptr)
1540 3402520 : return poBandBlockCache->IsInitOK();
1541 :
1542 : /* Do some validation of raster and block dimensions in case the driver */
1543 : /* would have neglected to do it itself */
1544 236490 : if (nBlockXSize <= 0 || nBlockYSize <= 0)
1545 : {
1546 0 : ReportError(CE_Failure, CPLE_AppDefined,
1547 : "Invalid block dimension : %d * %d", nBlockXSize,
1548 : nBlockYSize);
1549 0 : return FALSE;
1550 : }
1551 :
1552 236491 : if (nRasterXSize <= 0 || nRasterYSize <= 0)
1553 : {
1554 14 : ReportError(CE_Failure, CPLE_AppDefined,
1555 : "Invalid raster dimension : %d * %d", nRasterXSize,
1556 : nRasterYSize);
1557 0 : return FALSE;
1558 : }
1559 :
1560 236477 : const int nDataTypeSize = GDALGetDataTypeSizeBytes(eDataType);
1561 236482 : if (nDataTypeSize == 0)
1562 : {
1563 0 : ReportError(CE_Failure, CPLE_AppDefined, "Invalid data type");
1564 0 : return FALSE;
1565 : }
1566 :
1567 : #if SIZEOF_VOIDP == 4
1568 : if (nBlockXSize >= 10000 || nBlockYSize >= 10000)
1569 : {
1570 : /* As 10000 * 10000 * 16 < INT_MAX, we don't need to do the
1571 : * multiplication in other cases */
1572 : if (nBlockXSize > INT_MAX / nDataTypeSize ||
1573 : nBlockYSize > INT_MAX / (nDataTypeSize * nBlockXSize))
1574 : {
1575 : ReportError(CE_Failure, CPLE_NotSupported,
1576 : "Too big block : %d * %d for 32-bit build", nBlockXSize,
1577 : nBlockYSize);
1578 : return FALSE;
1579 : }
1580 : }
1581 : #endif
1582 :
1583 236482 : nBlocksPerRow = DIV_ROUND_UP(nRasterXSize, nBlockXSize);
1584 236482 : nBlocksPerColumn = DIV_ROUND_UP(nRasterYSize, nBlockYSize);
1585 :
1586 : const char *pszBlockStrategy =
1587 236482 : CPLGetConfigOption("GDAL_BAND_BLOCK_CACHE", nullptr);
1588 236492 : bool bUseArray = true;
1589 236492 : if (pszBlockStrategy == nullptr || EQUAL(pszBlockStrategy, "AUTO"))
1590 : {
1591 236452 : if (poDS == nullptr || (poDS->nOpenFlags & GDAL_OF_BLOCK_ACCESS_MASK) ==
1592 : GDAL_OF_DEFAULT_BLOCK_ACCESS)
1593 : {
1594 236433 : GUIntBig nBlockCount =
1595 236433 : static_cast<GIntBig>(nBlocksPerRow) * nBlocksPerColumn;
1596 236433 : if (poDS != nullptr)
1597 236238 : nBlockCount *= poDS->GetRasterCount();
1598 236433 : bUseArray = (nBlockCount < 1024 * 1024);
1599 : }
1600 19 : else if ((poDS->nOpenFlags & GDAL_OF_BLOCK_ACCESS_MASK) ==
1601 : GDAL_OF_HASHSET_BLOCK_ACCESS)
1602 : {
1603 0 : bUseArray = false;
1604 236452 : }
1605 : }
1606 40 : else if (EQUAL(pszBlockStrategy, "HASHSET"))
1607 40 : bUseArray = false;
1608 0 : else if (!EQUAL(pszBlockStrategy, "ARRAY"))
1609 0 : CPLError(CE_Warning, CPLE_AppDefined, "Unknown block cache method: %s",
1610 : pszBlockStrategy);
1611 :
1612 236491 : if (bUseArray)
1613 236420 : poBandBlockCache = GDALArrayBandBlockCacheCreate(this);
1614 : else
1615 : {
1616 71 : if (nBand == 1)
1617 26 : CPLDebug("GDAL", "Use hashset band block cache");
1618 71 : poBandBlockCache = GDALHashSetBandBlockCacheCreate(this);
1619 : }
1620 236489 : if (poBandBlockCache == nullptr)
1621 0 : return FALSE;
1622 236489 : return poBandBlockCache->Init();
1623 : }
1624 :
1625 : //! @endcond
1626 :
1627 : /************************************************************************/
1628 : /* FlushCache() */
1629 : /************************************************************************/
1630 :
1631 : /**
1632 : * \brief Flush raster data cache.
1633 : *
1634 : * This call will recover memory used to cache data blocks for this raster
1635 : * band, and ensure that new requests are referred to the underlying driver.
1636 : *
1637 : * This method is the same as the C function GDALFlushRasterCache().
1638 : *
1639 : * @param bAtClosing Whether this is called from a GDALDataset destructor
1640 : * @return CE_None on success.
1641 : */
1642 :
1643 5932920 : CPLErr GDALRasterBand::FlushCache(bool bAtClosing)
1644 :
1645 : {
1646 6046550 : if (bAtClosing && poDS && poDS->IsMarkedSuppressOnClose() &&
1647 113634 : poBandBlockCache)
1648 2537 : poBandBlockCache->DisableDirtyBlockWriting();
1649 :
1650 5931830 : CPLErr eGlobalErr = eFlushBlockErr;
1651 :
1652 5931830 : if (eFlushBlockErr != CE_None)
1653 : {
1654 0 : ReportError(
1655 : eFlushBlockErr, CPLE_AppDefined,
1656 : "An error occurred while writing a dirty block from FlushCache");
1657 0 : eFlushBlockErr = CE_None;
1658 : }
1659 :
1660 5931830 : if (poBandBlockCache == nullptr || !poBandBlockCache->IsInitOK())
1661 5173360 : return eGlobalErr;
1662 :
1663 758472 : return poBandBlockCache->FlushCache();
1664 : }
1665 :
1666 : /************************************************************************/
1667 : /* GDALFlushRasterCache() */
1668 : /************************************************************************/
1669 :
1670 : /**
1671 : * \brief Flush raster data cache.
1672 : *
1673 : * @see GDALRasterBand::FlushCache()
1674 : */
1675 :
1676 133 : CPLErr CPL_STDCALL GDALFlushRasterCache(GDALRasterBandH hBand)
1677 :
1678 : {
1679 133 : VALIDATE_POINTER1(hBand, "GDALFlushRasterCache", CE_Failure);
1680 :
1681 133 : return GDALRasterBand::FromHandle(hBand)->FlushCache(false);
1682 : }
1683 :
1684 : /************************************************************************/
1685 : /* DropCache() */
1686 : /************************************************************************/
1687 :
1688 : /**
1689 : * \brief Drop raster data cache : data in cache will be lost.
1690 : *
1691 : * This call will recover memory used to cache data blocks for this raster
1692 : * band, and ensure that new requests are referred to the underlying driver.
1693 : *
1694 : * This method is the same as the C function GDALDropRasterCache().
1695 : *
1696 : * @return CE_None on success.
1697 : * @since 3.9
1698 : */
1699 :
1700 1 : CPLErr GDALRasterBand::DropCache()
1701 :
1702 : {
1703 1 : CPLErr result = CE_None;
1704 :
1705 1 : if (poBandBlockCache)
1706 1 : poBandBlockCache->DisableDirtyBlockWriting();
1707 :
1708 1 : CPLErr eGlobalErr = eFlushBlockErr;
1709 :
1710 1 : if (eFlushBlockErr != CE_None)
1711 : {
1712 0 : ReportError(
1713 : eFlushBlockErr, CPLE_AppDefined,
1714 : "An error occurred while writing a dirty block from DropCache");
1715 0 : eFlushBlockErr = CE_None;
1716 : }
1717 :
1718 1 : if (poBandBlockCache == nullptr || !poBandBlockCache->IsInitOK())
1719 0 : result = eGlobalErr;
1720 : else
1721 1 : result = poBandBlockCache->FlushCache();
1722 :
1723 1 : if (poBandBlockCache)
1724 1 : poBandBlockCache->EnableDirtyBlockWriting();
1725 :
1726 1 : return result;
1727 : }
1728 :
1729 : /************************************************************************/
1730 : /* GDALDropRasterCache() */
1731 : /************************************************************************/
1732 :
1733 : /**
1734 : * \brief Drop raster data cache.
1735 : *
1736 : * @see GDALRasterBand::DropCache()
1737 : * @since 3.9
1738 : */
1739 :
1740 0 : CPLErr CPL_STDCALL GDALDropRasterCache(GDALRasterBandH hBand)
1741 :
1742 : {
1743 0 : VALIDATE_POINTER1(hBand, "GDALDropRasterCache", CE_Failure);
1744 :
1745 0 : return GDALRasterBand::FromHandle(hBand)->DropCache();
1746 : }
1747 :
1748 : /************************************************************************/
1749 : /* UnreferenceBlock() */
1750 : /* */
1751 : /* Unreference the block from our array of blocks */
1752 : /* This method should only be called by */
1753 : /* GDALRasterBlock::Internalize() and FlushCacheBlock() (and under */
1754 : /* the block cache mutex) */
1755 : /************************************************************************/
1756 :
1757 29655 : CPLErr GDALRasterBand::UnreferenceBlock(GDALRasterBlock *poBlock)
1758 : {
1759 : #ifdef notdef
1760 : if (poBandBlockCache == nullptr || !poBandBlockCache->IsInitOK())
1761 : {
1762 : if (poBandBlockCache == nullptr)
1763 : printf("poBandBlockCache == NULL\n"); /*ok*/
1764 : else
1765 : printf("!poBandBlockCache->IsInitOK()\n"); /*ok*/
1766 : printf("caller = %s\n", pszCaller); /*ok*/
1767 : printf("GDALRasterBand: %p\n", this); /*ok*/
1768 : printf("GDALRasterBand: nBand=%d\n", nBand); /*ok*/
1769 : printf("nRasterXSize = %d\n", nRasterXSize); /*ok*/
1770 : printf("nRasterYSize = %d\n", nRasterYSize); /*ok*/
1771 : printf("nBlockXSize = %d\n", nBlockXSize); /*ok*/
1772 : printf("nBlockYSize = %d\n", nBlockYSize); /*ok*/
1773 : poBlock->DumpBlock();
1774 : if (GetDataset() != nullptr)
1775 : printf("Dataset: %s\n", GetDataset()->GetDescription()); /*ok*/
1776 : GDALRasterBlock::Verify();
1777 : abort();
1778 : }
1779 : #endif
1780 29655 : CPLAssert(poBandBlockCache && poBandBlockCache->IsInitOK());
1781 29655 : return poBandBlockCache->UnreferenceBlock(poBlock);
1782 : }
1783 :
1784 : /************************************************************************/
1785 : /* AddBlockToFreeList() */
1786 : /* */
1787 : /* When GDALRasterBlock::Internalize() or FlushCacheBlock() are */
1788 : /* finished with a block about to be free'd, they pass it to that */
1789 : /* method. */
1790 : /************************************************************************/
1791 :
1792 : //! @cond Doxygen_Suppress
1793 29653 : void GDALRasterBand::AddBlockToFreeList(GDALRasterBlock *poBlock)
1794 : {
1795 29653 : CPLAssert(poBandBlockCache && poBandBlockCache->IsInitOK());
1796 29652 : return poBandBlockCache->AddBlockToFreeList(poBlock);
1797 : }
1798 :
1799 : //! @endcond
1800 :
1801 : /************************************************************************/
1802 : /* FlushBlock() */
1803 : /************************************************************************/
1804 :
1805 : /** Flush a block out of the block cache.
1806 : * @param nXBlockOff block x offset
1807 : * @param nYBlockOff blocky offset
1808 : * @param bWriteDirtyBlock whether the block should be written to disk if dirty.
1809 : * @return CE_None in case of success, an error code otherwise.
1810 : */
1811 2310 : CPLErr GDALRasterBand::FlushBlock(int nXBlockOff, int nYBlockOff,
1812 : int bWriteDirtyBlock)
1813 :
1814 : {
1815 2310 : if (poBandBlockCache == nullptr || !poBandBlockCache->IsInitOK())
1816 0 : return (CE_Failure);
1817 :
1818 : /* -------------------------------------------------------------------- */
1819 : /* Validate the request */
1820 : /* -------------------------------------------------------------------- */
1821 2310 : if (nXBlockOff < 0 || nXBlockOff >= nBlocksPerRow)
1822 : {
1823 0 : ReportError(CE_Failure, CPLE_IllegalArg,
1824 : "Illegal nBlockXOff value (%d) in "
1825 : "GDALRasterBand::FlushBlock()\n",
1826 : nXBlockOff);
1827 :
1828 0 : return (CE_Failure);
1829 : }
1830 :
1831 2310 : if (nYBlockOff < 0 || nYBlockOff >= nBlocksPerColumn)
1832 : {
1833 0 : ReportError(CE_Failure, CPLE_IllegalArg,
1834 : "Illegal nBlockYOff value (%d) in "
1835 : "GDALRasterBand::FlushBlock()\n",
1836 : nYBlockOff);
1837 :
1838 0 : return (CE_Failure);
1839 : }
1840 :
1841 2310 : return poBandBlockCache->FlushBlock(nXBlockOff, nYBlockOff,
1842 2310 : bWriteDirtyBlock);
1843 : }
1844 :
1845 : /************************************************************************/
1846 : /* TryGetLockedBlockRef() */
1847 : /************************************************************************/
1848 :
1849 : /**
1850 : * \brief Try fetching block ref.
1851 : *
1852 : * This method will returned the requested block (locked) if it is already
1853 : * in the block cache for the layer. If not, nullptr is returned.
1854 : *
1855 : * If a non-NULL value is returned, then a lock for the block will have been
1856 : * acquired on behalf of the caller. It is absolutely imperative that the
1857 : * caller release this lock (with GDALRasterBlock::DropLock()) or else
1858 : * severe problems may result.
1859 : *
1860 : * @param nXBlockOff the horizontal block offset, with zero indicating
1861 : * the left most block, 1 the next block and so forth.
1862 : *
1863 : * @param nYBlockOff the vertical block offset, with zero indicating
1864 : * the top most block, 1 the next block and so forth.
1865 : *
1866 : * @return NULL if block not available, or locked block pointer.
1867 : */
1868 :
1869 10624100 : GDALRasterBlock *GDALRasterBand::TryGetLockedBlockRef(int nXBlockOff,
1870 : int nYBlockOff)
1871 :
1872 : {
1873 10624100 : if (poBandBlockCache == nullptr || !poBandBlockCache->IsInitOK())
1874 170467 : return nullptr;
1875 :
1876 : /* -------------------------------------------------------------------- */
1877 : /* Validate the request */
1878 : /* -------------------------------------------------------------------- */
1879 10455000 : if (nXBlockOff < 0 || nXBlockOff >= nBlocksPerRow)
1880 : {
1881 1254 : ReportError(CE_Failure, CPLE_IllegalArg,
1882 : "Illegal nBlockXOff value (%d) in "
1883 : "GDALRasterBand::TryGetLockedBlockRef()\n",
1884 : nXBlockOff);
1885 :
1886 0 : return (nullptr);
1887 : }
1888 :
1889 10453700 : if (nYBlockOff < 0 || nYBlockOff >= nBlocksPerColumn)
1890 : {
1891 103 : ReportError(CE_Failure, CPLE_IllegalArg,
1892 : "Illegal nBlockYOff value (%d) in "
1893 : "GDALRasterBand::TryGetLockedBlockRef()\n",
1894 : nYBlockOff);
1895 :
1896 0 : return (nullptr);
1897 : }
1898 :
1899 10453600 : return poBandBlockCache->TryGetLockedBlockRef(nXBlockOff, nYBlockOff);
1900 : }
1901 :
1902 : /************************************************************************/
1903 : /* GetLockedBlockRef() */
1904 : /************************************************************************/
1905 :
1906 : /**
1907 : * \brief Fetch a pointer to an internally cached raster block.
1908 : *
1909 : * This method will returned the requested block (locked) if it is already
1910 : * in the block cache for the layer. If not, the block will be read from
1911 : * the driver, and placed in the layer block cached, then returned. If an
1912 : * error occurs reading the block from the driver, a NULL value will be
1913 : * returned.
1914 : *
1915 : * If a non-NULL value is returned, then a lock for the block will have been
1916 : * acquired on behalf of the caller. It is absolutely imperative that the
1917 : * caller release this lock (with GDALRasterBlock::DropLock()) or else
1918 : * severe problems may result.
1919 : *
1920 : * Note that calling GetLockedBlockRef() on a previously uncached band will
1921 : * enable caching.
1922 : *
1923 : * @param nXBlockOff the horizontal block offset, with zero indicating
1924 : * the left most block, 1 the next block and so forth.
1925 : *
1926 : * @param nYBlockOff the vertical block offset, with zero indicating
1927 : * the top most block, 1 the next block and so forth.
1928 : *
1929 : * @param bJustInitialize If TRUE the block will be allocated and initialized,
1930 : * but not actually read from the source. This is useful when it will just
1931 : * be completely set and written back.
1932 : *
1933 : * @return pointer to the block object, or NULL on failure.
1934 : */
1935 :
1936 10315500 : GDALRasterBlock *GDALRasterBand::GetLockedBlockRef(int nXBlockOff,
1937 : int nYBlockOff,
1938 : int bJustInitialize)
1939 :
1940 : {
1941 : /* -------------------------------------------------------------------- */
1942 : /* Try and fetch from cache. */
1943 : /* -------------------------------------------------------------------- */
1944 10315500 : GDALRasterBlock *poBlock = TryGetLockedBlockRef(nXBlockOff, nYBlockOff);
1945 :
1946 : /* -------------------------------------------------------------------- */
1947 : /* If we didn't find it in our memory cache, instantiate a */
1948 : /* block (potentially load from disk) and "adopt" it into the */
1949 : /* cache. */
1950 : /* -------------------------------------------------------------------- */
1951 10318500 : if (poBlock == nullptr)
1952 : {
1953 3362720 : if (!InitBlockInfo())
1954 0 : return (nullptr);
1955 :
1956 : /* --------------------------------------------------------------------
1957 : */
1958 : /* Validate the request */
1959 : /* --------------------------------------------------------------------
1960 : */
1961 3362710 : if (nXBlockOff < 0 || nXBlockOff >= nBlocksPerRow)
1962 : {
1963 72 : ReportError(CE_Failure, CPLE_IllegalArg,
1964 : "Illegal nBlockXOff value (%d) in "
1965 : "GDALRasterBand::GetLockedBlockRef()\n",
1966 : nXBlockOff);
1967 :
1968 0 : return (nullptr);
1969 : }
1970 :
1971 3362640 : if (nYBlockOff < 0 || nYBlockOff >= nBlocksPerColumn)
1972 : {
1973 0 : ReportError(CE_Failure, CPLE_IllegalArg,
1974 : "Illegal nBlockYOff value (%d) in "
1975 : "GDALRasterBand::GetLockedBlockRef()\n",
1976 : nYBlockOff);
1977 :
1978 0 : return (nullptr);
1979 : }
1980 :
1981 3362650 : poBlock = poBandBlockCache->CreateBlock(nXBlockOff, nYBlockOff);
1982 3362710 : if (poBlock == nullptr)
1983 0 : return nullptr;
1984 :
1985 3362710 : poBlock->AddLock();
1986 :
1987 : /* We need to temporarily drop the read-write lock in the following */
1988 : /*scenario. Imagine 2 threads T1 and T2 that respectively write dataset
1989 : */
1990 : /* D1 and D2. T1 will take the mutex on D1 and T2 on D2. Now when the */
1991 : /* block cache fills, T1 might need to flush dirty blocks of D2 in the
1992 : */
1993 : /* below Internalize(), which will cause GDALRasterBlock::Write() to be
1994 : */
1995 : /* called and attempt at taking the lock on T2 (already taken).
1996 : * Similarly */
1997 : /* for T2 with D1, hence a deadlock situation (#6163) */
1998 : /* But this may open the door to other problems... */
1999 3362730 : if (poDS)
2000 3361990 : poDS->TemporarilyDropReadWriteLock();
2001 : /* allocate data space */
2002 3362750 : CPLErr eErr = poBlock->Internalize();
2003 3362840 : if (poDS)
2004 3362090 : poDS->ReacquireReadWriteLock();
2005 3362810 : if (eErr != CE_None)
2006 : {
2007 0 : poBlock->DropLock();
2008 0 : delete poBlock;
2009 0 : return nullptr;
2010 : }
2011 :
2012 3362810 : if (poBandBlockCache->AdoptBlock(poBlock) != CE_None)
2013 : {
2014 0 : poBlock->DropLock();
2015 0 : delete poBlock;
2016 0 : return nullptr;
2017 : }
2018 :
2019 3362800 : if (!bJustInitialize)
2020 : {
2021 2901380 : const GUInt32 nErrorCounter = CPLGetErrorCounter();
2022 2901360 : int bCallLeaveReadWrite = EnterReadWrite(GF_Read);
2023 2901390 : eErr = IReadBlock(nXBlockOff, nYBlockOff, poBlock->GetDataRef());
2024 2901360 : if (bCallLeaveReadWrite)
2025 129980 : LeaveReadWrite();
2026 2901360 : if (eErr != CE_None)
2027 : {
2028 1160 : poBlock->DropLock();
2029 1160 : FlushBlock(nXBlockOff, nYBlockOff);
2030 1160 : ReportError(CE_Failure, CPLE_AppDefined,
2031 : "IReadBlock failed at X offset %d, Y offset %d%s",
2032 : nXBlockOff, nYBlockOff,
2033 1160 : (nErrorCounter != CPLGetErrorCounter())
2034 1158 : ? CPLSPrintf(": %s", CPLGetLastErrorMsg())
2035 : : "");
2036 1160 : return nullptr;
2037 : }
2038 :
2039 2900200 : nBlockReads++;
2040 2900200 : if (static_cast<GIntBig>(nBlockReads) ==
2041 2900200 : static_cast<GIntBig>(nBlocksPerRow) * nBlocksPerColumn +
2042 219 : 1 &&
2043 219 : nBand == 1 && poDS != nullptr)
2044 : {
2045 159 : CPLDebug("GDAL", "Potential thrashing on band %d of %s.", nBand,
2046 159 : poDS->GetDescription());
2047 : }
2048 : }
2049 : }
2050 :
2051 10317300 : return poBlock;
2052 : }
2053 :
2054 : /************************************************************************/
2055 : /* Fill() */
2056 : /************************************************************************/
2057 :
2058 : /**
2059 : * \brief Fill this band with a constant value.
2060 : *
2061 : * GDAL makes no guarantees
2062 : * about what values pixels in newly created files are set to, so this
2063 : * method can be used to clear a band to a specified "default" value.
2064 : * The fill value is passed in as a double but this will be converted
2065 : * to the underlying type before writing to the file. An optional
2066 : * second argument allows the imaginary component of a complex
2067 : * constant value to be specified.
2068 : *
2069 : * This method is the same as the C function GDALFillRaster().
2070 : *
2071 : * @param dfRealValue Real component of fill value
2072 : * @param dfImaginaryValue Imaginary component of fill value, defaults to zero
2073 : *
2074 : * @return CE_Failure if the write fails, otherwise CE_None
2075 : */
2076 268271 : CPLErr GDALRasterBand::Fill(double dfRealValue, double dfImaginaryValue)
2077 : {
2078 :
2079 : // General approach is to construct a source block of the file's
2080 : // native type containing the appropriate value and then copy this
2081 : // to each block in the image via the RasterBlock cache. Using
2082 : // the cache means we avoid file I/O if it is not necessary, at the
2083 : // expense of some extra memcpy's (since we write to the
2084 : // RasterBlock cache, which is then at some point written to the
2085 : // underlying file, rather than simply directly to the underlying
2086 : // file.)
2087 :
2088 : // Check we can write to the file.
2089 268271 : if (EmitErrorMessageIfWriteNotSupported("GDALRasterBand::Fill()"))
2090 : {
2091 6 : return CE_Failure;
2092 : }
2093 :
2094 : // Make sure block parameters are set.
2095 268265 : if (!InitBlockInfo())
2096 0 : return CE_Failure;
2097 :
2098 : // Allocate the source block.
2099 268265 : auto blockSize = static_cast<GPtrDiff_t>(nBlockXSize) * nBlockYSize;
2100 268265 : int elementSize = GDALGetDataTypeSizeBytes(eDataType);
2101 268265 : auto blockByteSize = blockSize * elementSize;
2102 : unsigned char *srcBlock =
2103 268265 : static_cast<unsigned char *>(VSIMalloc(blockByteSize));
2104 268265 : if (srcBlock == nullptr)
2105 : {
2106 0 : ReportError(CE_Failure, CPLE_OutOfMemory,
2107 : "GDALRasterBand::Fill(): Out of memory "
2108 : "allocating " CPL_FRMT_GUIB " bytes.\n",
2109 : static_cast<GUIntBig>(blockByteSize));
2110 0 : return CE_Failure;
2111 : }
2112 :
2113 : // Initialize the source block.
2114 268265 : double complexSrc[2] = {dfRealValue, dfImaginaryValue};
2115 268265 : GDALCopyWords64(complexSrc, GDT_CFloat64, 0, srcBlock, eDataType,
2116 : elementSize, blockSize);
2117 :
2118 268265 : const bool bCallLeaveReadWrite = CPL_TO_BOOL(EnterReadWrite(GF_Write));
2119 :
2120 : // Write block to block cache
2121 848582 : for (int j = 0; j < nBlocksPerColumn; ++j)
2122 : {
2123 1454970 : for (int i = 0; i < nBlocksPerRow; ++i)
2124 : {
2125 874650 : GDALRasterBlock *destBlock = GetLockedBlockRef(i, j, TRUE);
2126 874650 : if (destBlock == nullptr)
2127 : {
2128 0 : ReportError(CE_Failure, CPLE_OutOfMemory,
2129 : "GDALRasterBand::Fill(): Error "
2130 : "while retrieving cache block.");
2131 0 : VSIFree(srcBlock);
2132 0 : return CE_Failure;
2133 : }
2134 874650 : memcpy(destBlock->GetDataRef(), srcBlock, blockByteSize);
2135 874650 : destBlock->MarkDirty();
2136 874650 : destBlock->DropLock();
2137 : }
2138 : }
2139 :
2140 268265 : if (bCallLeaveReadWrite)
2141 267628 : LeaveReadWrite();
2142 :
2143 : // Free up the source block
2144 268265 : VSIFree(srcBlock);
2145 :
2146 268265 : return CE_None;
2147 : }
2148 :
2149 : /************************************************************************/
2150 : /* GDALFillRaster() */
2151 : /************************************************************************/
2152 :
2153 : /**
2154 : * \brief Fill this band with a constant value.
2155 : *
2156 : * @see GDALRasterBand::Fill()
2157 : */
2158 268208 : CPLErr CPL_STDCALL GDALFillRaster(GDALRasterBandH hBand, double dfRealValue,
2159 : double dfImaginaryValue)
2160 : {
2161 268208 : VALIDATE_POINTER1(hBand, "GDALFillRaster", CE_Failure);
2162 :
2163 268208 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2164 268208 : return poBand->Fill(dfRealValue, dfImaginaryValue);
2165 : }
2166 :
2167 : /************************************************************************/
2168 : /* GetAccess() */
2169 : /************************************************************************/
2170 :
2171 : /**
2172 : * \brief Find out if we have update permission for this band.
2173 : *
2174 : * This method is the same as the C function GDALGetRasterAccess().
2175 : *
2176 : * @return Either GA_Update or GA_ReadOnly.
2177 : */
2178 :
2179 2762 : GDALAccess GDALRasterBand::GetAccess()
2180 :
2181 : {
2182 2762 : return eAccess;
2183 : }
2184 :
2185 : /************************************************************************/
2186 : /* GDALGetRasterAccess() */
2187 : /************************************************************************/
2188 :
2189 : /**
2190 : * \brief Find out if we have update permission for this band.
2191 : *
2192 : * @see GDALRasterBand::GetAccess()
2193 : */
2194 :
2195 2113 : GDALAccess CPL_STDCALL GDALGetRasterAccess(GDALRasterBandH hBand)
2196 :
2197 : {
2198 2113 : VALIDATE_POINTER1(hBand, "GDALGetRasterAccess", GA_ReadOnly);
2199 :
2200 2113 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2201 2113 : return poBand->GetAccess();
2202 : }
2203 :
2204 : /************************************************************************/
2205 : /* GetCategoryNames() */
2206 : /************************************************************************/
2207 :
2208 : /**
2209 : * \brief Fetch the list of category names for this raster.
2210 : *
2211 : * The return list is a "StringList" in the sense of the CPL functions.
2212 : * That is a NULL terminated array of strings. Raster values without
2213 : * associated names will have an empty string in the returned list. The
2214 : * first entry in the list is for raster values of zero, and so on.
2215 : *
2216 : * The returned stringlist should not be altered or freed by the application.
2217 : * It may change on the next GDAL call, so please copy it if it is needed
2218 : * for any period of time.
2219 : *
2220 : * This method is the same as the C function GDALGetRasterCategoryNames().
2221 : *
2222 : * @return list of names, or NULL if none.
2223 : */
2224 :
2225 294 : char **GDALRasterBand::GetCategoryNames()
2226 :
2227 : {
2228 294 : return nullptr;
2229 : }
2230 :
2231 : /************************************************************************/
2232 : /* GDALGetRasterCategoryNames() */
2233 : /************************************************************************/
2234 :
2235 : /**
2236 : * \brief Fetch the list of category names for this raster.
2237 : *
2238 : * @see GDALRasterBand::GetCategoryNames()
2239 : */
2240 :
2241 186 : char **CPL_STDCALL GDALGetRasterCategoryNames(GDALRasterBandH hBand)
2242 :
2243 : {
2244 186 : VALIDATE_POINTER1(hBand, "GDALGetRasterCategoryNames", nullptr);
2245 :
2246 186 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2247 186 : return poBand->GetCategoryNames();
2248 : }
2249 :
2250 : /************************************************************************/
2251 : /* SetCategoryNames() */
2252 : /************************************************************************/
2253 :
2254 : /**
2255 : * \fn GDALRasterBand::SetCategoryNames(char**)
2256 : * \brief Set the category names for this band.
2257 : *
2258 : * See the GetCategoryNames() method for more on the interpretation of
2259 : * category names.
2260 : *
2261 : * This method is the same as the C function GDALSetRasterCategoryNames().
2262 : *
2263 : * @param papszNames the NULL terminated StringList of category names. May
2264 : * be NULL to just clear the existing list.
2265 : *
2266 : * @return CE_None on success of CE_Failure on failure. If unsupported
2267 : * by the driver CE_Failure is returned, but no error message is reported.
2268 : */
2269 :
2270 : /**/
2271 : /**/
2272 :
2273 0 : CPLErr GDALRasterBand::SetCategoryNames(char ** /*papszNames*/)
2274 : {
2275 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
2276 0 : ReportError(CE_Failure, CPLE_NotSupported,
2277 : "SetCategoryNames() not supported for this dataset.");
2278 :
2279 0 : return CE_Failure;
2280 : }
2281 :
2282 : /************************************************************************/
2283 : /* GDALSetCategoryNames() */
2284 : /************************************************************************/
2285 :
2286 : /**
2287 : * \brief Set the category names for this band.
2288 : *
2289 : * @see GDALRasterBand::SetCategoryNames()
2290 : */
2291 :
2292 2 : CPLErr CPL_STDCALL GDALSetRasterCategoryNames(GDALRasterBandH hBand,
2293 : CSLConstList papszNames)
2294 :
2295 : {
2296 2 : VALIDATE_POINTER1(hBand, "GDALSetRasterCategoryNames", CE_Failure);
2297 :
2298 2 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2299 2 : return poBand->SetCategoryNames(const_cast<char **>(papszNames));
2300 : }
2301 :
2302 : /************************************************************************/
2303 : /* GetNoDataValue() */
2304 : /************************************************************************/
2305 :
2306 : /**
2307 : * \brief Fetch the no data value for this band.
2308 : *
2309 : * If there is no out of data value, an out of range value will generally
2310 : * be returned. The no data value for a band is generally a special marker
2311 : * value used to mark pixels that are not valid data. Such pixels should
2312 : * generally not be displayed, nor contribute to analysis operations.
2313 : *
2314 : * The no data value returned is 'raw', meaning that it has no offset and
2315 : * scale applied.
2316 : *
2317 : * For rasters of type GDT_Int64 or GDT_UInt64, using this method might be
2318 : * lossy if the nodata value cannot exactly been represented by a double.
2319 : * Use GetNoDataValueAsInt64() or GetNoDataValueAsUInt64() instead.
2320 : *
2321 : * This method is the same as the C function GDALGetRasterNoDataValue().
2322 : *
2323 : * @param pbSuccess pointer to a boolean to use to indicate if a value
2324 : * is actually associated with this layer. May be NULL (default).
2325 : *
2326 : * @return the nodata value for this band.
2327 : */
2328 :
2329 31573 : double GDALRasterBand::GetNoDataValue(int *pbSuccess)
2330 :
2331 : {
2332 31573 : if (pbSuccess != nullptr)
2333 31573 : *pbSuccess = FALSE;
2334 :
2335 31573 : return -1e10;
2336 : }
2337 :
2338 : /************************************************************************/
2339 : /* GDALGetRasterNoDataValue() */
2340 : /************************************************************************/
2341 :
2342 : /**
2343 : * \brief Fetch the no data value for this band.
2344 : *
2345 : * @see GDALRasterBand::GetNoDataValue()
2346 : */
2347 :
2348 414233 : double CPL_STDCALL GDALGetRasterNoDataValue(GDALRasterBandH hBand,
2349 : int *pbSuccess)
2350 :
2351 : {
2352 414233 : VALIDATE_POINTER1(hBand, "GDALGetRasterNoDataValue", 0);
2353 :
2354 414233 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2355 414233 : return poBand->GetNoDataValue(pbSuccess);
2356 : }
2357 :
2358 : /************************************************************************/
2359 : /* GetNoDataValueAsInt64() */
2360 : /************************************************************************/
2361 :
2362 : /**
2363 : * \brief Fetch the no data value for this band.
2364 : *
2365 : * This method should ONLY be called on rasters whose data type is GDT_Int64.
2366 : *
2367 : * If there is no out of data value, an out of range value will generally
2368 : * be returned. The no data value for a band is generally a special marker
2369 : * value used to mark pixels that are not valid data. Such pixels should
2370 : * generally not be displayed, nor contribute to analysis operations.
2371 : *
2372 : * The no data value returned is 'raw', meaning that it has no offset and
2373 : * scale applied.
2374 : *
2375 : * This method is the same as the C function GDALGetRasterNoDataValueAsInt64().
2376 : *
2377 : * @param pbSuccess pointer to a boolean to use to indicate if a value
2378 : * is actually associated with this layer. May be NULL (default).
2379 : *
2380 : * @return the nodata value for this band.
2381 : *
2382 : * @since GDAL 3.5
2383 : */
2384 :
2385 4 : int64_t GDALRasterBand::GetNoDataValueAsInt64(int *pbSuccess)
2386 :
2387 : {
2388 4 : if (pbSuccess != nullptr)
2389 4 : *pbSuccess = FALSE;
2390 :
2391 4 : return std::numeric_limits<int64_t>::min();
2392 : }
2393 :
2394 : /************************************************************************/
2395 : /* GDALGetRasterNoDataValueAsInt64() */
2396 : /************************************************************************/
2397 :
2398 : /**
2399 : * \brief Fetch the no data value for this band.
2400 : *
2401 : * This function should ONLY be called on rasters whose data type is GDT_Int64.
2402 : *
2403 : * @see GDALRasterBand::GetNoDataValueAsInt64()
2404 : *
2405 : * @since GDAL 3.5
2406 : */
2407 :
2408 27 : int64_t CPL_STDCALL GDALGetRasterNoDataValueAsInt64(GDALRasterBandH hBand,
2409 : int *pbSuccess)
2410 :
2411 : {
2412 27 : VALIDATE_POINTER1(hBand, "GDALGetRasterNoDataValueAsInt64",
2413 : std::numeric_limits<int64_t>::min());
2414 :
2415 27 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2416 27 : return poBand->GetNoDataValueAsInt64(pbSuccess);
2417 : }
2418 :
2419 : /************************************************************************/
2420 : /* GetNoDataValueAsUInt64() */
2421 : /************************************************************************/
2422 :
2423 : /**
2424 : * \brief Fetch the no data value for this band.
2425 : *
2426 : * This method should ONLY be called on rasters whose data type is GDT_UInt64.
2427 : *
2428 : * If there is no out of data value, an out of range value will generally
2429 : * be returned. The no data value for a band is generally a special marker
2430 : * value used to mark pixels that are not valid data. Such pixels should
2431 : * generally not be displayed, nor contribute to analysis operations.
2432 : *
2433 : * The no data value returned is 'raw', meaning that it has no offset and
2434 : * scale applied.
2435 : *
2436 : * This method is the same as the C function GDALGetRasterNoDataValueAsUInt64().
2437 : *
2438 : * @param pbSuccess pointer to a boolean to use to indicate if a value
2439 : * is actually associated with this layer. May be NULL (default).
2440 : *
2441 : * @return the nodata value for this band.
2442 : *
2443 : * @since GDAL 3.5
2444 : */
2445 :
2446 3 : uint64_t GDALRasterBand::GetNoDataValueAsUInt64(int *pbSuccess)
2447 :
2448 : {
2449 3 : if (pbSuccess != nullptr)
2450 3 : *pbSuccess = FALSE;
2451 :
2452 3 : return std::numeric_limits<uint64_t>::max();
2453 : }
2454 :
2455 : /************************************************************************/
2456 : /* GDALGetRasterNoDataValueAsUInt64() */
2457 : /************************************************************************/
2458 :
2459 : /**
2460 : * \brief Fetch the no data value for this band.
2461 : *
2462 : * This function should ONLY be called on rasters whose data type is GDT_UInt64.
2463 : *
2464 : * @see GDALRasterBand::GetNoDataValueAsUInt64()
2465 : *
2466 : * @since GDAL 3.5
2467 : */
2468 :
2469 18 : uint64_t CPL_STDCALL GDALGetRasterNoDataValueAsUInt64(GDALRasterBandH hBand,
2470 : int *pbSuccess)
2471 :
2472 : {
2473 18 : VALIDATE_POINTER1(hBand, "GDALGetRasterNoDataValueAsUInt64",
2474 : std::numeric_limits<uint64_t>::max());
2475 :
2476 18 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2477 18 : return poBand->GetNoDataValueAsUInt64(pbSuccess);
2478 : }
2479 :
2480 : /************************************************************************/
2481 : /* SetNoDataValueAsString() */
2482 : /************************************************************************/
2483 :
2484 : /**
2485 : * \brief Set the no data value for this band.
2486 : *
2487 : * Depending on drivers, changing the no data value may or may not have an
2488 : * effect on the pixel values of a raster that has just been created. It is
2489 : * thus advised to explicitly called Fill() if the intent is to initialize
2490 : * the raster to the nodata value.
2491 : * In any case, changing an existing no data value, when one already exists and
2492 : * the dataset exists or has been initialized, has no effect on the pixel whose
2493 : * value matched the previous nodata value.
2494 : *
2495 : * To clear the nodata value, use DeleteNoDataValue().
2496 : *
2497 : * @param pszNoData the value to set.
2498 : * @param[out] pbCannotBeExactlyRepresented Pointer to a boolean, or nullptr.
2499 : * If the value cannot be exactly represented on the output data
2500 : * type, *pbCannotBeExactlyRepresented will be set to true.
2501 : *
2502 : * @return CE_None on success, or CE_Failure on failure. If unsupported
2503 : * by the driver, CE_Failure is returned but no error message will have
2504 : * been emitted.
2505 : *
2506 : * @since 3.11
2507 : */
2508 :
2509 : CPLErr
2510 123 : GDALRasterBand::SetNoDataValueAsString(const char *pszNoData,
2511 : bool *pbCannotBeExactlyRepresented)
2512 : {
2513 123 : if (pbCannotBeExactlyRepresented)
2514 123 : *pbCannotBeExactlyRepresented = false;
2515 123 : if (eDataType == GDT_Int64)
2516 : {
2517 8 : if (strchr(pszNoData, '.') ||
2518 3 : CPLGetValueType(pszNoData) == CPL_VALUE_STRING)
2519 : {
2520 2 : char *endptr = nullptr;
2521 2 : const double dfVal = CPLStrtod(pszNoData, &endptr);
2522 4 : if (endptr == pszNoData + strlen(pszNoData) &&
2523 2 : GDALIsValueExactAs<int64_t>(dfVal))
2524 : {
2525 0 : return SetNoDataValueAsInt64(static_cast<int64_t>(dfVal));
2526 : }
2527 : }
2528 : else
2529 : {
2530 : try
2531 : {
2532 7 : const auto val = std::stoll(pszNoData);
2533 1 : return SetNoDataValueAsInt64(static_cast<int64_t>(val));
2534 : }
2535 2 : catch (const std::exception &)
2536 : {
2537 : }
2538 : }
2539 : }
2540 118 : else if (eDataType == GDT_UInt64)
2541 : {
2542 2 : if (strchr(pszNoData, '.') ||
2543 1 : CPLGetValueType(pszNoData) == CPL_VALUE_STRING)
2544 : {
2545 0 : char *endptr = nullptr;
2546 0 : const double dfVal = CPLStrtod(pszNoData, &endptr);
2547 0 : if (endptr == pszNoData + strlen(pszNoData) &&
2548 0 : GDALIsValueExactAs<uint64_t>(dfVal))
2549 : {
2550 0 : return SetNoDataValueAsUInt64(static_cast<uint64_t>(dfVal));
2551 : }
2552 : }
2553 : else
2554 : {
2555 : try
2556 : {
2557 1 : const auto val = std::stoull(pszNoData);
2558 1 : return SetNoDataValueAsUInt64(static_cast<uint64_t>(val));
2559 : }
2560 0 : catch (const std::exception &)
2561 : {
2562 : }
2563 : }
2564 : }
2565 117 : else if (eDataType == GDT_Float32)
2566 : {
2567 10 : char *endptr = nullptr;
2568 10 : const float fVal = CPLStrtof(pszNoData, &endptr);
2569 10 : if (endptr == pszNoData + strlen(pszNoData))
2570 : {
2571 10 : return SetNoDataValue(fVal);
2572 : }
2573 : }
2574 : else
2575 : {
2576 107 : char *endptr = nullptr;
2577 107 : const double dfVal = CPLStrtod(pszNoData, &endptr);
2578 214 : if (endptr == pszNoData + strlen(pszNoData) &&
2579 107 : GDALIsValueExactAs(dfVal, eDataType))
2580 : {
2581 106 : return SetNoDataValue(dfVal);
2582 : }
2583 : }
2584 5 : if (pbCannotBeExactlyRepresented)
2585 5 : *pbCannotBeExactlyRepresented = true;
2586 5 : return CE_Failure;
2587 : }
2588 :
2589 : /************************************************************************/
2590 : /* SetNoDataValue() */
2591 : /************************************************************************/
2592 :
2593 : /**
2594 : * \fn GDALRasterBand::SetNoDataValue(double)
2595 : * \brief Set the no data value for this band.
2596 : *
2597 : * Depending on drivers, changing the no data value may or may not have an
2598 : * effect on the pixel values of a raster that has just been created. It is
2599 : * thus advised to explicitly called Fill() if the intent is to initialize
2600 : * the raster to the nodata value.
2601 : * In any case, changing an existing no data value, when one already exists and
2602 : * the dataset exists or has been initialized, has no effect on the pixel whose
2603 : * value matched the previous nodata value.
2604 : *
2605 : * For rasters of type GDT_Int64 or GDT_UInt64, whose nodata value cannot always
2606 : * be represented by a double, use SetNoDataValueAsInt64() or
2607 : * SetNoDataValueAsUInt64() instead.
2608 : *
2609 : * To clear the nodata value, use DeleteNoDataValue().
2610 : *
2611 : * This method is the same as the C function GDALSetRasterNoDataValue().
2612 : *
2613 : * @param dfNoData the value to set.
2614 : *
2615 : * @return CE_None on success, or CE_Failure on failure. If unsupported
2616 : * by the driver, CE_Failure is returned but no error message will have
2617 : * been emitted.
2618 : */
2619 :
2620 : /**/
2621 : /**/
2622 :
2623 0 : CPLErr GDALRasterBand::SetNoDataValue(double /*dfNoData*/)
2624 :
2625 : {
2626 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
2627 0 : ReportError(CE_Failure, CPLE_NotSupported,
2628 : "SetNoDataValue() not supported for this dataset.");
2629 :
2630 0 : return CE_Failure;
2631 : }
2632 :
2633 : /************************************************************************/
2634 : /* GDALSetRasterNoDataValue() */
2635 : /************************************************************************/
2636 :
2637 : /**
2638 : * \brief Set the no data value for this band.
2639 : *
2640 : * Depending on drivers, changing the no data value may or may not have an
2641 : * effect on the pixel values of a raster that has just been created. It is
2642 : * thus advised to explicitly called Fill() if the intent is to initialize
2643 : * the raster to the nodata value.
2644 : * In any case, changing an existing no data value, when one already exists and
2645 : * the dataset exists or has been initialized, has no effect on the pixel whose
2646 : * value matched the previous nodata value.
2647 : *
2648 : * For rasters of type GDT_Int64 or GDT_UInt64, whose nodata value cannot always
2649 : * be represented by a double, use GDALSetRasterNoDataValueAsInt64() or
2650 : * GDALSetRasterNoDataValueAsUInt64() instead.
2651 : *
2652 : * @see GDALRasterBand::SetNoDataValue()
2653 : */
2654 :
2655 848 : CPLErr CPL_STDCALL GDALSetRasterNoDataValue(GDALRasterBandH hBand,
2656 : double dfValue)
2657 :
2658 : {
2659 848 : VALIDATE_POINTER1(hBand, "GDALSetRasterNoDataValue", CE_Failure);
2660 :
2661 848 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2662 848 : return poBand->SetNoDataValue(dfValue);
2663 : }
2664 :
2665 : /************************************************************************/
2666 : /* SetNoDataValueAsInt64() */
2667 : /************************************************************************/
2668 :
2669 : /**
2670 : * \brief Set the no data value for this band.
2671 : *
2672 : * This method should ONLY be called on rasters whose data type is GDT_Int64.
2673 : *
2674 : * Depending on drivers, changing the no data value may or may not have an
2675 : * effect on the pixel values of a raster that has just been created. It is
2676 : * thus advised to explicitly called Fill() if the intent is to initialize
2677 : * the raster to the nodata value.
2678 : * In ay case, changing an existing no data value, when one already exists and
2679 : * the dataset exists or has been initialized, has no effect on the pixel whose
2680 : * value matched the previous nodata value.
2681 : *
2682 : * To clear the nodata value, use DeleteNoDataValue().
2683 : *
2684 : * This method is the same as the C function GDALSetRasterNoDataValueAsInt64().
2685 : *
2686 : * @param nNoDataValue the value to set.
2687 : *
2688 : * @return CE_None on success, or CE_Failure on failure. If unsupported
2689 : * by the driver, CE_Failure is returned but no error message will have
2690 : * been emitted.
2691 : *
2692 : * @since GDAL 3.5
2693 : */
2694 :
2695 0 : CPLErr GDALRasterBand::SetNoDataValueAsInt64(CPL_UNUSED int64_t nNoDataValue)
2696 :
2697 : {
2698 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
2699 0 : ReportError(CE_Failure, CPLE_NotSupported,
2700 : "SetNoDataValueAsInt64() not supported for this dataset.");
2701 :
2702 0 : return CE_Failure;
2703 : }
2704 :
2705 : /************************************************************************/
2706 : /* GDALSetRasterNoDataValueAsInt64() */
2707 : /************************************************************************/
2708 :
2709 : /**
2710 : * \brief Set the no data value for this band.
2711 : *
2712 : * This function should ONLY be called on rasters whose data type is GDT_Int64.
2713 : *
2714 : * Depending on drivers, changing the no data value may or may not have an
2715 : * effect on the pixel values of a raster that has just been created. It is
2716 : * thus advised to explicitly called Fill() if the intent is to initialize
2717 : * the raster to the nodata value.
2718 : * In ay case, changing an existing no data value, when one already exists and
2719 : * the dataset exists or has been initialized, has no effect on the pixel whose
2720 : * value matched the previous nodata value.
2721 : *
2722 : * @see GDALRasterBand::SetNoDataValueAsInt64()
2723 : *
2724 : * @since GDAL 3.5
2725 : */
2726 :
2727 19 : CPLErr CPL_STDCALL GDALSetRasterNoDataValueAsInt64(GDALRasterBandH hBand,
2728 : int64_t nValue)
2729 :
2730 : {
2731 19 : VALIDATE_POINTER1(hBand, "GDALSetRasterNoDataValueAsInt64", CE_Failure);
2732 :
2733 19 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2734 19 : return poBand->SetNoDataValueAsInt64(nValue);
2735 : }
2736 :
2737 : /************************************************************************/
2738 : /* SetNoDataValueAsUInt64() */
2739 : /************************************************************************/
2740 :
2741 : /**
2742 : * \brief Set the no data value for this band.
2743 : *
2744 : * This method should ONLY be called on rasters whose data type is GDT_UInt64.
2745 : *
2746 : * Depending on drivers, changing the no data value may or may not have an
2747 : * effect on the pixel values of a raster that has just been created. It is
2748 : * thus advised to explicitly called Fill() if the intent is to initialize
2749 : * the raster to the nodata value.
2750 : * In ay case, changing an existing no data value, when one already exists and
2751 : * the dataset exists or has been initialized, has no effect on the pixel whose
2752 : * value matched the previous nodata value.
2753 : *
2754 : * To clear the nodata value, use DeleteNoDataValue().
2755 : *
2756 : * This method is the same as the C function GDALSetRasterNoDataValueAsUInt64().
2757 : *
2758 : * @param nNoDataValue the value to set.
2759 : *
2760 : * @return CE_None on success, or CE_Failure on failure. If unsupported
2761 : * by the driver, CE_Failure is returned but no error message will have
2762 : * been emitted.
2763 : *
2764 : * @since GDAL 3.5
2765 : */
2766 :
2767 0 : CPLErr GDALRasterBand::SetNoDataValueAsUInt64(CPL_UNUSED uint64_t nNoDataValue)
2768 :
2769 : {
2770 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
2771 0 : ReportError(CE_Failure, CPLE_NotSupported,
2772 : "SetNoDataValueAsUInt64() not supported for this dataset.");
2773 :
2774 0 : return CE_Failure;
2775 : }
2776 :
2777 : /************************************************************************/
2778 : /* GDALSetRasterNoDataValueAsUInt64() */
2779 : /************************************************************************/
2780 :
2781 : /**
2782 : * \brief Set the no data value for this band.
2783 : *
2784 : * This function should ONLY be called on rasters whose data type is GDT_UInt64.
2785 : *
2786 : * Depending on drivers, changing the no data value may or may not have an
2787 : * effect on the pixel values of a raster that has just been created. It is
2788 : * thus advised to explicitly called Fill() if the intent is to initialize
2789 : * the raster to the nodata value.
2790 : * In ay case, changing an existing no data value, when one already exists and
2791 : * the dataset exists or has been initialized, has no effect on the pixel whose
2792 : * value matched the previous nodata value.
2793 : *
2794 : * @see GDALRasterBand::SetNoDataValueAsUInt64()
2795 : *
2796 : * @since GDAL 3.5
2797 : */
2798 :
2799 17 : CPLErr CPL_STDCALL GDALSetRasterNoDataValueAsUInt64(GDALRasterBandH hBand,
2800 : uint64_t nValue)
2801 :
2802 : {
2803 17 : VALIDATE_POINTER1(hBand, "GDALSetRasterNoDataValueAsUInt64", CE_Failure);
2804 :
2805 17 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2806 17 : return poBand->SetNoDataValueAsUInt64(nValue);
2807 : }
2808 :
2809 : /************************************************************************/
2810 : /* DeleteNoDataValue() */
2811 : /************************************************************************/
2812 :
2813 : /**
2814 : * \brief Remove the no data value for this band.
2815 : *
2816 : * This method is the same as the C function GDALDeleteRasterNoDataValue().
2817 : *
2818 : * @return CE_None on success, or CE_Failure on failure. If unsupported
2819 : * by the driver, CE_Failure is returned but no error message will have
2820 : * been emitted.
2821 : *
2822 : * @since GDAL 2.1
2823 : */
2824 :
2825 0 : CPLErr GDALRasterBand::DeleteNoDataValue()
2826 :
2827 : {
2828 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
2829 0 : ReportError(CE_Failure, CPLE_NotSupported,
2830 : "DeleteNoDataValue() not supported for this dataset.");
2831 :
2832 0 : return CE_Failure;
2833 : }
2834 :
2835 : /************************************************************************/
2836 : /* GDALDeleteRasterNoDataValue() */
2837 : /************************************************************************/
2838 :
2839 : /**
2840 : * \brief Remove the no data value for this band.
2841 : *
2842 : * @see GDALRasterBand::DeleteNoDataValue()
2843 : *
2844 : * @since GDAL 2.1
2845 : */
2846 :
2847 53 : CPLErr CPL_STDCALL GDALDeleteRasterNoDataValue(GDALRasterBandH hBand)
2848 :
2849 : {
2850 53 : VALIDATE_POINTER1(hBand, "GDALDeleteRasterNoDataValue", CE_Failure);
2851 :
2852 53 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2853 53 : return poBand->DeleteNoDataValue();
2854 : }
2855 :
2856 : /************************************************************************/
2857 : /* GetMaximum() */
2858 : /************************************************************************/
2859 :
2860 : /**
2861 : * \brief Fetch the maximum value for this band.
2862 : *
2863 : * For file formats that don't know this intrinsically, the maximum supported
2864 : * value for the data type will generally be returned.
2865 : *
2866 : * This method is the same as the C function GDALGetRasterMaximum().
2867 : *
2868 : * @param pbSuccess pointer to a boolean to use to indicate if the
2869 : * returned value is a tight maximum or not. May be NULL (default).
2870 : *
2871 : * @return the maximum raster value (excluding no data pixels)
2872 : */
2873 :
2874 519 : double GDALRasterBand::GetMaximum(int *pbSuccess)
2875 :
2876 : {
2877 519 : const char *pszValue = nullptr;
2878 :
2879 519 : if ((pszValue = GetMetadataItem("STATISTICS_MAXIMUM")) != nullptr)
2880 : {
2881 46 : if (pbSuccess != nullptr)
2882 41 : *pbSuccess = TRUE;
2883 :
2884 46 : return CPLAtofM(pszValue);
2885 : }
2886 :
2887 473 : if (pbSuccess != nullptr)
2888 469 : *pbSuccess = FALSE;
2889 :
2890 473 : switch (eDataType)
2891 : {
2892 323 : case GDT_Byte:
2893 : {
2894 323 : EnablePixelTypeSignedByteWarning(false);
2895 : const char *pszPixelType =
2896 323 : GetMetadataItem("PIXELTYPE", "IMAGE_STRUCTURE");
2897 323 : EnablePixelTypeSignedByteWarning(true);
2898 323 : if (pszPixelType != nullptr && EQUAL(pszPixelType, "SIGNEDBYTE"))
2899 0 : return 127;
2900 :
2901 323 : return 255;
2902 : }
2903 :
2904 1 : case GDT_Int8:
2905 1 : return 127;
2906 :
2907 21 : case GDT_UInt16:
2908 21 : return 65535;
2909 :
2910 23 : case GDT_Int16:
2911 : case GDT_CInt16:
2912 23 : return 32767;
2913 :
2914 39 : case GDT_Int32:
2915 : case GDT_CInt32:
2916 39 : return 2147483647.0;
2917 :
2918 12 : case GDT_UInt32:
2919 12 : return 4294967295.0;
2920 :
2921 1 : case GDT_Int64:
2922 1 : return static_cast<double>(std::numeric_limits<GInt64>::max());
2923 :
2924 1 : case GDT_UInt64:
2925 1 : return static_cast<double>(std::numeric_limits<GUInt64>::max());
2926 :
2927 0 : case GDT_Float16:
2928 : case GDT_CFloat16:
2929 0 : return 65504.0;
2930 :
2931 30 : case GDT_Float32:
2932 : case GDT_CFloat32:
2933 30 : return 4294967295.0; // Not actually accurate.
2934 :
2935 22 : case GDT_Float64:
2936 : case GDT_CFloat64:
2937 22 : return 4294967295.0; // Not actually accurate.
2938 :
2939 0 : case GDT_Unknown:
2940 : case GDT_TypeCount:
2941 0 : break;
2942 : }
2943 0 : return 4294967295.0; // Not actually accurate.
2944 : }
2945 :
2946 : /************************************************************************/
2947 : /* GDALGetRasterMaximum() */
2948 : /************************************************************************/
2949 :
2950 : /**
2951 : * \brief Fetch the maximum value for this band.
2952 : *
2953 : * @see GDALRasterBand::GetMaximum()
2954 : */
2955 :
2956 284 : double CPL_STDCALL GDALGetRasterMaximum(GDALRasterBandH hBand, int *pbSuccess)
2957 :
2958 : {
2959 284 : VALIDATE_POINTER1(hBand, "GDALGetRasterMaximum", 0);
2960 :
2961 284 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2962 284 : return poBand->GetMaximum(pbSuccess);
2963 : }
2964 :
2965 : /************************************************************************/
2966 : /* GetMinimum() */
2967 : /************************************************************************/
2968 :
2969 : /**
2970 : * \brief Fetch the minimum value for this band.
2971 : *
2972 : * For file formats that don't know this intrinsically, the minimum supported
2973 : * value for the data type will generally be returned.
2974 : *
2975 : * This method is the same as the C function GDALGetRasterMinimum().
2976 : *
2977 : * @param pbSuccess pointer to a boolean to use to indicate if the
2978 : * returned value is a tight minimum or not. May be NULL (default).
2979 : *
2980 : * @return the minimum raster value (excluding no data pixels)
2981 : */
2982 :
2983 527 : double GDALRasterBand::GetMinimum(int *pbSuccess)
2984 :
2985 : {
2986 527 : const char *pszValue = nullptr;
2987 :
2988 527 : if ((pszValue = GetMetadataItem("STATISTICS_MINIMUM")) != nullptr)
2989 : {
2990 51 : if (pbSuccess != nullptr)
2991 46 : *pbSuccess = TRUE;
2992 :
2993 51 : return CPLAtofM(pszValue);
2994 : }
2995 :
2996 476 : if (pbSuccess != nullptr)
2997 472 : *pbSuccess = FALSE;
2998 :
2999 476 : switch (eDataType)
3000 : {
3001 326 : case GDT_Byte:
3002 : {
3003 326 : EnablePixelTypeSignedByteWarning(false);
3004 : const char *pszPixelType =
3005 326 : GetMetadataItem("PIXELTYPE", "IMAGE_STRUCTURE");
3006 326 : EnablePixelTypeSignedByteWarning(true);
3007 326 : if (pszPixelType != nullptr && EQUAL(pszPixelType, "SIGNEDBYTE"))
3008 0 : return -128;
3009 :
3010 326 : return 0;
3011 : }
3012 :
3013 1 : case GDT_Int8:
3014 1 : return -128;
3015 : break;
3016 :
3017 21 : case GDT_UInt16:
3018 21 : return 0;
3019 :
3020 23 : case GDT_Int16:
3021 : case GDT_CInt16:
3022 23 : return -32768;
3023 :
3024 39 : case GDT_Int32:
3025 : case GDT_CInt32:
3026 39 : return -2147483648.0;
3027 :
3028 12 : case GDT_UInt32:
3029 12 : return 0;
3030 :
3031 1 : case GDT_Int64:
3032 1 : return static_cast<double>(std::numeric_limits<GInt64>::lowest());
3033 :
3034 1 : case GDT_UInt64:
3035 1 : return 0;
3036 :
3037 0 : case GDT_Float16:
3038 : case GDT_CFloat16:
3039 0 : return -65504.0;
3040 :
3041 30 : case GDT_Float32:
3042 : case GDT_CFloat32:
3043 30 : return -4294967295.0; // Not actually accurate.
3044 :
3045 22 : case GDT_Float64:
3046 : case GDT_CFloat64:
3047 22 : return -4294967295.0; // Not actually accurate.
3048 :
3049 0 : case GDT_Unknown:
3050 : case GDT_TypeCount:
3051 0 : break;
3052 : }
3053 0 : return -4294967295.0; // Not actually accurate.
3054 : }
3055 :
3056 : /************************************************************************/
3057 : /* GDALGetRasterMinimum() */
3058 : /************************************************************************/
3059 :
3060 : /**
3061 : * \brief Fetch the minimum value for this band.
3062 : *
3063 : * @see GDALRasterBand::GetMinimum()
3064 : */
3065 :
3066 294 : double CPL_STDCALL GDALGetRasterMinimum(GDALRasterBandH hBand, int *pbSuccess)
3067 :
3068 : {
3069 294 : VALIDATE_POINTER1(hBand, "GDALGetRasterMinimum", 0);
3070 :
3071 294 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3072 294 : return poBand->GetMinimum(pbSuccess);
3073 : }
3074 :
3075 : /************************************************************************/
3076 : /* GetColorInterpretation() */
3077 : /************************************************************************/
3078 :
3079 : /**
3080 : * \brief How should this band be interpreted as color?
3081 : *
3082 : * GCI_Undefined is returned when the format doesn't know anything
3083 : * about the color interpretation.
3084 : *
3085 : * This method is the same as the C function
3086 : * GDALGetRasterColorInterpretation().
3087 : *
3088 : * @return color interpretation value for band.
3089 : */
3090 :
3091 163 : GDALColorInterp GDALRasterBand::GetColorInterpretation()
3092 :
3093 : {
3094 163 : return GCI_Undefined;
3095 : }
3096 :
3097 : /************************************************************************/
3098 : /* GDALGetRasterColorInterpretation() */
3099 : /************************************************************************/
3100 :
3101 : /**
3102 : * \brief How should this band be interpreted as color?
3103 : *
3104 : * @see GDALRasterBand::GetColorInterpretation()
3105 : */
3106 :
3107 : GDALColorInterp CPL_STDCALL
3108 5430 : GDALGetRasterColorInterpretation(GDALRasterBandH hBand)
3109 :
3110 : {
3111 5430 : VALIDATE_POINTER1(hBand, "GDALGetRasterColorInterpretation", GCI_Undefined);
3112 :
3113 5430 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3114 5430 : return poBand->GetColorInterpretation();
3115 : }
3116 :
3117 : /************************************************************************/
3118 : /* SetColorInterpretation() */
3119 : /************************************************************************/
3120 :
3121 : /**
3122 : * \fn GDALRasterBand::SetColorInterpretation(GDALColorInterp)
3123 : * \brief Set color interpretation of a band.
3124 : *
3125 : * This method is the same as the C function GDALSetRasterColorInterpretation().
3126 : *
3127 : * @param eColorInterp the new color interpretation to apply to this band.
3128 : *
3129 : * @return CE_None on success or CE_Failure if method is unsupported by format.
3130 : */
3131 :
3132 : /**/
3133 : /**/
3134 :
3135 3 : CPLErr GDALRasterBand::SetColorInterpretation(GDALColorInterp /*eColorInterp*/)
3136 :
3137 : {
3138 3 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
3139 3 : ReportError(CE_Failure, CPLE_NotSupported,
3140 : "SetColorInterpretation() not supported for this dataset.");
3141 3 : return CE_Failure;
3142 : }
3143 :
3144 : /************************************************************************/
3145 : /* GDALSetRasterColorInterpretation() */
3146 : /************************************************************************/
3147 :
3148 : /**
3149 : * \brief Set color interpretation of a band.
3150 : *
3151 : * @see GDALRasterBand::SetColorInterpretation()
3152 : */
3153 :
3154 1818 : CPLErr CPL_STDCALL GDALSetRasterColorInterpretation(
3155 : GDALRasterBandH hBand, GDALColorInterp eColorInterp)
3156 :
3157 : {
3158 1818 : VALIDATE_POINTER1(hBand, "GDALSetRasterColorInterpretation", CE_Failure);
3159 :
3160 1818 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3161 1818 : return poBand->SetColorInterpretation(eColorInterp);
3162 : }
3163 :
3164 : /************************************************************************/
3165 : /* GetColorTable() */
3166 : /************************************************************************/
3167 :
3168 : /**
3169 : * \brief Fetch the color table associated with band.
3170 : *
3171 : * If there is no associated color table, the return result is NULL. The
3172 : * returned color table remains owned by the GDALRasterBand, and can't
3173 : * be depended on for long, nor should it ever be modified by the caller.
3174 : *
3175 : * This method is the same as the C function GDALGetRasterColorTable().
3176 : *
3177 : * @return internal color table, or NULL.
3178 : */
3179 :
3180 231 : GDALColorTable *GDALRasterBand::GetColorTable()
3181 :
3182 : {
3183 231 : return nullptr;
3184 : }
3185 :
3186 : /************************************************************************/
3187 : /* GDALGetRasterColorTable() */
3188 : /************************************************************************/
3189 :
3190 : /**
3191 : * \brief Fetch the color table associated with band.
3192 : *
3193 : * @see GDALRasterBand::GetColorTable()
3194 : */
3195 :
3196 1889 : GDALColorTableH CPL_STDCALL GDALGetRasterColorTable(GDALRasterBandH hBand)
3197 :
3198 : {
3199 1889 : VALIDATE_POINTER1(hBand, "GDALGetRasterColorTable", nullptr);
3200 :
3201 1889 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3202 1889 : return GDALColorTable::ToHandle(poBand->GetColorTable());
3203 : }
3204 :
3205 : /************************************************************************/
3206 : /* SetColorTable() */
3207 : /************************************************************************/
3208 :
3209 : /**
3210 : * \fn GDALRasterBand::SetColorTable(GDALColorTable*)
3211 : * \brief Set the raster color table.
3212 : *
3213 : * The driver will make a copy of all desired data in the colortable. It
3214 : * remains owned by the caller after the call.
3215 : *
3216 : * This method is the same as the C function GDALSetRasterColorTable().
3217 : *
3218 : * @param poCT the color table to apply. This may be NULL to clear the color
3219 : * table (where supported).
3220 : *
3221 : * @return CE_None on success, or CE_Failure on failure. If the action is
3222 : * unsupported by the driver, a value of CE_Failure is returned, but no
3223 : * error is issued.
3224 : */
3225 :
3226 : /**/
3227 : /**/
3228 :
3229 0 : CPLErr GDALRasterBand::SetColorTable(GDALColorTable * /*poCT*/)
3230 :
3231 : {
3232 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
3233 0 : ReportError(CE_Failure, CPLE_NotSupported,
3234 : "SetColorTable() not supported for this dataset.");
3235 0 : return CE_Failure;
3236 : }
3237 :
3238 : /************************************************************************/
3239 : /* GDALSetRasterColorTable() */
3240 : /************************************************************************/
3241 :
3242 : /**
3243 : * \brief Set the raster color table.
3244 : *
3245 : * @see GDALRasterBand::SetColorTable()
3246 : */
3247 :
3248 77 : CPLErr CPL_STDCALL GDALSetRasterColorTable(GDALRasterBandH hBand,
3249 : GDALColorTableH hCT)
3250 :
3251 : {
3252 77 : VALIDATE_POINTER1(hBand, "GDALSetRasterColorTable", CE_Failure);
3253 :
3254 77 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3255 77 : return poBand->SetColorTable(GDALColorTable::FromHandle(hCT));
3256 : }
3257 :
3258 : /************************************************************************/
3259 : /* HasArbitraryOverviews() */
3260 : /************************************************************************/
3261 :
3262 : /**
3263 : * \brief Check for arbitrary overviews.
3264 : *
3265 : * This returns TRUE if the underlying datastore can compute arbitrary
3266 : * overviews efficiently, such as is the case with OGDI over a network.
3267 : * Datastores with arbitrary overviews don't generally have any fixed
3268 : * overviews, but the RasterIO() method can be used in downsampling mode
3269 : * to get overview data efficiently.
3270 : *
3271 : * This method is the same as the C function GDALHasArbitraryOverviews(),
3272 : *
3273 : * @return TRUE if arbitrary overviews available (efficiently), otherwise
3274 : * FALSE.
3275 : */
3276 :
3277 254 : int GDALRasterBand::HasArbitraryOverviews()
3278 :
3279 : {
3280 254 : return FALSE;
3281 : }
3282 :
3283 : /************************************************************************/
3284 : /* GDALHasArbitraryOverviews() */
3285 : /************************************************************************/
3286 :
3287 : /**
3288 : * \brief Check for arbitrary overviews.
3289 : *
3290 : * @see GDALRasterBand::HasArbitraryOverviews()
3291 : */
3292 :
3293 176 : int CPL_STDCALL GDALHasArbitraryOverviews(GDALRasterBandH hBand)
3294 :
3295 : {
3296 176 : VALIDATE_POINTER1(hBand, "GDALHasArbitraryOverviews", 0);
3297 :
3298 176 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3299 176 : return poBand->HasArbitraryOverviews();
3300 : }
3301 :
3302 : /************************************************************************/
3303 : /* GetOverviewCount() */
3304 : /************************************************************************/
3305 :
3306 : /**
3307 : * \brief Return the number of overview layers available.
3308 : *
3309 : * This method is the same as the C function GDALGetOverviewCount().
3310 : *
3311 : * @return overview count, zero if none.
3312 : */
3313 :
3314 1065570 : int GDALRasterBand::GetOverviewCount()
3315 :
3316 : {
3317 1721990 : if (poDS != nullptr && poDS->oOvManager.IsInitialized() &&
3318 656414 : poDS->AreOverviewsEnabled())
3319 656414 : return poDS->oOvManager.GetOverviewCount(nBand);
3320 :
3321 409158 : return 0;
3322 : }
3323 :
3324 : /************************************************************************/
3325 : /* GDALGetOverviewCount() */
3326 : /************************************************************************/
3327 :
3328 : /**
3329 : * \brief Return the number of overview layers available.
3330 : *
3331 : * @see GDALRasterBand::GetOverviewCount()
3332 : */
3333 :
3334 3278 : int CPL_STDCALL GDALGetOverviewCount(GDALRasterBandH hBand)
3335 :
3336 : {
3337 3278 : VALIDATE_POINTER1(hBand, "GDALGetOverviewCount", 0);
3338 :
3339 3278 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3340 3278 : return poBand->GetOverviewCount();
3341 : }
3342 :
3343 : /************************************************************************/
3344 : /* GetOverview() */
3345 : /************************************************************************/
3346 :
3347 : /**
3348 : * \brief Fetch overview raster band object.
3349 : *
3350 : * This method is the same as the C function GDALGetOverview().
3351 : *
3352 : * @param i overview index between 0 and GetOverviewCount()-1.
3353 : *
3354 : * @return overview GDALRasterBand.
3355 : */
3356 :
3357 844 : GDALRasterBand *GDALRasterBand::GetOverview(int i)
3358 :
3359 : {
3360 1633 : if (poDS != nullptr && poDS->oOvManager.IsInitialized() &&
3361 789 : poDS->AreOverviewsEnabled())
3362 789 : return poDS->oOvManager.GetOverview(nBand, i);
3363 :
3364 55 : return nullptr;
3365 : }
3366 :
3367 : /************************************************************************/
3368 : /* GDALGetOverview() */
3369 : /************************************************************************/
3370 :
3371 : /**
3372 : * \brief Fetch overview raster band object.
3373 : *
3374 : * @see GDALRasterBand::GetOverview()
3375 : */
3376 :
3377 5654 : GDALRasterBandH CPL_STDCALL GDALGetOverview(GDALRasterBandH hBand, int i)
3378 :
3379 : {
3380 5654 : VALIDATE_POINTER1(hBand, "GDALGetOverview", nullptr);
3381 :
3382 5654 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3383 5654 : return GDALRasterBand::ToHandle(poBand->GetOverview(i));
3384 : }
3385 :
3386 : /************************************************************************/
3387 : /* GetRasterSampleOverview() */
3388 : /************************************************************************/
3389 :
3390 : /**
3391 : * \brief Fetch best sampling overview.
3392 : *
3393 : * Returns the most reduced overview of the given band that still satisfies
3394 : * the desired number of samples. This function can be used with zero
3395 : * as the number of desired samples to fetch the most reduced overview.
3396 : * The same band as was passed in will be returned if it has not overviews,
3397 : * or if none of the overviews have enough samples.
3398 : *
3399 : * This method is the same as the C functions GDALGetRasterSampleOverview()
3400 : * and GDALGetRasterSampleOverviewEx().
3401 : *
3402 : * @param nDesiredSamples the returned band will have at least this many
3403 : * pixels.
3404 : *
3405 : * @return optimal overview or the band itself.
3406 : */
3407 :
3408 : GDALRasterBand *
3409 2006 : GDALRasterBand::GetRasterSampleOverview(GUIntBig nDesiredSamples)
3410 :
3411 : {
3412 2006 : GDALRasterBand *poBestBand = this;
3413 :
3414 2006 : double dfBestSamples = GetXSize() * static_cast<double>(GetYSize());
3415 :
3416 4023 : for (int iOverview = 0; iOverview < GetOverviewCount(); iOverview++)
3417 : {
3418 2017 : GDALRasterBand *poOBand = GetOverview(iOverview);
3419 :
3420 2017 : if (poOBand == nullptr)
3421 0 : continue;
3422 :
3423 : const double dfOSamples =
3424 2017 : poOBand->GetXSize() * static_cast<double>(poOBand->GetYSize());
3425 :
3426 2017 : if (dfOSamples < dfBestSamples && dfOSamples > nDesiredSamples)
3427 : {
3428 2014 : dfBestSamples = dfOSamples;
3429 2014 : poBestBand = poOBand;
3430 : }
3431 : }
3432 :
3433 2006 : return poBestBand;
3434 : }
3435 :
3436 : /************************************************************************/
3437 : /* GDALGetRasterSampleOverview() */
3438 : /************************************************************************/
3439 :
3440 : /**
3441 : * \brief Fetch best sampling overview.
3442 : *
3443 : * Use GDALGetRasterSampleOverviewEx() to be able to specify more than 2
3444 : * billion samples.
3445 : *
3446 : * @see GDALRasterBand::GetRasterSampleOverview()
3447 : * @see GDALGetRasterSampleOverviewEx()
3448 : */
3449 :
3450 0 : GDALRasterBandH CPL_STDCALL GDALGetRasterSampleOverview(GDALRasterBandH hBand,
3451 : int nDesiredSamples)
3452 :
3453 : {
3454 0 : VALIDATE_POINTER1(hBand, "GDALGetRasterSampleOverview", nullptr);
3455 :
3456 0 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3457 0 : return GDALRasterBand::ToHandle(poBand->GetRasterSampleOverview(
3458 0 : nDesiredSamples < 0 ? 0 : static_cast<GUIntBig>(nDesiredSamples)));
3459 : }
3460 :
3461 : /************************************************************************/
3462 : /* GDALGetRasterSampleOverviewEx() */
3463 : /************************************************************************/
3464 :
3465 : /**
3466 : * \brief Fetch best sampling overview.
3467 : *
3468 : * @see GDALRasterBand::GetRasterSampleOverview()
3469 : * @since GDAL 2.0
3470 : */
3471 :
3472 : GDALRasterBandH CPL_STDCALL
3473 2000 : GDALGetRasterSampleOverviewEx(GDALRasterBandH hBand, GUIntBig nDesiredSamples)
3474 :
3475 : {
3476 2000 : VALIDATE_POINTER1(hBand, "GDALGetRasterSampleOverviewEx", nullptr);
3477 :
3478 2000 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3479 2000 : return GDALRasterBand::ToHandle(
3480 4000 : poBand->GetRasterSampleOverview(nDesiredSamples));
3481 : }
3482 :
3483 : /************************************************************************/
3484 : /* BuildOverviews() */
3485 : /************************************************************************/
3486 :
3487 : /**
3488 : * \fn GDALRasterBand::BuildOverviews(const char*, int, const int*,
3489 : * GDALProgressFunc, void*) \brief Build raster overview(s)
3490 : *
3491 : * If the operation is unsupported for the indicated dataset, then
3492 : * CE_Failure is returned, and CPLGetLastErrorNo() will return
3493 : * CPLE_NotSupported.
3494 : *
3495 : * WARNING: Most formats don't support per-band overview computation, but
3496 : * require that overviews are computed for all bands of a dataset, using
3497 : * GDALDataset::BuildOverviews(). The only exception for official GDAL drivers
3498 : * is the HFA driver which supports this method.
3499 : *
3500 : * @param pszResampling one of "NEAREST", "GAUSS", "CUBIC", "AVERAGE", "MODE",
3501 : * "AVERAGE_MAGPHASE" "RMS" or "NONE" controlling the downsampling method
3502 : * applied.
3503 : * @param nOverviews number of overviews to build.
3504 : * @param panOverviewList the list of overview decimation factors to build.
3505 : * @param pfnProgress a function to call to report progress, or NULL.
3506 : * @param pProgressData application data to pass to the progress function.
3507 : * @param papszOptions (GDAL >= 3.6) NULL terminated list of options as
3508 : * key=value pairs, or NULL
3509 : *
3510 : * @return CE_None on success or CE_Failure if the operation doesn't work.
3511 : */
3512 :
3513 : /**/
3514 : /**/
3515 :
3516 0 : CPLErr GDALRasterBand::BuildOverviews(const char * /*pszResampling*/,
3517 : int /*nOverviews*/,
3518 : const int * /*panOverviewList*/,
3519 : GDALProgressFunc /*pfnProgress*/,
3520 : void * /*pProgressData*/,
3521 : CSLConstList /* papszOptions */)
3522 :
3523 : {
3524 0 : ReportError(CE_Failure, CPLE_NotSupported,
3525 : "BuildOverviews() not supported for this dataset.");
3526 :
3527 0 : return (CE_Failure);
3528 : }
3529 :
3530 : /************************************************************************/
3531 : /* GetOffset() */
3532 : /************************************************************************/
3533 :
3534 : /**
3535 : * \brief Fetch the raster value offset.
3536 : *
3537 : * This value (in combination with the GetScale() value) can be used to
3538 : * transform raw pixel values into the units returned by GetUnitType().
3539 : * For example this might be used to store elevations in GUInt16 bands
3540 : * with a precision of 0.1, and starting from -100.
3541 : *
3542 : * Units value = (raw value * scale) + offset
3543 : *
3544 : * Note that applying scale and offset is of the responsibility of the user,
3545 : * and is not done by methods such as RasterIO() or ReadBlock().
3546 : *
3547 : * For file formats that don't know this intrinsically a value of zero
3548 : * is returned.
3549 : *
3550 : * This method is the same as the C function GDALGetRasterOffset().
3551 : *
3552 : * @param pbSuccess pointer to a boolean to use to indicate if the
3553 : * returned value is meaningful or not. May be NULL (default).
3554 : *
3555 : * @return the raster offset.
3556 : */
3557 :
3558 460 : double GDALRasterBand::GetOffset(int *pbSuccess)
3559 :
3560 : {
3561 460 : if (pbSuccess != nullptr)
3562 351 : *pbSuccess = FALSE;
3563 :
3564 460 : return 0.0;
3565 : }
3566 :
3567 : /************************************************************************/
3568 : /* GDALGetRasterOffset() */
3569 : /************************************************************************/
3570 :
3571 : /**
3572 : * \brief Fetch the raster value offset.
3573 : *
3574 : * @see GDALRasterBand::GetOffset()
3575 : */
3576 :
3577 380 : double CPL_STDCALL GDALGetRasterOffset(GDALRasterBandH hBand, int *pbSuccess)
3578 :
3579 : {
3580 380 : VALIDATE_POINTER1(hBand, "GDALGetRasterOffset", 0);
3581 :
3582 380 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3583 380 : return poBand->GetOffset(pbSuccess);
3584 : }
3585 :
3586 : /************************************************************************/
3587 : /* SetOffset() */
3588 : /************************************************************************/
3589 :
3590 : /**
3591 : * \fn GDALRasterBand::SetOffset(double)
3592 : * \brief Set scaling offset.
3593 : *
3594 : * Very few formats implement this method. When not implemented it will
3595 : * issue a CPLE_NotSupported error and return CE_Failure.
3596 : *
3597 : * This method is the same as the C function GDALSetRasterOffset().
3598 : *
3599 : * @param dfNewOffset the new offset.
3600 : *
3601 : * @return CE_None or success or CE_Failure on failure.
3602 : */
3603 :
3604 : /**/
3605 : /**/
3606 :
3607 0 : CPLErr GDALRasterBand::SetOffset(double /*dfNewOffset*/)
3608 : {
3609 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
3610 0 : ReportError(CE_Failure, CPLE_NotSupported,
3611 : "SetOffset() not supported on this raster band.");
3612 :
3613 0 : return CE_Failure;
3614 : }
3615 :
3616 : /************************************************************************/
3617 : /* GDALSetRasterOffset() */
3618 : /************************************************************************/
3619 :
3620 : /**
3621 : * \brief Set scaling offset.
3622 : *
3623 : * @see GDALRasterBand::SetOffset()
3624 : */
3625 :
3626 75 : CPLErr CPL_STDCALL GDALSetRasterOffset(GDALRasterBandH hBand,
3627 : double dfNewOffset)
3628 :
3629 : {
3630 75 : VALIDATE_POINTER1(hBand, "GDALSetRasterOffset", CE_Failure);
3631 :
3632 75 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3633 75 : return poBand->SetOffset(dfNewOffset);
3634 : }
3635 :
3636 : /************************************************************************/
3637 : /* GetScale() */
3638 : /************************************************************************/
3639 :
3640 : /**
3641 : * \brief Fetch the raster value scale.
3642 : *
3643 : * This value (in combination with the GetOffset() value) can be used to
3644 : * transform raw pixel values into the units returned by GetUnitType().
3645 : * For example this might be used to store elevations in GUInt16 bands
3646 : * with a precision of 0.1, and starting from -100.
3647 : *
3648 : * Units value = (raw value * scale) + offset
3649 : *
3650 : * Note that applying scale and offset is of the responsibility of the user,
3651 : * and is not done by methods such as RasterIO() or ReadBlock().
3652 : *
3653 : * For file formats that don't know this intrinsically a value of one
3654 : * is returned.
3655 : *
3656 : * This method is the same as the C function GDALGetRasterScale().
3657 : *
3658 : * @param pbSuccess pointer to a boolean to use to indicate if the
3659 : * returned value is meaningful or not. May be NULL (default).
3660 : *
3661 : * @return the raster scale.
3662 : */
3663 :
3664 460 : double GDALRasterBand::GetScale(int *pbSuccess)
3665 :
3666 : {
3667 460 : if (pbSuccess != nullptr)
3668 351 : *pbSuccess = FALSE;
3669 :
3670 460 : return 1.0;
3671 : }
3672 :
3673 : /************************************************************************/
3674 : /* GDALGetRasterScale() */
3675 : /************************************************************************/
3676 :
3677 : /**
3678 : * \brief Fetch the raster value scale.
3679 : *
3680 : * @see GDALRasterBand::GetScale()
3681 : */
3682 :
3683 378 : double CPL_STDCALL GDALGetRasterScale(GDALRasterBandH hBand, int *pbSuccess)
3684 :
3685 : {
3686 378 : VALIDATE_POINTER1(hBand, "GDALGetRasterScale", 0);
3687 :
3688 378 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3689 378 : return poBand->GetScale(pbSuccess);
3690 : }
3691 :
3692 : /************************************************************************/
3693 : /* SetScale() */
3694 : /************************************************************************/
3695 :
3696 : /**
3697 : * \fn GDALRasterBand::SetScale(double)
3698 : * \brief Set scaling ratio.
3699 : *
3700 : * Very few formats implement this method. When not implemented it will
3701 : * issue a CPLE_NotSupported error and return CE_Failure.
3702 : *
3703 : * This method is the same as the C function GDALSetRasterScale().
3704 : *
3705 : * @param dfNewScale the new scale.
3706 : *
3707 : * @return CE_None or success or CE_Failure on failure.
3708 : */
3709 :
3710 : /**/
3711 : /**/
3712 :
3713 0 : CPLErr GDALRasterBand::SetScale(double /*dfNewScale*/)
3714 :
3715 : {
3716 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
3717 0 : ReportError(CE_Failure, CPLE_NotSupported,
3718 : "SetScale() not supported on this raster band.");
3719 :
3720 0 : return CE_Failure;
3721 : }
3722 :
3723 : /************************************************************************/
3724 : /* GDALSetRasterScale() */
3725 : /************************************************************************/
3726 :
3727 : /**
3728 : * \brief Set scaling ratio.
3729 : *
3730 : * @see GDALRasterBand::SetScale()
3731 : */
3732 :
3733 76 : CPLErr CPL_STDCALL GDALSetRasterScale(GDALRasterBandH hBand, double dfNewOffset)
3734 :
3735 : {
3736 76 : VALIDATE_POINTER1(hBand, "GDALSetRasterScale", CE_Failure);
3737 :
3738 76 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3739 76 : return poBand->SetScale(dfNewOffset);
3740 : }
3741 :
3742 : /************************************************************************/
3743 : /* GetUnitType() */
3744 : /************************************************************************/
3745 :
3746 : /**
3747 : * \brief Return raster unit type.
3748 : *
3749 : * Return a name for the units of this raster's values. For instance, it
3750 : * might be "m" for an elevation model in meters, or "ft" for feet. If no
3751 : * units are available, a value of "" will be returned. The returned string
3752 : * should not be modified, nor freed by the calling application.
3753 : *
3754 : * This method is the same as the C function GDALGetRasterUnitType().
3755 : *
3756 : * @return unit name string.
3757 : */
3758 :
3759 183 : const char *GDALRasterBand::GetUnitType()
3760 :
3761 : {
3762 183 : return "";
3763 : }
3764 :
3765 : /************************************************************************/
3766 : /* GDALGetRasterUnitType() */
3767 : /************************************************************************/
3768 :
3769 : /**
3770 : * \brief Return raster unit type.
3771 : *
3772 : * @see GDALRasterBand::GetUnitType()
3773 : */
3774 :
3775 1421 : const char *CPL_STDCALL GDALGetRasterUnitType(GDALRasterBandH hBand)
3776 :
3777 : {
3778 1421 : VALIDATE_POINTER1(hBand, "GDALGetRasterUnitType", nullptr);
3779 :
3780 1421 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3781 1421 : return poBand->GetUnitType();
3782 : }
3783 :
3784 : /************************************************************************/
3785 : /* SetUnitType() */
3786 : /************************************************************************/
3787 :
3788 : /**
3789 : * \fn GDALRasterBand::SetUnitType(const char*)
3790 : * \brief Set unit type.
3791 : *
3792 : * Set the unit type for a raster band. Values should be one of
3793 : * "" (the default indicating it is unknown), "m" indicating meters,
3794 : * or "ft" indicating feet, though other nonstandard values are allowed.
3795 : *
3796 : * This method is the same as the C function GDALSetRasterUnitType().
3797 : *
3798 : * @param pszNewValue the new unit type value.
3799 : *
3800 : * @return CE_None on success or CE_Failure if not successful, or
3801 : * unsupported.
3802 : */
3803 :
3804 : /**/
3805 : /**/
3806 :
3807 0 : CPLErr GDALRasterBand::SetUnitType(const char * /*pszNewValue*/)
3808 :
3809 : {
3810 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
3811 0 : ReportError(CE_Failure, CPLE_NotSupported,
3812 : "SetUnitType() not supported on this raster band.");
3813 0 : return CE_Failure;
3814 : }
3815 :
3816 : /************************************************************************/
3817 : /* GDALSetRasterUnitType() */
3818 : /************************************************************************/
3819 :
3820 : /**
3821 : * \brief Set unit type.
3822 : *
3823 : * @see GDALRasterBand::SetUnitType()
3824 : *
3825 : * @since GDAL 1.8.0
3826 : */
3827 :
3828 75 : CPLErr CPL_STDCALL GDALSetRasterUnitType(GDALRasterBandH hBand,
3829 : const char *pszNewValue)
3830 :
3831 : {
3832 75 : VALIDATE_POINTER1(hBand, "GDALSetRasterUnitType", CE_Failure);
3833 :
3834 75 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3835 75 : return poBand->SetUnitType(pszNewValue);
3836 : }
3837 :
3838 : /************************************************************************/
3839 : /* GetXSize() */
3840 : /************************************************************************/
3841 :
3842 : /**
3843 : * \brief Fetch XSize of raster.
3844 : *
3845 : * This method is the same as the C function GDALGetRasterBandXSize().
3846 : *
3847 : * @return the width in pixels of this band.
3848 : */
3849 :
3850 8445530 : int GDALRasterBand::GetXSize() const
3851 :
3852 : {
3853 8445530 : return nRasterXSize;
3854 : }
3855 :
3856 : /************************************************************************/
3857 : /* GDALGetRasterBandXSize() */
3858 : /************************************************************************/
3859 :
3860 : /**
3861 : * \brief Fetch XSize of raster.
3862 : *
3863 : * @see GDALRasterBand::GetXSize()
3864 : */
3865 :
3866 57488 : int CPL_STDCALL GDALGetRasterBandXSize(GDALRasterBandH hBand)
3867 :
3868 : {
3869 57488 : VALIDATE_POINTER1(hBand, "GDALGetRasterBandXSize", 0);
3870 :
3871 57488 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3872 57488 : return poBand->GetXSize();
3873 : }
3874 :
3875 : /************************************************************************/
3876 : /* GetYSize() */
3877 : /************************************************************************/
3878 :
3879 : /**
3880 : * \brief Fetch YSize of raster.
3881 : *
3882 : * This method is the same as the C function GDALGetRasterBandYSize().
3883 : *
3884 : * @return the height in pixels of this band.
3885 : */
3886 :
3887 4659400 : int GDALRasterBand::GetYSize() const
3888 :
3889 : {
3890 4659400 : return nRasterYSize;
3891 : }
3892 :
3893 : /************************************************************************/
3894 : /* GDALGetRasterBandYSize() */
3895 : /************************************************************************/
3896 :
3897 : /**
3898 : * \brief Fetch YSize of raster.
3899 : *
3900 : * @see GDALRasterBand::GetYSize()
3901 : */
3902 :
3903 56347 : int CPL_STDCALL GDALGetRasterBandYSize(GDALRasterBandH hBand)
3904 :
3905 : {
3906 56347 : VALIDATE_POINTER1(hBand, "GDALGetRasterBandYSize", 0);
3907 :
3908 56347 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3909 56347 : return poBand->GetYSize();
3910 : }
3911 :
3912 : /************************************************************************/
3913 : /* GetBand() */
3914 : /************************************************************************/
3915 :
3916 : /**
3917 : * \brief Fetch the band number.
3918 : *
3919 : * This method returns the band that this GDALRasterBand objects represents
3920 : * within its dataset. This method may return a value of 0 to indicate
3921 : * GDALRasterBand objects without an apparently relationship to a dataset,
3922 : * such as GDALRasterBands serving as overviews.
3923 : *
3924 : * This method is the same as the C function GDALGetBandNumber().
3925 : *
3926 : * @return band number (1+) or 0 if the band number isn't known.
3927 : */
3928 :
3929 151344 : int GDALRasterBand::GetBand() const
3930 :
3931 : {
3932 151344 : return nBand;
3933 : }
3934 :
3935 : /************************************************************************/
3936 : /* GDALGetBandNumber() */
3937 : /************************************************************************/
3938 :
3939 : /**
3940 : * \brief Fetch the band number.
3941 : *
3942 : * @see GDALRasterBand::GetBand()
3943 : */
3944 :
3945 202 : int CPL_STDCALL GDALGetBandNumber(GDALRasterBandH hBand)
3946 :
3947 : {
3948 202 : VALIDATE_POINTER1(hBand, "GDALGetBandNumber", 0);
3949 :
3950 202 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3951 202 : return poBand->GetBand();
3952 : }
3953 :
3954 : /************************************************************************/
3955 : /* GetDataset() */
3956 : /************************************************************************/
3957 :
3958 : /**
3959 : * \brief Fetch the owning dataset handle.
3960 : *
3961 : * Note that some GDALRasterBands are not considered to be a part of a dataset,
3962 : * such as overviews or other "freestanding" bands.
3963 : *
3964 : * This method is the same as the C function GDALGetBandDataset().
3965 : *
3966 : * @return the pointer to the GDALDataset to which this band belongs, or
3967 : * NULL if this cannot be determined.
3968 : */
3969 :
3970 5271300 : GDALDataset *GDALRasterBand::GetDataset() const
3971 :
3972 : {
3973 5271300 : return poDS;
3974 : }
3975 :
3976 : /************************************************************************/
3977 : /* GDALGetBandDataset() */
3978 : /************************************************************************/
3979 :
3980 : /**
3981 : * \brief Fetch the owning dataset handle.
3982 : *
3983 : * @see GDALRasterBand::GetDataset()
3984 : */
3985 :
3986 445 : GDALDatasetH CPL_STDCALL GDALGetBandDataset(GDALRasterBandH hBand)
3987 :
3988 : {
3989 445 : VALIDATE_POINTER1(hBand, "GDALGetBandDataset", nullptr);
3990 :
3991 445 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3992 445 : return GDALDataset::ToHandle(poBand->GetDataset());
3993 : }
3994 :
3995 : /************************************************************************/
3996 : /* ComputeFloat16NoDataValue() */
3997 : /************************************************************************/
3998 :
3999 2214 : static inline void ComputeFloat16NoDataValue(GDALDataType eDataType,
4000 : double dfNoDataValue,
4001 : int &bGotNoDataValue,
4002 : GFloat16 &fNoDataValue,
4003 : bool &bGotFloat16NoDataValue)
4004 : {
4005 2214 : if (eDataType == GDT_Float16 && bGotNoDataValue)
4006 : {
4007 0 : dfNoDataValue = GDALAdjustNoDataCloseToFloatMax(dfNoDataValue);
4008 0 : if (GDALIsValueInRange<GFloat16>(dfNoDataValue))
4009 : {
4010 0 : fNoDataValue = static_cast<GFloat16>(dfNoDataValue);
4011 0 : bGotFloat16NoDataValue = true;
4012 0 : bGotNoDataValue = false;
4013 : }
4014 : }
4015 2214 : }
4016 :
4017 : /************************************************************************/
4018 : /* ComputeFloatNoDataValue() */
4019 : /************************************************************************/
4020 :
4021 2214 : static inline void ComputeFloatNoDataValue(GDALDataType eDataType,
4022 : double dfNoDataValue,
4023 : int &bGotNoDataValue,
4024 : float &fNoDataValue,
4025 : bool &bGotFloatNoDataValue)
4026 : {
4027 2214 : if (eDataType == GDT_Float32 && bGotNoDataValue)
4028 : {
4029 84 : dfNoDataValue = GDALAdjustNoDataCloseToFloatMax(dfNoDataValue);
4030 84 : if (GDALIsValueInRange<float>(dfNoDataValue))
4031 : {
4032 84 : fNoDataValue = static_cast<float>(dfNoDataValue);
4033 84 : bGotFloatNoDataValue = true;
4034 84 : bGotNoDataValue = false;
4035 : }
4036 : }
4037 2214 : }
4038 :
4039 : /************************************************************************/
4040 : /* struct GDALNoDataValues */
4041 : /************************************************************************/
4042 :
4043 : /**
4044 : * \brief No-data-values for all types
4045 : *
4046 : * The functions below pass various no-data-values around. To avoid
4047 : * long argument lists, this struct collects the no-data-values for
4048 : * all types into a single, convenient place.
4049 : **/
4050 :
4051 : struct GDALNoDataValues
4052 : {
4053 : int bGotNoDataValue;
4054 : double dfNoDataValue;
4055 :
4056 : bool bGotInt64NoDataValue;
4057 : int64_t nInt64NoDataValue;
4058 :
4059 : bool bGotUInt64NoDataValue;
4060 : uint64_t nUInt64NoDataValue;
4061 :
4062 : bool bGotFloatNoDataValue;
4063 : float fNoDataValue;
4064 :
4065 : bool bGotFloat16NoDataValue;
4066 : GFloat16 hfNoDataValue;
4067 :
4068 2258 : GDALNoDataValues(GDALRasterBand *poRasterBand, GDALDataType eDataType)
4069 2258 : : bGotNoDataValue(FALSE), dfNoDataValue(0.0),
4070 : bGotInt64NoDataValue(false), nInt64NoDataValue(0),
4071 : bGotUInt64NoDataValue(false), nUInt64NoDataValue(0),
4072 : bGotFloatNoDataValue(false), fNoDataValue(0.0f),
4073 2258 : bGotFloat16NoDataValue(false), hfNoDataValue(GFloat16(0.0f))
4074 : {
4075 2258 : if (eDataType == GDT_Int64)
4076 : {
4077 28 : int nGot = false;
4078 28 : nInt64NoDataValue = poRasterBand->GetNoDataValueAsInt64(&nGot);
4079 28 : bGotInt64NoDataValue = CPL_TO_BOOL(nGot);
4080 28 : if (bGotInt64NoDataValue)
4081 : {
4082 3 : dfNoDataValue = static_cast<double>(nInt64NoDataValue);
4083 3 : bGotNoDataValue =
4084 3 : nInt64NoDataValue <=
4085 6 : std::numeric_limits<int64_t>::max() - 1024 &&
4086 3 : static_cast<int64_t>(dfNoDataValue) == nInt64NoDataValue;
4087 : }
4088 : else
4089 25 : dfNoDataValue = poRasterBand->GetNoDataValue(&bGotNoDataValue);
4090 : }
4091 2230 : else if (eDataType == GDT_UInt64)
4092 : {
4093 16 : int nGot = false;
4094 16 : nUInt64NoDataValue = poRasterBand->GetNoDataValueAsUInt64(&nGot);
4095 16 : bGotUInt64NoDataValue = CPL_TO_BOOL(nGot);
4096 16 : if (bGotUInt64NoDataValue)
4097 : {
4098 3 : dfNoDataValue = static_cast<double>(nUInt64NoDataValue);
4099 3 : bGotNoDataValue =
4100 3 : nUInt64NoDataValue <=
4101 6 : std::numeric_limits<uint64_t>::max() - 2048 &&
4102 3 : static_cast<uint64_t>(dfNoDataValue) == nUInt64NoDataValue;
4103 : }
4104 : else
4105 13 : dfNoDataValue = poRasterBand->GetNoDataValue(&bGotNoDataValue);
4106 : }
4107 : else
4108 : {
4109 2214 : dfNoDataValue = poRasterBand->GetNoDataValue(&bGotNoDataValue);
4110 2214 : bGotNoDataValue = bGotNoDataValue && !std::isnan(dfNoDataValue);
4111 :
4112 2214 : ComputeFloatNoDataValue(eDataType, dfNoDataValue, bGotNoDataValue,
4113 2214 : fNoDataValue, bGotFloatNoDataValue);
4114 :
4115 2214 : ComputeFloat16NoDataValue(eDataType, dfNoDataValue, bGotNoDataValue,
4116 2214 : hfNoDataValue, bGotFloat16NoDataValue);
4117 : }
4118 2258 : }
4119 : };
4120 :
4121 : /************************************************************************/
4122 : /* ARE_REAL_EQUAL() */
4123 : /************************************************************************/
4124 :
4125 0 : inline bool ARE_REAL_EQUAL(GFloat16 dfVal1, GFloat16 dfVal2, int ulp = 2)
4126 : {
4127 : using std::abs;
4128 0 : return dfVal1 == dfVal2 || /* Should cover infinity */
4129 0 : abs(dfVal1 - dfVal2) < cpl::NumericLimits<GFloat16>::epsilon() *
4130 0 : abs(dfVal1 + dfVal2) * ulp;
4131 : }
4132 :
4133 : /************************************************************************/
4134 : /* GetHistogram() */
4135 : /************************************************************************/
4136 :
4137 : /**
4138 : * \brief Compute raster histogram.
4139 : *
4140 : * Note that the bucket size is (dfMax-dfMin) / nBuckets.
4141 : *
4142 : * For example to compute a simple 256 entry histogram of eight bit data,
4143 : * the following would be suitable. The unusual bounds are to ensure that
4144 : * bucket boundaries don't fall right on integer values causing possible errors
4145 : * due to rounding after scaling.
4146 : \code{.cpp}
4147 : GUIntBig anHistogram[256];
4148 :
4149 : poBand->GetHistogram( -0.5, 255.5, 256, anHistogram, FALSE, FALSE,
4150 : GDALDummyProgress, nullptr );
4151 : \endcode
4152 : *
4153 : * Note that setting bApproxOK will generally result in a subsampling of the
4154 : * file, and will utilize overviews if available. It should generally
4155 : * produce a representative histogram for the data that is suitable for use
4156 : * in generating histogram based luts for instance. Generally bApproxOK is
4157 : * much faster than an exactly computed histogram.
4158 : *
4159 : * This method is the same as the C functions GDALGetRasterHistogram() and
4160 : * GDALGetRasterHistogramEx().
4161 : *
4162 : * @param dfMin the lower bound of the histogram.
4163 : * @param dfMax the upper bound of the histogram.
4164 : * @param nBuckets the number of buckets in panHistogram.
4165 : * @param panHistogram array into which the histogram totals are placed.
4166 : * @param bIncludeOutOfRange if TRUE values below the histogram range will
4167 : * mapped into panHistogram[0], and values above will be mapped into
4168 : * panHistogram[nBuckets-1] otherwise out of range values are discarded.
4169 : * @param bApproxOK TRUE if an approximate, or incomplete histogram OK.
4170 : * @param pfnProgress function to report progress to completion.
4171 : * @param pProgressData application data to pass to pfnProgress.
4172 : *
4173 : * @return CE_None on success, or CE_Failure if something goes wrong.
4174 : */
4175 :
4176 40 : CPLErr GDALRasterBand::GetHistogram(double dfMin, double dfMax, int nBuckets,
4177 : GUIntBig *panHistogram,
4178 : int bIncludeOutOfRange, int bApproxOK,
4179 : GDALProgressFunc pfnProgress,
4180 : void *pProgressData)
4181 :
4182 : {
4183 40 : CPLAssert(nullptr != panHistogram);
4184 :
4185 40 : if (pfnProgress == nullptr)
4186 27 : pfnProgress = GDALDummyProgress;
4187 :
4188 : /* -------------------------------------------------------------------- */
4189 : /* If we have overviews, use them for the histogram. */
4190 : /* -------------------------------------------------------------------- */
4191 40 : if (bApproxOK && GetOverviewCount() > 0 && !HasArbitraryOverviews())
4192 : {
4193 : // FIXME: should we use the most reduced overview here or use some
4194 : // minimum number of samples like GDALRasterBand::ComputeStatistics()
4195 : // does?
4196 0 : GDALRasterBand *poBestOverview = GetRasterSampleOverview(0);
4197 :
4198 0 : if (poBestOverview != this)
4199 : {
4200 0 : return poBestOverview->GetHistogram(
4201 : dfMin, dfMax, nBuckets, panHistogram, bIncludeOutOfRange,
4202 0 : bApproxOK, pfnProgress, pProgressData);
4203 : }
4204 : }
4205 :
4206 : /* -------------------------------------------------------------------- */
4207 : /* Read actual data and build histogram. */
4208 : /* -------------------------------------------------------------------- */
4209 40 : if (!pfnProgress(0.0, "Compute Histogram", pProgressData))
4210 : {
4211 0 : ReportError(CE_Failure, CPLE_UserInterrupt, "User terminated");
4212 0 : return CE_Failure;
4213 : }
4214 :
4215 : // Written this way to deal with NaN
4216 40 : if (!(dfMax > dfMin))
4217 : {
4218 5 : ReportError(CE_Failure, CPLE_IllegalArg,
4219 : "dfMax should be strictly greater than dfMin");
4220 5 : return CE_Failure;
4221 : }
4222 :
4223 : GDALRasterIOExtraArg sExtraArg;
4224 35 : INIT_RASTERIO_EXTRA_ARG(sExtraArg);
4225 :
4226 35 : const double dfScale = nBuckets / (dfMax - dfMin);
4227 35 : if (dfScale == 0 || !std::isfinite(dfScale))
4228 : {
4229 5 : ReportError(CE_Failure, CPLE_IllegalArg,
4230 : "dfMin and dfMax should be finite values such that "
4231 : "nBuckets / (dfMax - dfMin) is non-zero");
4232 5 : return CE_Failure;
4233 : }
4234 30 : memset(panHistogram, 0, sizeof(GUIntBig) * nBuckets);
4235 :
4236 30 : GDALNoDataValues sNoDataValues(this, eDataType);
4237 30 : GDALRasterBand *poMaskBand = nullptr;
4238 30 : if (!sNoDataValues.bGotNoDataValue)
4239 : {
4240 29 : const int l_nMaskFlags = GetMaskFlags();
4241 31 : if (l_nMaskFlags != GMF_ALL_VALID &&
4242 2 : GetColorInterpretation() != GCI_AlphaBand)
4243 : {
4244 2 : poMaskBand = GetMaskBand();
4245 : }
4246 : }
4247 :
4248 30 : bool bSignedByte = false;
4249 30 : if (eDataType == GDT_Byte)
4250 : {
4251 23 : EnablePixelTypeSignedByteWarning(false);
4252 : const char *pszPixelType =
4253 23 : GetMetadataItem("PIXELTYPE", "IMAGE_STRUCTURE");
4254 23 : EnablePixelTypeSignedByteWarning(true);
4255 23 : bSignedByte =
4256 23 : pszPixelType != nullptr && EQUAL(pszPixelType, "SIGNEDBYTE");
4257 : }
4258 :
4259 30 : if (bApproxOK && HasArbitraryOverviews())
4260 : {
4261 : /* --------------------------------------------------------------------
4262 : */
4263 : /* Figure out how much the image should be reduced to get an */
4264 : /* approximate value. */
4265 : /* --------------------------------------------------------------------
4266 : */
4267 : const double dfReduction =
4268 0 : sqrt(static_cast<double>(nRasterXSize) * nRasterYSize /
4269 : GDALSTAT_APPROX_NUMSAMPLES);
4270 :
4271 0 : int nXReduced = nRasterXSize;
4272 0 : int nYReduced = nRasterYSize;
4273 0 : if (dfReduction > 1.0)
4274 : {
4275 0 : nXReduced = static_cast<int>(nRasterXSize / dfReduction);
4276 0 : nYReduced = static_cast<int>(nRasterYSize / dfReduction);
4277 :
4278 : // Catch the case of huge resizing ratios here
4279 0 : if (nXReduced == 0)
4280 0 : nXReduced = 1;
4281 0 : if (nYReduced == 0)
4282 0 : nYReduced = 1;
4283 : }
4284 :
4285 0 : void *pData = VSI_MALLOC3_VERBOSE(GDALGetDataTypeSizeBytes(eDataType),
4286 : nXReduced, nYReduced);
4287 0 : if (!pData)
4288 0 : return CE_Failure;
4289 :
4290 : const CPLErr eErr =
4291 0 : IRasterIO(GF_Read, 0, 0, nRasterXSize, nRasterYSize, pData,
4292 0 : nXReduced, nYReduced, eDataType, 0, 0, &sExtraArg);
4293 0 : if (eErr != CE_None)
4294 : {
4295 0 : CPLFree(pData);
4296 0 : return eErr;
4297 : }
4298 :
4299 0 : GByte *pabyMaskData = nullptr;
4300 0 : if (poMaskBand)
4301 : {
4302 : pabyMaskData =
4303 0 : static_cast<GByte *>(VSI_MALLOC2_VERBOSE(nXReduced, nYReduced));
4304 0 : if (!pabyMaskData)
4305 : {
4306 0 : CPLFree(pData);
4307 0 : return CE_Failure;
4308 : }
4309 :
4310 0 : if (poMaskBand->RasterIO(GF_Read, 0, 0, nRasterXSize, nRasterYSize,
4311 : pabyMaskData, nXReduced, nYReduced,
4312 0 : GDT_Byte, 0, 0, nullptr) != CE_None)
4313 : {
4314 0 : CPLFree(pData);
4315 0 : CPLFree(pabyMaskData);
4316 0 : return CE_Failure;
4317 : }
4318 : }
4319 :
4320 : // This isn't the fastest way to do this, but is easier for now.
4321 0 : for (int iY = 0; iY < nYReduced; iY++)
4322 : {
4323 0 : for (int iX = 0; iX < nXReduced; iX++)
4324 : {
4325 0 : const int iOffset = iX + iY * nXReduced;
4326 0 : double dfValue = 0.0;
4327 :
4328 0 : if (pabyMaskData && pabyMaskData[iOffset] == 0)
4329 0 : continue;
4330 :
4331 0 : switch (eDataType)
4332 : {
4333 0 : case GDT_Byte:
4334 : {
4335 0 : if (bSignedByte)
4336 0 : dfValue =
4337 0 : static_cast<signed char *>(pData)[iOffset];
4338 : else
4339 0 : dfValue = static_cast<GByte *>(pData)[iOffset];
4340 0 : break;
4341 : }
4342 0 : case GDT_Int8:
4343 0 : dfValue = static_cast<GInt8 *>(pData)[iOffset];
4344 0 : break;
4345 0 : case GDT_UInt16:
4346 0 : dfValue = static_cast<GUInt16 *>(pData)[iOffset];
4347 0 : break;
4348 0 : case GDT_Int16:
4349 0 : dfValue = static_cast<GInt16 *>(pData)[iOffset];
4350 0 : break;
4351 0 : case GDT_UInt32:
4352 0 : dfValue = static_cast<GUInt32 *>(pData)[iOffset];
4353 0 : break;
4354 0 : case GDT_Int32:
4355 0 : dfValue = static_cast<GInt32 *>(pData)[iOffset];
4356 0 : break;
4357 0 : case GDT_UInt64:
4358 0 : dfValue = static_cast<double>(
4359 0 : static_cast<GUInt64 *>(pData)[iOffset]);
4360 0 : break;
4361 0 : case GDT_Int64:
4362 0 : dfValue = static_cast<double>(
4363 0 : static_cast<GInt64 *>(pData)[iOffset]);
4364 0 : break;
4365 0 : case GDT_Float16:
4366 : {
4367 : using namespace std;
4368 0 : const GFloat16 hfValue =
4369 0 : static_cast<GFloat16 *>(pData)[iOffset];
4370 0 : if (isnan(hfValue) ||
4371 0 : (sNoDataValues.bGotFloat16NoDataValue &&
4372 0 : ARE_REAL_EQUAL(hfValue,
4373 : sNoDataValues.hfNoDataValue)))
4374 0 : continue;
4375 0 : dfValue = hfValue;
4376 0 : break;
4377 : }
4378 0 : case GDT_Float32:
4379 : {
4380 0 : const float fValue =
4381 0 : static_cast<float *>(pData)[iOffset];
4382 0 : if (std::isnan(fValue) ||
4383 0 : (sNoDataValues.bGotFloatNoDataValue &&
4384 0 : ARE_REAL_EQUAL(fValue,
4385 : sNoDataValues.fNoDataValue)))
4386 0 : continue;
4387 0 : dfValue = fValue;
4388 0 : break;
4389 : }
4390 0 : case GDT_Float64:
4391 0 : dfValue = static_cast<double *>(pData)[iOffset];
4392 0 : if (std::isnan(dfValue))
4393 0 : continue;
4394 0 : break;
4395 0 : case GDT_CInt16:
4396 : {
4397 0 : const double dfReal =
4398 0 : static_cast<GInt16 *>(pData)[iOffset * 2];
4399 0 : const double dfImag =
4400 0 : static_cast<GInt16 *>(pData)[iOffset * 2 + 1];
4401 0 : if (std::isnan(dfReal) || std::isnan(dfImag))
4402 0 : continue;
4403 0 : dfValue = sqrt(dfReal * dfReal + dfImag * dfImag);
4404 : }
4405 0 : break;
4406 0 : case GDT_CInt32:
4407 : {
4408 0 : const double dfReal =
4409 0 : static_cast<GInt32 *>(pData)[iOffset * 2];
4410 0 : const double dfImag =
4411 0 : static_cast<GInt32 *>(pData)[iOffset * 2 + 1];
4412 0 : if (std::isnan(dfReal) || std::isnan(dfImag))
4413 0 : continue;
4414 0 : dfValue = sqrt(dfReal * dfReal + dfImag * dfImag);
4415 : }
4416 0 : break;
4417 0 : case GDT_CFloat16:
4418 : {
4419 : const double dfReal =
4420 0 : static_cast<GFloat16 *>(pData)[iOffset * 2];
4421 : const double dfImag =
4422 0 : static_cast<GFloat16 *>(pData)[iOffset * 2 + 1];
4423 0 : if (std::isnan(dfReal) || std::isnan(dfImag))
4424 0 : continue;
4425 0 : dfValue = sqrt(dfReal * dfReal + dfImag * dfImag);
4426 0 : break;
4427 : }
4428 0 : case GDT_CFloat32:
4429 : {
4430 0 : const double dfReal =
4431 0 : static_cast<float *>(pData)[iOffset * 2];
4432 0 : const double dfImag =
4433 0 : static_cast<float *>(pData)[iOffset * 2 + 1];
4434 0 : if (std::isnan(dfReal) || std::isnan(dfImag))
4435 0 : continue;
4436 0 : dfValue = sqrt(dfReal * dfReal + dfImag * dfImag);
4437 0 : break;
4438 : }
4439 0 : case GDT_CFloat64:
4440 : {
4441 0 : const double dfReal =
4442 0 : static_cast<double *>(pData)[iOffset * 2];
4443 0 : const double dfImag =
4444 0 : static_cast<double *>(pData)[iOffset * 2 + 1];
4445 0 : if (std::isnan(dfReal) || std::isnan(dfImag))
4446 0 : continue;
4447 0 : dfValue = sqrt(dfReal * dfReal + dfImag * dfImag);
4448 0 : break;
4449 : }
4450 0 : case GDT_Unknown:
4451 : case GDT_TypeCount:
4452 0 : CPLAssert(false);
4453 : }
4454 :
4455 0 : if (eDataType != GDT_Float16 && eDataType != GDT_Float32 &&
4456 0 : sNoDataValues.bGotNoDataValue &&
4457 0 : ARE_REAL_EQUAL(dfValue, sNoDataValues.dfNoDataValue))
4458 0 : continue;
4459 :
4460 : // Given that dfValue and dfMin are not NaN, and dfScale > 0 and
4461 : // finite, the result of the multiplication cannot be NaN
4462 0 : const double dfIndex = floor((dfValue - dfMin) * dfScale);
4463 :
4464 0 : if (dfIndex < 0)
4465 : {
4466 0 : if (bIncludeOutOfRange)
4467 0 : panHistogram[0]++;
4468 : }
4469 0 : else if (dfIndex >= nBuckets)
4470 : {
4471 0 : if (bIncludeOutOfRange)
4472 0 : ++panHistogram[nBuckets - 1];
4473 : }
4474 : else
4475 : {
4476 0 : ++panHistogram[static_cast<int>(dfIndex)];
4477 : }
4478 : }
4479 : }
4480 :
4481 0 : CPLFree(pData);
4482 0 : CPLFree(pabyMaskData);
4483 : }
4484 : else // No arbitrary overviews.
4485 : {
4486 30 : if (!InitBlockInfo())
4487 0 : return CE_Failure;
4488 :
4489 : /* --------------------------------------------------------------------
4490 : */
4491 : /* Figure out the ratio of blocks we will read to get an */
4492 : /* approximate value. */
4493 : /* --------------------------------------------------------------------
4494 : */
4495 :
4496 30 : int nSampleRate = 1;
4497 30 : if (bApproxOK)
4498 : {
4499 8 : nSampleRate = static_cast<int>(std::max(
4500 16 : 1.0,
4501 8 : sqrt(static_cast<double>(nBlocksPerRow) * nBlocksPerColumn)));
4502 : // We want to avoid probing only the first column of blocks for
4503 : // a square shaped raster, because it is not unlikely that it may
4504 : // be padding only (#6378).
4505 8 : if (nSampleRate == nBlocksPerRow && nBlocksPerRow > 1)
4506 1 : nSampleRate += 1;
4507 : }
4508 :
4509 30 : GByte *pabyMaskData = nullptr;
4510 30 : if (poMaskBand)
4511 : {
4512 : pabyMaskData = static_cast<GByte *>(
4513 2 : VSI_MALLOC2_VERBOSE(nBlockXSize, nBlockYSize));
4514 2 : if (!pabyMaskData)
4515 : {
4516 0 : return CE_Failure;
4517 : }
4518 : }
4519 :
4520 : /* --------------------------------------------------------------------
4521 : */
4522 : /* Read the blocks, and add to histogram. */
4523 : /* --------------------------------------------------------------------
4524 : */
4525 30 : for (GIntBig iSampleBlock = 0;
4526 150 : iSampleBlock <
4527 150 : static_cast<GIntBig>(nBlocksPerRow) * nBlocksPerColumn;
4528 120 : iSampleBlock += nSampleRate)
4529 : {
4530 120 : if (!pfnProgress(
4531 120 : static_cast<double>(iSampleBlock) /
4532 120 : (static_cast<double>(nBlocksPerRow) * nBlocksPerColumn),
4533 : "Compute Histogram", pProgressData))
4534 : {
4535 0 : CPLFree(pabyMaskData);
4536 0 : return CE_Failure;
4537 : }
4538 :
4539 120 : const int iYBlock = static_cast<int>(iSampleBlock / nBlocksPerRow);
4540 120 : const int iXBlock = static_cast<int>(iSampleBlock % nBlocksPerRow);
4541 :
4542 120 : int nXCheck = 0, nYCheck = 0;
4543 120 : GetActualBlockSize(iXBlock, iYBlock, &nXCheck, &nYCheck);
4544 :
4545 122 : if (poMaskBand &&
4546 2 : poMaskBand->RasterIO(GF_Read, iXBlock * nBlockXSize,
4547 2 : iYBlock * nBlockYSize, nXCheck, nYCheck,
4548 : pabyMaskData, nXCheck, nYCheck, GDT_Byte,
4549 2 : 0, nBlockXSize, nullptr) != CE_None)
4550 : {
4551 0 : CPLFree(pabyMaskData);
4552 0 : return CE_Failure;
4553 : }
4554 :
4555 120 : GDALRasterBlock *poBlock = GetLockedBlockRef(iXBlock, iYBlock);
4556 120 : if (poBlock == nullptr)
4557 : {
4558 0 : CPLFree(pabyMaskData);
4559 0 : return CE_Failure;
4560 : }
4561 :
4562 120 : void *pData = poBlock->GetDataRef();
4563 :
4564 : // this is a special case for a common situation.
4565 120 : if (eDataType == GDT_Byte && !bSignedByte && dfScale == 1.0 &&
4566 86 : (dfMin >= -0.5 && dfMin <= 0.5) && nYCheck == nBlockYSize &&
4567 83 : nXCheck == nBlockXSize && nBuckets == 256)
4568 : {
4569 83 : const GPtrDiff_t nPixels =
4570 83 : static_cast<GPtrDiff_t>(nXCheck) * nYCheck;
4571 83 : GByte *pabyData = static_cast<GByte *>(pData);
4572 :
4573 72137 : for (GPtrDiff_t i = 0; i < nPixels; i++)
4574 : {
4575 72054 : if (pabyMaskData && pabyMaskData[i] == 0)
4576 0 : continue;
4577 72054 : if (!(sNoDataValues.bGotNoDataValue &&
4578 512 : (pabyData[i] ==
4579 512 : static_cast<GByte>(sNoDataValues.dfNoDataValue))))
4580 : {
4581 71798 : panHistogram[pabyData[i]]++;
4582 : }
4583 : }
4584 :
4585 83 : poBlock->DropLock();
4586 83 : continue; // To next sample block.
4587 : }
4588 :
4589 : // This isn't the fastest way to do this, but is easier for now.
4590 253 : for (int iY = 0; iY < nYCheck; iY++)
4591 : {
4592 36385 : for (int iX = 0; iX < nXCheck; iX++)
4593 : {
4594 36169 : const GPtrDiff_t iOffset =
4595 36169 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
4596 :
4597 36169 : if (pabyMaskData && pabyMaskData[iOffset] == 0)
4598 2 : continue;
4599 :
4600 36167 : double dfValue = 0.0;
4601 :
4602 36167 : switch (eDataType)
4603 : {
4604 19716 : case GDT_Byte:
4605 : {
4606 19716 : if (bSignedByte)
4607 0 : dfValue =
4608 0 : static_cast<signed char *>(pData)[iOffset];
4609 : else
4610 19716 : dfValue = static_cast<GByte *>(pData)[iOffset];
4611 19716 : break;
4612 : }
4613 0 : case GDT_Int8:
4614 0 : dfValue = static_cast<GInt8 *>(pData)[iOffset];
4615 0 : break;
4616 16384 : case GDT_UInt16:
4617 16384 : dfValue = static_cast<GUInt16 *>(pData)[iOffset];
4618 16384 : break;
4619 2 : case GDT_Int16:
4620 2 : dfValue = static_cast<GInt16 *>(pData)[iOffset];
4621 2 : break;
4622 0 : case GDT_UInt32:
4623 0 : dfValue = static_cast<GUInt32 *>(pData)[iOffset];
4624 0 : break;
4625 60 : case GDT_Int32:
4626 60 : dfValue = static_cast<GInt32 *>(pData)[iOffset];
4627 60 : break;
4628 0 : case GDT_UInt64:
4629 0 : dfValue = static_cast<double>(
4630 0 : static_cast<GUInt64 *>(pData)[iOffset]);
4631 0 : break;
4632 0 : case GDT_Int64:
4633 0 : dfValue = static_cast<double>(
4634 0 : static_cast<GInt64 *>(pData)[iOffset]);
4635 0 : break;
4636 0 : case GDT_Float16:
4637 : {
4638 : using namespace std;
4639 0 : const GFloat16 hfValue =
4640 0 : static_cast<GFloat16 *>(pData)[iOffset];
4641 0 : if (isnan(hfValue) ||
4642 0 : (sNoDataValues.bGotFloat16NoDataValue &&
4643 0 : ARE_REAL_EQUAL(hfValue,
4644 : sNoDataValues.hfNoDataValue)))
4645 0 : continue;
4646 0 : dfValue = hfValue;
4647 0 : break;
4648 : }
4649 3 : case GDT_Float32:
4650 : {
4651 3 : const float fValue =
4652 3 : static_cast<float *>(pData)[iOffset];
4653 6 : if (std::isnan(fValue) ||
4654 6 : (sNoDataValues.bGotFloatNoDataValue &&
4655 3 : ARE_REAL_EQUAL(fValue,
4656 : sNoDataValues.fNoDataValue)))
4657 0 : continue;
4658 3 : dfValue = fValue;
4659 3 : break;
4660 : }
4661 2 : case GDT_Float64:
4662 2 : dfValue = static_cast<double *>(pData)[iOffset];
4663 2 : if (std::isnan(dfValue))
4664 0 : continue;
4665 2 : break;
4666 0 : case GDT_CInt16:
4667 : {
4668 0 : double dfReal =
4669 0 : static_cast<GInt16 *>(pData)[iOffset * 2];
4670 0 : double dfImag =
4671 0 : static_cast<GInt16 *>(pData)[iOffset * 2 + 1];
4672 0 : dfValue = sqrt(dfReal * dfReal + dfImag * dfImag);
4673 0 : break;
4674 : }
4675 0 : case GDT_CInt32:
4676 : {
4677 0 : double dfReal =
4678 0 : static_cast<GInt32 *>(pData)[iOffset * 2];
4679 0 : double dfImag =
4680 0 : static_cast<GInt32 *>(pData)[iOffset * 2 + 1];
4681 0 : dfValue = sqrt(dfReal * dfReal + dfImag * dfImag);
4682 0 : break;
4683 : }
4684 0 : case GDT_CFloat16:
4685 : {
4686 : double dfReal =
4687 0 : static_cast<GFloat16 *>(pData)[iOffset * 2];
4688 : double dfImag =
4689 0 : static_cast<GFloat16 *>(pData)[iOffset * 2 + 1];
4690 0 : if (std::isnan(dfReal) || std::isnan(dfImag))
4691 0 : continue;
4692 0 : dfValue = sqrt(dfReal * dfReal + dfImag * dfImag);
4693 0 : break;
4694 : }
4695 0 : case GDT_CFloat32:
4696 : {
4697 0 : double dfReal =
4698 0 : static_cast<float *>(pData)[iOffset * 2];
4699 0 : double dfImag =
4700 0 : static_cast<float *>(pData)[iOffset * 2 + 1];
4701 0 : if (std::isnan(dfReal) || std::isnan(dfImag))
4702 0 : continue;
4703 0 : dfValue = sqrt(dfReal * dfReal + dfImag * dfImag);
4704 0 : break;
4705 : }
4706 0 : case GDT_CFloat64:
4707 : {
4708 0 : double dfReal =
4709 0 : static_cast<double *>(pData)[iOffset * 2];
4710 0 : double dfImag =
4711 0 : static_cast<double *>(pData)[iOffset * 2 + 1];
4712 0 : if (std::isnan(dfReal) || std::isnan(dfImag))
4713 0 : continue;
4714 0 : dfValue = sqrt(dfReal * dfReal + dfImag * dfImag);
4715 0 : break;
4716 : }
4717 0 : case GDT_Unknown:
4718 : case GDT_TypeCount:
4719 0 : CPLAssert(false);
4720 : CPLFree(pabyMaskData);
4721 : return CE_Failure;
4722 : }
4723 :
4724 36167 : if (eDataType != GDT_Float16 && eDataType != GDT_Float32 &&
4725 72334 : sNoDataValues.bGotNoDataValue &&
4726 0 : ARE_REAL_EQUAL(dfValue, sNoDataValues.dfNoDataValue))
4727 0 : continue;
4728 :
4729 : // Given that dfValue and dfMin are not NaN, and dfScale > 0
4730 : // and finite, the result of the multiplication cannot be
4731 : // NaN
4732 36167 : const double dfIndex = floor((dfValue - dfMin) * dfScale);
4733 :
4734 36167 : if (dfIndex < 0)
4735 : {
4736 1 : if (bIncludeOutOfRange)
4737 1 : panHistogram[0]++;
4738 : }
4739 36166 : else if (dfIndex >= nBuckets)
4740 : {
4741 7 : if (bIncludeOutOfRange)
4742 4 : ++panHistogram[nBuckets - 1];
4743 : }
4744 : else
4745 : {
4746 36159 : ++panHistogram[static_cast<int>(dfIndex)];
4747 : }
4748 : }
4749 : }
4750 :
4751 37 : poBlock->DropLock();
4752 : }
4753 :
4754 30 : CPLFree(pabyMaskData);
4755 : }
4756 :
4757 30 : pfnProgress(1.0, "Compute Histogram", pProgressData);
4758 :
4759 30 : return CE_None;
4760 : }
4761 :
4762 : /************************************************************************/
4763 : /* GDALGetRasterHistogram() */
4764 : /************************************************************************/
4765 :
4766 : /**
4767 : * \brief Compute raster histogram.
4768 : *
4769 : * Use GDALGetRasterHistogramEx() instead to get correct counts for values
4770 : * exceeding 2 billion.
4771 : *
4772 : * @see GDALRasterBand::GetHistogram()
4773 : * @see GDALGetRasterHistogramEx()
4774 : */
4775 :
4776 0 : CPLErr CPL_STDCALL GDALGetRasterHistogram(GDALRasterBandH hBand, double dfMin,
4777 : double dfMax, int nBuckets,
4778 : int *panHistogram,
4779 : int bIncludeOutOfRange, int bApproxOK,
4780 : GDALProgressFunc pfnProgress,
4781 : void *pProgressData)
4782 :
4783 : {
4784 0 : VALIDATE_POINTER1(hBand, "GDALGetRasterHistogram", CE_Failure);
4785 0 : VALIDATE_POINTER1(panHistogram, "GDALGetRasterHistogram", CE_Failure);
4786 :
4787 0 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
4788 :
4789 : GUIntBig *panHistogramTemp =
4790 0 : static_cast<GUIntBig *>(VSIMalloc2(sizeof(GUIntBig), nBuckets));
4791 0 : if (panHistogramTemp == nullptr)
4792 : {
4793 0 : poBand->ReportError(CE_Failure, CPLE_OutOfMemory,
4794 : "Out of memory in GDALGetRasterHistogram().");
4795 0 : return CE_Failure;
4796 : }
4797 :
4798 0 : CPLErr eErr = poBand->GetHistogram(dfMin, dfMax, nBuckets, panHistogramTemp,
4799 : bIncludeOutOfRange, bApproxOK,
4800 0 : pfnProgress, pProgressData);
4801 :
4802 0 : if (eErr == CE_None)
4803 : {
4804 0 : for (int i = 0; i < nBuckets; i++)
4805 : {
4806 0 : if (panHistogramTemp[i] > INT_MAX)
4807 : {
4808 0 : CPLError(CE_Warning, CPLE_AppDefined,
4809 : "Count for bucket %d, which is " CPL_FRMT_GUIB
4810 : " exceeds maximum 32 bit value",
4811 0 : i, panHistogramTemp[i]);
4812 0 : panHistogram[i] = INT_MAX;
4813 : }
4814 : else
4815 : {
4816 0 : panHistogram[i] = static_cast<int>(panHistogramTemp[i]);
4817 : }
4818 : }
4819 : }
4820 :
4821 0 : CPLFree(panHistogramTemp);
4822 :
4823 0 : return eErr;
4824 : }
4825 :
4826 : /************************************************************************/
4827 : /* GDALGetRasterHistogramEx() */
4828 : /************************************************************************/
4829 :
4830 : /**
4831 : * \brief Compute raster histogram.
4832 : *
4833 : * @see GDALRasterBand::GetHistogram()
4834 : *
4835 : * @since GDAL 2.0
4836 : */
4837 :
4838 26 : CPLErr CPL_STDCALL GDALGetRasterHistogramEx(
4839 : GDALRasterBandH hBand, double dfMin, double dfMax, int nBuckets,
4840 : GUIntBig *panHistogram, int bIncludeOutOfRange, int bApproxOK,
4841 : GDALProgressFunc pfnProgress, void *pProgressData)
4842 :
4843 : {
4844 26 : VALIDATE_POINTER1(hBand, "GDALGetRasterHistogramEx", CE_Failure);
4845 26 : VALIDATE_POINTER1(panHistogram, "GDALGetRasterHistogramEx", CE_Failure);
4846 :
4847 26 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
4848 :
4849 26 : return poBand->GetHistogram(dfMin, dfMax, nBuckets, panHistogram,
4850 : bIncludeOutOfRange, bApproxOK, pfnProgress,
4851 26 : pProgressData);
4852 : }
4853 :
4854 : /************************************************************************/
4855 : /* GetDefaultHistogram() */
4856 : /************************************************************************/
4857 :
4858 : /**
4859 : * \brief Fetch default raster histogram.
4860 : *
4861 : * The default method in GDALRasterBand will compute a default histogram. This
4862 : * method is overridden by derived classes (such as GDALPamRasterBand,
4863 : * VRTDataset, HFADataset...) that may be able to fetch efficiently an already
4864 : * stored histogram.
4865 : *
4866 : * This method is the same as the C functions GDALGetDefaultHistogram() and
4867 : * GDALGetDefaultHistogramEx().
4868 : *
4869 : * @param pdfMin pointer to double value that will contain the lower bound of
4870 : * the histogram.
4871 : * @param pdfMax pointer to double value that will contain the upper bound of
4872 : * the histogram.
4873 : * @param pnBuckets pointer to int value that will contain the number of buckets
4874 : * in *ppanHistogram.
4875 : * @param ppanHistogram pointer to array into which the histogram totals are
4876 : * placed. To be freed with VSIFree
4877 : * @param bForce TRUE to force the computation. If FALSE and no default
4878 : * histogram is available, the method will return CE_Warning
4879 : * @param pfnProgress function to report progress to completion.
4880 : * @param pProgressData application data to pass to pfnProgress.
4881 : *
4882 : * @return CE_None on success, CE_Failure if something goes wrong, or
4883 : * CE_Warning if no default histogram is available.
4884 : */
4885 :
4886 22 : CPLErr GDALRasterBand::GetDefaultHistogram(double *pdfMin, double *pdfMax,
4887 : int *pnBuckets,
4888 : GUIntBig **ppanHistogram, int bForce,
4889 : GDALProgressFunc pfnProgress,
4890 : void *pProgressData)
4891 :
4892 : {
4893 22 : CPLAssert(nullptr != pnBuckets);
4894 22 : CPLAssert(nullptr != ppanHistogram);
4895 22 : CPLAssert(nullptr != pdfMin);
4896 22 : CPLAssert(nullptr != pdfMax);
4897 :
4898 22 : *pnBuckets = 0;
4899 22 : *ppanHistogram = nullptr;
4900 :
4901 22 : if (!bForce)
4902 5 : return CE_Warning;
4903 :
4904 17 : const int nBuckets = 256;
4905 :
4906 17 : bool bSignedByte = false;
4907 17 : if (eDataType == GDT_Byte)
4908 : {
4909 17 : EnablePixelTypeSignedByteWarning(false);
4910 : const char *pszPixelType =
4911 17 : GetMetadataItem("PIXELTYPE", "IMAGE_STRUCTURE");
4912 17 : EnablePixelTypeSignedByteWarning(true);
4913 17 : bSignedByte =
4914 17 : pszPixelType != nullptr && EQUAL(pszPixelType, "SIGNEDBYTE");
4915 : }
4916 :
4917 17 : if (GetRasterDataType() == GDT_Byte && !bSignedByte)
4918 : {
4919 17 : *pdfMin = -0.5;
4920 17 : *pdfMax = 255.5;
4921 : }
4922 : else
4923 : {
4924 :
4925 : const CPLErr eErr =
4926 0 : GetStatistics(TRUE, TRUE, pdfMin, pdfMax, nullptr, nullptr);
4927 0 : const double dfHalfBucket = (*pdfMax - *pdfMin) / (2 * (nBuckets - 1));
4928 0 : *pdfMin -= dfHalfBucket;
4929 0 : *pdfMax += dfHalfBucket;
4930 :
4931 0 : if (eErr != CE_None)
4932 0 : return eErr;
4933 : }
4934 :
4935 17 : *ppanHistogram =
4936 17 : static_cast<GUIntBig *>(VSICalloc(sizeof(GUIntBig), nBuckets));
4937 17 : if (*ppanHistogram == nullptr)
4938 : {
4939 0 : ReportError(CE_Failure, CPLE_OutOfMemory,
4940 : "Out of memory in InitBlockInfo().");
4941 0 : return CE_Failure;
4942 : }
4943 :
4944 17 : *pnBuckets = nBuckets;
4945 34 : CPLErr eErr = GetHistogram(*pdfMin, *pdfMax, *pnBuckets, *ppanHistogram,
4946 17 : TRUE, FALSE, pfnProgress, pProgressData);
4947 17 : if (eErr != CE_None)
4948 : {
4949 0 : *pnBuckets = 0;
4950 : }
4951 17 : return eErr;
4952 : }
4953 :
4954 : /************************************************************************/
4955 : /* GDALGetDefaultHistogram() */
4956 : /************************************************************************/
4957 :
4958 : /**
4959 : * \brief Fetch default raster histogram.
4960 : *
4961 : * Use GDALGetRasterHistogramEx() instead to get correct counts for values
4962 : * exceeding 2 billion.
4963 : *
4964 : * @see GDALRasterBand::GDALGetDefaultHistogram()
4965 : * @see GDALGetRasterHistogramEx()
4966 : */
4967 :
4968 0 : CPLErr CPL_STDCALL GDALGetDefaultHistogram(GDALRasterBandH hBand,
4969 : double *pdfMin, double *pdfMax,
4970 : int *pnBuckets, int **ppanHistogram,
4971 : int bForce,
4972 : GDALProgressFunc pfnProgress,
4973 : void *pProgressData)
4974 :
4975 : {
4976 0 : VALIDATE_POINTER1(hBand, "GDALGetDefaultHistogram", CE_Failure);
4977 0 : VALIDATE_POINTER1(pdfMin, "GDALGetDefaultHistogram", CE_Failure);
4978 0 : VALIDATE_POINTER1(pdfMax, "GDALGetDefaultHistogram", CE_Failure);
4979 0 : VALIDATE_POINTER1(pnBuckets, "GDALGetDefaultHistogram", CE_Failure);
4980 0 : VALIDATE_POINTER1(ppanHistogram, "GDALGetDefaultHistogram", CE_Failure);
4981 :
4982 0 : GDALRasterBand *const poBand = GDALRasterBand::FromHandle(hBand);
4983 0 : GUIntBig *panHistogramTemp = nullptr;
4984 0 : CPLErr eErr = poBand->GetDefaultHistogram(pdfMin, pdfMax, pnBuckets,
4985 : &panHistogramTemp, bForce,
4986 0 : pfnProgress, pProgressData);
4987 0 : if (eErr == CE_None)
4988 : {
4989 0 : const int nBuckets = *pnBuckets;
4990 0 : *ppanHistogram = static_cast<int *>(VSIMalloc2(sizeof(int), nBuckets));
4991 0 : if (*ppanHistogram == nullptr)
4992 : {
4993 0 : poBand->ReportError(CE_Failure, CPLE_OutOfMemory,
4994 : "Out of memory in GDALGetDefaultHistogram().");
4995 0 : VSIFree(panHistogramTemp);
4996 0 : return CE_Failure;
4997 : }
4998 :
4999 0 : for (int i = 0; i < nBuckets; ++i)
5000 : {
5001 0 : if (panHistogramTemp[i] > INT_MAX)
5002 : {
5003 0 : CPLError(CE_Warning, CPLE_AppDefined,
5004 : "Count for bucket %d, which is " CPL_FRMT_GUIB
5005 : " exceeds maximum 32 bit value",
5006 0 : i, panHistogramTemp[i]);
5007 0 : (*ppanHistogram)[i] = INT_MAX;
5008 : }
5009 : else
5010 : {
5011 0 : (*ppanHistogram)[i] = static_cast<int>(panHistogramTemp[i]);
5012 : }
5013 : }
5014 :
5015 0 : CPLFree(panHistogramTemp);
5016 : }
5017 : else
5018 : {
5019 0 : *ppanHistogram = nullptr;
5020 : }
5021 :
5022 0 : return eErr;
5023 : }
5024 :
5025 : /************************************************************************/
5026 : /* GDALGetDefaultHistogramEx() */
5027 : /************************************************************************/
5028 :
5029 : /**
5030 : * \brief Fetch default raster histogram.
5031 : *
5032 : * @see GDALRasterBand::GetDefaultHistogram()
5033 : *
5034 : * @since GDAL 2.0
5035 : */
5036 :
5037 : CPLErr CPL_STDCALL
5038 28 : GDALGetDefaultHistogramEx(GDALRasterBandH hBand, double *pdfMin, double *pdfMax,
5039 : int *pnBuckets, GUIntBig **ppanHistogram, int bForce,
5040 : GDALProgressFunc pfnProgress, void *pProgressData)
5041 :
5042 : {
5043 28 : VALIDATE_POINTER1(hBand, "GDALGetDefaultHistogram", CE_Failure);
5044 28 : VALIDATE_POINTER1(pdfMin, "GDALGetDefaultHistogram", CE_Failure);
5045 28 : VALIDATE_POINTER1(pdfMax, "GDALGetDefaultHistogram", CE_Failure);
5046 28 : VALIDATE_POINTER1(pnBuckets, "GDALGetDefaultHistogram", CE_Failure);
5047 28 : VALIDATE_POINTER1(ppanHistogram, "GDALGetDefaultHistogram", CE_Failure);
5048 :
5049 28 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
5050 28 : return poBand->GetDefaultHistogram(pdfMin, pdfMax, pnBuckets, ppanHistogram,
5051 28 : bForce, pfnProgress, pProgressData);
5052 : }
5053 :
5054 : /************************************************************************/
5055 : /* AdviseRead() */
5056 : /************************************************************************/
5057 :
5058 : /**
5059 : * \fn GDALRasterBand::AdviseRead(int,int,int,int,int,int,GDALDataType,char**)
5060 : * \brief Advise driver of upcoming read requests.
5061 : *
5062 : * Some GDAL drivers operate more efficiently if they know in advance what
5063 : * set of upcoming read requests will be made. The AdviseRead() method allows
5064 : * an application to notify the driver of the region of interest,
5065 : * and at what resolution the region will be read.
5066 : *
5067 : * Many drivers just ignore the AdviseRead() call, but it can dramatically
5068 : * accelerate access via some drivers.
5069 : *
5070 : * Depending on call paths, drivers might receive several calls to
5071 : * AdviseRead() with the same parameters.
5072 : *
5073 : * @param nXOff The pixel offset to the top left corner of the region
5074 : * of the band to be accessed. This would be zero to start from the left side.
5075 : *
5076 : * @param nYOff The line offset to the top left corner of the region
5077 : * of the band to be accessed. This would be zero to start from the top.
5078 : *
5079 : * @param nXSize The width of the region of the band to be accessed in pixels.
5080 : *
5081 : * @param nYSize The height of the region of the band to be accessed in lines.
5082 : *
5083 : * @param nBufXSize the width of the buffer image into which the desired region
5084 : * is to be read, or from which it is to be written.
5085 : *
5086 : * @param nBufYSize the height of the buffer image into which the desired
5087 : * region is to be read, or from which it is to be written.
5088 : *
5089 : * @param eBufType the type of the pixel values in the pData data buffer. The
5090 : * pixel values will automatically be translated to/from the GDALRasterBand
5091 : * data type as needed.
5092 : *
5093 : * @param papszOptions a list of name=value strings with special control
5094 : * options. Normally this is NULL.
5095 : *
5096 : * @return CE_Failure if the request is invalid and CE_None if it works or
5097 : * is ignored.
5098 : */
5099 :
5100 : /**/
5101 : /**/
5102 :
5103 114349 : CPLErr GDALRasterBand::AdviseRead(int /*nXOff*/, int /*nYOff*/, int /*nXSize*/,
5104 : int /*nYSize*/, int /*nBufXSize*/,
5105 : int /*nBufYSize*/, GDALDataType /*eBufType*/,
5106 : char ** /*papszOptions*/)
5107 : {
5108 114349 : return CE_None;
5109 : }
5110 :
5111 : /************************************************************************/
5112 : /* GDALRasterAdviseRead() */
5113 : /************************************************************************/
5114 :
5115 : /**
5116 : * \brief Advise driver of upcoming read requests.
5117 : *
5118 : * @see GDALRasterBand::AdviseRead()
5119 : */
5120 :
5121 2 : CPLErr CPL_STDCALL GDALRasterAdviseRead(GDALRasterBandH hBand, int nXOff,
5122 : int nYOff, int nXSize, int nYSize,
5123 : int nBufXSize, int nBufYSize,
5124 : GDALDataType eDT,
5125 : CSLConstList papszOptions)
5126 :
5127 : {
5128 2 : VALIDATE_POINTER1(hBand, "GDALRasterAdviseRead", CE_Failure);
5129 :
5130 2 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
5131 2 : return poBand->AdviseRead(nXOff, nYOff, nXSize, nYSize, nBufXSize,
5132 : nBufYSize, eDT,
5133 2 : const_cast<char **>(papszOptions));
5134 : }
5135 :
5136 : /************************************************************************/
5137 : /* GetStatistics() */
5138 : /************************************************************************/
5139 :
5140 : /**
5141 : * \brief Fetch image statistics.
5142 : *
5143 : * Returns the minimum, maximum, mean and standard deviation of all
5144 : * pixel values in this band. If approximate statistics are sufficient,
5145 : * the bApproxOK flag can be set to true in which case overviews, or a
5146 : * subset of image tiles may be used in computing the statistics.
5147 : *
5148 : * If bForce is FALSE results will only be returned if it can be done
5149 : * quickly (i.e. without scanning the image, typically by using pre-existing
5150 : * STATISTICS_xxx metadata items). If bForce is FALSE and results cannot be
5151 : * returned efficiently, the method will return CE_Warning but no warning will
5152 : * be issued. This is a non-standard use of the CE_Warning return value
5153 : * to indicate "nothing done".
5154 : *
5155 : * If bForce is TRUE, and results are quickly available without scanning the
5156 : * image, they will be used. If bForce is TRUE and results are not quickly
5157 : * available, GetStatistics() forwards the computation to ComputeStatistics(),
5158 : * which will scan the image.
5159 : *
5160 : * To always force recomputation of statistics, use ComputeStatistics() instead
5161 : * of this method.
5162 : *
5163 : * Note that file formats using PAM (Persistent Auxiliary Metadata) services
5164 : * will generally cache statistics in the .pam file allowing fast fetch
5165 : * after the first request.
5166 : *
5167 : * This method is the same as the C function GDALGetRasterStatistics().
5168 : *
5169 : * @param bApproxOK If TRUE statistics may be computed based on overviews
5170 : * or a subset of all tiles.
5171 : *
5172 : * @param bForce If FALSE statistics will only be returned if it can
5173 : * be done without rescanning the image. If TRUE, statistics computation will
5174 : * be forced if pre-existing values are not quickly available.
5175 : *
5176 : * @param pdfMin Location into which to load image minimum (may be NULL).
5177 : *
5178 : * @param pdfMax Location into which to load image maximum (may be NULL).-
5179 : *
5180 : * @param pdfMean Location into which to load image mean (may be NULL).
5181 : *
5182 : * @param pdfStdDev Location into which to load image standard deviation
5183 : * (may be NULL).
5184 : *
5185 : * @return CE_None on success, CE_Warning if no values returned,
5186 : * CE_Failure if an error occurs.
5187 : */
5188 :
5189 622 : CPLErr GDALRasterBand::GetStatistics(int bApproxOK, int bForce, double *pdfMin,
5190 : double *pdfMax, double *pdfMean,
5191 : double *pdfStdDev)
5192 :
5193 : {
5194 : /* -------------------------------------------------------------------- */
5195 : /* Do we already have metadata items for the requested values? */
5196 : /* -------------------------------------------------------------------- */
5197 1244 : if ((pdfMin == nullptr ||
5198 622 : GetMetadataItem("STATISTICS_MINIMUM") != nullptr) &&
5199 202 : (pdfMax == nullptr ||
5200 202 : GetMetadataItem("STATISTICS_MAXIMUM") != nullptr) &&
5201 1446 : (pdfMean == nullptr || GetMetadataItem("STATISTICS_MEAN") != nullptr) &&
5202 202 : (pdfStdDev == nullptr ||
5203 202 : GetMetadataItem("STATISTICS_STDDEV") != nullptr))
5204 : {
5205 202 : if (!(GetMetadataItem("STATISTICS_APPROXIMATE") && !bApproxOK))
5206 : {
5207 195 : if (pdfMin != nullptr)
5208 195 : *pdfMin = CPLAtofM(GetMetadataItem("STATISTICS_MINIMUM"));
5209 195 : if (pdfMax != nullptr)
5210 195 : *pdfMax = CPLAtofM(GetMetadataItem("STATISTICS_MAXIMUM"));
5211 195 : if (pdfMean != nullptr)
5212 195 : *pdfMean = CPLAtofM(GetMetadataItem("STATISTICS_MEAN"));
5213 195 : if (pdfStdDev != nullptr)
5214 195 : *pdfStdDev = CPLAtofM(GetMetadataItem("STATISTICS_STDDEV"));
5215 :
5216 195 : return CE_None;
5217 : }
5218 : }
5219 :
5220 : /* -------------------------------------------------------------------- */
5221 : /* Does the driver already know the min/max? */
5222 : /* -------------------------------------------------------------------- */
5223 427 : if (bApproxOK && pdfMean == nullptr && pdfStdDev == nullptr)
5224 : {
5225 0 : int bSuccessMin = FALSE;
5226 0 : int bSuccessMax = FALSE;
5227 :
5228 0 : const double dfMin = GetMinimum(&bSuccessMin);
5229 0 : const double dfMax = GetMaximum(&bSuccessMax);
5230 :
5231 0 : if (bSuccessMin && bSuccessMax)
5232 : {
5233 0 : if (pdfMin != nullptr)
5234 0 : *pdfMin = dfMin;
5235 0 : if (pdfMax != nullptr)
5236 0 : *pdfMax = dfMax;
5237 0 : return CE_None;
5238 : }
5239 : }
5240 :
5241 : /* -------------------------------------------------------------------- */
5242 : /* Either return without results, or force computation. */
5243 : /* -------------------------------------------------------------------- */
5244 427 : if (!bForce)
5245 172 : return CE_Warning;
5246 : else
5247 255 : return ComputeStatistics(bApproxOK, pdfMin, pdfMax, pdfMean, pdfStdDev,
5248 255 : GDALDummyProgress, nullptr);
5249 : }
5250 :
5251 : /************************************************************************/
5252 : /* GDALGetRasterStatistics() */
5253 : /************************************************************************/
5254 :
5255 : /**
5256 : * \brief Fetch image statistics.
5257 : *
5258 : * @see GDALRasterBand::GetStatistics()
5259 : */
5260 :
5261 271 : CPLErr CPL_STDCALL GDALGetRasterStatistics(GDALRasterBandH hBand, int bApproxOK,
5262 : int bForce, double *pdfMin,
5263 : double *pdfMax, double *pdfMean,
5264 : double *pdfStdDev)
5265 :
5266 : {
5267 271 : VALIDATE_POINTER1(hBand, "GDALGetRasterStatistics", CE_Failure);
5268 :
5269 271 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
5270 271 : return poBand->GetStatistics(bApproxOK, bForce, pdfMin, pdfMax, pdfMean,
5271 271 : pdfStdDev);
5272 : }
5273 :
5274 : /************************************************************************/
5275 : /* GDALUInt128 */
5276 : /************************************************************************/
5277 :
5278 : #ifdef HAVE_UINT128_T
5279 : class GDALUInt128
5280 : {
5281 : __uint128_t val;
5282 :
5283 642 : explicit GDALUInt128(__uint128_t valIn) : val(valIn)
5284 : {
5285 642 : }
5286 :
5287 : public:
5288 428 : static GDALUInt128 Mul(GUIntBig first, GUIntBig second)
5289 : {
5290 : // Evaluates to just a single mul on x86_64
5291 428 : return GDALUInt128(static_cast<__uint128_t>(first) * second);
5292 : }
5293 :
5294 214 : GDALUInt128 operator-(const GDALUInt128 &other) const
5295 : {
5296 214 : return GDALUInt128(val - other.val);
5297 : }
5298 :
5299 205 : operator double() const
5300 : {
5301 205 : return static_cast<double>(val);
5302 : }
5303 : };
5304 : #else
5305 :
5306 : #if defined(_MSC_VER) && defined(_M_X64)
5307 : #include <intrin.h>
5308 : #endif
5309 :
5310 : class GDALUInt128
5311 : {
5312 : GUIntBig low, high;
5313 :
5314 : GDALUInt128(GUIntBig lowIn, GUIntBig highIn) : low(lowIn), high(highIn)
5315 : {
5316 : }
5317 :
5318 : public:
5319 : static GDALUInt128 Mul(GUIntBig first, GUIntBig second)
5320 : {
5321 : #if defined(_MSC_VER) && defined(_M_X64)
5322 : GUIntBig highRes;
5323 : GUIntBig lowRes = _umul128(first, second, &highRes);
5324 : return GDALUInt128(lowRes, highRes);
5325 : #else
5326 : const GUInt32 firstLow = static_cast<GUInt32>(first);
5327 : const GUInt32 firstHigh = static_cast<GUInt32>(first >> 32);
5328 : const GUInt32 secondLow = static_cast<GUInt32>(second);
5329 : const GUInt32 secondHigh = static_cast<GUInt32>(second >> 32);
5330 : GUIntBig highRes = 0;
5331 : const GUIntBig firstLowSecondHigh =
5332 : static_cast<GUIntBig>(firstLow) * secondHigh;
5333 : const GUIntBig firstHighSecondLow =
5334 : static_cast<GUIntBig>(firstHigh) * secondLow;
5335 : const GUIntBig middleTerm = firstLowSecondHigh + firstHighSecondLow;
5336 : if (middleTerm < firstLowSecondHigh) // check for overflow
5337 : highRes += static_cast<GUIntBig>(1) << 32;
5338 : const GUIntBig firstLowSecondLow =
5339 : static_cast<GUIntBig>(firstLow) * secondLow;
5340 : GUIntBig lowRes = firstLowSecondLow + (middleTerm << 32);
5341 : if (lowRes < firstLowSecondLow) // check for overflow
5342 : highRes++;
5343 : highRes +=
5344 : (middleTerm >> 32) + static_cast<GUIntBig>(firstHigh) * secondHigh;
5345 : return GDALUInt128(lowRes, highRes);
5346 : #endif
5347 : }
5348 :
5349 : GDALUInt128 operator-(const GDALUInt128 &other) const
5350 : {
5351 : GUIntBig highRes = high - other.high;
5352 : GUIntBig lowRes = low - other.low;
5353 : if (lowRes > low) // check for underflow
5354 : --highRes;
5355 : return GDALUInt128(lowRes, highRes);
5356 : }
5357 :
5358 : operator double() const
5359 : {
5360 : const double twoPow64 = 18446744073709551616.0;
5361 : return high * twoPow64 + low;
5362 : }
5363 : };
5364 : #endif
5365 :
5366 : /************************************************************************/
5367 : /* ComputeStatisticsInternal() */
5368 : /************************************************************************/
5369 :
5370 : // Just to make coverity scan happy w.r.t overflow_before_widen, but otherwise
5371 : // not needed.
5372 : #define static_cast_for_coverity_scan static_cast
5373 :
5374 : // The rationale for below optimizations is detailed in statistics.txt
5375 :
5376 : // Use with T = GByte or GUInt16 only !
5377 : template <class T, bool COMPUTE_OTHER_STATS>
5378 : struct ComputeStatisticsInternalGeneric
5379 : {
5380 208 : static void f(int nXCheck, int nBlockXSize, int nYCheck, const T *pData,
5381 : bool bHasNoData, GUInt32 nNoDataValue, GUInt32 &nMin,
5382 : GUInt32 &nMax, GUIntBig &nSum, GUIntBig &nSumSquare,
5383 : GUIntBig &nSampleCount, GUIntBig &nValidCount)
5384 : {
5385 : static_assert(std::is_same<T, GByte>::value ||
5386 : std::is_same<T, GUInt16>::value,
5387 : "bad type for T");
5388 208 : if (bHasNoData)
5389 : {
5390 : // General case
5391 386 : for (int iY = 0; iY < nYCheck; iY++)
5392 : {
5393 81751 : for (int iX = 0; iX < nXCheck; iX++)
5394 : {
5395 81468 : const GPtrDiff_t iOffset =
5396 81468 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
5397 81468 : const GUInt32 nValue = pData[iOffset];
5398 81468 : if (nValue == nNoDataValue)
5399 175 : continue;
5400 81293 : if (nValue < nMin)
5401 26 : nMin = nValue;
5402 81293 : if (nValue > nMax)
5403 57 : nMax = nValue;
5404 : if constexpr (COMPUTE_OTHER_STATS)
5405 : {
5406 79657 : nValidCount++;
5407 79657 : nSum += nValue;
5408 79657 : nSumSquare +=
5409 79657 : static_cast_for_coverity_scan<GUIntBig>(nValue) *
5410 79657 : nValue;
5411 : }
5412 : }
5413 : }
5414 : if constexpr (COMPUTE_OTHER_STATS)
5415 : {
5416 20 : nSampleCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
5417 : }
5418 : }
5419 115 : else if (nMin == std::numeric_limits<T>::lowest() &&
5420 10 : nMax == std::numeric_limits<T>::max())
5421 : {
5422 : if constexpr (COMPUTE_OTHER_STATS)
5423 : {
5424 : // Optimization when there is no nodata and we know we have already
5425 : // reached the min and max
5426 208 : for (int iY = 0; iY < nYCheck; iY++)
5427 : {
5428 : int iX;
5429 1002 : for (iX = 0; iX + 3 < nXCheck; iX += 4)
5430 : {
5431 800 : const GPtrDiff_t iOffset =
5432 800 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
5433 800 : const GUIntBig nValue = pData[iOffset];
5434 800 : const GUIntBig nValue2 = pData[iOffset + 1];
5435 800 : const GUIntBig nValue3 = pData[iOffset + 2];
5436 800 : const GUIntBig nValue4 = pData[iOffset + 3];
5437 800 : nSum += nValue;
5438 800 : nSumSquare += nValue * nValue;
5439 800 : nSum += nValue2;
5440 800 : nSumSquare += nValue2 * nValue2;
5441 800 : nSum += nValue3;
5442 800 : nSumSquare += nValue3 * nValue3;
5443 800 : nSum += nValue4;
5444 800 : nSumSquare += nValue4 * nValue4;
5445 : }
5446 207 : for (; iX < nXCheck; ++iX)
5447 : {
5448 5 : const GPtrDiff_t iOffset =
5449 5 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
5450 5 : const GUIntBig nValue = pData[iOffset];
5451 5 : nSum += nValue;
5452 5 : nSumSquare += nValue * nValue;
5453 : }
5454 : }
5455 6 : nSampleCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
5456 6 : nValidCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
5457 : }
5458 : }
5459 : else
5460 : {
5461 3434 : for (int iY = 0; iY < nYCheck; iY++)
5462 : {
5463 : int iX;
5464 643297 : for (iX = 0; iX + 1 < nXCheck; iX += 2)
5465 : {
5466 639962 : const GPtrDiff_t iOffset =
5467 639962 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
5468 639962 : const GUInt32 nValue = pData[iOffset];
5469 639962 : const GUInt32 nValue2 = pData[iOffset + 1];
5470 639962 : if (nValue < nValue2)
5471 : {
5472 2320 : if (nValue < nMin)
5473 48 : nMin = nValue;
5474 2320 : if (nValue2 > nMax)
5475 116 : nMax = nValue2;
5476 : }
5477 : else
5478 : {
5479 637642 : if (nValue2 < nMin)
5480 66 : nMin = nValue2;
5481 637642 : if (nValue > nMax)
5482 215 : nMax = nValue;
5483 : }
5484 : if constexpr (COMPUTE_OTHER_STATS)
5485 : {
5486 632911 : nSum += nValue;
5487 632911 : nSumSquare +=
5488 632911 : static_cast_for_coverity_scan<GUIntBig>(nValue) *
5489 632911 : nValue;
5490 632911 : nSum += nValue2;
5491 632911 : nSumSquare +=
5492 632911 : static_cast_for_coverity_scan<GUIntBig>(nValue2) *
5493 632911 : nValue2;
5494 : }
5495 : }
5496 3335 : if (iX < nXCheck)
5497 : {
5498 18 : const GPtrDiff_t iOffset =
5499 18 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
5500 18 : const GUInt32 nValue = pData[iOffset];
5501 18 : if (nValue < nMin)
5502 13 : nMin = nValue;
5503 18 : if (nValue > nMax)
5504 14 : nMax = nValue;
5505 : if (COMPUTE_OTHER_STATS)
5506 : {
5507 9 : nSum += nValue;
5508 9 : nSumSquare +=
5509 9 : static_cast_for_coverity_scan<GUIntBig>(nValue) *
5510 9 : nValue;
5511 : }
5512 : }
5513 : }
5514 : if constexpr (COMPUTE_OTHER_STATS)
5515 : {
5516 44 : nSampleCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
5517 44 : nValidCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
5518 : }
5519 : }
5520 208 : }
5521 : };
5522 :
5523 : // Specialization for Byte that is mostly 32 bit friendly as it avoids
5524 : // using 64bit accumulators in internal loops. This also slightly helps in
5525 : // 64bit mode.
5526 : template <bool COMPUTE_OTHER_STATS>
5527 : struct ComputeStatisticsInternalGeneric<GByte, COMPUTE_OTHER_STATS>
5528 : {
5529 13697 : static void f(int nXCheck, int nBlockXSize, int nYCheck, const GByte *pData,
5530 : bool bHasNoData, GUInt32 nNoDataValue, GUInt32 &nMin,
5531 : GUInt32 &nMax, GUIntBig &nSum, GUIntBig &nSumSquare,
5532 : GUIntBig &nSampleCount, GUIntBig &nValidCount)
5533 : {
5534 13697 : int nOuterLoops = nXCheck / 65536;
5535 13697 : if (nXCheck % 65536)
5536 13697 : nOuterLoops++;
5537 :
5538 13697 : if (bHasNoData)
5539 : {
5540 : // General case
5541 23475 : for (int iY = 0; iY < nYCheck; iY++)
5542 : {
5543 12901 : int iX = 0;
5544 25802 : for (int k = 0; k < nOuterLoops; k++)
5545 : {
5546 12901 : int iMax = iX + 65536;
5547 12901 : if (iMax > nXCheck)
5548 12901 : iMax = nXCheck;
5549 12901 : GUInt32 nSum32bit = 0;
5550 12901 : GUInt32 nSumSquare32bit = 0;
5551 12901 : GUInt32 nValidCount32bit = 0;
5552 12901 : GUInt32 nSampleCount32bit = 0;
5553 20707205 : for (; iX < iMax; iX++)
5554 : {
5555 20694353 : const GPtrDiff_t iOffset =
5556 20694353 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
5557 20694353 : const GUInt32 nValue = pData[iOffset];
5558 :
5559 20694353 : nSampleCount32bit++;
5560 20694353 : if (nValue == nNoDataValue)
5561 20353480 : continue;
5562 340818 : if (nValue < nMin)
5563 357 : nMin = nValue;
5564 340818 : if (nValue > nMax)
5565 813 : nMax = nValue;
5566 : if constexpr (COMPUTE_OTHER_STATS)
5567 : {
5568 17073 : nValidCount32bit++;
5569 17073 : nSum32bit += nValue;
5570 17073 : nSumSquare32bit += nValue * nValue;
5571 : }
5572 : }
5573 : if constexpr (COMPUTE_OTHER_STATS)
5574 : {
5575 652 : nSampleCount += nSampleCount32bit;
5576 652 : nValidCount += nValidCount32bit;
5577 652 : nSum += nSum32bit;
5578 652 : nSumSquare += nSumSquare32bit;
5579 : }
5580 : }
5581 : }
5582 : }
5583 3123 : else if (nMin == 0 && nMax == 255)
5584 : {
5585 : if constexpr (COMPUTE_OTHER_STATS)
5586 : {
5587 : // Optimization when there is no nodata and we know we have already
5588 : // reached the min and max
5589 2644 : for (int iY = 0; iY < nYCheck; iY++)
5590 : {
5591 2617 : int iX = 0;
5592 5234 : for (int k = 0; k < nOuterLoops; k++)
5593 : {
5594 2617 : int iMax = iX + 65536;
5595 2617 : if (iMax > nXCheck)
5596 2617 : iMax = nXCheck;
5597 2617 : GUInt32 nSum32bit = 0;
5598 2617 : GUInt32 nSumSquare32bit = 0;
5599 176297 : for (; iX + 3 < iMax; iX += 4)
5600 : {
5601 173680 : const GPtrDiff_t iOffset =
5602 173680 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
5603 173680 : const GUInt32 nValue = pData[iOffset];
5604 173680 : const GUInt32 nValue2 = pData[iOffset + 1];
5605 173680 : const GUInt32 nValue3 = pData[iOffset + 2];
5606 173680 : const GUInt32 nValue4 = pData[iOffset + 3];
5607 173680 : nSum32bit += nValue;
5608 173680 : nSumSquare32bit += nValue * nValue;
5609 173680 : nSum32bit += nValue2;
5610 173680 : nSumSquare32bit += nValue2 * nValue2;
5611 173680 : nSum32bit += nValue3;
5612 173680 : nSumSquare32bit += nValue3 * nValue3;
5613 173680 : nSum32bit += nValue4;
5614 173680 : nSumSquare32bit += nValue4 * nValue4;
5615 : }
5616 2617 : nSum += nSum32bit;
5617 2617 : nSumSquare += nSumSquare32bit;
5618 : }
5619 2620 : for (; iX < nXCheck; ++iX)
5620 : {
5621 3 : const GPtrDiff_t iOffset =
5622 3 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
5623 3 : const GUIntBig nValue = pData[iOffset];
5624 3 : nSum += nValue;
5625 3 : nSumSquare += nValue * nValue;
5626 : }
5627 : }
5628 27 : nSampleCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
5629 27 : nValidCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
5630 27 : }
5631 : }
5632 : else
5633 : {
5634 7883 : for (int iY = 0; iY < nYCheck; iY++)
5635 : {
5636 4787 : int iX = 0;
5637 9574 : for (int k = 0; k < nOuterLoops; k++)
5638 : {
5639 4787 : int iMax = iX + 65536;
5640 4787 : if (iMax > nXCheck)
5641 4787 : iMax = nXCheck;
5642 4787 : GUInt32 nSum32bit = 0;
5643 4787 : GUInt32 nSumSquare32bit = 0;
5644 159415 : for (; iX + 1 < iMax; iX += 2)
5645 : {
5646 154628 : const GPtrDiff_t iOffset =
5647 154628 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
5648 154628 : const GUInt32 nValue = pData[iOffset];
5649 154628 : const GUInt32 nValue2 = pData[iOffset + 1];
5650 154628 : if (nValue < nValue2)
5651 : {
5652 8047 : if (nValue < nMin)
5653 230 : nMin = nValue;
5654 8047 : if (nValue2 > nMax)
5655 219 : nMax = nValue2;
5656 : }
5657 : else
5658 : {
5659 146581 : if (nValue2 < nMin)
5660 359 : nMin = nValue2;
5661 146581 : if (nValue > nMax)
5662 828 : nMax = nValue;
5663 : }
5664 : if constexpr (COMPUTE_OTHER_STATS)
5665 : {
5666 132491 : nSum32bit += nValue;
5667 132491 : nSumSquare32bit += nValue * nValue;
5668 132491 : nSum32bit += nValue2;
5669 132491 : nSumSquare32bit += nValue2 * nValue2;
5670 : }
5671 : }
5672 : if constexpr (COMPUTE_OTHER_STATS)
5673 : {
5674 1610 : nSum += nSum32bit;
5675 1610 : nSumSquare += nSumSquare32bit;
5676 : }
5677 : }
5678 4787 : if (iX < nXCheck)
5679 : {
5680 1515 : const GPtrDiff_t iOffset =
5681 1515 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
5682 1515 : const GUInt32 nValue = pData[iOffset];
5683 1515 : if (nValue < nMin)
5684 108 : nMin = nValue;
5685 1515 : if (nValue > nMax)
5686 95 : nMax = nValue;
5687 : if constexpr (COMPUTE_OTHER_STATS)
5688 : {
5689 313 : nSum += nValue;
5690 313 : nSumSquare +=
5691 313 : static_cast_for_coverity_scan<GUIntBig>(nValue) *
5692 313 : nValue;
5693 : }
5694 : }
5695 : }
5696 : if constexpr (COMPUTE_OTHER_STATS)
5697 : {
5698 909 : nSampleCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
5699 909 : nValidCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
5700 : }
5701 : }
5702 13697 : }
5703 : };
5704 :
5705 : template <class T, bool COMPUTE_OTHER_STATS> struct ComputeStatisticsInternal
5706 : {
5707 : static void f(int nXCheck, int nBlockXSize, int nYCheck, const T *pData,
5708 : bool bHasNoData, GUInt32 nNoDataValue, GUInt32 &nMin,
5709 : GUInt32 &nMax, GUIntBig &nSum, GUIntBig &nSumSquare,
5710 : GUIntBig &nSampleCount, GUIntBig &nValidCount)
5711 : {
5712 : ComputeStatisticsInternalGeneric<T, COMPUTE_OTHER_STATS>::f(
5713 : nXCheck, nBlockXSize, nYCheck, pData, bHasNoData, nNoDataValue,
5714 : nMin, nMax, nSum, nSumSquare, nSampleCount, nValidCount);
5715 : }
5716 : };
5717 :
5718 : #if (defined(__x86_64__) || defined(_M_X64)) && \
5719 : (defined(__GNUC__) || defined(_MSC_VER))
5720 :
5721 : #include "gdal_avx2_emulation.hpp"
5722 :
5723 : #define ZERO256 GDALmm256_setzero_si256()
5724 :
5725 : template <bool COMPUTE_MIN, bool COMPUTE_MAX, bool COMPUTE_OTHER_STATS>
5726 : static void
5727 21332 : ComputeStatisticsByteNoNodata(GPtrDiff_t nBlockPixels,
5728 : // assumed to be aligned on 256 bits
5729 : const GByte *pData, GUInt32 &nMin, GUInt32 &nMax,
5730 : GUIntBig &nSum, GUIntBig &nSumSquare,
5731 : GUIntBig &nSampleCount, GUIntBig &nValidCount)
5732 : {
5733 : // 32-byte alignment may not be enforced by linker, so do it at hand
5734 : GByte
5735 : aby32ByteUnaligned[32 + 32 + 32 + (COMPUTE_OTHER_STATS ? 32 + 32 : 0)];
5736 21332 : GByte *paby32ByteAligned =
5737 : aby32ByteUnaligned +
5738 21332 : (32 - (reinterpret_cast<GUIntptr_t>(aby32ByteUnaligned) % 32));
5739 21332 : GByte *pabyMin = paby32ByteAligned;
5740 21332 : GByte *pabyMax = paby32ByteAligned + 32;
5741 21332 : GUInt32 *panSum =
5742 : COMPUTE_OTHER_STATS
5743 : ? reinterpret_cast<GUInt32 *>(paby32ByteAligned + 32 * 2)
5744 : : nullptr;
5745 21332 : GUInt32 *panSumSquare =
5746 : COMPUTE_OTHER_STATS
5747 : ? reinterpret_cast<GUInt32 *>(paby32ByteAligned + 32 * 3)
5748 : : nullptr;
5749 :
5750 21332 : CPLAssert((reinterpret_cast<uintptr_t>(pData) % 32) == 0);
5751 :
5752 21332 : GPtrDiff_t i = 0;
5753 : // Make sure that sumSquare can fit on uint32
5754 : // * 8 since we can hold 8 sums per vector register
5755 21332 : const int nMaxIterationsPerInnerLoop =
5756 : 8 * ((std::numeric_limits<GUInt32>::max() / (255 * 255)) & ~31);
5757 21332 : GPtrDiff_t nOuterLoops = nBlockPixels / nMaxIterationsPerInnerLoop;
5758 21332 : if ((nBlockPixels % nMaxIterationsPerInnerLoop) != 0)
5759 21332 : nOuterLoops++;
5760 :
5761 : GDALm256i ymm_min =
5762 21332 : GDALmm256_load_si256(reinterpret_cast<const GDALm256i *>(pData + i));
5763 21332 : GDALm256i ymm_max = ymm_min;
5764 21332 : [[maybe_unused]] const auto ymm_mask_8bits = GDALmm256_set1_epi16(0xFF);
5765 :
5766 42664 : for (GPtrDiff_t k = 0; k < nOuterLoops; k++)
5767 : {
5768 21332 : const auto iMax =
5769 21332 : std::min(nBlockPixels, i + nMaxIterationsPerInnerLoop);
5770 :
5771 : // holds 4 uint32 sums in [0], [2], [4] and [6]
5772 21332 : [[maybe_unused]] GDALm256i ymm_sum = ZERO256;
5773 : [[maybe_unused]] GDALm256i ymm_sumsquare =
5774 21332 : ZERO256; // holds 8 uint32 sums
5775 710963 : for (; i + 31 < iMax; i += 32)
5776 : {
5777 689631 : const GDALm256i ymm = GDALmm256_load_si256(
5778 689631 : reinterpret_cast<const GDALm256i *>(pData + i));
5779 : if (COMPUTE_MIN)
5780 : {
5781 231794 : ymm_min = GDALmm256_min_epu8(ymm_min, ymm);
5782 : }
5783 : if (COMPUTE_MAX)
5784 : {
5785 598690 : ymm_max = GDALmm256_max_epu8(ymm_max, ymm);
5786 : }
5787 :
5788 : if constexpr (COMPUTE_OTHER_STATS)
5789 : {
5790 : // Extract even-8bit values
5791 : const GDALm256i ymm_even =
5792 493495 : GDALmm256_and_si256(ymm, ymm_mask_8bits);
5793 : // Compute square of those 16 values as 32 bit result
5794 : // and add adjacent pairs
5795 : const GDALm256i ymm_even_square =
5796 493495 : GDALmm256_madd_epi16(ymm_even, ymm_even);
5797 : // Add to the sumsquare accumulator
5798 : ymm_sumsquare =
5799 493495 : GDALmm256_add_epi32(ymm_sumsquare, ymm_even_square);
5800 :
5801 : // Extract odd-8bit values
5802 493495 : const GDALm256i ymm_odd = GDALmm256_srli_epi16(ymm, 8);
5803 : const GDALm256i ymm_odd_square =
5804 493495 : GDALmm256_madd_epi16(ymm_odd, ymm_odd);
5805 : ymm_sumsquare =
5806 493495 : GDALmm256_add_epi32(ymm_sumsquare, ymm_odd_square);
5807 :
5808 : // Now compute the sums
5809 493495 : ymm_sum = GDALmm256_add_epi32(ymm_sum,
5810 : GDALmm256_sad_epu8(ymm, ZERO256));
5811 : }
5812 : }
5813 :
5814 : if constexpr (COMPUTE_OTHER_STATS)
5815 : {
5816 10649 : GDALmm256_store_si256(reinterpret_cast<GDALm256i *>(panSum),
5817 : ymm_sum);
5818 10649 : GDALmm256_store_si256(reinterpret_cast<GDALm256i *>(panSumSquare),
5819 : ymm_sumsquare);
5820 :
5821 10649 : nSum += panSum[0] + panSum[2] + panSum[4] + panSum[6];
5822 10649 : nSumSquare += static_cast<GUIntBig>(panSumSquare[0]) +
5823 10649 : panSumSquare[1] + panSumSquare[2] + panSumSquare[3] +
5824 10649 : panSumSquare[4] + panSumSquare[5] + panSumSquare[6] +
5825 : panSumSquare[7];
5826 : }
5827 : }
5828 :
5829 : if constexpr (COMPUTE_MIN)
5830 : {
5831 8458 : GDALmm256_store_si256(reinterpret_cast<GDALm256i *>(pabyMin), ymm_min);
5832 : }
5833 : if constexpr (COMPUTE_MAX)
5834 : {
5835 17335 : GDALmm256_store_si256(reinterpret_cast<GDALm256i *>(pabyMax), ymm_max);
5836 : }
5837 : if constexpr (COMPUTE_MIN || COMPUTE_MAX)
5838 : {
5839 589545 : for (int j = 0; j < 32; j++)
5840 : {
5841 : if constexpr (COMPUTE_MIN)
5842 : {
5843 270656 : if (pabyMin[j] < nMin)
5844 1261 : nMin = pabyMin[j];
5845 : }
5846 : if constexpr (COMPUTE_MAX)
5847 : {
5848 554720 : if (pabyMax[j] > nMax)
5849 1813 : nMax = pabyMax[j];
5850 : }
5851 : }
5852 : }
5853 :
5854 234398 : for (; i < nBlockPixels; i++)
5855 : {
5856 213066 : const GUInt32 nValue = pData[i];
5857 : if constexpr (COMPUTE_MIN)
5858 : {
5859 88390 : if (nValue < nMin)
5860 1 : nMin = nValue;
5861 : }
5862 : if constexpr (COMPUTE_MAX)
5863 : {
5864 210291 : if (nValue > nMax)
5865 1149 : nMax = nValue;
5866 : }
5867 : if constexpr (COMPUTE_OTHER_STATS)
5868 : {
5869 77195 : nSum += nValue;
5870 77195 : nSumSquare +=
5871 77195 : static_cast_for_coverity_scan<GUIntBig>(nValue) * nValue;
5872 : }
5873 : }
5874 :
5875 : if constexpr (COMPUTE_OTHER_STATS)
5876 : {
5877 10649 : nSampleCount += static_cast<GUIntBig>(nBlockPixels);
5878 10649 : nValidCount += static_cast<GUIntBig>(nBlockPixels);
5879 : }
5880 21332 : }
5881 :
5882 : // SSE2/AVX2 optimization for GByte case
5883 : // In pure SSE2, this relies on gdal_avx2_emulation.hpp. There is no
5884 : // penaly in using the emulation, because, given the mm256 intrinsics used here,
5885 : // there are strictly equivalent to 2 parallel SSE2 streams.
5886 : template <bool COMPUTE_OTHER_STATS>
5887 : struct ComputeStatisticsInternal<GByte, COMPUTE_OTHER_STATS>
5888 : {
5889 30165 : static void f(int nXCheck, int nBlockXSize, int nYCheck,
5890 : // assumed to be aligned on 256 bits
5891 : const GByte *pData, bool bHasNoData, GUInt32 nNoDataValue,
5892 : GUInt32 &nMin, GUInt32 &nMax, GUIntBig &nSum,
5893 : GUIntBig &nSumSquare, GUIntBig &nSampleCount,
5894 : GUIntBig &nValidCount)
5895 : {
5896 30165 : const auto nBlockPixels = static_cast<GPtrDiff_t>(nXCheck) * nYCheck;
5897 30165 : if (bHasNoData && nXCheck == nBlockXSize && nBlockPixels >= 32 &&
5898 11574 : nMin <= nMax)
5899 : {
5900 : // 32-byte alignment may not be enforced by linker, so do it at hand
5901 : GByte aby32ByteUnaligned[32 + 32 + 32 + 32 + 32];
5902 1459 : GByte *paby32ByteAligned =
5903 : aby32ByteUnaligned +
5904 1459 : (32 - (reinterpret_cast<GUIntptr_t>(aby32ByteUnaligned) % 32));
5905 1459 : GByte *pabyMin = paby32ByteAligned;
5906 1459 : GByte *pabyMax = paby32ByteAligned + 32;
5907 1459 : GUInt32 *panSum =
5908 : reinterpret_cast<GUInt32 *>(paby32ByteAligned + 32 * 2);
5909 1459 : GUInt32 *panSumSquare =
5910 : reinterpret_cast<GUInt32 *>(paby32ByteAligned + 32 * 3);
5911 :
5912 1459 : CPLAssert((reinterpret_cast<uintptr_t>(pData) % 32) == 0);
5913 :
5914 1459 : GPtrDiff_t i = 0;
5915 : // Make sure that sumSquare can fit on uint32
5916 : // * 8 since we can hold 8 sums per vector register
5917 1459 : const int nMaxIterationsPerInnerLoop =
5918 : 8 * ((std::numeric_limits<GUInt32>::max() / (255 * 255)) & ~31);
5919 1459 : auto nOuterLoops = nBlockPixels / nMaxIterationsPerInnerLoop;
5920 1459 : if ((nBlockPixels % nMaxIterationsPerInnerLoop) != 0)
5921 1459 : nOuterLoops++;
5922 :
5923 : const GDALm256i ymm_nodata =
5924 1459 : GDALmm256_set1_epi8(static_cast<GByte>(nNoDataValue));
5925 : // any non noData value in [min,max] would do.
5926 : const GDALm256i ymm_neutral =
5927 1459 : GDALmm256_set1_epi8(static_cast<GByte>(nMin));
5928 1459 : GDALm256i ymm_min = ymm_neutral;
5929 1459 : GDALm256i ymm_max = ymm_neutral;
5930 : [[maybe_unused]] const auto ymm_mask_8bits =
5931 1459 : GDALmm256_set1_epi16(0xFF);
5932 :
5933 1459 : const GUInt32 nMinThreshold = (nNoDataValue == 0) ? 1 : 0;
5934 1459 : const GUInt32 nMaxThreshold = (nNoDataValue == 255) ? 254 : 255;
5935 1459 : const bool bComputeMinMax =
5936 1459 : nMin > nMinThreshold || nMax < nMaxThreshold;
5937 :
5938 2918 : for (GPtrDiff_t k = 0; k < nOuterLoops; k++)
5939 : {
5940 1459 : const auto iMax =
5941 1459 : std::min(nBlockPixels, i + nMaxIterationsPerInnerLoop);
5942 :
5943 : // holds 4 uint32 sums in [0], [2], [4] and [6]
5944 1459 : [[maybe_unused]] GDALm256i ymm_sum = ZERO256;
5945 : // holds 8 uint32 sums
5946 1459 : [[maybe_unused]] GDALm256i ymm_sumsquare = ZERO256;
5947 : // holds 4 uint32 sums in [0], [2], [4] and [6]
5948 1459 : [[maybe_unused]] GDALm256i ymm_count_nodata_mul_255 = ZERO256;
5949 1459 : const auto iInit = i;
5950 14435 : for (; i + 31 < iMax; i += 32)
5951 : {
5952 12976 : const GDALm256i ymm = GDALmm256_load_si256(
5953 12976 : reinterpret_cast<const GDALm256i *>(pData + i));
5954 :
5955 : // Check which values are nodata
5956 : const GDALm256i ymm_eq_nodata =
5957 12976 : GDALmm256_cmpeq_epi8(ymm, ymm_nodata);
5958 : if constexpr (COMPUTE_OTHER_STATS)
5959 : {
5960 : // Count how many values are nodata (due to cmpeq
5961 : // putting 255 when condition is met, this will actually
5962 : // be 255 times the number of nodata value, spread in 4
5963 : // 64 bits words). We can use add_epi32 as the counter
5964 : // will not overflow uint32
5965 4634 : ymm_count_nodata_mul_255 = GDALmm256_add_epi32(
5966 : ymm_count_nodata_mul_255,
5967 : GDALmm256_sad_epu8(ymm_eq_nodata, ZERO256));
5968 : }
5969 : // Replace all nodata values by zero for the purpose of sum
5970 : // and sumquare.
5971 : const GDALm256i ymm_nodata_by_zero =
5972 12976 : GDALmm256_andnot_si256(ymm_eq_nodata, ymm);
5973 12976 : if (bComputeMinMax)
5974 : {
5975 : // Replace all nodata values by a neutral value for the
5976 : // purpose of min and max.
5977 : const GDALm256i ymm_nodata_by_neutral =
5978 8591 : GDALmm256_or_si256(
5979 : GDALmm256_and_si256(ymm_eq_nodata, ymm_neutral),
5980 : ymm_nodata_by_zero);
5981 :
5982 : ymm_min =
5983 8591 : GDALmm256_min_epu8(ymm_min, ymm_nodata_by_neutral);
5984 : ymm_max =
5985 8591 : GDALmm256_max_epu8(ymm_max, ymm_nodata_by_neutral);
5986 : }
5987 :
5988 : if constexpr (COMPUTE_OTHER_STATS)
5989 : {
5990 : // Extract even-8bit values
5991 4634 : const GDALm256i ymm_even = GDALmm256_and_si256(
5992 : ymm_nodata_by_zero, ymm_mask_8bits);
5993 : // Compute square of those 16 values as 32 bit result
5994 : // and add adjacent pairs
5995 : const GDALm256i ymm_even_square =
5996 4634 : GDALmm256_madd_epi16(ymm_even, ymm_even);
5997 : // Add to the sumsquare accumulator
5998 : ymm_sumsquare =
5999 4634 : GDALmm256_add_epi32(ymm_sumsquare, ymm_even_square);
6000 :
6001 : // Extract odd-8bit values
6002 : const GDALm256i ymm_odd =
6003 4634 : GDALmm256_srli_epi16(ymm_nodata_by_zero, 8);
6004 : const GDALm256i ymm_odd_square =
6005 4634 : GDALmm256_madd_epi16(ymm_odd, ymm_odd);
6006 : ymm_sumsquare =
6007 4634 : GDALmm256_add_epi32(ymm_sumsquare, ymm_odd_square);
6008 :
6009 : // Now compute the sums
6010 4634 : ymm_sum = GDALmm256_add_epi32(
6011 : ymm_sum,
6012 : GDALmm256_sad_epu8(ymm_nodata_by_zero, ZERO256));
6013 : }
6014 : }
6015 :
6016 : if constexpr (COMPUTE_OTHER_STATS)
6017 : {
6018 153 : GUInt32 *panCoutNoDataMul255 = panSum;
6019 153 : GDALmm256_store_si256(
6020 : reinterpret_cast<GDALm256i *>(panCoutNoDataMul255),
6021 : ymm_count_nodata_mul_255);
6022 :
6023 153 : nSampleCount += (i - iInit);
6024 :
6025 153 : nValidCount +=
6026 153 : (i - iInit) -
6027 153 : (panCoutNoDataMul255[0] + panCoutNoDataMul255[2] +
6028 153 : panCoutNoDataMul255[4] + panCoutNoDataMul255[6]) /
6029 : 255;
6030 :
6031 153 : GDALmm256_store_si256(reinterpret_cast<GDALm256i *>(panSum),
6032 : ymm_sum);
6033 153 : GDALmm256_store_si256(
6034 : reinterpret_cast<GDALm256i *>(panSumSquare),
6035 : ymm_sumsquare);
6036 153 : nSum += panSum[0] + panSum[2] + panSum[4] + panSum[6];
6037 153 : nSumSquare += static_cast<GUIntBig>(panSumSquare[0]) +
6038 153 : panSumSquare[1] + panSumSquare[2] +
6039 153 : panSumSquare[3] + panSumSquare[4] +
6040 153 : panSumSquare[5] + panSumSquare[6] +
6041 : panSumSquare[7];
6042 : }
6043 : }
6044 :
6045 1459 : if (bComputeMinMax)
6046 : {
6047 1428 : GDALmm256_store_si256(reinterpret_cast<GDALm256i *>(pabyMin),
6048 : ymm_min);
6049 1428 : GDALmm256_store_si256(reinterpret_cast<GDALm256i *>(pabyMax),
6050 : ymm_max);
6051 47124 : for (int j = 0; j < 32; j++)
6052 : {
6053 45696 : if (pabyMin[j] < nMin)
6054 40 : nMin = pabyMin[j];
6055 45696 : if (pabyMax[j] > nMax)
6056 159 : nMax = pabyMax[j];
6057 : }
6058 : }
6059 :
6060 : if constexpr (COMPUTE_OTHER_STATS)
6061 : {
6062 153 : nSampleCount += nBlockPixels - i;
6063 : }
6064 33905 : for (; i < nBlockPixels; i++)
6065 : {
6066 32446 : const GUInt32 nValue = pData[i];
6067 32446 : if (nValue == nNoDataValue)
6068 24923 : continue;
6069 7523 : if (nValue < nMin)
6070 1 : nMin = nValue;
6071 7523 : if (nValue > nMax)
6072 13 : nMax = nValue;
6073 : if constexpr (COMPUTE_OTHER_STATS)
6074 : {
6075 3590 : nValidCount++;
6076 3590 : nSum += nValue;
6077 3590 : nSumSquare +=
6078 3590 : static_cast_for_coverity_scan<GUIntBig>(nValue) *
6079 3590 : nValue;
6080 : }
6081 1459 : }
6082 : }
6083 28706 : else if (!bHasNoData && nXCheck == nBlockXSize && nBlockPixels >= 32)
6084 : {
6085 14976 : if (nMin > 0)
6086 : {
6087 2102 : if (nMax < 255)
6088 : {
6089 : ComputeStatisticsByteNoNodata<true, true,
6090 1572 : COMPUTE_OTHER_STATS>(
6091 : nBlockPixels, pData, nMin, nMax, nSum, nSumSquare,
6092 : nSampleCount, nValidCount);
6093 : }
6094 : else
6095 : {
6096 : ComputeStatisticsByteNoNodata<true, false,
6097 530 : COMPUTE_OTHER_STATS>(
6098 : nBlockPixels, pData, nMin, nMax, nSum, nSumSquare,
6099 : nSampleCount, nValidCount);
6100 : }
6101 : }
6102 : else
6103 : {
6104 12874 : if (nMax < 255)
6105 : {
6106 : ComputeStatisticsByteNoNodata<false, true,
6107 9407 : COMPUTE_OTHER_STATS>(
6108 : nBlockPixels, pData, nMin, nMax, nSum, nSumSquare,
6109 : nSampleCount, nValidCount);
6110 : }
6111 : else
6112 : {
6113 : ComputeStatisticsByteNoNodata<false, false,
6114 3467 : COMPUTE_OTHER_STATS>(
6115 : nBlockPixels, pData, nMin, nMax, nSum, nSumSquare,
6116 : nSampleCount, nValidCount);
6117 : }
6118 : }
6119 : }
6120 12475 : else if (!COMPUTE_OTHER_STATS && !bHasNoData && nXCheck >= 32 &&
6121 33 : (nBlockXSize % 32) == 0)
6122 : {
6123 6389 : for (int iY = 0; iY < nYCheck; iY++)
6124 : {
6125 6356 : ComputeStatisticsByteNoNodata<true, true, COMPUTE_OTHER_STATS>(
6126 6356 : nXCheck, pData + static_cast<size_t>(iY) * nBlockXSize,
6127 : nMin, nMax, nSum, nSumSquare, nSampleCount, nValidCount);
6128 33 : }
6129 : }
6130 : else
6131 : {
6132 13697 : ComputeStatisticsInternalGeneric<GByte, COMPUTE_OTHER_STATS>::f(
6133 : nXCheck, nBlockXSize, nYCheck, pData, bHasNoData, nNoDataValue,
6134 : nMin, nMax, nSum, nSumSquare, nSampleCount, nValidCount);
6135 : }
6136 30165 : }
6137 : };
6138 :
6139 : CPL_NOSANITIZE_UNSIGNED_INT_OVERFLOW
6140 400 : static void UnshiftSumSquare(GUIntBig &nSumSquare, GUIntBig nSumThis,
6141 : GUIntBig i)
6142 : {
6143 400 : nSumSquare += 32768 * (2 * nSumThis - i * 32768);
6144 400 : }
6145 :
6146 : // AVX2/SSE2 optimization for GUInt16 case
6147 : template <bool COMPUTE_OTHER_STATS>
6148 : struct ComputeStatisticsInternal<GUInt16, COMPUTE_OTHER_STATS>
6149 : {
6150 1626 : static void f(int nXCheck, int nBlockXSize, int nYCheck,
6151 : // assumed to be aligned on 128 bits
6152 : const GUInt16 *pData, bool bHasNoData, GUInt32 nNoDataValue,
6153 : GUInt32 &nMin, GUInt32 &nMax, GUIntBig &nSum,
6154 : GUIntBig &nSumSquare, GUIntBig &nSampleCount,
6155 : GUIntBig &nValidCount)
6156 : {
6157 1626 : const auto nBlockPixels = static_cast<GPtrDiff_t>(nXCheck) * nYCheck;
6158 1626 : if (!bHasNoData && nXCheck == nBlockXSize && nBlockPixels >= 16)
6159 : {
6160 1418 : CPLAssert((reinterpret_cast<uintptr_t>(pData) % 16) == 0);
6161 :
6162 1418 : GPtrDiff_t i = 0;
6163 : // In SSE2, min_epu16 and max_epu16 do not exist, so shift from
6164 : // UInt16 to SInt16 to be able to use min_epi16 and max_epi16.
6165 : // Furthermore the shift is also needed to use madd_epi16
6166 1418 : const GDALm256i ymm_m32768 = GDALmm256_set1_epi16(-32768);
6167 1418 : GDALm256i ymm_min = GDALmm256_load_si256(
6168 1418 : reinterpret_cast<const GDALm256i *>(pData + i));
6169 1418 : ymm_min = GDALmm256_add_epi16(ymm_min, ymm_m32768);
6170 1418 : GDALm256i ymm_max = ymm_min;
6171 : [[maybe_unused]] GDALm256i ymm_sumsquare =
6172 1418 : ZERO256; // holds 4 uint64 sums
6173 :
6174 : // Make sure that sum can fit on uint32
6175 : // * 8 since we can hold 8 sums per vector register
6176 1418 : const int nMaxIterationsPerInnerLoop =
6177 : 8 * ((std::numeric_limits<GUInt32>::max() / 65535) & ~15);
6178 1418 : GPtrDiff_t nOuterLoops = nBlockPixels / nMaxIterationsPerInnerLoop;
6179 1418 : if ((nBlockPixels % nMaxIterationsPerInnerLoop) != 0)
6180 1418 : nOuterLoops++;
6181 :
6182 1418 : const bool bComputeMinMax = nMin > 0 || nMax < 65535;
6183 : [[maybe_unused]] const auto ymm_mask_16bits =
6184 1418 : GDALmm256_set1_epi32(0xFFFF);
6185 : [[maybe_unused]] const auto ymm_mask_32bits =
6186 1418 : GDALmm256_set1_epi64x(0xFFFFFFFF);
6187 :
6188 1418 : GUIntBig nSumThis = 0;
6189 2860 : for (int k = 0; k < nOuterLoops; k++)
6190 : {
6191 1442 : const auto iMax =
6192 1442 : std::min(nBlockPixels, i + nMaxIterationsPerInnerLoop);
6193 :
6194 : [[maybe_unused]] GDALm256i ymm_sum =
6195 1442 : ZERO256; // holds 8 uint32 sums
6196 959774 : for (; i + 15 < iMax; i += 16)
6197 : {
6198 958332 : const GDALm256i ymm = GDALmm256_load_si256(
6199 958332 : reinterpret_cast<const GDALm256i *>(pData + i));
6200 : const GDALm256i ymm_shifted =
6201 958332 : GDALmm256_add_epi16(ymm, ymm_m32768);
6202 958332 : if (bComputeMinMax)
6203 : {
6204 949313 : ymm_min = GDALmm256_min_epi16(ymm_min, ymm_shifted);
6205 949313 : ymm_max = GDALmm256_max_epi16(ymm_max, ymm_shifted);
6206 : }
6207 :
6208 : if constexpr (COMPUTE_OTHER_STATS)
6209 : {
6210 : // Note: the int32 range can overflow for (0-32768)^2 +
6211 : // (0-32768)^2 = 0x80000000, but as we know the result
6212 : // is positive, this is OK as we interpret is a uint32.
6213 : const GDALm256i ymm_square =
6214 95410 : GDALmm256_madd_epi16(ymm_shifted, ymm_shifted);
6215 95410 : ymm_sumsquare = GDALmm256_add_epi64(
6216 : ymm_sumsquare,
6217 : GDALmm256_and_si256(ymm_square, ymm_mask_32bits));
6218 95410 : ymm_sumsquare = GDALmm256_add_epi64(
6219 : ymm_sumsquare,
6220 : GDALmm256_srli_epi64(ymm_square, 32));
6221 :
6222 : // Now compute the sums
6223 95410 : ymm_sum = GDALmm256_add_epi32(
6224 : ymm_sum, GDALmm256_and_si256(ymm, ymm_mask_16bits));
6225 95410 : ymm_sum = GDALmm256_add_epi32(
6226 : ymm_sum, GDALmm256_srli_epi32(ymm, 16));
6227 : }
6228 : }
6229 :
6230 : if constexpr (COMPUTE_OTHER_STATS)
6231 : {
6232 : GUInt32 anSum[8];
6233 400 : GDALmm256_storeu_si256(reinterpret_cast<GDALm256i *>(anSum),
6234 : ymm_sum);
6235 400 : nSumThis += static_cast<GUIntBig>(anSum[0]) + anSum[1] +
6236 400 : anSum[2] + anSum[3] + anSum[4] + anSum[5] +
6237 400 : anSum[6] + anSum[7];
6238 : }
6239 : }
6240 :
6241 1418 : if (bComputeMinMax)
6242 : {
6243 : GUInt16 anMin[16];
6244 : GUInt16 anMax[16];
6245 :
6246 : // Unshift the result
6247 1377 : ymm_min = GDALmm256_sub_epi16(ymm_min, ymm_m32768);
6248 1377 : ymm_max = GDALmm256_sub_epi16(ymm_max, ymm_m32768);
6249 1377 : GDALmm256_storeu_si256(reinterpret_cast<GDALm256i *>(anMin),
6250 : ymm_min);
6251 1377 : GDALmm256_storeu_si256(reinterpret_cast<GDALm256i *>(anMax),
6252 : ymm_max);
6253 23409 : for (int j = 0; j < 16; j++)
6254 : {
6255 22032 : if (anMin[j] < nMin)
6256 342 : nMin = anMin[j];
6257 22032 : if (anMax[j] > nMax)
6258 481 : nMax = anMax[j];
6259 : }
6260 : }
6261 :
6262 : if constexpr (COMPUTE_OTHER_STATS)
6263 : {
6264 : GUIntBig anSumSquare[4];
6265 400 : GDALmm256_storeu_si256(
6266 : reinterpret_cast<GDALm256i *>(anSumSquare), ymm_sumsquare);
6267 400 : nSumSquare += anSumSquare[0] + anSumSquare[1] + anSumSquare[2] +
6268 : anSumSquare[3];
6269 :
6270 : // Unshift the sum of squares
6271 400 : UnshiftSumSquare(nSumSquare, nSumThis,
6272 : static_cast<GUIntBig>(i));
6273 :
6274 400 : nSum += nSumThis;
6275 :
6276 722 : for (; i < nBlockPixels; i++)
6277 : {
6278 322 : const GUInt32 nValue = pData[i];
6279 322 : if (nValue < nMin)
6280 1 : nMin = nValue;
6281 322 : if (nValue > nMax)
6282 1 : nMax = nValue;
6283 322 : nSum += nValue;
6284 322 : nSumSquare +=
6285 322 : static_cast_for_coverity_scan<GUIntBig>(nValue) *
6286 322 : nValue;
6287 : }
6288 :
6289 400 : nSampleCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
6290 400 : nValidCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
6291 1418 : }
6292 : }
6293 : else
6294 : {
6295 208 : ComputeStatisticsInternalGeneric<GUInt16, COMPUTE_OTHER_STATS>::f(
6296 : nXCheck, nBlockXSize, nYCheck, pData, bHasNoData, nNoDataValue,
6297 : nMin, nMax, nSum, nSumSquare, nSampleCount, nValidCount);
6298 : }
6299 1626 : }
6300 : };
6301 :
6302 : #endif
6303 : // (defined(__x86_64__) || defined(_M_X64)) && (defined(__GNUC__) ||
6304 : // defined(_MSC_VER))
6305 :
6306 : /************************************************************************/
6307 : /* GetPixelValue() */
6308 : /************************************************************************/
6309 :
6310 23619100 : static inline double GetPixelValue(GDALDataType eDataType, bool bSignedByte,
6311 : const void *pData, GPtrDiff_t iOffset,
6312 : const GDALNoDataValues &sNoDataValues,
6313 : bool &bValid)
6314 : {
6315 23619100 : bValid = true;
6316 23619100 : double dfValue = 0;
6317 23619100 : switch (eDataType)
6318 : {
6319 1413690 : case GDT_Byte:
6320 : {
6321 1413690 : if (bSignedByte)
6322 192 : dfValue = static_cast<const signed char *>(pData)[iOffset];
6323 : else
6324 1413500 : dfValue = static_cast<const GByte *>(pData)[iOffset];
6325 1413690 : break;
6326 : }
6327 10409 : case GDT_Int8:
6328 10409 : dfValue = static_cast<const GInt8 *>(pData)[iOffset];
6329 10409 : break;
6330 4000 : case GDT_UInt16:
6331 4000 : dfValue = static_cast<const GUInt16 *>(pData)[iOffset];
6332 4000 : break;
6333 60192 : case GDT_Int16:
6334 60192 : dfValue = static_cast<const GInt16 *>(pData)[iOffset];
6335 60192 : break;
6336 27600 : case GDT_UInt32:
6337 27600 : dfValue = static_cast<const GUInt32 *>(pData)[iOffset];
6338 27600 : break;
6339 455610 : case GDT_Int32:
6340 455610 : dfValue = static_cast<const GInt32 *>(pData)[iOffset];
6341 455610 : break;
6342 2604 : case GDT_UInt64:
6343 2604 : dfValue = static_cast<double>(
6344 2604 : static_cast<const std::uint64_t *>(pData)[iOffset]);
6345 2604 : break;
6346 7404 : case GDT_Int64:
6347 7404 : dfValue = static_cast<double>(
6348 7404 : static_cast<const std::int64_t *>(pData)[iOffset]);
6349 7404 : break;
6350 0 : case GDT_Float16:
6351 : {
6352 : using namespace std;
6353 0 : const GFloat16 hfValue =
6354 0 : static_cast<const GFloat16 *>(pData)[iOffset];
6355 0 : if (isnan(hfValue) ||
6356 0 : (sNoDataValues.bGotFloat16NoDataValue &&
6357 0 : ARE_REAL_EQUAL(hfValue, sNoDataValues.hfNoDataValue)))
6358 : {
6359 0 : bValid = false;
6360 0 : return 0.0;
6361 : }
6362 0 : dfValue = hfValue;
6363 0 : return dfValue;
6364 : }
6365 17931500 : case GDT_Float32:
6366 : {
6367 17931500 : const float fValue = static_cast<const float *>(pData)[iOffset];
6368 35836200 : if (std::isnan(fValue) ||
6369 31039700 : (sNoDataValues.bGotFloatNoDataValue &&
6370 13135100 : ARE_REAL_EQUAL(fValue, sNoDataValues.fNoDataValue)))
6371 : {
6372 26881 : bValid = false;
6373 26881 : return 0.0;
6374 : }
6375 17904600 : dfValue = fValue;
6376 17904600 : return dfValue;
6377 : }
6378 3688930 : case GDT_Float64:
6379 3688930 : dfValue = static_cast<const double *>(pData)[iOffset];
6380 3688930 : if (std::isnan(dfValue))
6381 : {
6382 52 : bValid = false;
6383 52 : return 0.0;
6384 : }
6385 3688880 : break;
6386 2692 : case GDT_CInt16:
6387 2692 : dfValue = static_cast<const GInt16 *>(pData)[iOffset * 2];
6388 2692 : break;
6389 2692 : case GDT_CInt32:
6390 2692 : dfValue = static_cast<const GInt32 *>(pData)[iOffset * 2];
6391 2692 : break;
6392 0 : case GDT_CFloat16:
6393 0 : dfValue = static_cast<const GFloat16 *>(pData)[iOffset * 2];
6394 0 : if (std::isnan(dfValue))
6395 : {
6396 0 : bValid = false;
6397 0 : return 0.0;
6398 : }
6399 0 : break;
6400 5812 : case GDT_CFloat32:
6401 5812 : dfValue = static_cast<const float *>(pData)[iOffset * 2];
6402 5812 : if (std::isnan(dfValue))
6403 : {
6404 0 : bValid = false;
6405 0 : return 0.0;
6406 : }
6407 5812 : break;
6408 5892 : case GDT_CFloat64:
6409 5892 : dfValue = static_cast<const double *>(pData)[iOffset * 2];
6410 5892 : if (std::isnan(dfValue))
6411 : {
6412 0 : bValid = false;
6413 0 : return 0.0;
6414 : }
6415 5892 : break;
6416 0 : case GDT_Unknown:
6417 : case GDT_TypeCount:
6418 0 : CPLAssert(false);
6419 : break;
6420 : }
6421 :
6422 9427660 : if (sNoDataValues.bGotNoDataValue &&
6423 3740190 : ARE_REAL_EQUAL(dfValue, sNoDataValues.dfNoDataValue))
6424 : {
6425 3346220 : bValid = false;
6426 3346220 : return 0.0;
6427 : }
6428 2341250 : return dfValue;
6429 : }
6430 :
6431 : /************************************************************************/
6432 : /* SetValidPercent() */
6433 : /************************************************************************/
6434 :
6435 : //! @cond Doxygen_Suppress
6436 : /**
6437 : * \brief Set percentage of valid (not nodata) pixels.
6438 : *
6439 : * Stores the percentage of valid pixels in the metadata item
6440 : * STATISTICS_VALID_PERCENT
6441 : *
6442 : * @param nSampleCount Number of sampled pixels.
6443 : *
6444 : * @param nValidCount Number of valid pixels.
6445 : */
6446 :
6447 494 : void GDALRasterBand::SetValidPercent(GUIntBig nSampleCount,
6448 : GUIntBig nValidCount)
6449 : {
6450 494 : if (nValidCount == 0)
6451 : {
6452 12 : SetMetadataItem("STATISTICS_VALID_PERCENT", "0");
6453 : }
6454 482 : else if (nValidCount == nSampleCount)
6455 : {
6456 435 : SetMetadataItem("STATISTICS_VALID_PERCENT", "100");
6457 : }
6458 : else /* nValidCount < nSampleCount */
6459 : {
6460 47 : char szValue[128] = {0};
6461 :
6462 : /* percentage is only an indicator: limit precision */
6463 47 : CPLsnprintf(szValue, sizeof(szValue), "%.4g",
6464 47 : 100. * static_cast<double>(nValidCount) / nSampleCount);
6465 :
6466 47 : if (EQUAL(szValue, "100"))
6467 : {
6468 : /* don't set 100 percent valid
6469 : * because some of the sampled pixels were nodata */
6470 0 : SetMetadataItem("STATISTICS_VALID_PERCENT", "99.999");
6471 : }
6472 : else
6473 : {
6474 47 : SetMetadataItem("STATISTICS_VALID_PERCENT", szValue);
6475 : }
6476 : }
6477 494 : }
6478 :
6479 : //! @endcond
6480 :
6481 : /************************************************************************/
6482 : /* ComputeStatistics() */
6483 : /************************************************************************/
6484 :
6485 : /**
6486 : * \brief Compute image statistics.
6487 : *
6488 : * Returns the minimum, maximum, mean and standard deviation of all
6489 : * pixel values in this band. If approximate statistics are sufficient,
6490 : * the bApproxOK flag can be set to true in which case overviews, or a
6491 : * subset of image tiles may be used in computing the statistics.
6492 : *
6493 : * Once computed, the statistics will generally be "set" back on the
6494 : * raster band using SetStatistics().
6495 : *
6496 : * Cached statistics can be cleared with GDALDataset::ClearStatistics().
6497 : *
6498 : * This method is the same as the C function GDALComputeRasterStatistics().
6499 : *
6500 : * @param bApproxOK If TRUE statistics may be computed based on overviews
6501 : * or a subset of all tiles.
6502 : *
6503 : * @param pdfMin Location into which to load image minimum (may be NULL).
6504 : *
6505 : * @param pdfMax Location into which to load image maximum (may be NULL).-
6506 : *
6507 : * @param pdfMean Location into which to load image mean (may be NULL).
6508 : *
6509 : * @param pdfStdDev Location into which to load image standard deviation
6510 : * (may be NULL).
6511 : *
6512 : * @param pfnProgress a function to call to report progress, or NULL.
6513 : *
6514 : * @param pProgressData application data to pass to the progress function.
6515 : *
6516 : * @return CE_None on success, or CE_Failure if an error occurs or processing
6517 : * is terminated by the user.
6518 : */
6519 :
6520 472 : CPLErr GDALRasterBand::ComputeStatistics(int bApproxOK, double *pdfMin,
6521 : double *pdfMax, double *pdfMean,
6522 : double *pdfStdDev,
6523 : GDALProgressFunc pfnProgress,
6524 : void *pProgressData)
6525 :
6526 : {
6527 472 : if (pfnProgress == nullptr)
6528 171 : pfnProgress = GDALDummyProgress;
6529 :
6530 : /* -------------------------------------------------------------------- */
6531 : /* If we have overview bands, use them for statistics. */
6532 : /* -------------------------------------------------------------------- */
6533 472 : if (bApproxOK && GetOverviewCount() > 0 && !HasArbitraryOverviews())
6534 : {
6535 : GDALRasterBand *poBand =
6536 3 : GetRasterSampleOverview(GDALSTAT_APPROX_NUMSAMPLES);
6537 :
6538 3 : if (poBand != this)
6539 : {
6540 6 : CPLErr eErr = poBand->ComputeStatistics(FALSE, pdfMin, pdfMax,
6541 : pdfMean, pdfStdDev,
6542 3 : pfnProgress, pProgressData);
6543 3 : if (eErr == CE_None)
6544 : {
6545 3 : if (pdfMin && pdfMax && pdfMean && pdfStdDev)
6546 : {
6547 3 : SetMetadataItem("STATISTICS_APPROXIMATE", "YES");
6548 3 : SetStatistics(*pdfMin, *pdfMax, *pdfMean, *pdfStdDev);
6549 : }
6550 :
6551 : /* transfer metadata from overview band to this */
6552 : const char *pszPercentValid =
6553 3 : poBand->GetMetadataItem("STATISTICS_VALID_PERCENT");
6554 :
6555 3 : if (pszPercentValid != nullptr)
6556 : {
6557 3 : SetMetadataItem("STATISTICS_VALID_PERCENT",
6558 3 : pszPercentValid);
6559 : }
6560 : }
6561 3 : return eErr;
6562 : }
6563 : }
6564 :
6565 469 : if (!pfnProgress(0.0, "Compute Statistics", pProgressData))
6566 : {
6567 0 : ReportError(CE_Failure, CPLE_UserInterrupt, "User terminated");
6568 0 : return CE_Failure;
6569 : }
6570 :
6571 : /* -------------------------------------------------------------------- */
6572 : /* Read actual data and compute statistics. */
6573 : /* -------------------------------------------------------------------- */
6574 : // Using Welford algorithm:
6575 : // http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
6576 : // to compute standard deviation in a more numerically robust way than
6577 : // the difference of the sum of square values with the square of the sum.
6578 : // dfMean and dfM2 are updated at each sample.
6579 : // dfM2 is the sum of square of differences to the current mean.
6580 469 : double dfMin = std::numeric_limits<double>::infinity();
6581 469 : double dfMax = -std::numeric_limits<double>::infinity();
6582 469 : double dfMean = 0.0;
6583 469 : double dfM2 = 0.0;
6584 :
6585 : GDALRasterIOExtraArg sExtraArg;
6586 469 : INIT_RASTERIO_EXTRA_ARG(sExtraArg);
6587 :
6588 469 : GDALNoDataValues sNoDataValues(this, eDataType);
6589 469 : GDALRasterBand *poMaskBand = nullptr;
6590 469 : if (!sNoDataValues.bGotNoDataValue)
6591 : {
6592 442 : const int l_nMaskFlags = GetMaskFlags();
6593 487 : if (l_nMaskFlags != GMF_ALL_VALID &&
6594 45 : GetColorInterpretation() != GCI_AlphaBand)
6595 : {
6596 45 : poMaskBand = GetMaskBand();
6597 : }
6598 : }
6599 :
6600 469 : bool bSignedByte = false;
6601 469 : if (eDataType == GDT_Byte)
6602 : {
6603 203 : EnablePixelTypeSignedByteWarning(false);
6604 : const char *pszPixelType =
6605 203 : GetMetadataItem("PIXELTYPE", "IMAGE_STRUCTURE");
6606 203 : EnablePixelTypeSignedByteWarning(true);
6607 203 : bSignedByte =
6608 203 : pszPixelType != nullptr && EQUAL(pszPixelType, "SIGNEDBYTE");
6609 : }
6610 :
6611 469 : GUIntBig nSampleCount = 0;
6612 469 : GUIntBig nValidCount = 0;
6613 :
6614 469 : if (bApproxOK && HasArbitraryOverviews())
6615 : {
6616 : /* --------------------------------------------------------------------
6617 : */
6618 : /* Figure out how much the image should be reduced to get an */
6619 : /* approximate value. */
6620 : /* --------------------------------------------------------------------
6621 : */
6622 0 : double dfReduction = sqrt(static_cast<double>(nRasterXSize) *
6623 0 : nRasterYSize / GDALSTAT_APPROX_NUMSAMPLES);
6624 :
6625 0 : int nXReduced = nRasterXSize;
6626 0 : int nYReduced = nRasterYSize;
6627 0 : if (dfReduction > 1.0)
6628 : {
6629 0 : nXReduced = static_cast<int>(nRasterXSize / dfReduction);
6630 0 : nYReduced = static_cast<int>(nRasterYSize / dfReduction);
6631 :
6632 : // Catch the case of huge resizing ratios here
6633 0 : if (nXReduced == 0)
6634 0 : nXReduced = 1;
6635 0 : if (nYReduced == 0)
6636 0 : nYReduced = 1;
6637 : }
6638 :
6639 0 : void *pData = CPLMalloc(cpl::fits_on<int>(
6640 0 : GDALGetDataTypeSizeBytes(eDataType) * nXReduced * nYReduced));
6641 :
6642 : const CPLErr eErr =
6643 0 : IRasterIO(GF_Read, 0, 0, nRasterXSize, nRasterYSize, pData,
6644 0 : nXReduced, nYReduced, eDataType, 0, 0, &sExtraArg);
6645 0 : if (eErr != CE_None)
6646 : {
6647 0 : CPLFree(pData);
6648 0 : return eErr;
6649 : }
6650 :
6651 0 : GByte *pabyMaskData = nullptr;
6652 0 : if (poMaskBand)
6653 : {
6654 : pabyMaskData =
6655 0 : static_cast<GByte *>(VSI_MALLOC2_VERBOSE(nXReduced, nYReduced));
6656 0 : if (!pabyMaskData)
6657 : {
6658 0 : CPLFree(pData);
6659 0 : return CE_Failure;
6660 : }
6661 :
6662 0 : if (poMaskBand->RasterIO(GF_Read, 0, 0, nRasterXSize, nRasterYSize,
6663 : pabyMaskData, nXReduced, nYReduced,
6664 0 : GDT_Byte, 0, 0, nullptr) != CE_None)
6665 : {
6666 0 : CPLFree(pData);
6667 0 : CPLFree(pabyMaskData);
6668 0 : return CE_Failure;
6669 : }
6670 : }
6671 :
6672 : /* this isn't the fastest way to do this, but is easier for now */
6673 0 : for (int iY = 0; iY < nYReduced; iY++)
6674 : {
6675 0 : for (int iX = 0; iX < nXReduced; iX++)
6676 : {
6677 0 : const int iOffset = iX + iY * nXReduced;
6678 0 : if (pabyMaskData && pabyMaskData[iOffset] == 0)
6679 0 : continue;
6680 :
6681 0 : bool bValid = true;
6682 0 : double dfValue = GetPixelValue(eDataType, bSignedByte, pData,
6683 0 : iOffset, sNoDataValues, bValid);
6684 0 : if (!bValid)
6685 0 : continue;
6686 :
6687 0 : dfMin = std::min(dfMin, dfValue);
6688 0 : dfMax = std::max(dfMax, dfValue);
6689 :
6690 0 : nValidCount++;
6691 0 : if (dfMin == dfMax)
6692 : {
6693 0 : if (nValidCount == 1)
6694 0 : dfMean = dfMin;
6695 : }
6696 : else
6697 : {
6698 0 : const double dfDelta = dfValue - dfMean;
6699 0 : dfMean += dfDelta / nValidCount;
6700 0 : dfM2 += dfDelta * (dfValue - dfMean);
6701 : }
6702 : }
6703 : }
6704 :
6705 0 : nSampleCount = static_cast<GUIntBig>(nXReduced) * nYReduced;
6706 :
6707 0 : CPLFree(pData);
6708 0 : CPLFree(pabyMaskData);
6709 : }
6710 :
6711 : else // No arbitrary overviews.
6712 : {
6713 469 : if (!InitBlockInfo())
6714 0 : return CE_Failure;
6715 :
6716 : /* --------------------------------------------------------------------
6717 : */
6718 : /* Figure out the ratio of blocks we will read to get an */
6719 : /* approximate value. */
6720 : /* --------------------------------------------------------------------
6721 : */
6722 469 : int nSampleRate = 1;
6723 469 : if (bApproxOK)
6724 : {
6725 42 : nSampleRate = static_cast<int>(std::max(
6726 84 : 1.0,
6727 42 : sqrt(static_cast<double>(nBlocksPerRow) * nBlocksPerColumn)));
6728 : // We want to avoid probing only the first column of blocks for
6729 : // a square shaped raster, because it is not unlikely that it may
6730 : // be padding only (#6378)
6731 42 : if (nSampleRate == nBlocksPerRow && nBlocksPerRow > 1)
6732 1 : nSampleRate += 1;
6733 : }
6734 469 : if (nSampleRate == 1)
6735 435 : bApproxOK = false;
6736 :
6737 : // Particular case for GDT_Byte that only use integral types for all
6738 : // intermediate computations. Only possible if the number of pixels
6739 : // explored is lower than GUINTBIG_MAX / (255*255), so that nSumSquare
6740 : // can fit on a uint64. Should be 99.99999% of cases.
6741 : // For GUInt16, this limits to raster of 4 giga pixels
6742 469 : if ((!poMaskBand && eDataType == GDT_Byte && !bSignedByte &&
6743 185 : static_cast<GUIntBig>(nBlocksPerRow) * nBlocksPerColumn /
6744 185 : nSampleRate <
6745 185 : GUINTBIG_MAX / (255U * 255U) /
6746 185 : (static_cast<GUInt64>(nBlockXSize) *
6747 185 : static_cast<GUInt64>(nBlockYSize))) ||
6748 284 : (eDataType == GDT_UInt16 &&
6749 29 : static_cast<GUIntBig>(nBlocksPerRow) * nBlocksPerColumn /
6750 29 : nSampleRate <
6751 29 : GUINTBIG_MAX / (65535U * 65535U) /
6752 29 : (static_cast<GUInt64>(nBlockXSize) *
6753 29 : static_cast<GUInt64>(nBlockYSize))))
6754 : {
6755 214 : const GUInt32 nMaxValueType = (eDataType == GDT_Byte) ? 255 : 65535;
6756 214 : GUInt32 nMin = nMaxValueType;
6757 214 : GUInt32 nMax = 0;
6758 214 : GUIntBig nSum = 0;
6759 214 : GUIntBig nSumSquare = 0;
6760 : // If no valid nodata, map to invalid value (256 for Byte)
6761 214 : const GUInt32 nNoDataValue =
6762 237 : (sNoDataValues.bGotNoDataValue &&
6763 23 : sNoDataValues.dfNoDataValue >= 0 &&
6764 23 : sNoDataValues.dfNoDataValue <= nMaxValueType &&
6765 23 : fabs(sNoDataValues.dfNoDataValue -
6766 23 : static_cast<GUInt32>(sNoDataValues.dfNoDataValue +
6767 : 1e-10)) < 1e-10)
6768 237 : ? static_cast<GUInt32>(sNoDataValues.dfNoDataValue + 1e-10)
6769 : : nMaxValueType + 1;
6770 :
6771 214 : for (GIntBig iSampleBlock = 0;
6772 12741 : iSampleBlock <
6773 12741 : static_cast<GIntBig>(nBlocksPerRow) * nBlocksPerColumn;
6774 12527 : iSampleBlock += nSampleRate)
6775 : {
6776 12527 : const int iYBlock =
6777 12527 : static_cast<int>(iSampleBlock / nBlocksPerRow);
6778 12527 : const int iXBlock =
6779 12527 : static_cast<int>(iSampleBlock % nBlocksPerRow);
6780 :
6781 : GDALRasterBlock *const poBlock =
6782 12527 : GetLockedBlockRef(iXBlock, iYBlock);
6783 12527 : if (poBlock == nullptr)
6784 0 : return CE_Failure;
6785 :
6786 12527 : void *const pData = poBlock->GetDataRef();
6787 :
6788 12527 : int nXCheck = 0, nYCheck = 0;
6789 12527 : GetActualBlockSize(iXBlock, iYBlock, &nXCheck, &nYCheck);
6790 :
6791 12527 : if (eDataType == GDT_Byte)
6792 : {
6793 : ComputeStatisticsInternal<
6794 : GByte, /* COMPUTE_OTHER_STATS = */ true>::
6795 12057 : f(nXCheck, nBlockXSize, nYCheck,
6796 : static_cast<const GByte *>(pData),
6797 : nNoDataValue <= nMaxValueType, nNoDataValue, nMin,
6798 : nMax, nSum, nSumSquare, nSampleCount, nValidCount);
6799 : }
6800 : else
6801 : {
6802 : ComputeStatisticsInternal<
6803 : GUInt16, /* COMPUTE_OTHER_STATS = */ true>::
6804 470 : f(nXCheck, nBlockXSize, nYCheck,
6805 : static_cast<const GUInt16 *>(pData),
6806 : nNoDataValue <= nMaxValueType, nNoDataValue, nMin,
6807 : nMax, nSum, nSumSquare, nSampleCount, nValidCount);
6808 : }
6809 :
6810 12527 : poBlock->DropLock();
6811 :
6812 12527 : if (!pfnProgress(static_cast<double>(iSampleBlock) /
6813 12527 : (static_cast<double>(nBlocksPerRow) *
6814 12527 : nBlocksPerColumn),
6815 : "Compute Statistics", pProgressData))
6816 : {
6817 0 : ReportError(CE_Failure, CPLE_UserInterrupt,
6818 : "User terminated");
6819 0 : return CE_Failure;
6820 : }
6821 : }
6822 :
6823 214 : if (!pfnProgress(1.0, "Compute Statistics", pProgressData))
6824 : {
6825 0 : ReportError(CE_Failure, CPLE_UserInterrupt, "User terminated");
6826 0 : return CE_Failure;
6827 : }
6828 :
6829 : /* --------------------------------------------------------------------
6830 : */
6831 : /* Save computed information. */
6832 : /* --------------------------------------------------------------------
6833 : */
6834 214 : if (nValidCount)
6835 205 : dfMean = static_cast<double>(nSum) / nValidCount;
6836 :
6837 : // To avoid potential precision issues when doing the difference,
6838 : // we need to do that computation on 128 bit rather than casting
6839 : // to double
6840 : const GDALUInt128 nTmpForStdDev(
6841 214 : GDALUInt128::Mul(nSumSquare, nValidCount) -
6842 428 : GDALUInt128::Mul(nSum, nSum));
6843 : const double dfStdDev =
6844 214 : nValidCount > 0
6845 214 : ? sqrt(static_cast<double>(nTmpForStdDev)) / nValidCount
6846 214 : : 0.0;
6847 :
6848 214 : if (nValidCount > 0)
6849 : {
6850 205 : if (bApproxOK)
6851 : {
6852 24 : SetMetadataItem("STATISTICS_APPROXIMATE", "YES");
6853 : }
6854 181 : else if (GetMetadataItem("STATISTICS_APPROXIMATE"))
6855 : {
6856 3 : SetMetadataItem("STATISTICS_APPROXIMATE", nullptr);
6857 : }
6858 205 : SetStatistics(nMin, nMax, dfMean, dfStdDev);
6859 : }
6860 :
6861 214 : SetValidPercent(nSampleCount, nValidCount);
6862 :
6863 : /* --------------------------------------------------------------------
6864 : */
6865 : /* Record results. */
6866 : /* --------------------------------------------------------------------
6867 : */
6868 214 : if (pdfMin != nullptr)
6869 211 : *pdfMin = nValidCount ? nMin : 0;
6870 214 : if (pdfMax != nullptr)
6871 211 : *pdfMax = nValidCount ? nMax : 0;
6872 :
6873 214 : if (pdfMean != nullptr)
6874 207 : *pdfMean = dfMean;
6875 :
6876 214 : if (pdfStdDev != nullptr)
6877 207 : *pdfStdDev = dfStdDev;
6878 :
6879 214 : if (nValidCount > 0)
6880 205 : return CE_None;
6881 :
6882 9 : ReportError(CE_Failure, CPLE_AppDefined,
6883 : "Failed to compute statistics, no valid pixels found "
6884 : "in sampling.");
6885 9 : return CE_Failure;
6886 : }
6887 :
6888 255 : GByte *pabyMaskData = nullptr;
6889 255 : if (poMaskBand)
6890 : {
6891 : pabyMaskData = static_cast<GByte *>(
6892 45 : VSI_MALLOC2_VERBOSE(nBlockXSize, nBlockYSize));
6893 45 : if (!pabyMaskData)
6894 : {
6895 0 : return CE_Failure;
6896 : }
6897 : }
6898 :
6899 255 : for (GIntBig iSampleBlock = 0;
6900 5889 : iSampleBlock <
6901 5889 : static_cast<GIntBig>(nBlocksPerRow) * nBlocksPerColumn;
6902 5634 : iSampleBlock += nSampleRate)
6903 : {
6904 5634 : const int iYBlock = static_cast<int>(iSampleBlock / nBlocksPerRow);
6905 5634 : const int iXBlock = static_cast<int>(iSampleBlock % nBlocksPerRow);
6906 :
6907 5634 : int nXCheck = 0, nYCheck = 0;
6908 5634 : GetActualBlockSize(iXBlock, iYBlock, &nXCheck, &nYCheck);
6909 :
6910 6219 : if (poMaskBand &&
6911 585 : poMaskBand->RasterIO(GF_Read, iXBlock * nBlockXSize,
6912 585 : iYBlock * nBlockYSize, nXCheck, nYCheck,
6913 : pabyMaskData, nXCheck, nYCheck, GDT_Byte,
6914 585 : 0, nBlockXSize, nullptr) != CE_None)
6915 : {
6916 0 : CPLFree(pabyMaskData);
6917 0 : return CE_Failure;
6918 : }
6919 :
6920 : GDALRasterBlock *const poBlock =
6921 5634 : GetLockedBlockRef(iXBlock, iYBlock);
6922 5634 : if (poBlock == nullptr)
6923 : {
6924 0 : CPLFree(pabyMaskData);
6925 0 : return CE_Failure;
6926 : }
6927 :
6928 5634 : void *const pData = poBlock->GetDataRef();
6929 :
6930 : // This isn't the fastest way to do this, but is easier for now.
6931 13492 : for (int iY = 0; iY < nYCheck; iY++)
6932 : {
6933 4891200 : for (int iX = 0; iX < nXCheck; iX++)
6934 : {
6935 4883340 : const GPtrDiff_t iOffset =
6936 4883340 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
6937 4883340 : if (pabyMaskData && pabyMaskData[iOffset] == 0)
6938 111829 : continue;
6939 :
6940 4779080 : bool bValid = true;
6941 : double dfValue =
6942 4779080 : GetPixelValue(eDataType, bSignedByte, pData, iOffset,
6943 4779080 : sNoDataValues, bValid);
6944 :
6945 4779080 : if (!bValid)
6946 7574 : continue;
6947 :
6948 4771510 : dfMin = std::min(dfMin, dfValue);
6949 4771510 : dfMax = std::max(dfMax, dfValue);
6950 :
6951 4771510 : nValidCount++;
6952 4771510 : if (dfMin == dfMax)
6953 : {
6954 2173320 : if (nValidCount == 1)
6955 254 : dfMean = dfMin;
6956 : }
6957 : else
6958 : {
6959 2598180 : const double dfDelta = dfValue - dfMean;
6960 2598180 : dfMean += dfDelta / nValidCount;
6961 2598180 : dfM2 += dfDelta * (dfValue - dfMean);
6962 : }
6963 : }
6964 : }
6965 :
6966 5634 : nSampleCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
6967 :
6968 5634 : poBlock->DropLock();
6969 :
6970 5634 : if (!pfnProgress(
6971 5634 : static_cast<double>(iSampleBlock) /
6972 5634 : (static_cast<double>(nBlocksPerRow) * nBlocksPerColumn),
6973 : "Compute Statistics", pProgressData))
6974 : {
6975 0 : ReportError(CE_Failure, CPLE_UserInterrupt, "User terminated");
6976 0 : CPLFree(pabyMaskData);
6977 0 : return CE_Failure;
6978 : }
6979 : }
6980 :
6981 255 : CPLFree(pabyMaskData);
6982 : }
6983 :
6984 255 : if (!pfnProgress(1.0, "Compute Statistics", pProgressData))
6985 : {
6986 0 : ReportError(CE_Failure, CPLE_UserInterrupt, "User terminated");
6987 0 : return CE_Failure;
6988 : }
6989 :
6990 : /* -------------------------------------------------------------------- */
6991 : /* Save computed information. */
6992 : /* -------------------------------------------------------------------- */
6993 255 : const double dfStdDev = nValidCount > 0 ? sqrt(dfM2 / nValidCount) : 0.0;
6994 :
6995 255 : if (nValidCount > 0)
6996 : {
6997 254 : if (bApproxOK)
6998 : {
6999 8 : SetMetadataItem("STATISTICS_APPROXIMATE", "YES");
7000 : }
7001 246 : else if (GetMetadataItem("STATISTICS_APPROXIMATE"))
7002 : {
7003 2 : SetMetadataItem("STATISTICS_APPROXIMATE", nullptr);
7004 : }
7005 254 : SetStatistics(dfMin, dfMax, dfMean, dfStdDev);
7006 : }
7007 : else
7008 : {
7009 1 : dfMin = 0.0;
7010 1 : dfMax = 0.0;
7011 : }
7012 :
7013 255 : SetValidPercent(nSampleCount, nValidCount);
7014 :
7015 : /* -------------------------------------------------------------------- */
7016 : /* Record results. */
7017 : /* -------------------------------------------------------------------- */
7018 255 : if (pdfMin != nullptr)
7019 252 : *pdfMin = dfMin;
7020 255 : if (pdfMax != nullptr)
7021 252 : *pdfMax = dfMax;
7022 :
7023 255 : if (pdfMean != nullptr)
7024 250 : *pdfMean = dfMean;
7025 :
7026 255 : if (pdfStdDev != nullptr)
7027 250 : *pdfStdDev = dfStdDev;
7028 :
7029 255 : if (nValidCount > 0)
7030 254 : return CE_None;
7031 :
7032 1 : ReportError(
7033 : CE_Failure, CPLE_AppDefined,
7034 : "Failed to compute statistics, no valid pixels found in sampling.");
7035 1 : return CE_Failure;
7036 : }
7037 :
7038 : /************************************************************************/
7039 : /* GDALComputeRasterStatistics() */
7040 : /************************************************************************/
7041 :
7042 : /**
7043 : * \brief Compute image statistics.
7044 : *
7045 : * @see GDALRasterBand::ComputeStatistics()
7046 : */
7047 :
7048 157 : CPLErr CPL_STDCALL GDALComputeRasterStatistics(GDALRasterBandH hBand,
7049 : int bApproxOK, double *pdfMin,
7050 : double *pdfMax, double *pdfMean,
7051 : double *pdfStdDev,
7052 : GDALProgressFunc pfnProgress,
7053 : void *pProgressData)
7054 :
7055 : {
7056 157 : VALIDATE_POINTER1(hBand, "GDALComputeRasterStatistics", CE_Failure);
7057 :
7058 157 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
7059 :
7060 157 : return poBand->ComputeStatistics(bApproxOK, pdfMin, pdfMax, pdfMean,
7061 157 : pdfStdDev, pfnProgress, pProgressData);
7062 : }
7063 :
7064 : /************************************************************************/
7065 : /* SetStatistics() */
7066 : /************************************************************************/
7067 :
7068 : /**
7069 : * \brief Set statistics on band.
7070 : *
7071 : * This method can be used to store min/max/mean/standard deviation
7072 : * statistics on a raster band.
7073 : *
7074 : * The default implementation stores them as metadata, and will only work
7075 : * on formats that can save arbitrary metadata. This method cannot detect
7076 : * whether metadata will be properly saved and so may return CE_None even
7077 : * if the statistics will never be saved.
7078 : *
7079 : * This method is the same as the C function GDALSetRasterStatistics().
7080 : *
7081 : * @param dfMin minimum pixel value.
7082 : *
7083 : * @param dfMax maximum pixel value.
7084 : *
7085 : * @param dfMean mean (average) of all pixel values.
7086 : *
7087 : * @param dfStdDev Standard deviation of all pixel values.
7088 : *
7089 : * @return CE_None on success or CE_Failure on failure.
7090 : */
7091 :
7092 492 : CPLErr GDALRasterBand::SetStatistics(double dfMin, double dfMax, double dfMean,
7093 : double dfStdDev)
7094 :
7095 : {
7096 492 : char szValue[128] = {0};
7097 :
7098 492 : CPLsnprintf(szValue, sizeof(szValue), "%.14g", dfMin);
7099 492 : SetMetadataItem("STATISTICS_MINIMUM", szValue);
7100 :
7101 492 : CPLsnprintf(szValue, sizeof(szValue), "%.14g", dfMax);
7102 492 : SetMetadataItem("STATISTICS_MAXIMUM", szValue);
7103 :
7104 492 : CPLsnprintf(szValue, sizeof(szValue), "%.14g", dfMean);
7105 492 : SetMetadataItem("STATISTICS_MEAN", szValue);
7106 :
7107 492 : CPLsnprintf(szValue, sizeof(szValue), "%.14g", dfStdDev);
7108 492 : SetMetadataItem("STATISTICS_STDDEV", szValue);
7109 :
7110 492 : return CE_None;
7111 : }
7112 :
7113 : /************************************************************************/
7114 : /* GDALSetRasterStatistics() */
7115 : /************************************************************************/
7116 :
7117 : /**
7118 : * \brief Set statistics on band.
7119 : *
7120 : * @see GDALRasterBand::SetStatistics()
7121 : */
7122 :
7123 2 : CPLErr CPL_STDCALL GDALSetRasterStatistics(GDALRasterBandH hBand, double dfMin,
7124 : double dfMax, double dfMean,
7125 : double dfStdDev)
7126 :
7127 : {
7128 2 : VALIDATE_POINTER1(hBand, "GDALSetRasterStatistics", CE_Failure);
7129 :
7130 2 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
7131 2 : return poBand->SetStatistics(dfMin, dfMax, dfMean, dfStdDev);
7132 : }
7133 :
7134 : /************************************************************************/
7135 : /* ComputeRasterMinMax() */
7136 : /************************************************************************/
7137 :
7138 : template <class T, bool HAS_NODATA>
7139 120175 : static void ComputeMinMax(const T *buffer, size_t nElts, T nodataValue, T *pMin,
7140 : T *pMax)
7141 : {
7142 120175 : T min0 = *pMin;
7143 120175 : T max0 = *pMax;
7144 120175 : T min1 = *pMin;
7145 120175 : T max1 = *pMax;
7146 : size_t i;
7147 214453 : for (i = 0; i + 1 < nElts; i += 2)
7148 : {
7149 81892 : if (!HAS_NODATA || buffer[i] != nodataValue)
7150 : {
7151 94278 : min0 = std::min(min0, buffer[i]);
7152 94278 : max0 = std::max(max0, buffer[i]);
7153 : }
7154 81892 : if (!HAS_NODATA || buffer[i + 1] != nodataValue)
7155 : {
7156 94278 : min1 = std::min(min1, buffer[i + 1]);
7157 94278 : max1 = std::max(max1, buffer[i + 1]);
7158 : }
7159 : }
7160 120175 : T min = std::min(min0, min1);
7161 120175 : T max = std::max(max0, max1);
7162 120175 : if (i < nElts)
7163 : {
7164 118460 : if (!HAS_NODATA || buffer[i] != nodataValue)
7165 : {
7166 118480 : min = std::min(min, buffer[i]);
7167 118480 : max = std::max(max, buffer[i]);
7168 : }
7169 : }
7170 120175 : *pMin = min;
7171 120175 : *pMax = max;
7172 120175 : }
7173 :
7174 : template <GDALDataType eDataType, bool bSignedByte>
7175 : static void
7176 11416 : ComputeMinMaxGeneric(const void *pData, int nXCheck, int nYCheck,
7177 : int nBlockXSize, const GDALNoDataValues &sNoDataValues,
7178 : const GByte *pabyMaskData, double &dfMin, double &dfMax)
7179 : {
7180 11416 : double dfLocalMin = dfMin;
7181 11416 : double dfLocalMax = dfMax;
7182 :
7183 40981 : for (int iY = 0; iY < nYCheck; iY++)
7184 : {
7185 18964243 : for (int iX = 0; iX < nXCheck; iX++)
7186 : {
7187 18934695 : const GPtrDiff_t iOffset =
7188 18934695 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
7189 18934695 : if (pabyMaskData && pabyMaskData[iOffset] == 0)
7190 3460312 : continue;
7191 18839952 : bool bValid = true;
7192 18839952 : double dfValue = GetPixelValue(eDataType, bSignedByte, pData,
7193 : iOffset, sNoDataValues, bValid);
7194 18839952 : if (!bValid)
7195 3365580 : continue;
7196 :
7197 15474340 : dfLocalMin = std::min(dfLocalMin, dfValue);
7198 15474340 : dfLocalMax = std::max(dfLocalMax, dfValue);
7199 : }
7200 : }
7201 :
7202 11416 : dfMin = dfLocalMin;
7203 11416 : dfMax = dfLocalMax;
7204 11416 : }
7205 :
7206 11416 : static void ComputeMinMaxGeneric(const void *pData, GDALDataType eDataType,
7207 : bool bSignedByte, int nXCheck, int nYCheck,
7208 : int nBlockXSize,
7209 : const GDALNoDataValues &sNoDataValues,
7210 : const GByte *pabyMaskData, double &dfMin,
7211 : double &dfMax)
7212 : {
7213 11416 : switch (eDataType)
7214 : {
7215 0 : case GDT_Unknown:
7216 0 : CPLAssert(false);
7217 : break;
7218 672 : case GDT_Byte:
7219 672 : if (bSignedByte)
7220 : {
7221 3 : ComputeMinMaxGeneric<GDT_Byte, true>(
7222 : pData, nXCheck, nYCheck, nBlockXSize, sNoDataValues,
7223 : pabyMaskData, dfMin, dfMax);
7224 : }
7225 : else
7226 : {
7227 669 : ComputeMinMaxGeneric<GDT_Byte, false>(
7228 : pData, nXCheck, nYCheck, nBlockXSize, sNoDataValues,
7229 : pabyMaskData, dfMin, dfMax);
7230 : }
7231 672 : break;
7232 106 : case GDT_Int8:
7233 106 : ComputeMinMaxGeneric<GDT_Int8, false>(pData, nXCheck, nYCheck,
7234 : nBlockXSize, sNoDataValues,
7235 : pabyMaskData, dfMin, dfMax);
7236 106 : break;
7237 200 : case GDT_UInt16:
7238 200 : ComputeMinMaxGeneric<GDT_UInt16, false>(pData, nXCheck, nYCheck,
7239 : nBlockXSize, sNoDataValues,
7240 : pabyMaskData, dfMin, dfMax);
7241 200 : break;
7242 1 : case GDT_Int16:
7243 1 : ComputeMinMaxGeneric<GDT_Int16, false>(pData, nXCheck, nYCheck,
7244 : nBlockXSize, sNoDataValues,
7245 : pabyMaskData, dfMin, dfMax);
7246 1 : break;
7247 201 : case GDT_UInt32:
7248 201 : ComputeMinMaxGeneric<GDT_UInt32, false>(pData, nXCheck, nYCheck,
7249 : nBlockXSize, sNoDataValues,
7250 : pabyMaskData, dfMin, dfMax);
7251 201 : break;
7252 1048 : case GDT_Int32:
7253 1048 : ComputeMinMaxGeneric<GDT_Int32, false>(pData, nXCheck, nYCheck,
7254 : nBlockXSize, sNoDataValues,
7255 : pabyMaskData, dfMin, dfMax);
7256 1048 : break;
7257 17 : case GDT_UInt64:
7258 17 : ComputeMinMaxGeneric<GDT_UInt64, false>(pData, nXCheck, nYCheck,
7259 : nBlockXSize, sNoDataValues,
7260 : pabyMaskData, dfMin, dfMax);
7261 17 : break;
7262 29 : case GDT_Int64:
7263 29 : ComputeMinMaxGeneric<GDT_Int64, false>(pData, nXCheck, nYCheck,
7264 : nBlockXSize, sNoDataValues,
7265 : pabyMaskData, dfMin, dfMax);
7266 29 : break;
7267 0 : case GDT_Float16:
7268 0 : ComputeMinMaxGeneric<GDT_Float16, false>(
7269 : pData, nXCheck, nYCheck, nBlockXSize, sNoDataValues,
7270 : pabyMaskData, dfMin, dfMax);
7271 0 : break;
7272 5550 : case GDT_Float32:
7273 5550 : ComputeMinMaxGeneric<GDT_Float32, false>(
7274 : pData, nXCheck, nYCheck, nBlockXSize, sNoDataValues,
7275 : pabyMaskData, dfMin, dfMax);
7276 5550 : break;
7277 3482 : case GDT_Float64:
7278 3482 : ComputeMinMaxGeneric<GDT_Float64, false>(
7279 : pData, nXCheck, nYCheck, nBlockXSize, sNoDataValues,
7280 : pabyMaskData, dfMin, dfMax);
7281 3482 : break;
7282 9 : case GDT_CInt16:
7283 9 : ComputeMinMaxGeneric<GDT_CInt16, false>(pData, nXCheck, nYCheck,
7284 : nBlockXSize, sNoDataValues,
7285 : pabyMaskData, dfMin, dfMax);
7286 9 : break;
7287 9 : case GDT_CInt32:
7288 9 : ComputeMinMaxGeneric<GDT_CInt32, false>(pData, nXCheck, nYCheck,
7289 : nBlockXSize, sNoDataValues,
7290 : pabyMaskData, dfMin, dfMax);
7291 9 : break;
7292 0 : case GDT_CFloat16:
7293 0 : ComputeMinMaxGeneric<GDT_CFloat16, false>(
7294 : pData, nXCheck, nYCheck, nBlockXSize, sNoDataValues,
7295 : pabyMaskData, dfMin, dfMax);
7296 0 : break;
7297 75 : case GDT_CFloat32:
7298 75 : ComputeMinMaxGeneric<GDT_CFloat32, false>(
7299 : pData, nXCheck, nYCheck, nBlockXSize, sNoDataValues,
7300 : pabyMaskData, dfMin, dfMax);
7301 75 : break;
7302 17 : case GDT_CFloat64:
7303 17 : ComputeMinMaxGeneric<GDT_CFloat64, false>(
7304 : pData, nXCheck, nYCheck, nBlockXSize, sNoDataValues,
7305 : pabyMaskData, dfMin, dfMax);
7306 17 : break;
7307 0 : case GDT_TypeCount:
7308 0 : CPLAssert(false);
7309 : break;
7310 : }
7311 11416 : }
7312 :
7313 765 : static bool ComputeMinMaxGenericIterBlocks(
7314 : GDALRasterBand *poBand, GDALDataType eDataType, bool bSignedByte,
7315 : GIntBig nTotalBlocks, int nSampleRate, int nBlocksPerRow,
7316 : const GDALNoDataValues &sNoDataValues, GDALRasterBand *poMaskBand,
7317 : double &dfMin, double &dfMax)
7318 :
7319 : {
7320 765 : GByte *pabyMaskData = nullptr;
7321 : int nBlockXSize, nBlockYSize;
7322 765 : poBand->GetBlockSize(&nBlockXSize, &nBlockYSize);
7323 :
7324 765 : if (poMaskBand)
7325 : {
7326 : pabyMaskData =
7327 106 : static_cast<GByte *>(VSI_MALLOC2_VERBOSE(nBlockXSize, nBlockYSize));
7328 106 : if (!pabyMaskData)
7329 : {
7330 0 : return false;
7331 : }
7332 : }
7333 :
7334 12181 : for (GIntBig iSampleBlock = 0; iSampleBlock < nTotalBlocks;
7335 11416 : iSampleBlock += nSampleRate)
7336 : {
7337 11416 : const int iYBlock = static_cast<int>(iSampleBlock / nBlocksPerRow);
7338 11416 : const int iXBlock = static_cast<int>(iSampleBlock % nBlocksPerRow);
7339 :
7340 11416 : int nXCheck = 0, nYCheck = 0;
7341 11416 : poBand->GetActualBlockSize(iXBlock, iYBlock, &nXCheck, &nYCheck);
7342 :
7343 17148 : if (poMaskBand &&
7344 5732 : poMaskBand->RasterIO(GF_Read, iXBlock * nBlockXSize,
7345 : iYBlock * nBlockYSize, nXCheck, nYCheck,
7346 : pabyMaskData, nXCheck, nYCheck, GDT_Byte, 0,
7347 : nBlockXSize, nullptr) != CE_None)
7348 : {
7349 0 : CPLFree(pabyMaskData);
7350 0 : return false;
7351 : }
7352 :
7353 11416 : GDALRasterBlock *poBlock = poBand->GetLockedBlockRef(iXBlock, iYBlock);
7354 11416 : if (poBlock == nullptr)
7355 : {
7356 0 : CPLFree(pabyMaskData);
7357 0 : return false;
7358 : }
7359 :
7360 11416 : void *const pData = poBlock->GetDataRef();
7361 :
7362 11416 : ComputeMinMaxGeneric(pData, eDataType, bSignedByte, nXCheck, nYCheck,
7363 : nBlockXSize, sNoDataValues, pabyMaskData, dfMin,
7364 : dfMax);
7365 :
7366 11416 : poBlock->DropLock();
7367 : }
7368 :
7369 765 : CPLFree(pabyMaskData);
7370 765 : return true;
7371 : }
7372 :
7373 : /**
7374 : * \brief Compute the min/max values for a band.
7375 : *
7376 : * If approximate is OK, then the band's GetMinimum()/GetMaximum() will
7377 : * be trusted. If it doesn't work, a subsample of blocks will be read to
7378 : * get an approximate min/max. If the band has a nodata value it will
7379 : * be excluded from the minimum and maximum.
7380 : *
7381 : * If bApprox is FALSE, then all pixels will be read and used to compute
7382 : * an exact range.
7383 : *
7384 : * This method is the same as the C function GDALComputeRasterMinMax().
7385 : *
7386 : * @param bApproxOK TRUE if an approximate (faster) answer is OK, otherwise
7387 : * FALSE.
7388 : * @param adfMinMax the array in which the minimum (adfMinMax[0]) and the
7389 : * maximum (adfMinMax[1]) are returned.
7390 : *
7391 : * @return CE_None on success or CE_Failure on failure.
7392 : */
7393 :
7394 1752 : CPLErr GDALRasterBand::ComputeRasterMinMax(int bApproxOK, double *adfMinMax)
7395 : {
7396 : /* -------------------------------------------------------------------- */
7397 : /* Does the driver already know the min/max? */
7398 : /* -------------------------------------------------------------------- */
7399 1752 : if (bApproxOK)
7400 : {
7401 23 : int bSuccessMin = FALSE;
7402 23 : int bSuccessMax = FALSE;
7403 :
7404 23 : double dfMin = GetMinimum(&bSuccessMin);
7405 23 : double dfMax = GetMaximum(&bSuccessMax);
7406 :
7407 23 : if (bSuccessMin && bSuccessMax)
7408 : {
7409 1 : adfMinMax[0] = dfMin;
7410 1 : adfMinMax[1] = dfMax;
7411 1 : return CE_None;
7412 : }
7413 : }
7414 :
7415 : /* -------------------------------------------------------------------- */
7416 : /* If we have overview bands, use them for min/max. */
7417 : /* -------------------------------------------------------------------- */
7418 : // cppcheck-suppress knownConditionTrueFalse
7419 1751 : if (bApproxOK && GetOverviewCount() > 0 && !HasArbitraryOverviews())
7420 : {
7421 : GDALRasterBand *poBand =
7422 0 : GetRasterSampleOverview(GDALSTAT_APPROX_NUMSAMPLES);
7423 :
7424 0 : if (poBand != this)
7425 0 : return poBand->ComputeRasterMinMax(FALSE, adfMinMax);
7426 : }
7427 :
7428 : /* -------------------------------------------------------------------- */
7429 : /* Read actual data and compute minimum and maximum. */
7430 : /* -------------------------------------------------------------------- */
7431 1751 : GDALNoDataValues sNoDataValues(this, eDataType);
7432 1751 : GDALRasterBand *poMaskBand = nullptr;
7433 1751 : if (!sNoDataValues.bGotNoDataValue)
7434 : {
7435 1502 : const int l_nMaskFlags = GetMaskFlags();
7436 1608 : if (l_nMaskFlags != GMF_ALL_VALID &&
7437 106 : GetColorInterpretation() != GCI_AlphaBand)
7438 : {
7439 106 : poMaskBand = GetMaskBand();
7440 : }
7441 : }
7442 :
7443 1751 : bool bSignedByte = false;
7444 1751 : if (eDataType == GDT_Byte)
7445 : {
7446 776 : EnablePixelTypeSignedByteWarning(false);
7447 : const char *pszPixelType =
7448 776 : GetMetadataItem("PIXELTYPE", "IMAGE_STRUCTURE");
7449 776 : EnablePixelTypeSignedByteWarning(true);
7450 776 : bSignedByte =
7451 776 : pszPixelType != nullptr && EQUAL(pszPixelType, "SIGNEDBYTE");
7452 : }
7453 :
7454 : GDALRasterIOExtraArg sExtraArg;
7455 1751 : INIT_RASTERIO_EXTRA_ARG(sExtraArg);
7456 :
7457 3502 : GUInt32 nMin = (eDataType == GDT_Byte)
7458 1751 : ? 255
7459 : : 65535; // used for GByte & GUInt16 cases
7460 1751 : GUInt32 nMax = 0; // used for GByte & GUInt16 cases
7461 1751 : GInt16 nMinInt16 =
7462 : std::numeric_limits<GInt16>::max(); // used for GInt16 case
7463 1751 : GInt16 nMaxInt16 =
7464 : std::numeric_limits<GInt16>::lowest(); // used for GInt16 case
7465 1751 : double dfMin =
7466 : std::numeric_limits<double>::infinity(); // used for generic code path
7467 1751 : double dfMax =
7468 : -std::numeric_limits<double>::infinity(); // used for generic code path
7469 1751 : const bool bUseOptimizedPath =
7470 2651 : !poMaskBand && ((eDataType == GDT_Byte && !bSignedByte) ||
7471 900 : eDataType == GDT_Int16 || eDataType == GDT_UInt16);
7472 :
7473 : const auto ComputeMinMaxForBlock =
7474 20652 : [this, bSignedByte, &sNoDataValues, &nMin, &nMax, &nMinInt16,
7475 : &nMaxInt16](const void *pData, int nXCheck, int nBufferWidth,
7476 241357 : int nYCheck)
7477 : {
7478 20652 : if (eDataType == GDT_Byte && !bSignedByte)
7479 : {
7480 : const bool bHasNoData =
7481 11561 : sNoDataValues.bGotNoDataValue &&
7482 29669 : GDALIsValueInRange<GByte>(sNoDataValues.dfNoDataValue) &&
7483 11561 : static_cast<GByte>(sNoDataValues.dfNoDataValue) ==
7484 11561 : sNoDataValues.dfNoDataValue;
7485 18108 : const GUInt32 nNoDataValue =
7486 18108 : bHasNoData ? static_cast<GByte>(sNoDataValues.dfNoDataValue)
7487 : : 0;
7488 : GUIntBig nSum, nSumSquare, nSampleCount, nValidCount; // unused
7489 : ComputeStatisticsInternal<GByte,
7490 : /* COMPUTE_OTHER_STATS = */ false>::
7491 18108 : f(nXCheck, nBufferWidth, nYCheck,
7492 : static_cast<const GByte *>(pData), bHasNoData, nNoDataValue,
7493 18108 : nMin, nMax, nSum, nSumSquare, nSampleCount, nValidCount);
7494 : }
7495 2544 : else if (eDataType == GDT_UInt16)
7496 : {
7497 : const bool bHasNoData =
7498 83 : sNoDataValues.bGotNoDataValue &&
7499 1239 : GDALIsValueInRange<GUInt16>(sNoDataValues.dfNoDataValue) &&
7500 83 : static_cast<GUInt16>(sNoDataValues.dfNoDataValue) ==
7501 83 : sNoDataValues.dfNoDataValue;
7502 1156 : const GUInt32 nNoDataValue =
7503 1156 : bHasNoData ? static_cast<GUInt16>(sNoDataValues.dfNoDataValue)
7504 : : 0;
7505 : GUIntBig nSum, nSumSquare, nSampleCount, nValidCount; // unused
7506 : ComputeStatisticsInternal<GUInt16,
7507 : /* COMPUTE_OTHER_STATS = */ false>::
7508 1156 : f(nXCheck, nBufferWidth, nYCheck,
7509 : static_cast<const GUInt16 *>(pData), bHasNoData, nNoDataValue,
7510 : nMin, nMax, nSum, nSumSquare, nSampleCount, nValidCount);
7511 : }
7512 1388 : else if (eDataType == GDT_Int16)
7513 : {
7514 : const bool bHasNoData =
7515 1214 : sNoDataValues.bGotNoDataValue &&
7516 2602 : GDALIsValueInRange<int16_t>(sNoDataValues.dfNoDataValue) &&
7517 1214 : static_cast<int16_t>(sNoDataValues.dfNoDataValue) ==
7518 1214 : sNoDataValues.dfNoDataValue;
7519 1388 : if (bHasNoData)
7520 : {
7521 1214 : const int16_t nNoDataValue =
7522 1214 : static_cast<int16_t>(sNoDataValues.dfNoDataValue);
7523 120117 : for (int iY = 0; iY < nYCheck; iY++)
7524 : {
7525 118903 : ComputeMinMax<int16_t, true>(
7526 118903 : static_cast<const int16_t *>(pData) +
7527 118903 : static_cast<size_t>(iY) * nBufferWidth,
7528 : nXCheck, nNoDataValue, &nMinInt16, &nMaxInt16);
7529 : }
7530 : }
7531 : else
7532 : {
7533 1446 : for (int iY = 0; iY < nYCheck; iY++)
7534 : {
7535 1272 : ComputeMinMax<int16_t, false>(
7536 1272 : static_cast<const int16_t *>(pData) +
7537 1272 : static_cast<size_t>(iY) * nBufferWidth,
7538 : nXCheck, 0, &nMinInt16, &nMaxInt16);
7539 : }
7540 : }
7541 : }
7542 20652 : };
7543 :
7544 1751 : if (bApproxOK && HasArbitraryOverviews())
7545 : {
7546 : /* --------------------------------------------------------------------
7547 : */
7548 : /* Figure out how much the image should be reduced to get an */
7549 : /* approximate value. */
7550 : /* --------------------------------------------------------------------
7551 : */
7552 0 : double dfReduction = sqrt(static_cast<double>(nRasterXSize) *
7553 0 : nRasterYSize / GDALSTAT_APPROX_NUMSAMPLES);
7554 :
7555 0 : int nXReduced = nRasterXSize;
7556 0 : int nYReduced = nRasterYSize;
7557 0 : if (dfReduction > 1.0)
7558 : {
7559 0 : nXReduced = static_cast<int>(nRasterXSize / dfReduction);
7560 0 : nYReduced = static_cast<int>(nRasterYSize / dfReduction);
7561 :
7562 : // Catch the case of huge resizing ratios here
7563 0 : if (nXReduced == 0)
7564 0 : nXReduced = 1;
7565 0 : if (nYReduced == 0)
7566 0 : nYReduced = 1;
7567 : }
7568 :
7569 0 : void *const pData = CPLMalloc(cpl::fits_on<int>(
7570 0 : GDALGetDataTypeSizeBytes(eDataType) * nXReduced * nYReduced));
7571 :
7572 : const CPLErr eErr =
7573 0 : IRasterIO(GF_Read, 0, 0, nRasterXSize, nRasterYSize, pData,
7574 0 : nXReduced, nYReduced, eDataType, 0, 0, &sExtraArg);
7575 0 : if (eErr != CE_None)
7576 : {
7577 0 : CPLFree(pData);
7578 0 : return eErr;
7579 : }
7580 :
7581 0 : GByte *pabyMaskData = nullptr;
7582 0 : if (poMaskBand)
7583 : {
7584 : pabyMaskData =
7585 0 : static_cast<GByte *>(VSI_MALLOC2_VERBOSE(nXReduced, nYReduced));
7586 0 : if (!pabyMaskData)
7587 : {
7588 0 : CPLFree(pData);
7589 0 : return CE_Failure;
7590 : }
7591 :
7592 0 : if (poMaskBand->RasterIO(GF_Read, 0, 0, nRasterXSize, nRasterYSize,
7593 : pabyMaskData, nXReduced, nYReduced,
7594 0 : GDT_Byte, 0, 0, nullptr) != CE_None)
7595 : {
7596 0 : CPLFree(pData);
7597 0 : CPLFree(pabyMaskData);
7598 0 : return CE_Failure;
7599 : }
7600 : }
7601 :
7602 0 : if (bUseOptimizedPath)
7603 : {
7604 0 : ComputeMinMaxForBlock(pData, nXReduced, nXReduced, nYReduced);
7605 : }
7606 : else
7607 : {
7608 0 : ComputeMinMaxGeneric(pData, eDataType, bSignedByte, nXReduced,
7609 : nYReduced, nXReduced, sNoDataValues,
7610 : pabyMaskData, dfMin, dfMax);
7611 : }
7612 :
7613 0 : CPLFree(pData);
7614 0 : CPLFree(pabyMaskData);
7615 : }
7616 :
7617 : else // No arbitrary overviews
7618 : {
7619 1751 : if (!InitBlockInfo())
7620 0 : return CE_Failure;
7621 :
7622 : /* --------------------------------------------------------------------
7623 : */
7624 : /* Figure out the ratio of blocks we will read to get an */
7625 : /* approximate value. */
7626 : /* --------------------------------------------------------------------
7627 : */
7628 1751 : int nSampleRate = 1;
7629 :
7630 1751 : if (bApproxOK)
7631 : {
7632 22 : nSampleRate = static_cast<int>(std::max(
7633 44 : 1.0,
7634 22 : sqrt(static_cast<double>(nBlocksPerRow) * nBlocksPerColumn)));
7635 : // We want to avoid probing only the first column of blocks for
7636 : // a square shaped raster, because it is not unlikely that it may
7637 : // be padding only (#6378).
7638 22 : if (nSampleRate == nBlocksPerRow && nBlocksPerRow > 1)
7639 0 : nSampleRate += 1;
7640 : }
7641 :
7642 1751 : if (bUseOptimizedPath)
7643 : {
7644 986 : for (GIntBig iSampleBlock = 0;
7645 21560 : iSampleBlock <
7646 21560 : static_cast<GIntBig>(nBlocksPerRow) * nBlocksPerColumn;
7647 20574 : iSampleBlock += nSampleRate)
7648 : {
7649 20653 : const int iYBlock =
7650 20653 : static_cast<int>(iSampleBlock / nBlocksPerRow);
7651 20653 : const int iXBlock =
7652 20653 : static_cast<int>(iSampleBlock % nBlocksPerRow);
7653 :
7654 20653 : GDALRasterBlock *poBlock = GetLockedBlockRef(iXBlock, iYBlock);
7655 20653 : if (poBlock == nullptr)
7656 1 : return CE_Failure;
7657 :
7658 20652 : void *const pData = poBlock->GetDataRef();
7659 :
7660 20652 : int nXCheck = 0, nYCheck = 0;
7661 20652 : GetActualBlockSize(iXBlock, iYBlock, &nXCheck, &nYCheck);
7662 :
7663 20652 : ComputeMinMaxForBlock(pData, nXCheck, nBlockXSize, nYCheck);
7664 :
7665 20652 : poBlock->DropLock();
7666 :
7667 20652 : if (eDataType == GDT_Byte && !bSignedByte && nMin == 0 &&
7668 4108 : nMax == 255)
7669 78 : break;
7670 : }
7671 : }
7672 : else
7673 : {
7674 765 : const GIntBig nTotalBlocks =
7675 765 : static_cast<GIntBig>(nBlocksPerRow) * nBlocksPerColumn;
7676 765 : if (!ComputeMinMaxGenericIterBlocks(
7677 : this, eDataType, bSignedByte, nTotalBlocks, nSampleRate,
7678 : nBlocksPerRow, sNoDataValues, poMaskBand, dfMin, dfMax))
7679 : {
7680 0 : return CE_Failure;
7681 : }
7682 : }
7683 : }
7684 :
7685 1750 : if (bUseOptimizedPath)
7686 : {
7687 985 : if ((eDataType == GDT_Byte && !bSignedByte) || eDataType == GDT_UInt16)
7688 : {
7689 883 : dfMin = nMin;
7690 883 : dfMax = nMax;
7691 : }
7692 102 : else if (eDataType == GDT_Int16)
7693 : {
7694 102 : dfMin = nMinInt16;
7695 102 : dfMax = nMaxInt16;
7696 : }
7697 : }
7698 :
7699 1750 : if (dfMin > dfMax)
7700 : {
7701 9 : adfMinMax[0] = 0;
7702 9 : adfMinMax[1] = 0;
7703 9 : ReportError(
7704 : CE_Failure, CPLE_AppDefined,
7705 : "Failed to compute min/max, no valid pixels found in sampling.");
7706 9 : return CE_Failure;
7707 : }
7708 :
7709 1741 : adfMinMax[0] = dfMin;
7710 1741 : adfMinMax[1] = dfMax;
7711 :
7712 1741 : return CE_None;
7713 : }
7714 :
7715 : /************************************************************************/
7716 : /* GDALComputeRasterMinMax() */
7717 : /************************************************************************/
7718 :
7719 : /**
7720 : * \brief Compute the min/max values for a band.
7721 : *
7722 : * @see GDALRasterBand::ComputeRasterMinMax()
7723 : *
7724 : * @note Prior to GDAL 3.6, this function returned void
7725 : */
7726 :
7727 1601 : CPLErr CPL_STDCALL GDALComputeRasterMinMax(GDALRasterBandH hBand, int bApproxOK,
7728 : double adfMinMax[2])
7729 :
7730 : {
7731 1601 : VALIDATE_POINTER1(hBand, "GDALComputeRasterMinMax", CE_Failure);
7732 :
7733 1601 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
7734 1601 : return poBand->ComputeRasterMinMax(bApproxOK, adfMinMax);
7735 : }
7736 :
7737 : /************************************************************************/
7738 : /* ComputeRasterMinMaxLocation() */
7739 : /************************************************************************/
7740 :
7741 : /**
7742 : * \brief Compute the min/max values for a band, and their location.
7743 : *
7744 : * Pixels whose value matches the nodata value or are masked by the mask
7745 : * band are ignored.
7746 : *
7747 : * If the minimum or maximum value is hit in several locations, it is not
7748 : * specified which one will be returned.
7749 : *
7750 : * @param[out] pdfMin Pointer to the minimum value.
7751 : * @param[out] pdfMax Pointer to the maximum value.
7752 : * @param[out] pnMinX Pointer to the column where the minimum value is hit.
7753 : * @param[out] pnMinY Pointer to the line where the minimum value is hit.
7754 : * @param[out] pnMaxX Pointer to the column where the maximum value is hit.
7755 : * @param[out] pnMaxY Pointer to the line where the maximum value is hit.
7756 : *
7757 : * @return CE_None in case of success, CE_Warning if there are no valid values,
7758 : * CE_Failure in case of error.
7759 : *
7760 : * @since GDAL 3.11
7761 : */
7762 :
7763 8 : CPLErr GDALRasterBand::ComputeRasterMinMaxLocation(double *pdfMin,
7764 : double *pdfMax, int *pnMinX,
7765 : int *pnMinY, int *pnMaxX,
7766 : int *pnMaxY)
7767 : {
7768 8 : int nMinX = -1;
7769 8 : int nMinY = -1;
7770 8 : int nMaxX = -1;
7771 8 : int nMaxY = -1;
7772 8 : double dfMin = std::numeric_limits<double>::infinity();
7773 8 : double dfMax = -std::numeric_limits<double>::infinity();
7774 8 : if (pdfMin)
7775 5 : *pdfMin = dfMin;
7776 8 : if (pdfMax)
7777 5 : *pdfMax = dfMax;
7778 8 : if (pnMinX)
7779 6 : *pnMinX = nMinX;
7780 8 : if (pnMinY)
7781 6 : *pnMinY = nMinY;
7782 8 : if (pnMaxX)
7783 6 : *pnMaxX = nMaxX;
7784 8 : if (pnMaxY)
7785 6 : *pnMaxY = nMaxY;
7786 :
7787 8 : if (GDALDataTypeIsComplex(eDataType))
7788 : {
7789 0 : CPLError(CE_Failure, CPLE_NotSupported,
7790 : "Complex data type not supported");
7791 0 : return CE_Failure;
7792 : }
7793 :
7794 8 : if (!InitBlockInfo())
7795 0 : return CE_Failure;
7796 :
7797 8 : GDALNoDataValues sNoDataValues(this, eDataType);
7798 8 : GDALRasterBand *poMaskBand = nullptr;
7799 8 : if (!sNoDataValues.bGotNoDataValue)
7800 : {
7801 8 : const int l_nMaskFlags = GetMaskFlags();
7802 9 : if (l_nMaskFlags != GMF_ALL_VALID &&
7803 1 : GetColorInterpretation() != GCI_AlphaBand)
7804 : {
7805 1 : poMaskBand = GetMaskBand();
7806 : }
7807 : }
7808 :
7809 8 : bool bSignedByte = false;
7810 8 : if (eDataType == GDT_Byte)
7811 : {
7812 7 : EnablePixelTypeSignedByteWarning(false);
7813 : const char *pszPixelType =
7814 7 : GetMetadataItem("PIXELTYPE", "IMAGE_STRUCTURE");
7815 7 : EnablePixelTypeSignedByteWarning(true);
7816 7 : bSignedByte =
7817 7 : pszPixelType != nullptr && EQUAL(pszPixelType, "SIGNEDBYTE");
7818 : }
7819 :
7820 8 : GByte *pabyMaskData = nullptr;
7821 8 : if (poMaskBand)
7822 : {
7823 : pabyMaskData =
7824 1 : static_cast<GByte *>(VSI_MALLOC2_VERBOSE(nBlockXSize, nBlockYSize));
7825 1 : if (!pabyMaskData)
7826 : {
7827 0 : return CE_Failure;
7828 : }
7829 : }
7830 :
7831 8 : const GIntBig nTotalBlocks =
7832 8 : static_cast<GIntBig>(nBlocksPerRow) * nBlocksPerColumn;
7833 8 : bool bNeedsMin = pdfMin || pnMinX || pnMinY;
7834 8 : bool bNeedsMax = pdfMax || pnMaxX || pnMaxY;
7835 16 : for (GIntBig iBlock = 0; iBlock < nTotalBlocks; ++iBlock)
7836 : {
7837 11 : const int iYBlock = static_cast<int>(iBlock / nBlocksPerRow);
7838 11 : const int iXBlock = static_cast<int>(iBlock % nBlocksPerRow);
7839 :
7840 11 : int nXCheck = 0, nYCheck = 0;
7841 11 : GetActualBlockSize(iXBlock, iYBlock, &nXCheck, &nYCheck);
7842 :
7843 13 : if (poMaskBand &&
7844 2 : poMaskBand->RasterIO(GF_Read, iXBlock * nBlockXSize,
7845 2 : iYBlock * nBlockYSize, nXCheck, nYCheck,
7846 : pabyMaskData, nXCheck, nYCheck, GDT_Byte, 0,
7847 2 : nBlockXSize, nullptr) != CE_None)
7848 : {
7849 0 : CPLFree(pabyMaskData);
7850 0 : return CE_Failure;
7851 : }
7852 :
7853 11 : GDALRasterBlock *poBlock = GetLockedBlockRef(iXBlock, iYBlock);
7854 11 : if (poBlock == nullptr)
7855 : {
7856 0 : CPLFree(pabyMaskData);
7857 0 : return CE_Failure;
7858 : }
7859 :
7860 11 : void *const pData = poBlock->GetDataRef();
7861 :
7862 11 : if (poMaskBand || nYCheck < nBlockYSize || nXCheck < nBlockXSize)
7863 : {
7864 4 : for (int iY = 0; iY < nYCheck; ++iY)
7865 : {
7866 6 : for (int iX = 0; iX < nXCheck; ++iX)
7867 : {
7868 4 : const GPtrDiff_t iOffset =
7869 4 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
7870 4 : if (pabyMaskData && pabyMaskData[iOffset] == 0)
7871 2 : continue;
7872 2 : bool bValid = true;
7873 : double dfValue =
7874 2 : GetPixelValue(eDataType, bSignedByte, pData, iOffset,
7875 : sNoDataValues, bValid);
7876 2 : if (!bValid)
7877 0 : continue;
7878 2 : if (dfValue < dfMin)
7879 : {
7880 2 : dfMin = dfValue;
7881 2 : nMinX = iXBlock * nBlockXSize + iX;
7882 2 : nMinY = iYBlock * nBlockYSize + iY;
7883 : }
7884 2 : if (dfValue > dfMax)
7885 : {
7886 1 : dfMax = dfValue;
7887 1 : nMaxX = iXBlock * nBlockXSize + iX;
7888 1 : nMaxY = iYBlock * nBlockYSize + iY;
7889 : }
7890 : }
7891 2 : }
7892 : }
7893 : else
7894 : {
7895 9 : size_t pos_min = 0;
7896 9 : size_t pos_max = 0;
7897 9 : const auto eEffectiveDT = bSignedByte ? GDT_Int8 : eDataType;
7898 9 : if (bNeedsMin && bNeedsMax)
7899 : {
7900 10 : std::tie(pos_min, pos_max) = gdal::minmax_element(
7901 5 : pData, static_cast<size_t>(nBlockXSize) * nBlockYSize,
7902 5 : eEffectiveDT, sNoDataValues.bGotNoDataValue,
7903 10 : sNoDataValues.dfNoDataValue);
7904 : }
7905 4 : else if (bNeedsMin)
7906 : {
7907 1 : pos_min = gdal::min_element(
7908 1 : pData, static_cast<size_t>(nBlockXSize) * nBlockYSize,
7909 1 : eEffectiveDT, sNoDataValues.bGotNoDataValue,
7910 : sNoDataValues.dfNoDataValue);
7911 : }
7912 3 : else if (bNeedsMax)
7913 : {
7914 2 : pos_max = gdal::max_element(
7915 2 : pData, static_cast<size_t>(nBlockXSize) * nBlockYSize,
7916 2 : eEffectiveDT, sNoDataValues.bGotNoDataValue,
7917 : sNoDataValues.dfNoDataValue);
7918 : }
7919 :
7920 9 : if (bNeedsMin)
7921 : {
7922 6 : const int nMinXBlock = static_cast<int>(pos_min % nBlockXSize);
7923 6 : const int nMinYBlock = static_cast<int>(pos_min / nBlockXSize);
7924 6 : bool bValid = true;
7925 : const double dfMinValueBlock =
7926 6 : GetPixelValue(eDataType, bSignedByte, pData, pos_min,
7927 : sNoDataValues, bValid);
7928 6 : if (bValid && dfMinValueBlock < dfMin)
7929 : {
7930 5 : dfMin = dfMinValueBlock;
7931 5 : nMinX = iXBlock * nBlockXSize + nMinXBlock;
7932 5 : nMinY = iYBlock * nBlockYSize + nMinYBlock;
7933 : }
7934 : }
7935 :
7936 9 : if (bNeedsMax)
7937 : {
7938 7 : const int nMaxXBlock = static_cast<int>(pos_max % nBlockXSize);
7939 7 : const int nMaxYBlock = static_cast<int>(pos_max / nBlockXSize);
7940 7 : bool bValid = true;
7941 : const double dfMaxValueBlock =
7942 7 : GetPixelValue(eDataType, bSignedByte, pData, pos_max,
7943 : sNoDataValues, bValid);
7944 7 : if (bValid && dfMaxValueBlock > dfMax)
7945 : {
7946 5 : dfMax = dfMaxValueBlock;
7947 5 : nMaxX = iXBlock * nBlockXSize + nMaxXBlock;
7948 5 : nMaxY = iYBlock * nBlockYSize + nMaxYBlock;
7949 : }
7950 : }
7951 : }
7952 :
7953 11 : poBlock->DropLock();
7954 :
7955 11 : if (eDataType == GDT_Byte)
7956 : {
7957 10 : if (bNeedsMin && dfMin == 0)
7958 : {
7959 1 : bNeedsMin = false;
7960 : }
7961 10 : if (bNeedsMax && dfMax == 255)
7962 : {
7963 4 : bNeedsMax = false;
7964 : }
7965 10 : if (!bNeedsMin && !bNeedsMax)
7966 : {
7967 3 : break;
7968 : }
7969 : }
7970 : }
7971 :
7972 8 : CPLFree(pabyMaskData);
7973 :
7974 8 : if (pdfMin)
7975 5 : *pdfMin = dfMin;
7976 8 : if (pdfMax)
7977 5 : *pdfMax = dfMax;
7978 8 : if (pnMinX)
7979 6 : *pnMinX = nMinX;
7980 8 : if (pnMinY)
7981 6 : *pnMinY = nMinY;
7982 8 : if (pnMaxX)
7983 6 : *pnMaxX = nMaxX;
7984 8 : if (pnMaxY)
7985 6 : *pnMaxY = nMaxY;
7986 8 : return ((bNeedsMin && nMinX < 0) || (bNeedsMax && nMaxX < 0)) ? CE_Warning
7987 8 : : CE_None;
7988 : }
7989 :
7990 : /************************************************************************/
7991 : /* GDALComputeRasterMinMaxLocation() */
7992 : /************************************************************************/
7993 :
7994 : /**
7995 : * \brief Compute the min/max values for a band, and their location.
7996 : *
7997 : * @see GDALRasterBand::ComputeRasterMinMax()
7998 : * @since GDAL 3.11
7999 : */
8000 :
8001 6 : CPLErr GDALComputeRasterMinMaxLocation(GDALRasterBandH hBand, double *pdfMin,
8002 : double *pdfMax, int *pnMinX, int *pnMinY,
8003 : int *pnMaxX, int *pnMaxY)
8004 :
8005 : {
8006 6 : VALIDATE_POINTER1(hBand, "GDALComputeRasterMinMaxLocation", CE_Failure);
8007 :
8008 6 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
8009 6 : return poBand->ComputeRasterMinMaxLocation(pdfMin, pdfMax, pnMinX, pnMinY,
8010 6 : pnMaxX, pnMaxY);
8011 : }
8012 :
8013 : /************************************************************************/
8014 : /* SetDefaultHistogram() */
8015 : /************************************************************************/
8016 :
8017 : /* FIXME : add proper documentation */
8018 : /**
8019 : * \brief Set default histogram.
8020 : *
8021 : * This method is the same as the C function GDALSetDefaultHistogram() and
8022 : * GDALSetDefaultHistogramEx()
8023 : */
8024 0 : CPLErr GDALRasterBand::SetDefaultHistogram(double /* dfMin */,
8025 : double /* dfMax */,
8026 : int /* nBuckets */,
8027 : GUIntBig * /* panHistogram */)
8028 :
8029 : {
8030 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
8031 0 : ReportError(CE_Failure, CPLE_NotSupported,
8032 : "SetDefaultHistogram() not implemented for this format.");
8033 :
8034 0 : return CE_Failure;
8035 : }
8036 :
8037 : /************************************************************************/
8038 : /* GDALSetDefaultHistogram() */
8039 : /************************************************************************/
8040 :
8041 : /**
8042 : * \brief Set default histogram.
8043 : *
8044 : * Use GDALSetRasterHistogramEx() instead to be able to set counts exceeding
8045 : * 2 billion.
8046 : *
8047 : * @see GDALRasterBand::SetDefaultHistogram()
8048 : * @see GDALSetRasterHistogramEx()
8049 : */
8050 :
8051 0 : CPLErr CPL_STDCALL GDALSetDefaultHistogram(GDALRasterBandH hBand, double dfMin,
8052 : double dfMax, int nBuckets,
8053 : int *panHistogram)
8054 :
8055 : {
8056 0 : VALIDATE_POINTER1(hBand, "GDALSetDefaultHistogram", CE_Failure);
8057 :
8058 0 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
8059 :
8060 : GUIntBig *panHistogramTemp =
8061 0 : static_cast<GUIntBig *>(VSIMalloc2(sizeof(GUIntBig), nBuckets));
8062 0 : if (panHistogramTemp == nullptr)
8063 : {
8064 0 : poBand->ReportError(CE_Failure, CPLE_OutOfMemory,
8065 : "Out of memory in GDALSetDefaultHistogram().");
8066 0 : return CE_Failure;
8067 : }
8068 :
8069 0 : for (int i = 0; i < nBuckets; ++i)
8070 : {
8071 0 : panHistogramTemp[i] = static_cast<GUIntBig>(panHistogram[i]);
8072 : }
8073 :
8074 : const CPLErr eErr =
8075 0 : poBand->SetDefaultHistogram(dfMin, dfMax, nBuckets, panHistogramTemp);
8076 :
8077 0 : CPLFree(panHistogramTemp);
8078 :
8079 0 : return eErr;
8080 : }
8081 :
8082 : /************************************************************************/
8083 : /* GDALSetDefaultHistogramEx() */
8084 : /************************************************************************/
8085 :
8086 : /**
8087 : * \brief Set default histogram.
8088 : *
8089 : * @see GDALRasterBand::SetDefaultHistogram()
8090 : *
8091 : * @since GDAL 2.0
8092 : */
8093 :
8094 5 : CPLErr CPL_STDCALL GDALSetDefaultHistogramEx(GDALRasterBandH hBand,
8095 : double dfMin, double dfMax,
8096 : int nBuckets,
8097 : GUIntBig *panHistogram)
8098 :
8099 : {
8100 5 : VALIDATE_POINTER1(hBand, "GDALSetDefaultHistogramEx", CE_Failure);
8101 :
8102 5 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
8103 5 : return poBand->SetDefaultHistogram(dfMin, dfMax, nBuckets, panHistogram);
8104 : }
8105 :
8106 : /************************************************************************/
8107 : /* GetDefaultRAT() */
8108 : /************************************************************************/
8109 :
8110 : /**
8111 : * \brief Fetch default Raster Attribute Table.
8112 : *
8113 : * A RAT will be returned if there is a default one associated with the
8114 : * band, otherwise NULL is returned. The returned RAT is owned by the
8115 : * band and should not be deleted by the application.
8116 : *
8117 : * This method is the same as the C function GDALGetDefaultRAT().
8118 : *
8119 : * @return NULL, or a pointer to an internal RAT owned by the band.
8120 : */
8121 :
8122 173 : GDALRasterAttributeTable *GDALRasterBand::GetDefaultRAT()
8123 :
8124 : {
8125 173 : return nullptr;
8126 : }
8127 :
8128 : /************************************************************************/
8129 : /* GDALGetDefaultRAT() */
8130 : /************************************************************************/
8131 :
8132 : /**
8133 : * \brief Fetch default Raster Attribute Table.
8134 : *
8135 : * @see GDALRasterBand::GetDefaultRAT()
8136 : */
8137 :
8138 1067 : GDALRasterAttributeTableH CPL_STDCALL GDALGetDefaultRAT(GDALRasterBandH hBand)
8139 :
8140 : {
8141 1067 : VALIDATE_POINTER1(hBand, "GDALGetDefaultRAT", nullptr);
8142 :
8143 1067 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
8144 1067 : return GDALRasterAttributeTable::ToHandle(poBand->GetDefaultRAT());
8145 : }
8146 :
8147 : /************************************************************************/
8148 : /* SetDefaultRAT() */
8149 : /************************************************************************/
8150 :
8151 : /**
8152 : * \fn GDALRasterBand::SetDefaultRAT(const GDALRasterAttributeTable*)
8153 : * \brief Set default Raster Attribute Table.
8154 : *
8155 : * Associates a default RAT with the band. If not implemented for the
8156 : * format a CPLE_NotSupported error will be issued. If successful a copy
8157 : * of the RAT is made, the original remains owned by the caller.
8158 : *
8159 : * This method is the same as the C function GDALSetDefaultRAT().
8160 : *
8161 : * @param poRAT the RAT to assign to the band.
8162 : *
8163 : * @return CE_None on success or CE_Failure if unsupported or otherwise
8164 : * failing.
8165 : */
8166 :
8167 : /**/
8168 : /**/
8169 :
8170 : CPLErr
8171 0 : GDALRasterBand::SetDefaultRAT(const GDALRasterAttributeTable * /* poRAT */)
8172 : {
8173 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
8174 : {
8175 0 : CPLPushErrorHandler(CPLQuietErrorHandler);
8176 0 : ReportError(CE_Failure, CPLE_NotSupported,
8177 : "SetDefaultRAT() not implemented for this format.");
8178 0 : CPLPopErrorHandler();
8179 : }
8180 0 : return CE_Failure;
8181 : }
8182 :
8183 : /************************************************************************/
8184 : /* GDALSetDefaultRAT() */
8185 : /************************************************************************/
8186 :
8187 : /**
8188 : * \brief Set default Raster Attribute Table.
8189 : *
8190 : * @see GDALRasterBand::GDALSetDefaultRAT()
8191 : */
8192 :
8193 18 : CPLErr CPL_STDCALL GDALSetDefaultRAT(GDALRasterBandH hBand,
8194 : GDALRasterAttributeTableH hRAT)
8195 :
8196 : {
8197 18 : VALIDATE_POINTER1(hBand, "GDALSetDefaultRAT", CE_Failure);
8198 :
8199 18 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
8200 :
8201 18 : return poBand->SetDefaultRAT(GDALRasterAttributeTable::FromHandle(hRAT));
8202 : }
8203 :
8204 : /************************************************************************/
8205 : /* GetMaskBand() */
8206 : /************************************************************************/
8207 :
8208 : /**
8209 : * \brief Return the mask band associated with the band.
8210 : *
8211 : * The GDALRasterBand class includes a default implementation of GetMaskBand()
8212 : * that returns one of four default implementations :
8213 : * <ul>
8214 : * <li>If a corresponding .msk file exists it will be used for the mask band.
8215 : * </li>
8216 : * <li>If the dataset has a NODATA_VALUES metadata item, an instance of the new
8217 : * GDALNoDataValuesMaskBand class will be returned. GetMaskFlags() will return
8218 : * GMF_NODATA | GMF_PER_DATASET.
8219 : * </li>
8220 : * <li>If the band has a nodata value set, an instance of the new
8221 : * GDALNodataMaskRasterBand class will be returned. GetMaskFlags() will return
8222 : * GMF_NODATA.
8223 : * </li>
8224 : * <li>If there is no nodata value, but the dataset has an alpha band that seems
8225 : * to apply to this band (specific rules yet to be determined) and that is of
8226 : * type GDT_Byte then that alpha band will be returned, and the flags
8227 : * GMF_PER_DATASET and GMF_ALPHA will be returned in the flags.
8228 : * </li>
8229 : * <li>If neither of the above apply, an instance of the new
8230 : * GDALAllValidRasterBand class will be returned that has 255 values for all
8231 : * pixels. The null flags will return GMF_ALL_VALID.
8232 : * </li>
8233 : * </ul>
8234 : *
8235 : * Note that the GetMaskBand() should always return a GDALRasterBand mask, even
8236 : * if it is only an all 255 mask with the flags indicating GMF_ALL_VALID.
8237 : *
8238 : * For an external .msk file to be recognized by GDAL, it must be a valid GDAL
8239 : * dataset, with the same name as the main dataset and suffixed with .msk,
8240 : * with either one band (in the GMF_PER_DATASET case), or as many bands as the
8241 : * main dataset.
8242 : * It must have INTERNAL_MASK_FLAGS_xx metadata items set at the dataset
8243 : * level, where xx matches the band number of a band of the main dataset. The
8244 : * value of those items is a combination of the flags GMF_ALL_VALID,
8245 : * GMF_PER_DATASET, GMF_ALPHA and GMF_NODATA. If a metadata item is missing for
8246 : * a band, then the other rules explained above will be used to generate a
8247 : * on-the-fly mask band.
8248 : * \see CreateMaskBand() for the characteristics of .msk files created by GDAL.
8249 : *
8250 : * This method is the same as the C function GDALGetMaskBand().
8251 : *
8252 : * @return a valid mask band.
8253 : *
8254 : * @since GDAL 1.5.0
8255 : *
8256 : * @see https://gdal.org/development/rfc/rfc15_nodatabitmask.html
8257 : *
8258 : */
8259 802679 : GDALRasterBand *GDALRasterBand::GetMaskBand()
8260 :
8261 : {
8262 381697 : const auto HasNoData = [this]()
8263 : {
8264 126905 : int bHaveNoDataRaw = FALSE;
8265 126905 : bool bHaveNoData = false;
8266 126905 : if (eDataType == GDT_Int64)
8267 : {
8268 65 : CPL_IGNORE_RET_VAL(GetNoDataValueAsInt64(&bHaveNoDataRaw));
8269 65 : bHaveNoData = CPL_TO_BOOL(bHaveNoDataRaw);
8270 : }
8271 126840 : else if (eDataType == GDT_UInt64)
8272 : {
8273 47 : CPL_IGNORE_RET_VAL(GetNoDataValueAsUInt64(&bHaveNoDataRaw));
8274 47 : bHaveNoData = CPL_TO_BOOL(bHaveNoDataRaw);
8275 : }
8276 : else
8277 : {
8278 126793 : const double dfNoDataValue = GetNoDataValue(&bHaveNoDataRaw);
8279 126681 : if (bHaveNoDataRaw &&
8280 126681 : GDALNoDataMaskBand::IsNoDataInRange(dfNoDataValue, eDataType))
8281 : {
8282 1006 : bHaveNoData = true;
8283 : }
8284 : }
8285 126499 : return bHaveNoData;
8286 802679 : };
8287 :
8288 802679 : if (poMask != nullptr)
8289 : {
8290 705438 : if (poMask.IsOwned())
8291 : {
8292 332377 : if (dynamic_cast<GDALAllValidMaskBand *>(poMask.get()) != nullptr)
8293 : {
8294 32643 : if (HasNoData())
8295 : {
8296 9 : InvalidateMaskBand();
8297 : }
8298 : }
8299 300423 : else if (auto poNoDataMaskBand =
8300 299986 : dynamic_cast<GDALNoDataMaskBand *>(poMask.get()))
8301 : {
8302 346 : int bHaveNoDataRaw = FALSE;
8303 346 : bool bIsSame = false;
8304 346 : if (eDataType == GDT_Int64)
8305 11 : bIsSame = poNoDataMaskBand->m_nNoDataValueInt64 ==
8306 15 : GetNoDataValueAsInt64(&bHaveNoDataRaw) &&
8307 4 : bHaveNoDataRaw;
8308 335 : else if (eDataType == GDT_UInt64)
8309 11 : bIsSame = poNoDataMaskBand->m_nNoDataValueUInt64 ==
8310 15 : GetNoDataValueAsUInt64(&bHaveNoDataRaw) &&
8311 4 : bHaveNoDataRaw;
8312 : else
8313 : {
8314 : const double dfNoDataValue =
8315 324 : GetNoDataValue(&bHaveNoDataRaw);
8316 324 : if (bHaveNoDataRaw)
8317 : {
8318 321 : bIsSame =
8319 321 : std::isnan(dfNoDataValue)
8320 321 : ? std::isnan(poNoDataMaskBand->m_dfNoDataValue)
8321 290 : : poNoDataMaskBand->m_dfNoDataValue ==
8322 : dfNoDataValue;
8323 : }
8324 : }
8325 346 : if (!bIsSame)
8326 23 : InvalidateMaskBand();
8327 : }
8328 : }
8329 :
8330 706323 : if (poMask)
8331 708277 : return poMask.get();
8332 : }
8333 :
8334 : /* -------------------------------------------------------------------- */
8335 : /* Check for a mask in a .msk file. */
8336 : /* -------------------------------------------------------------------- */
8337 94699 : if (poDS != nullptr && poDS->oOvManager.HaveMaskFile())
8338 : {
8339 46 : poMask.resetNotOwned(poDS->oOvManager.GetMaskBand(nBand));
8340 46 : if (poMask != nullptr)
8341 : {
8342 44 : nMaskFlags = poDS->oOvManager.GetMaskFlags(nBand);
8343 44 : return poMask.get();
8344 : }
8345 : }
8346 :
8347 : /* -------------------------------------------------------------------- */
8348 : /* Check for NODATA_VALUES metadata. */
8349 : /* -------------------------------------------------------------------- */
8350 94655 : if (poDS != nullptr)
8351 : {
8352 : const char *pszGDALNoDataValues =
8353 94642 : poDS->GetMetadataItem("NODATA_VALUES");
8354 94642 : if (pszGDALNoDataValues != nullptr)
8355 : {
8356 68 : char **papszGDALNoDataValues = CSLTokenizeStringComplex(
8357 : pszGDALNoDataValues, " ", FALSE, FALSE);
8358 :
8359 : // Make sure we have as many values as bands.
8360 136 : if (CSLCount(papszGDALNoDataValues) == poDS->GetRasterCount() &&
8361 68 : poDS->GetRasterCount() != 0)
8362 : {
8363 : // Make sure that all bands have the same data type
8364 : // This is clearly not a fundamental condition, just a
8365 : // condition to make implementation easier.
8366 68 : GDALDataType eDT = GDT_Unknown;
8367 68 : int i = 0; // Used after for.
8368 270 : for (; i < poDS->GetRasterCount(); ++i)
8369 : {
8370 202 : if (i == 0)
8371 68 : eDT = poDS->GetRasterBand(1)->GetRasterDataType();
8372 134 : else if (eDT !=
8373 134 : poDS->GetRasterBand(i + 1)->GetRasterDataType())
8374 : {
8375 0 : break;
8376 : }
8377 : }
8378 68 : if (i == poDS->GetRasterCount())
8379 : {
8380 68 : nMaskFlags = GMF_NODATA | GMF_PER_DATASET;
8381 : try
8382 : {
8383 68 : poMask.reset(
8384 136 : std::make_unique<GDALNoDataValuesMaskBand>(poDS));
8385 : }
8386 0 : catch (const std::bad_alloc &)
8387 : {
8388 0 : CPLError(CE_Failure, CPLE_OutOfMemory, "Out of memory");
8389 0 : poMask.reset();
8390 : }
8391 68 : CSLDestroy(papszGDALNoDataValues);
8392 68 : return poMask.get();
8393 : }
8394 : else
8395 : {
8396 0 : ReportError(CE_Warning, CPLE_AppDefined,
8397 : "All bands should have the same type in "
8398 : "order the NODATA_VALUES metadata item "
8399 : "to be used as a mask.");
8400 : }
8401 : }
8402 : else
8403 : {
8404 0 : ReportError(
8405 : CE_Warning, CPLE_AppDefined,
8406 : "NODATA_VALUES metadata item doesn't have the same number "
8407 : "of values as the number of bands. "
8408 : "Ignoring it for mask.");
8409 : }
8410 :
8411 0 : CSLDestroy(papszGDALNoDataValues);
8412 : }
8413 : }
8414 :
8415 : /* -------------------------------------------------------------------- */
8416 : /* Check for nodata case. */
8417 : /* -------------------------------------------------------------------- */
8418 94587 : if (HasNoData())
8419 : {
8420 1030 : nMaskFlags = GMF_NODATA;
8421 : try
8422 : {
8423 1030 : poMask.reset(std::make_unique<GDALNoDataMaskBand>(this));
8424 : }
8425 0 : catch (const std::bad_alloc &)
8426 : {
8427 0 : CPLError(CE_Failure, CPLE_OutOfMemory, "Out of memory");
8428 0 : poMask.reset();
8429 : }
8430 1030 : return poMask.get();
8431 : }
8432 :
8433 : /* -------------------------------------------------------------------- */
8434 : /* Check for alpha case. */
8435 : /* -------------------------------------------------------------------- */
8436 93545 : if (poDS != nullptr && poDS->GetRasterCount() == 2 &&
8437 187687 : this == poDS->GetRasterBand(1) &&
8438 586 : poDS->GetRasterBand(2)->GetColorInterpretation() == GCI_AlphaBand)
8439 : {
8440 223 : if (poDS->GetRasterBand(2)->GetRasterDataType() == GDT_Byte)
8441 : {
8442 179 : nMaskFlags = GMF_ALPHA | GMF_PER_DATASET;
8443 179 : poMask.resetNotOwned(poDS->GetRasterBand(2));
8444 179 : return poMask.get();
8445 : }
8446 44 : else if (poDS->GetRasterBand(2)->GetRasterDataType() == GDT_UInt16)
8447 : {
8448 23 : nMaskFlags = GMF_ALPHA | GMF_PER_DATASET;
8449 : try
8450 : {
8451 23 : poMask.reset(std::make_unique<GDALRescaledAlphaBand>(
8452 46 : poDS->GetRasterBand(2)));
8453 : }
8454 0 : catch (const std::bad_alloc &)
8455 : {
8456 0 : CPLError(CE_Failure, CPLE_OutOfMemory, "Out of memory");
8457 0 : poMask.reset();
8458 : }
8459 23 : return poMask.get();
8460 : }
8461 : }
8462 :
8463 93343 : if (poDS != nullptr && poDS->GetRasterCount() == 4 &&
8464 2917 : (this == poDS->GetRasterBand(1) || this == poDS->GetRasterBand(2) ||
8465 187391 : this == poDS->GetRasterBand(3)) &&
8466 2269 : poDS->GetRasterBand(4)->GetColorInterpretation() == GCI_AlphaBand)
8467 : {
8468 1397 : if (poDS->GetRasterBand(4)->GetRasterDataType() == GDT_Byte)
8469 : {
8470 1350 : nMaskFlags = GMF_ALPHA | GMF_PER_DATASET;
8471 1350 : poMask.resetNotOwned(poDS->GetRasterBand(4));
8472 1350 : return poMask.get();
8473 : }
8474 47 : else if (poDS->GetRasterBand(4)->GetRasterDataType() == GDT_UInt16)
8475 : {
8476 35 : nMaskFlags = GMF_ALPHA | GMF_PER_DATASET;
8477 : try
8478 : {
8479 35 : poMask.reset(std::make_unique<GDALRescaledAlphaBand>(
8480 70 : poDS->GetRasterBand(4)));
8481 : }
8482 0 : catch (const std::bad_alloc &)
8483 : {
8484 0 : CPLError(CE_Failure, CPLE_OutOfMemory, "Out of memory");
8485 0 : poMask.reset();
8486 : }
8487 35 : return poMask.get();
8488 : }
8489 : }
8490 :
8491 : /* -------------------------------------------------------------------- */
8492 : /* Fallback to all valid case. */
8493 : /* -------------------------------------------------------------------- */
8494 91969 : nMaskFlags = GMF_ALL_VALID;
8495 : try
8496 : {
8497 91969 : poMask.reset(std::make_unique<GDALAllValidMaskBand>(this));
8498 : }
8499 0 : catch (const std::bad_alloc &)
8500 : {
8501 0 : CPLError(CE_Failure, CPLE_OutOfMemory, "Out of memory");
8502 0 : poMask.reset();
8503 : }
8504 :
8505 91969 : return poMask.get();
8506 : }
8507 :
8508 : /************************************************************************/
8509 : /* GDALGetMaskBand() */
8510 : /************************************************************************/
8511 :
8512 : /**
8513 : * \brief Return the mask band associated with the band.
8514 : *
8515 : * @see GDALRasterBand::GetMaskBand()
8516 : */
8517 :
8518 10994 : GDALRasterBandH CPL_STDCALL GDALGetMaskBand(GDALRasterBandH hBand)
8519 :
8520 : {
8521 10994 : VALIDATE_POINTER1(hBand, "GDALGetMaskBand", nullptr);
8522 :
8523 10994 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
8524 10994 : return poBand->GetMaskBand();
8525 : }
8526 :
8527 : /************************************************************************/
8528 : /* GetMaskFlags() */
8529 : /************************************************************************/
8530 :
8531 : /**
8532 : * \brief Return the status flags of the mask band associated with the band.
8533 : *
8534 : * The GetMaskFlags() method returns an bitwise OR-ed set of status flags with
8535 : * the following available definitions that may be extended in the future:
8536 : * <ul>
8537 : * <li>GMF_ALL_VALID(0x01): There are no invalid pixels, all mask values will be
8538 : * 255. When used this will normally be the only flag set.
8539 : * </li>
8540 : * <li>GMF_PER_DATASET(0x02): The mask band is shared between all bands on the
8541 : * dataset.
8542 : * </li>
8543 : * <li>GMF_ALPHA(0x04): The mask band is actually an alpha band
8544 : * and may have values other than 0 and 255.
8545 : * </li>
8546 : * <li>GMF_NODATA(0x08): Indicates the mask is actually being generated from
8547 : * nodata values. (mutually exclusive of GMF_ALPHA)
8548 : * </li>
8549 : * </ul>
8550 : *
8551 : * The GDALRasterBand class includes a default implementation of GetMaskBand()
8552 : * that returns one of four default implementations:
8553 : * <ul>
8554 : * <li>If a corresponding .msk file exists it will be used for the mask band.
8555 : * </li>
8556 : * <li>If the dataset has a NODATA_VALUES metadata item, an instance of the new
8557 : * GDALNoDataValuesMaskBand class will be returned. GetMaskFlags() will return
8558 : * GMF_NODATA | GMF_PER_DATASET.
8559 : * </li>
8560 : * <li>If the band has a nodata value set, an instance of the new
8561 : * GDALNodataMaskRasterBand class will be returned. GetMaskFlags() will return
8562 : * GMF_NODATA.
8563 : * </li>
8564 : * <li>If there is no nodata value, but the dataset has an alpha band that
8565 : * seems to apply to this band (specific rules yet to be determined) and that is
8566 : * of type GDT_Byte then that alpha band will be returned, and the flags
8567 : * GMF_PER_DATASET and GMF_ALPHA will be returned in the flags.
8568 : * </li>
8569 : * <li>If neither of the above apply, an instance of the new
8570 : * GDALAllValidRasterBand class will be returned that has 255 values for all
8571 : * pixels. The null flags will return GMF_ALL_VALID.
8572 : * </li>
8573 : * </ul>
8574 : *
8575 : * For an external .msk file to be recognized by GDAL, it must be a valid GDAL
8576 : * dataset, with the same name as the main dataset and suffixed with .msk,
8577 : * with either one band (in the GMF_PER_DATASET case), or as many bands as the
8578 : * main dataset.
8579 : * It must have INTERNAL_MASK_FLAGS_xx metadata items set at the dataset
8580 : * level, where xx matches the band number of a band of the main dataset. The
8581 : * value of those items is a combination of the flags GMF_ALL_VALID,
8582 : * GMF_PER_DATASET, GMF_ALPHA and GMF_NODATA. If a metadata item is missing for
8583 : * a band, then the other rules explained above will be used to generate a
8584 : * on-the-fly mask band.
8585 : * \see CreateMaskBand() for the characteristics of .msk files created by GDAL.
8586 : *
8587 : * This method is the same as the C function GDALGetMaskFlags().
8588 : *
8589 : * @since GDAL 1.5.0
8590 : *
8591 : * @return a valid mask band.
8592 : *
8593 : * @see https://gdal.org/development/rfc/rfc15_nodatabitmask.html
8594 : *
8595 : */
8596 149564 : int GDALRasterBand::GetMaskFlags()
8597 :
8598 : {
8599 : // If we don't have a band yet, force this now so that the masks value
8600 : // will be initialized.
8601 :
8602 149564 : if (poMask == nullptr)
8603 93407 : GetMaskBand();
8604 :
8605 149558 : return nMaskFlags;
8606 : }
8607 :
8608 : /************************************************************************/
8609 : /* GDALGetMaskFlags() */
8610 : /************************************************************************/
8611 :
8612 : /**
8613 : * \brief Return the status flags of the mask band associated with the band.
8614 : *
8615 : * @see GDALRasterBand::GetMaskFlags()
8616 : */
8617 :
8618 6798 : int CPL_STDCALL GDALGetMaskFlags(GDALRasterBandH hBand)
8619 :
8620 : {
8621 6798 : VALIDATE_POINTER1(hBand, "GDALGetMaskFlags", GMF_ALL_VALID);
8622 :
8623 6798 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
8624 6798 : return poBand->GetMaskFlags();
8625 : }
8626 :
8627 : /************************************************************************/
8628 : /* InvalidateMaskBand() */
8629 : /************************************************************************/
8630 :
8631 : //! @cond Doxygen_Suppress
8632 1910140 : void GDALRasterBand::InvalidateMaskBand()
8633 : {
8634 1910140 : poMask.reset();
8635 1910110 : nMaskFlags = 0;
8636 1910110 : }
8637 :
8638 : //! @endcond
8639 :
8640 : /************************************************************************/
8641 : /* CreateMaskBand() */
8642 : /************************************************************************/
8643 :
8644 : /**
8645 : * \brief Adds a mask band to the current band
8646 : *
8647 : * The default implementation of the CreateMaskBand() method is implemented
8648 : * based on similar rules to the .ovr handling implemented using the
8649 : * GDALDefaultOverviews object. A TIFF file with the extension .msk will
8650 : * be created with the same basename as the original file, and it will have
8651 : * as many bands as the original image (or just one for GMF_PER_DATASET).
8652 : * The mask images will be deflate compressed tiled images with the same
8653 : * block size as the original image if possible.
8654 : * It will have INTERNAL_MASK_FLAGS_xx metadata items set at the dataset
8655 : * level, where xx matches the band number of a band of the main dataset. The
8656 : * value of those items will be the one of the nFlagsIn parameter.
8657 : *
8658 : * Note that if you got a mask band with a previous call to GetMaskBand(),
8659 : * it might be invalidated by CreateMaskBand(). So you have to call
8660 : * GetMaskBand() again.
8661 : *
8662 : * This method is the same as the C function GDALCreateMaskBand().
8663 : *
8664 : * @since GDAL 1.5.0
8665 : *
8666 : * @param nFlagsIn 0 or combination of GMF_PER_DATASET / GMF_ALPHA.
8667 : *
8668 : * @return CE_None on success or CE_Failure on an error.
8669 : *
8670 : * @see https://gdal.org/development/rfc/rfc15_nodatabitmask.html
8671 : * @see GDALDataset::CreateMaskBand()
8672 : *
8673 : */
8674 :
8675 9 : CPLErr GDALRasterBand::CreateMaskBand(int nFlagsIn)
8676 :
8677 : {
8678 9 : if (poDS != nullptr && poDS->oOvManager.IsInitialized())
8679 : {
8680 9 : const CPLErr eErr = poDS->oOvManager.CreateMaskBand(nFlagsIn, nBand);
8681 9 : if (eErr != CE_None)
8682 1 : return eErr;
8683 :
8684 8 : InvalidateMaskBand();
8685 :
8686 8 : return CE_None;
8687 : }
8688 :
8689 0 : ReportError(CE_Failure, CPLE_NotSupported,
8690 : "CreateMaskBand() not supported for this band.");
8691 :
8692 0 : return CE_Failure;
8693 : }
8694 :
8695 : /************************************************************************/
8696 : /* GDALCreateMaskBand() */
8697 : /************************************************************************/
8698 :
8699 : /**
8700 : * \brief Adds a mask band to the current band
8701 : *
8702 : * @see GDALRasterBand::CreateMaskBand()
8703 : */
8704 :
8705 33 : CPLErr CPL_STDCALL GDALCreateMaskBand(GDALRasterBandH hBand, int nFlags)
8706 :
8707 : {
8708 33 : VALIDATE_POINTER1(hBand, "GDALCreateMaskBand", CE_Failure);
8709 :
8710 33 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
8711 33 : return poBand->CreateMaskBand(nFlags);
8712 : }
8713 :
8714 : /************************************************************************/
8715 : /* IsMaskBand() */
8716 : /************************************************************************/
8717 :
8718 : /**
8719 : * \brief Returns whether a band is a mask band.
8720 : *
8721 : * Mask band must be understood in the broad term: it can be a per-dataset
8722 : * mask band, an alpha band, or an implicit mask band.
8723 : * Typically the return of GetMaskBand()->IsMaskBand() should be true.
8724 : *
8725 : * This method is the same as the C function GDALIsMaskBand().
8726 : *
8727 : * @return true if the band is a mask band.
8728 : *
8729 : * @see GDALDataset::CreateMaskBand()
8730 : *
8731 : * @since GDAL 3.5.0
8732 : *
8733 : */
8734 :
8735 439 : bool GDALRasterBand::IsMaskBand() const
8736 : {
8737 : // The GeoTIFF driver, among others, override this method to
8738 : // also handle external .msk bands.
8739 439 : return const_cast<GDALRasterBand *>(this)->GetColorInterpretation() ==
8740 439 : GCI_AlphaBand;
8741 : }
8742 :
8743 : /************************************************************************/
8744 : /* GDALIsMaskBand() */
8745 : /************************************************************************/
8746 :
8747 : /**
8748 : * \brief Returns whether a band is a mask band.
8749 : *
8750 : * Mask band must be understood in the broad term: it can be a per-dataset
8751 : * mask band, an alpha band, or an implicit mask band.
8752 : * Typically the return of GetMaskBand()->IsMaskBand() should be true.
8753 : *
8754 : * This function is the same as the C++ method GDALRasterBand::IsMaskBand()
8755 : *
8756 : * @return true if the band is a mask band.
8757 : *
8758 : * @see GDALRasterBand::IsMaskBand()
8759 : *
8760 : * @since GDAL 3.5.0
8761 : *
8762 : */
8763 :
8764 37 : bool GDALIsMaskBand(GDALRasterBandH hBand)
8765 :
8766 : {
8767 37 : VALIDATE_POINTER1(hBand, "GDALIsMaskBand", false);
8768 :
8769 37 : const GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
8770 37 : return poBand->IsMaskBand();
8771 : }
8772 :
8773 : /************************************************************************/
8774 : /* GetMaskValueRange() */
8775 : /************************************************************************/
8776 :
8777 : /**
8778 : * \brief Returns the range of values that a mask band can take.
8779 : *
8780 : * @return the range of values that a mask band can take.
8781 : *
8782 : * @since GDAL 3.5.0
8783 : *
8784 : */
8785 :
8786 0 : GDALMaskValueRange GDALRasterBand::GetMaskValueRange() const
8787 : {
8788 0 : return GMVR_UNKNOWN;
8789 : }
8790 :
8791 : /************************************************************************/
8792 : /* GetIndexColorTranslationTo() */
8793 : /************************************************************************/
8794 :
8795 : /**
8796 : * \brief Compute translation table for color tables.
8797 : *
8798 : * When the raster band has a palette index, it may be useful to compute
8799 : * the "translation" of this palette to the palette of another band.
8800 : * The translation tries to do exact matching first, and then approximate
8801 : * matching if no exact matching is possible.
8802 : * This method returns a table such that table[i] = j where i is an index
8803 : * of the 'this' rasterband and j the corresponding index for the reference
8804 : * rasterband.
8805 : *
8806 : * This method is thought as internal to GDAL and is used for drivers
8807 : * like RPFTOC.
8808 : *
8809 : * The implementation only supports 1-byte palette rasterbands.
8810 : *
8811 : * @param poReferenceBand the raster band
8812 : * @param pTranslationTable an already allocated translation table (at least 256
8813 : * bytes), or NULL to let the method allocate it
8814 : * @param pApproximateMatching a pointer to a flag that is set if the matching
8815 : * is approximate. May be NULL.
8816 : *
8817 : * @return a translation table if the two bands are palette index and that they
8818 : * do not match or NULL in other cases. The table must be freed with CPLFree if
8819 : * NULL was passed for pTranslationTable.
8820 : */
8821 :
8822 : unsigned char *
8823 4 : GDALRasterBand::GetIndexColorTranslationTo(GDALRasterBand *poReferenceBand,
8824 : unsigned char *pTranslationTable,
8825 : int *pApproximateMatching)
8826 : {
8827 4 : if (poReferenceBand == nullptr)
8828 0 : return nullptr;
8829 :
8830 : // cppcheck-suppress knownConditionTrueFalse
8831 4 : if (poReferenceBand->GetColorInterpretation() == GCI_PaletteIndex &&
8832 : // cppcheck-suppress knownConditionTrueFalse
8833 4 : GetColorInterpretation() == GCI_PaletteIndex &&
8834 12 : poReferenceBand->GetRasterDataType() == GDT_Byte &&
8835 4 : GetRasterDataType() == GDT_Byte)
8836 : {
8837 4 : const GDALColorTable *srcColorTable = GetColorTable();
8838 4 : GDALColorTable *destColorTable = poReferenceBand->GetColorTable();
8839 4 : if (srcColorTable != nullptr && destColorTable != nullptr)
8840 : {
8841 4 : const int nEntries = srcColorTable->GetColorEntryCount();
8842 4 : const int nRefEntries = destColorTable->GetColorEntryCount();
8843 :
8844 4 : int bHasNoDataValueSrc = FALSE;
8845 4 : double dfNoDataValueSrc = GetNoDataValue(&bHasNoDataValueSrc);
8846 4 : if (!(bHasNoDataValueSrc && dfNoDataValueSrc >= 0 &&
8847 4 : dfNoDataValueSrc <= 255 &&
8848 4 : dfNoDataValueSrc == static_cast<int>(dfNoDataValueSrc)))
8849 0 : bHasNoDataValueSrc = FALSE;
8850 4 : const int noDataValueSrc =
8851 4 : bHasNoDataValueSrc ? static_cast<int>(dfNoDataValueSrc) : 0;
8852 :
8853 4 : int bHasNoDataValueRef = FALSE;
8854 : const double dfNoDataValueRef =
8855 4 : poReferenceBand->GetNoDataValue(&bHasNoDataValueRef);
8856 4 : if (!(bHasNoDataValueRef && dfNoDataValueRef >= 0 &&
8857 3 : dfNoDataValueRef <= 255 &&
8858 3 : dfNoDataValueRef == static_cast<int>(dfNoDataValueRef)))
8859 1 : bHasNoDataValueRef = FALSE;
8860 4 : const int noDataValueRef =
8861 4 : bHasNoDataValueRef ? static_cast<int>(dfNoDataValueRef) : 0;
8862 :
8863 4 : bool samePalette = false;
8864 :
8865 4 : if (pApproximateMatching)
8866 3 : *pApproximateMatching = FALSE;
8867 :
8868 4 : if (nEntries == nRefEntries &&
8869 3 : bHasNoDataValueSrc == bHasNoDataValueRef &&
8870 3 : (bHasNoDataValueSrc == FALSE ||
8871 : noDataValueSrc == noDataValueRef))
8872 : {
8873 3 : samePalette = true;
8874 654 : for (int i = 0; i < nEntries; ++i)
8875 : {
8876 651 : if (noDataValueSrc == i)
8877 3 : continue;
8878 : const GDALColorEntry *entry =
8879 648 : srcColorTable->GetColorEntry(i);
8880 : const GDALColorEntry *entryRef =
8881 648 : destColorTable->GetColorEntry(i);
8882 648 : if (entry->c1 != entryRef->c1 ||
8883 648 : entry->c2 != entryRef->c2 || entry->c3 != entryRef->c3)
8884 : {
8885 0 : samePalette = false;
8886 : }
8887 : }
8888 : }
8889 :
8890 4 : if (!samePalette)
8891 : {
8892 1 : if (pTranslationTable == nullptr)
8893 : {
8894 : pTranslationTable = static_cast<unsigned char *>(
8895 1 : VSI_CALLOC_VERBOSE(1, std::max(256, nEntries)));
8896 1 : if (pTranslationTable == nullptr)
8897 1 : return nullptr;
8898 : }
8899 :
8900 : // Trying to remap the product palette on the subdataset
8901 : // palette.
8902 5 : for (int i = 0; i < nEntries; ++i)
8903 : {
8904 4 : if (bHasNoDataValueSrc && bHasNoDataValueRef &&
8905 : noDataValueSrc == i)
8906 0 : continue;
8907 : const GDALColorEntry *entry =
8908 4 : srcColorTable->GetColorEntry(i);
8909 4 : bool bMatchFound = false;
8910 13 : for (int j = 0; j < nRefEntries; ++j)
8911 : {
8912 10 : if (bHasNoDataValueRef && noDataValueRef == j)
8913 0 : continue;
8914 : const GDALColorEntry *entryRef =
8915 10 : destColorTable->GetColorEntry(j);
8916 10 : if (entry->c1 == entryRef->c1 &&
8917 2 : entry->c2 == entryRef->c2 &&
8918 2 : entry->c3 == entryRef->c3)
8919 : {
8920 1 : pTranslationTable[i] =
8921 : static_cast<unsigned char>(j);
8922 1 : bMatchFound = true;
8923 1 : break;
8924 : }
8925 : }
8926 4 : if (!bMatchFound)
8927 : {
8928 : // No exact match. Looking for closest color now.
8929 3 : int best_j = 0;
8930 3 : int best_distance = 0;
8931 3 : if (pApproximateMatching)
8932 0 : *pApproximateMatching = TRUE;
8933 12 : for (int j = 0; j < nRefEntries; ++j)
8934 : {
8935 : const GDALColorEntry *entryRef =
8936 9 : destColorTable->GetColorEntry(j);
8937 9 : int distance = (entry->c1 - entryRef->c1) *
8938 9 : (entry->c1 - entryRef->c1) +
8939 9 : (entry->c2 - entryRef->c2) *
8940 9 : (entry->c2 - entryRef->c2) +
8941 9 : (entry->c3 - entryRef->c3) *
8942 9 : (entry->c3 - entryRef->c3);
8943 9 : if (j == 0 || distance < best_distance)
8944 : {
8945 7 : best_j = j;
8946 7 : best_distance = distance;
8947 : }
8948 : }
8949 3 : pTranslationTable[i] =
8950 : static_cast<unsigned char>(best_j);
8951 : }
8952 : }
8953 1 : if (bHasNoDataValueRef && bHasNoDataValueSrc)
8954 0 : pTranslationTable[noDataValueSrc] =
8955 : static_cast<unsigned char>(noDataValueRef);
8956 :
8957 1 : return pTranslationTable;
8958 : }
8959 : }
8960 : }
8961 3 : return nullptr;
8962 : }
8963 :
8964 : /************************************************************************/
8965 : /* SetFlushBlockErr() */
8966 : /************************************************************************/
8967 :
8968 : /**
8969 : * \brief Store that an error occurred while writing a dirty block.
8970 : *
8971 : * This function stores the fact that an error occurred while writing a dirty
8972 : * block from GDALRasterBlock::FlushCacheBlock(). Indeed when dirty blocks are
8973 : * flushed when the block cache get full, it is not convenient/possible to
8974 : * report that a dirty block could not be written correctly. This function
8975 : * remembers the error and re-issue it from GDALRasterBand::FlushCache(),
8976 : * GDALRasterBand::WriteBlock() and GDALRasterBand::RasterIO(), which are
8977 : * places where the user can easily match the error with the relevant dataset.
8978 : */
8979 :
8980 0 : void GDALRasterBand::SetFlushBlockErr(CPLErr eErr)
8981 : {
8982 0 : eFlushBlockErr = eErr;
8983 0 : }
8984 :
8985 : /************************************************************************/
8986 : /* IncDirtyBlocks() */
8987 : /************************************************************************/
8988 :
8989 : /**
8990 : * \brief Increment/decrement the number of dirty blocks
8991 : */
8992 :
8993 750036 : void GDALRasterBand::IncDirtyBlocks(int nInc)
8994 : {
8995 750036 : if (poBandBlockCache)
8996 750035 : poBandBlockCache->IncDirtyBlocks(nInc);
8997 750040 : }
8998 :
8999 : /************************************************************************/
9000 : /* ReportError() */
9001 : /************************************************************************/
9002 :
9003 : #ifndef DOXYGEN_XML
9004 : /**
9005 : * \brief Emits an error related to a raster band.
9006 : *
9007 : * This function is a wrapper for regular CPLError(). The only difference
9008 : * with CPLError() is that it prepends the error message with the dataset
9009 : * name and the band number.
9010 : *
9011 : * @param eErrClass one of CE_Warning, CE_Failure or CE_Fatal.
9012 : * @param err_no the error number (CPLE_*) from cpl_error.h.
9013 : * @param fmt a printf() style format string. Any additional arguments
9014 : * will be treated as arguments to fill in this format in a manner
9015 : * similar to printf().
9016 : *
9017 : * @since GDAL 1.9.0
9018 : */
9019 :
9020 2470 : void GDALRasterBand::ReportError(CPLErr eErrClass, CPLErrorNum err_no,
9021 : const char *fmt, ...) const
9022 : {
9023 : va_list args;
9024 :
9025 2470 : va_start(args, fmt);
9026 :
9027 2470 : const char *pszDSName = poDS ? poDS->GetDescription() : "";
9028 2470 : pszDSName = CPLGetFilename(pszDSName);
9029 2470 : if (pszDSName[0] != '\0')
9030 : {
9031 2402 : CPLError(eErrClass, err_no, "%s",
9032 4804 : CPLString()
9033 2402 : .Printf("%s, band %d: ", pszDSName, GetBand())
9034 4804 : .append(CPLString().vPrintf(fmt, args))
9035 : .c_str());
9036 : }
9037 : else
9038 : {
9039 68 : CPLErrorV(eErrClass, err_no, fmt, args);
9040 : }
9041 :
9042 2470 : va_end(args);
9043 2470 : }
9044 : #endif
9045 :
9046 : /************************************************************************/
9047 : /* GetVirtualMemAuto() */
9048 : /************************************************************************/
9049 :
9050 : /** \brief Create a CPLVirtualMem object from a GDAL raster band object.
9051 : *
9052 : * Only supported on Linux and Unix systems with mmap() for now.
9053 : *
9054 : * This method allows creating a virtual memory object for a GDALRasterBand,
9055 : * that exposes the whole image data as a virtual array.
9056 : *
9057 : * The default implementation relies on GDALRasterBandGetVirtualMem(), but
9058 : * specialized implementation, such as for raw files, may also directly use
9059 : * mechanisms of the operating system to create a view of the underlying file
9060 : * into virtual memory ( CPLVirtualMemFileMapNew() )
9061 : *
9062 : * At the time of writing, the GeoTIFF driver and "raw" drivers (EHdr, ...)
9063 : * offer a specialized implementation with direct file mapping, provided that
9064 : * some requirements are met :
9065 : * - for all drivers, the dataset must be backed by a "real" file in the file
9066 : * system, and the byte ordering of multi-byte datatypes (Int16, etc.)
9067 : * must match the native ordering of the CPU.
9068 : * - in addition, for the GeoTIFF driver, the GeoTIFF file must be
9069 : * uncompressed, scanline oriented (i.e. not tiled). Strips must be organized in
9070 : * the file in sequential order, and be equally spaced (which is generally the
9071 : * case). Only power-of-two bit depths are supported (8 for GDT_Bye, 16 for
9072 : * GDT_Int16/GDT_UInt16/GDT_Float16, 32 for GDT_Float32 and 64 for GDT_Float64)
9073 : *
9074 : * The pointer returned remains valid until CPLVirtualMemFree() is called.
9075 : * CPLVirtualMemFree() must be called before the raster band object is
9076 : * destroyed.
9077 : *
9078 : * If p is such a pointer and base_type the type matching
9079 : * GDALGetRasterDataType(), the element of image coordinates (x, y) can be
9080 : * accessed with
9081 : * *(base_type*) ((GByte*)p + x * *pnPixelSpace + y * *pnLineSpace)
9082 : *
9083 : * This method is the same as the C GDALGetVirtualMemAuto() function.
9084 : *
9085 : * @param eRWFlag Either GF_Read to read the band, or GF_Write to
9086 : * read/write the band.
9087 : *
9088 : * @param pnPixelSpace Output parameter giving the byte offset from the start of
9089 : * one pixel value in the buffer to the start of the next pixel value within a
9090 : * scanline.
9091 : *
9092 : * @param pnLineSpace Output parameter giving the byte offset from the start of
9093 : * one scanline in the buffer to the start of the next.
9094 : *
9095 : * @param papszOptions NULL terminated list of options.
9096 : * If a specialized implementation exists, defining
9097 : * USE_DEFAULT_IMPLEMENTATION=YES will cause the default implementation to be
9098 : * used. On the contrary, starting with GDAL 2.2, defining
9099 : * USE_DEFAULT_IMPLEMENTATION=NO will prevent the default implementation from
9100 : * being used (thus only allowing efficient implementations to be used). When
9101 : * requiring or falling back to the default implementation, the following
9102 : * options are available : CACHE_SIZE (in bytes, defaults to
9103 : * 40 MB), PAGE_SIZE_HINT (in bytes), SINGLE_THREAD ("FALSE" / "TRUE", defaults
9104 : * to FALSE)
9105 : *
9106 : * @return a virtual memory object that must be unreferenced by
9107 : * CPLVirtualMemFree(), or NULL in case of failure.
9108 : *
9109 : * @since GDAL 1.11
9110 : */
9111 :
9112 9 : CPLVirtualMem *GDALRasterBand::GetVirtualMemAuto(GDALRWFlag eRWFlag,
9113 : int *pnPixelSpace,
9114 : GIntBig *pnLineSpace,
9115 : char **papszOptions)
9116 : {
9117 9 : const char *pszImpl = CSLFetchNameValueDef(
9118 : papszOptions, "USE_DEFAULT_IMPLEMENTATION", "AUTO");
9119 9 : if (EQUAL(pszImpl, "NO") || EQUAL(pszImpl, "OFF") || EQUAL(pszImpl, "0") ||
9120 8 : EQUAL(pszImpl, "FALSE"))
9121 : {
9122 1 : return nullptr;
9123 : }
9124 :
9125 8 : const int nPixelSpace = GDALGetDataTypeSizeBytes(eDataType);
9126 8 : const GIntBig nLineSpace = static_cast<GIntBig>(nRasterXSize) * nPixelSpace;
9127 8 : if (pnPixelSpace)
9128 8 : *pnPixelSpace = nPixelSpace;
9129 8 : if (pnLineSpace)
9130 8 : *pnLineSpace = nLineSpace;
9131 : const size_t nCacheSize =
9132 8 : atoi(CSLFetchNameValueDef(papszOptions, "CACHE_SIZE", "40000000"));
9133 : const size_t nPageSizeHint =
9134 8 : atoi(CSLFetchNameValueDef(papszOptions, "PAGE_SIZE_HINT", "0"));
9135 8 : const bool bSingleThreadUsage = CPLTestBool(
9136 : CSLFetchNameValueDef(papszOptions, "SINGLE_THREAD", "FALSE"));
9137 8 : return GDALRasterBandGetVirtualMem(
9138 : GDALRasterBand::ToHandle(this), eRWFlag, 0, 0, nRasterXSize,
9139 : nRasterYSize, nRasterXSize, nRasterYSize, eDataType, nPixelSpace,
9140 : nLineSpace, nCacheSize, nPageSizeHint, bSingleThreadUsage,
9141 8 : papszOptions);
9142 : }
9143 :
9144 : /************************************************************************/
9145 : /* GDALGetVirtualMemAuto() */
9146 : /************************************************************************/
9147 :
9148 : /**
9149 : * \brief Create a CPLVirtualMem object from a GDAL raster band object.
9150 : *
9151 : * @see GDALRasterBand::GetVirtualMemAuto()
9152 : */
9153 :
9154 31 : CPLVirtualMem *GDALGetVirtualMemAuto(GDALRasterBandH hBand, GDALRWFlag eRWFlag,
9155 : int *pnPixelSpace, GIntBig *pnLineSpace,
9156 : CSLConstList papszOptions)
9157 : {
9158 31 : VALIDATE_POINTER1(hBand, "GDALGetVirtualMemAuto", nullptr);
9159 :
9160 31 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
9161 :
9162 31 : return poBand->GetVirtualMemAuto(eRWFlag, pnPixelSpace, pnLineSpace,
9163 31 : const_cast<char **>(papszOptions));
9164 : }
9165 :
9166 : /************************************************************************/
9167 : /* GDALGetDataCoverageStatus() */
9168 : /************************************************************************/
9169 :
9170 : /**
9171 : * \brief Get the coverage status of a sub-window of the raster.
9172 : *
9173 : * Returns whether a sub-window of the raster contains only data, only empty
9174 : * blocks or a mix of both. This function can be used to determine quickly
9175 : * if it is worth issuing RasterIO / ReadBlock requests in datasets that may
9176 : * be sparse.
9177 : *
9178 : * Empty blocks are blocks that are generally not physically present in the
9179 : * file, and when read through GDAL, contain only pixels whose value is the
9180 : * nodata value when it is set, or whose value is 0 when the nodata value is
9181 : * not set.
9182 : *
9183 : * The query is done in an efficient way without reading the actual pixel
9184 : * values. If not possible, or not implemented at all by the driver,
9185 : * GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED | GDAL_DATA_COVERAGE_STATUS_DATA will
9186 : * be returned.
9187 : *
9188 : * The values that can be returned by the function are the following,
9189 : * potentially combined with the binary or operator :
9190 : * <ul>
9191 : * <li>GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED : the driver does not implement
9192 : * GetDataCoverageStatus(). This flag should be returned together with
9193 : * GDAL_DATA_COVERAGE_STATUS_DATA.</li>
9194 : * <li>GDAL_DATA_COVERAGE_STATUS_DATA: There is (potentially) data in the
9195 : * queried window.</li> <li>GDAL_DATA_COVERAGE_STATUS_EMPTY: There is nodata in
9196 : * the queried window. This is typically identified by the concept of missing
9197 : * block in formats that supports it.
9198 : * </li>
9199 : * </ul>
9200 : *
9201 : * Note that GDAL_DATA_COVERAGE_STATUS_DATA might have false positives and
9202 : * should be interpreted more as hint of potential presence of data. For example
9203 : * if a GeoTIFF file is created with blocks filled with zeroes (or set to the
9204 : * nodata value), instead of using the missing block mechanism,
9205 : * GDAL_DATA_COVERAGE_STATUS_DATA will be returned. On the contrary,
9206 : * GDAL_DATA_COVERAGE_STATUS_EMPTY should have no false positives.
9207 : *
9208 : * The nMaskFlagStop should be generally set to 0. It can be set to a
9209 : * binary-or'ed mask of the above mentioned values to enable a quick exiting of
9210 : * the function as soon as the computed mask matches the nMaskFlagStop. For
9211 : * example, you can issue a request on the whole raster with nMaskFlagStop =
9212 : * GDAL_DATA_COVERAGE_STATUS_EMPTY. As soon as one missing block is encountered,
9213 : * the function will exit, so that you can potentially refine the requested area
9214 : * to find which particular region(s) have missing blocks.
9215 : *
9216 : * @see GDALRasterBand::GetDataCoverageStatus()
9217 : *
9218 : * @param hBand raster band
9219 : *
9220 : * @param nXOff The pixel offset to the top left corner of the region
9221 : * of the band to be queried. This would be zero to start from the left side.
9222 : *
9223 : * @param nYOff The line offset to the top left corner of the region
9224 : * of the band to be queried. This would be zero to start from the top.
9225 : *
9226 : * @param nXSize The width of the region of the band to be queried in pixels.
9227 : *
9228 : * @param nYSize The height of the region of the band to be queried in lines.
9229 : *
9230 : * @param nMaskFlagStop 0, or a binary-or'ed mask of possible values
9231 : * GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED,
9232 : * GDAL_DATA_COVERAGE_STATUS_DATA and GDAL_DATA_COVERAGE_STATUS_EMPTY. As soon
9233 : * as the computation of the coverage matches the mask, the computation will be
9234 : * stopped. *pdfDataPct will not be valid in that case.
9235 : *
9236 : * @param pdfDataPct Optional output parameter whose pointed value will be set
9237 : * to the (approximate) percentage in [0,100] of pixels in the queried
9238 : * sub-window that have valid values. The implementation might not always be
9239 : * able to compute it, in which case it will be set to a negative value.
9240 : *
9241 : * @return a binary-or'ed combination of possible values
9242 : * GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED,
9243 : * GDAL_DATA_COVERAGE_STATUS_DATA and GDAL_DATA_COVERAGE_STATUS_EMPTY
9244 : *
9245 : * @note Added in GDAL 2.2
9246 : */
9247 :
9248 26 : int CPL_STDCALL GDALGetDataCoverageStatus(GDALRasterBandH hBand, int nXOff,
9249 : int nYOff, int nXSize, int nYSize,
9250 : int nMaskFlagStop, double *pdfDataPct)
9251 : {
9252 26 : VALIDATE_POINTER1(hBand, "GDALGetDataCoverageStatus",
9253 : GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED);
9254 :
9255 26 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
9256 :
9257 26 : return poBand->GetDataCoverageStatus(nXOff, nYOff, nXSize, nYSize,
9258 26 : nMaskFlagStop, pdfDataPct);
9259 : }
9260 :
9261 : /************************************************************************/
9262 : /* GetDataCoverageStatus() */
9263 : /************************************************************************/
9264 :
9265 : /**
9266 : * \fn GDALRasterBand::IGetDataCoverageStatus( int nXOff,
9267 : * int nYOff,
9268 : * int nXSize,
9269 : * int nYSize,
9270 : * int nMaskFlagStop,
9271 : * double* pdfDataPct)
9272 : * \brief Get the coverage status of a sub-window of the raster.
9273 : *
9274 : * Returns whether a sub-window of the raster contains only data, only empty
9275 : * blocks or a mix of both. This function can be used to determine quickly
9276 : * if it is worth issuing RasterIO / ReadBlock requests in datasets that may
9277 : * be sparse.
9278 : *
9279 : * Empty blocks are blocks that contain only pixels whose value is the nodata
9280 : * value when it is set, or whose value is 0 when the nodata value is not set.
9281 : *
9282 : * The query is done in an efficient way without reading the actual pixel
9283 : * values. If not possible, or not implemented at all by the driver,
9284 : * GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED | GDAL_DATA_COVERAGE_STATUS_DATA will
9285 : * be returned.
9286 : *
9287 : * The values that can be returned by the function are the following,
9288 : * potentially combined with the binary or operator :
9289 : * <ul>
9290 : * <li>GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED : the driver does not implement
9291 : * GetDataCoverageStatus(). This flag should be returned together with
9292 : * GDAL_DATA_COVERAGE_STATUS_DATA.</li>
9293 : * <li>GDAL_DATA_COVERAGE_STATUS_DATA: There is (potentially) data in the
9294 : * queried window.</li> <li>GDAL_DATA_COVERAGE_STATUS_EMPTY: There is nodata in
9295 : * the queried window. This is typically identified by the concept of missing
9296 : * block in formats that supports it.
9297 : * </li>
9298 : * </ul>
9299 : *
9300 : * Note that GDAL_DATA_COVERAGE_STATUS_DATA might have false positives and
9301 : * should be interpreted more as hint of potential presence of data. For example
9302 : * if a GeoTIFF file is created with blocks filled with zeroes (or set to the
9303 : * nodata value), instead of using the missing block mechanism,
9304 : * GDAL_DATA_COVERAGE_STATUS_DATA will be returned. On the contrary,
9305 : * GDAL_DATA_COVERAGE_STATUS_EMPTY should have no false positives.
9306 : *
9307 : * The nMaskFlagStop should be generally set to 0. It can be set to a
9308 : * binary-or'ed mask of the above mentioned values to enable a quick exiting of
9309 : * the function as soon as the computed mask matches the nMaskFlagStop. For
9310 : * example, you can issue a request on the whole raster with nMaskFlagStop =
9311 : * GDAL_DATA_COVERAGE_STATUS_EMPTY. As soon as one missing block is encountered,
9312 : * the function will exit, so that you can potentially refine the requested area
9313 : * to find which particular region(s) have missing blocks.
9314 : *
9315 : * @see GDALGetDataCoverageStatus()
9316 : *
9317 : * @param nXOff The pixel offset to the top left corner of the region
9318 : * of the band to be queried. This would be zero to start from the left side.
9319 : *
9320 : * @param nYOff The line offset to the top left corner of the region
9321 : * of the band to be queried. This would be zero to start from the top.
9322 : *
9323 : * @param nXSize The width of the region of the band to be queried in pixels.
9324 : *
9325 : * @param nYSize The height of the region of the band to be queried in lines.
9326 : *
9327 : * @param nMaskFlagStop 0, or a binary-or'ed mask of possible values
9328 : * GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED,
9329 : * GDAL_DATA_COVERAGE_STATUS_DATA and GDAL_DATA_COVERAGE_STATUS_EMPTY. As soon
9330 : * as the computation of the coverage matches the mask, the computation will be
9331 : * stopped. *pdfDataPct will not be valid in that case.
9332 : *
9333 : * @param pdfDataPct Optional output parameter whose pointed value will be set
9334 : * to the (approximate) percentage in [0,100] of pixels in the queried
9335 : * sub-window that have valid values. The implementation might not always be
9336 : * able to compute it, in which case it will be set to a negative value.
9337 : *
9338 : * @return a binary-or'ed combination of possible values
9339 : * GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED,
9340 : * GDAL_DATA_COVERAGE_STATUS_DATA and GDAL_DATA_COVERAGE_STATUS_EMPTY
9341 : *
9342 : * @note Added in GDAL 2.2
9343 : */
9344 :
9345 : /**
9346 : * \brief Get the coverage status of a sub-window of the raster.
9347 : *
9348 : * Returns whether a sub-window of the raster contains only data, only empty
9349 : * blocks or a mix of both. This function can be used to determine quickly
9350 : * if it is worth issuing RasterIO / ReadBlock requests in datasets that may
9351 : * be sparse.
9352 : *
9353 : * Empty blocks are blocks that contain only pixels whose value is the nodata
9354 : * value when it is set, or whose value is 0 when the nodata value is not set.
9355 : *
9356 : * The query is done in an efficient way without reading the actual pixel
9357 : * values. If not possible, or not implemented at all by the driver,
9358 : * GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED | GDAL_DATA_COVERAGE_STATUS_DATA will
9359 : * be returned.
9360 : *
9361 : * The values that can be returned by the function are the following,
9362 : * potentially combined with the binary or operator :
9363 : * <ul>
9364 : * <li>GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED : the driver does not implement
9365 : * GetDataCoverageStatus(). This flag should be returned together with
9366 : * GDAL_DATA_COVERAGE_STATUS_DATA.</li>
9367 : * <li>GDAL_DATA_COVERAGE_STATUS_DATA: There is (potentially) data in the
9368 : * queried window.</li> <li>GDAL_DATA_COVERAGE_STATUS_EMPTY: There is nodata in
9369 : * the queried window. This is typically identified by the concept of missing
9370 : * block in formats that supports it.
9371 : * </li>
9372 : * </ul>
9373 : *
9374 : * Note that GDAL_DATA_COVERAGE_STATUS_DATA might have false positives and
9375 : * should be interpreted more as hint of potential presence of data. For example
9376 : * if a GeoTIFF file is created with blocks filled with zeroes (or set to the
9377 : * nodata value), instead of using the missing block mechanism,
9378 : * GDAL_DATA_COVERAGE_STATUS_DATA will be returned. On the contrary,
9379 : * GDAL_DATA_COVERAGE_STATUS_EMPTY should have no false positives.
9380 : *
9381 : * The nMaskFlagStop should be generally set to 0. It can be set to a
9382 : * binary-or'ed mask of the above mentioned values to enable a quick exiting of
9383 : * the function as soon as the computed mask matches the nMaskFlagStop. For
9384 : * example, you can issue a request on the whole raster with nMaskFlagStop =
9385 : * GDAL_DATA_COVERAGE_STATUS_EMPTY. As soon as one missing block is encountered,
9386 : * the function will exit, so that you can potentially refine the requested area
9387 : * to find which particular region(s) have missing blocks.
9388 : *
9389 : * @see GDALGetDataCoverageStatus()
9390 : *
9391 : * @param nXOff The pixel offset to the top left corner of the region
9392 : * of the band to be queried. This would be zero to start from the left side.
9393 : *
9394 : * @param nYOff The line offset to the top left corner of the region
9395 : * of the band to be queried. This would be zero to start from the top.
9396 : *
9397 : * @param nXSize The width of the region of the band to be queried in pixels.
9398 : *
9399 : * @param nYSize The height of the region of the band to be queried in lines.
9400 : *
9401 : * @param nMaskFlagStop 0, or a binary-or'ed mask of possible values
9402 : * GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED,
9403 : * GDAL_DATA_COVERAGE_STATUS_DATA and GDAL_DATA_COVERAGE_STATUS_EMPTY. As soon
9404 : * as the computation of the coverage matches the mask, the computation will be
9405 : * stopped. *pdfDataPct will not be valid in that case.
9406 : *
9407 : * @param pdfDataPct Optional output parameter whose pointed value will be set
9408 : * to the (approximate) percentage in [0,100] of pixels in the queried
9409 : * sub-window that have valid values. The implementation might not always be
9410 : * able to compute it, in which case it will be set to a negative value.
9411 : *
9412 : * @return a binary-or'ed combination of possible values
9413 : * GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED,
9414 : * GDAL_DATA_COVERAGE_STATUS_DATA and GDAL_DATA_COVERAGE_STATUS_EMPTY
9415 : *
9416 : * @note Added in GDAL 2.2
9417 : */
9418 :
9419 4615 : int GDALRasterBand::GetDataCoverageStatus(int nXOff, int nYOff, int nXSize,
9420 : int nYSize, int nMaskFlagStop,
9421 : double *pdfDataPct)
9422 : {
9423 4615 : if (nXOff < 0 || nYOff < 0 || nXSize > INT_MAX - nXOff ||
9424 4615 : nYSize > INT_MAX - nYOff || nXOff + nXSize > nRasterXSize ||
9425 4615 : nYOff + nYSize > nRasterYSize)
9426 : {
9427 0 : CPLError(CE_Failure, CPLE_AppDefined, "Bad window");
9428 0 : if (pdfDataPct)
9429 0 : *pdfDataPct = 0.0;
9430 : return GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED |
9431 0 : GDAL_DATA_COVERAGE_STATUS_EMPTY;
9432 : }
9433 4615 : return IGetDataCoverageStatus(nXOff, nYOff, nXSize, nYSize, nMaskFlagStop,
9434 4615 : pdfDataPct);
9435 : }
9436 :
9437 : /************************************************************************/
9438 : /* IGetDataCoverageStatus() */
9439 : /************************************************************************/
9440 :
9441 684 : int GDALRasterBand::IGetDataCoverageStatus(int /*nXOff*/, int /*nYOff*/,
9442 : int /*nXSize*/, int /*nYSize*/,
9443 : int /*nMaskFlagStop*/,
9444 : double *pdfDataPct)
9445 : {
9446 684 : if (pdfDataPct != nullptr)
9447 0 : *pdfDataPct = 100.0;
9448 : return GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED |
9449 684 : GDAL_DATA_COVERAGE_STATUS_DATA;
9450 : }
9451 :
9452 : //! @cond Doxygen_Suppress
9453 : /************************************************************************/
9454 : /* EnterReadWrite() */
9455 : /************************************************************************/
9456 :
9457 7786570 : int GDALRasterBand::EnterReadWrite(GDALRWFlag eRWFlag)
9458 : {
9459 7786570 : if (poDS != nullptr)
9460 7025280 : return poDS->EnterReadWrite(eRWFlag);
9461 761297 : return FALSE;
9462 : }
9463 :
9464 : /************************************************************************/
9465 : /* LeaveReadWrite() */
9466 : /************************************************************************/
9467 :
9468 1127910 : void GDALRasterBand::LeaveReadWrite()
9469 : {
9470 1127910 : if (poDS != nullptr)
9471 1127910 : poDS->LeaveReadWrite();
9472 1127870 : }
9473 :
9474 : /************************************************************************/
9475 : /* InitRWLock() */
9476 : /************************************************************************/
9477 :
9478 3954910 : void GDALRasterBand::InitRWLock()
9479 : {
9480 3954910 : if (poDS != nullptr)
9481 3954500 : poDS->InitRWLock();
9482 3954900 : }
9483 :
9484 : //! @endcond
9485 :
9486 : // clang-format off
9487 :
9488 : /**
9489 : * \fn GDALRasterBand::SetMetadata( char ** papszMetadata, const char * pszDomain)
9490 : * \brief Set metadata.
9491 : *
9492 : * CAUTION: depending on the format, older values of the updated information
9493 : * might still be found in the file in a "ghost" state, even if no longer
9494 : * accessible through the GDAL API. This is for example the case of the GTiff
9495 : * format (this is not a exhaustive list)
9496 : *
9497 : * The C function GDALSetMetadata() does the same thing as this method.
9498 : *
9499 : * @param papszMetadata the metadata in name=value string list format to
9500 : * apply.
9501 : * @param pszDomain the domain of interest. Use "" or NULL for the default
9502 : * domain.
9503 : * @return CE_None on success, CE_Failure on failure and CE_Warning if the
9504 : * metadata has been accepted, but is likely not maintained persistently
9505 : * by the underlying object between sessions.
9506 : */
9507 :
9508 : /**
9509 : * \fn GDALRasterBand::SetMetadataItem( const char * pszName, const char * pszValue, const char * pszDomain)
9510 : * \brief Set single metadata item.
9511 : *
9512 : * CAUTION: depending on the format, older values of the updated information
9513 : * might still be found in the file in a "ghost" state, even if no longer
9514 : * accessible through the GDAL API. This is for example the case of the GTiff
9515 : * format (this is not a exhaustive list)
9516 : *
9517 : * The C function GDALSetMetadataItem() does the same thing as this method.
9518 : *
9519 : * @param pszName the key for the metadata item to fetch.
9520 : * @param pszValue the value to assign to the key.
9521 : * @param pszDomain the domain to set within, use NULL for the default domain.
9522 : *
9523 : * @return CE_None on success, or an error code on failure.
9524 : */
9525 :
9526 : // clang-format on
9527 :
9528 : //! @cond Doxygen_Suppress
9529 : /************************************************************************/
9530 : /* EnablePixelTypeSignedByteWarning() */
9531 : /************************************************************************/
9532 :
9533 156048 : void GDALRasterBand::EnablePixelTypeSignedByteWarning(bool b)
9534 : {
9535 156048 : m_bEnablePixelTypeSignedByteWarning = b;
9536 156048 : }
9537 :
9538 4878 : void GDALEnablePixelTypeSignedByteWarning(GDALRasterBandH hBand, bool b)
9539 : {
9540 4878 : GDALRasterBand::FromHandle(hBand)->EnablePixelTypeSignedByteWarning(b);
9541 4878 : }
9542 :
9543 : //! @endcond
9544 :
9545 : /************************************************************************/
9546 : /* GetMetadataItem() */
9547 : /************************************************************************/
9548 :
9549 487237 : const char *GDALRasterBand::GetMetadataItem(const char *pszName,
9550 : const char *pszDomain)
9551 : {
9552 : // TODO (GDAL 4.0?): remove this when GDAL 3.7 has been widely adopted.
9553 487237 : if (m_bEnablePixelTypeSignedByteWarning && eDataType == GDT_Byte &&
9554 330118 : pszDomain != nullptr && EQUAL(pszDomain, "IMAGE_STRUCTURE") &&
9555 321086 : EQUAL(pszName, "PIXELTYPE"))
9556 : {
9557 2 : CPLError(CE_Warning, CPLE_AppDefined,
9558 : "Starting with GDAL 3.7, PIXELTYPE=SIGNEDBYTE is no longer "
9559 : "used to signal signed 8-bit raster. Change your code to "
9560 : "test for the new GDT_Int8 data type instead.");
9561 : }
9562 487237 : return GDALMajorObject::GetMetadataItem(pszName, pszDomain);
9563 : }
9564 :
9565 : /************************************************************************/
9566 : /* WindowIterator */
9567 : /************************************************************************/
9568 :
9569 : //! @cond Doxygen_Suppress
9570 :
9571 2 : GDALRasterBand::WindowIterator::WindowIterator(int nRasterXSize,
9572 : int nRasterYSize,
9573 : int nBlockXSize, int nBlockYSize,
9574 2 : int nRow, int nCol)
9575 : : m_nRasterXSize(nRasterXSize), m_nRasterYSize(nRasterYSize),
9576 : m_nBlockXSize(nBlockXSize), m_nBlockYSize(nBlockYSize), m_row(nRow),
9577 2 : m_col(nCol)
9578 : {
9579 2 : }
9580 :
9581 10 : bool GDALRasterBand::WindowIterator::operator==(
9582 : const WindowIterator &other) const
9583 : {
9584 1 : return m_row == other.m_row && m_col == other.m_col &&
9585 1 : m_nRasterXSize == other.m_nRasterXSize &&
9586 1 : m_nRasterYSize == other.m_nRasterYSize &&
9587 12 : m_nBlockXSize == other.m_nBlockXSize &&
9588 11 : m_nBlockYSize == other.m_nBlockYSize;
9589 : }
9590 :
9591 10 : bool GDALRasterBand::WindowIterator::operator!=(
9592 : const WindowIterator &other) const
9593 : {
9594 10 : return !(*this == other);
9595 : }
9596 :
9597 : GDALRasterBand::WindowIterator::value_type
9598 9 : GDALRasterBand::WindowIterator::operator*() const
9599 : {
9600 : GDALRasterWindow ret;
9601 9 : ret.nXOff = m_col * m_nBlockXSize;
9602 9 : ret.nYOff = m_row * m_nBlockYSize;
9603 9 : ret.nXSize = std::min(m_nBlockXSize, m_nRasterXSize - ret.nXOff);
9604 9 : ret.nYSize = std::min(m_nBlockYSize, m_nRasterYSize - ret.nYOff);
9605 :
9606 9 : return ret;
9607 : }
9608 :
9609 9 : GDALRasterBand::WindowIterator &GDALRasterBand::WindowIterator::operator++()
9610 : {
9611 9 : m_col++;
9612 9 : if (m_col >= DIV_ROUND_UP(m_nRasterXSize, m_nBlockXSize))
9613 : {
9614 3 : m_col = 0;
9615 3 : m_row++;
9616 : }
9617 9 : return *this;
9618 : }
9619 :
9620 2 : GDALRasterBand::WindowIteratorWrapper::WindowIteratorWrapper(
9621 2 : const GDALRasterBand &band)
9622 2 : : m_nRasterXSize(band.GetDataset()->GetRasterXSize()),
9623 2 : m_nRasterYSize(band.GetDataset()->GetRasterYSize()), m_nBlockXSize(-1),
9624 2 : m_nBlockYSize(-1)
9625 : {
9626 2 : band.GetBlockSize(&m_nBlockXSize, &m_nBlockYSize);
9627 2 : }
9628 :
9629 : GDALRasterBand::WindowIterator
9630 1 : GDALRasterBand::WindowIteratorWrapper::begin() const
9631 : {
9632 1 : return WindowIterator(m_nRasterXSize, m_nRasterYSize, m_nBlockXSize,
9633 1 : m_nBlockYSize, 0, 0);
9634 : }
9635 :
9636 : GDALRasterBand::WindowIterator
9637 1 : GDALRasterBand::WindowIteratorWrapper::end() const
9638 : {
9639 1 : return WindowIterator(m_nRasterXSize, m_nRasterYSize, m_nBlockXSize,
9640 1 : m_nBlockYSize,
9641 1 : DIV_ROUND_UP(m_nRasterYSize, m_nBlockYSize), 0);
9642 : }
9643 :
9644 : //! @endcond
9645 :
9646 : /** Return an object whose begin() and end() methods can be used to iterate
9647 : * over a GDALRasterWindow for each block in this raster band. The iteration
9648 : * order is from left to right, then from top to bottom.
9649 : *
9650 : \code{.cpp}
9651 : std::vector<double> pixelValues;
9652 : for (const auto& window : poBand->IterateWindows()) {
9653 : CPLErr eErr = window.ReadRaster(pixelValues, window.nXOff, window.nYOff,
9654 : window.nXSize, window.nYSize);
9655 : // check eErr
9656 : }
9657 : \endcode
9658 : *
9659 : *
9660 : * @since GDAL 3.12
9661 : */
9662 2 : GDALRasterBand::WindowIteratorWrapper GDALRasterBand::IterateWindows() const
9663 : {
9664 2 : return WindowIteratorWrapper(*this);
9665 : }
9666 :
9667 : /************************************************************************/
9668 : /* GDALMDArrayFromRasterBand */
9669 : /************************************************************************/
9670 :
9671 : class GDALMDArrayFromRasterBand final : public GDALMDArray
9672 : {
9673 : CPL_DISALLOW_COPY_ASSIGN(GDALMDArrayFromRasterBand)
9674 :
9675 : GDALDataset *m_poDS;
9676 : GDALRasterBand *m_poBand;
9677 : GDALExtendedDataType m_dt;
9678 : std::vector<std::shared_ptr<GDALDimension>> m_dims{};
9679 : std::string m_osUnit;
9680 : std::vector<GByte> m_pabyNoData{};
9681 : std::shared_ptr<GDALMDArray> m_varX{};
9682 : std::shared_ptr<GDALMDArray> m_varY{};
9683 : std::string m_osFilename{};
9684 :
9685 : bool ReadWrite(GDALRWFlag eRWFlag, const GUInt64 *arrayStartIdx,
9686 : const size_t *count, const GInt64 *arrayStep,
9687 : const GPtrDiff_t *bufferStride,
9688 : const GDALExtendedDataType &bufferDataType,
9689 : void *pBuffer) const;
9690 :
9691 : protected:
9692 23 : GDALMDArrayFromRasterBand(GDALDataset *poDS, GDALRasterBand *poBand)
9693 46 : : GDALAbstractMDArray(std::string(),
9694 46 : std::string(poDS->GetDescription()) +
9695 : CPLSPrintf(" band %d", poBand->GetBand())),
9696 46 : GDALMDArray(std::string(),
9697 46 : std::string(poDS->GetDescription()) +
9698 : CPLSPrintf(" band %d", poBand->GetBand())),
9699 : m_poDS(poDS), m_poBand(poBand),
9700 : m_dt(GDALExtendedDataType::Create(poBand->GetRasterDataType())),
9701 115 : m_osUnit(poBand->GetUnitType()), m_osFilename(poDS->GetDescription())
9702 : {
9703 23 : m_poDS->Reference();
9704 :
9705 23 : int bHasNoData = false;
9706 23 : if (m_poBand->GetRasterDataType() == GDT_Int64)
9707 : {
9708 0 : const auto nNoData = m_poBand->GetNoDataValueAsInt64(&bHasNoData);
9709 0 : if (bHasNoData)
9710 : {
9711 0 : m_pabyNoData.resize(m_dt.GetSize());
9712 0 : GDALCopyWords64(&nNoData, GDT_Int64, 0, &m_pabyNoData[0],
9713 : m_dt.GetNumericDataType(), 0, 1);
9714 : }
9715 : }
9716 23 : else if (m_poBand->GetRasterDataType() == GDT_UInt64)
9717 : {
9718 0 : const auto nNoData = m_poBand->GetNoDataValueAsUInt64(&bHasNoData);
9719 0 : if (bHasNoData)
9720 : {
9721 0 : m_pabyNoData.resize(m_dt.GetSize());
9722 0 : GDALCopyWords64(&nNoData, GDT_UInt64, 0, &m_pabyNoData[0],
9723 : m_dt.GetNumericDataType(), 0, 1);
9724 : }
9725 : }
9726 : else
9727 : {
9728 23 : const auto dfNoData = m_poBand->GetNoDataValue(&bHasNoData);
9729 23 : if (bHasNoData)
9730 : {
9731 1 : m_pabyNoData.resize(m_dt.GetSize());
9732 1 : GDALCopyWords64(&dfNoData, GDT_Float64, 0, &m_pabyNoData[0],
9733 : m_dt.GetNumericDataType(), 0, 1);
9734 : }
9735 : }
9736 :
9737 23 : const int nXSize = poBand->GetXSize();
9738 23 : const int nYSize = poBand->GetYSize();
9739 :
9740 23 : auto poSRS = m_poDS->GetSpatialRef();
9741 46 : std::string osTypeY;
9742 46 : std::string osTypeX;
9743 46 : std::string osDirectionY;
9744 46 : std::string osDirectionX;
9745 23 : if (poSRS && poSRS->GetAxesCount() == 2)
9746 : {
9747 21 : const auto &mapping = poSRS->GetDataAxisToSRSAxisMapping();
9748 21 : OGRAxisOrientation eOrientation1 = OAO_Other;
9749 21 : poSRS->GetAxis(nullptr, 0, &eOrientation1);
9750 21 : OGRAxisOrientation eOrientation2 = OAO_Other;
9751 21 : poSRS->GetAxis(nullptr, 1, &eOrientation2);
9752 21 : if (eOrientation1 == OAO_East && eOrientation2 == OAO_North)
9753 : {
9754 5 : if (mapping == std::vector<int>{1, 2})
9755 : {
9756 5 : osTypeY = GDAL_DIM_TYPE_HORIZONTAL_Y;
9757 5 : osDirectionY = "NORTH";
9758 5 : osTypeX = GDAL_DIM_TYPE_HORIZONTAL_X;
9759 5 : osDirectionX = "EAST";
9760 : }
9761 : }
9762 16 : else if (eOrientation1 == OAO_North && eOrientation2 == OAO_East)
9763 : {
9764 16 : if (mapping == std::vector<int>{2, 1})
9765 : {
9766 16 : osTypeY = GDAL_DIM_TYPE_HORIZONTAL_Y;
9767 16 : osDirectionY = "NORTH";
9768 16 : osTypeX = GDAL_DIM_TYPE_HORIZONTAL_X;
9769 16 : osDirectionX = "EAST";
9770 : }
9771 : }
9772 : }
9773 :
9774 115 : m_dims = {std::make_shared<GDALDimensionWeakIndexingVar>(
9775 : "/", "Y", osTypeY, osDirectionY, nYSize),
9776 46 : std::make_shared<GDALDimensionWeakIndexingVar>(
9777 69 : "/", "X", osTypeX, osDirectionX, nXSize)};
9778 :
9779 23 : GDALGeoTransform gt;
9780 23 : if (m_poDS->GetGeoTransform(gt) == CE_None && gt[2] == 0 && gt[4] == 0)
9781 : {
9782 44 : m_varX = GDALMDArrayRegularlySpaced::Create("/", "X", m_dims[1],
9783 44 : gt[0], gt[1], 0.5);
9784 22 : m_dims[1]->SetIndexingVariable(m_varX);
9785 :
9786 44 : m_varY = GDALMDArrayRegularlySpaced::Create("/", "Y", m_dims[0],
9787 44 : gt[3], gt[5], 0.5);
9788 22 : m_dims[0]->SetIndexingVariable(m_varY);
9789 : }
9790 23 : }
9791 :
9792 : bool IRead(const GUInt64 *arrayStartIdx, const size_t *count,
9793 : const GInt64 *arrayStep, const GPtrDiff_t *bufferStride,
9794 : const GDALExtendedDataType &bufferDataType,
9795 : void *pDstBuffer) const override;
9796 :
9797 1 : bool IWrite(const GUInt64 *arrayStartIdx, const size_t *count,
9798 : const GInt64 *arrayStep, const GPtrDiff_t *bufferStride,
9799 : const GDALExtendedDataType &bufferDataType,
9800 : const void *pSrcBuffer) override
9801 : {
9802 1 : return ReadWrite(GF_Write, arrayStartIdx, count, arrayStep,
9803 : bufferStride, bufferDataType,
9804 1 : const_cast<void *>(pSrcBuffer));
9805 : }
9806 :
9807 : public:
9808 46 : ~GDALMDArrayFromRasterBand()
9809 23 : {
9810 23 : m_poDS->ReleaseRef();
9811 46 : }
9812 :
9813 23 : static std::shared_ptr<GDALMDArray> Create(GDALDataset *poDS,
9814 : GDALRasterBand *poBand)
9815 : {
9816 : auto array(std::shared_ptr<GDALMDArrayFromRasterBand>(
9817 46 : new GDALMDArrayFromRasterBand(poDS, poBand)));
9818 23 : array->SetSelf(array);
9819 46 : return array;
9820 : }
9821 :
9822 2 : bool IsWritable() const override
9823 : {
9824 2 : return m_poDS->GetAccess() == GA_Update;
9825 : }
9826 :
9827 97 : const std::string &GetFilename() const override
9828 : {
9829 97 : return m_osFilename;
9830 : }
9831 :
9832 : const std::vector<std::shared_ptr<GDALDimension>> &
9833 299 : GetDimensions() const override
9834 : {
9835 299 : return m_dims;
9836 : }
9837 :
9838 138 : const GDALExtendedDataType &GetDataType() const override
9839 : {
9840 138 : return m_dt;
9841 : }
9842 :
9843 3 : const std::string &GetUnit() const override
9844 : {
9845 3 : return m_osUnit;
9846 : }
9847 :
9848 29 : const void *GetRawNoDataValue() const override
9849 : {
9850 29 : return m_pabyNoData.empty() ? nullptr : m_pabyNoData.data();
9851 : }
9852 :
9853 2 : double GetOffset(bool *pbHasOffset,
9854 : GDALDataType *peStorageType) const override
9855 : {
9856 2 : int bHasOffset = false;
9857 2 : double dfRes = m_poBand->GetOffset(&bHasOffset);
9858 2 : if (pbHasOffset)
9859 2 : *pbHasOffset = CPL_TO_BOOL(bHasOffset);
9860 2 : if (peStorageType)
9861 1 : *peStorageType = GDT_Unknown;
9862 2 : return dfRes;
9863 : }
9864 :
9865 2 : double GetScale(bool *pbHasScale,
9866 : GDALDataType *peStorageType) const override
9867 : {
9868 2 : int bHasScale = false;
9869 2 : double dfRes = m_poBand->GetScale(&bHasScale);
9870 2 : if (pbHasScale)
9871 2 : *pbHasScale = CPL_TO_BOOL(bHasScale);
9872 2 : if (peStorageType)
9873 1 : *peStorageType = GDT_Unknown;
9874 2 : return dfRes;
9875 : }
9876 :
9877 84 : std::shared_ptr<OGRSpatialReference> GetSpatialRef() const override
9878 : {
9879 84 : auto poSrcSRS = m_poDS->GetSpatialRef();
9880 84 : if (!poSrcSRS)
9881 2 : return nullptr;
9882 164 : auto poSRS = std::shared_ptr<OGRSpatialReference>(poSrcSRS->Clone());
9883 :
9884 164 : auto axisMapping = poSRS->GetDataAxisToSRSAxisMapping();
9885 82 : constexpr int iYDim = 0;
9886 82 : constexpr int iXDim = 1;
9887 246 : for (auto &m : axisMapping)
9888 : {
9889 164 : if (m == 1)
9890 82 : m = iXDim + 1;
9891 82 : else if (m == 2)
9892 82 : m = iYDim + 1;
9893 : else
9894 0 : m = 0;
9895 : }
9896 82 : poSRS->SetDataAxisToSRSAxisMapping(axisMapping);
9897 82 : return poSRS;
9898 : }
9899 :
9900 29 : std::vector<GUInt64> GetBlockSize() const override
9901 : {
9902 29 : int nBlockXSize = 0;
9903 29 : int nBlockYSize = 0;
9904 29 : m_poBand->GetBlockSize(&nBlockXSize, &nBlockYSize);
9905 29 : return std::vector<GUInt64>{static_cast<GUInt64>(nBlockYSize),
9906 29 : static_cast<GUInt64>(nBlockXSize)};
9907 : }
9908 :
9909 : class MDIAsAttribute : public GDALAttribute
9910 : {
9911 : std::vector<std::shared_ptr<GDALDimension>> m_dims{};
9912 : const GDALExtendedDataType m_dt = GDALExtendedDataType::CreateString();
9913 : std::string m_osValue;
9914 :
9915 : public:
9916 2 : MDIAsAttribute(const std::string &name, const std::string &value)
9917 2 : : GDALAbstractMDArray(std::string(), name),
9918 4 : GDALAttribute(std::string(), name), m_osValue(value)
9919 : {
9920 2 : }
9921 :
9922 : const std::vector<std::shared_ptr<GDALDimension>> &
9923 : GetDimensions() const override;
9924 :
9925 2 : const GDALExtendedDataType &GetDataType() const override
9926 : {
9927 2 : return m_dt;
9928 : }
9929 :
9930 1 : bool IRead(const GUInt64 *, const size_t *, const GInt64 *,
9931 : const GPtrDiff_t *,
9932 : const GDALExtendedDataType &bufferDataType,
9933 : void *pDstBuffer) const override
9934 : {
9935 1 : const char *pszStr = m_osValue.c_str();
9936 1 : GDALExtendedDataType::CopyValue(&pszStr, m_dt, pDstBuffer,
9937 : bufferDataType);
9938 1 : return true;
9939 : }
9940 : };
9941 :
9942 : std::vector<std::shared_ptr<GDALAttribute>>
9943 14 : GetAttributes(CSLConstList) const override
9944 : {
9945 14 : std::vector<std::shared_ptr<GDALAttribute>> res;
9946 14 : auto papszMD = m_poBand->GetMetadata();
9947 16 : for (auto iter = papszMD; iter && iter[0]; ++iter)
9948 : {
9949 2 : char *pszKey = nullptr;
9950 2 : const char *pszValue = CPLParseNameValue(*iter, &pszKey);
9951 2 : if (pszKey && pszValue)
9952 : {
9953 : res.emplace_back(
9954 2 : std::make_shared<MDIAsAttribute>(pszKey, pszValue));
9955 : }
9956 2 : CPLFree(pszKey);
9957 : }
9958 14 : return res;
9959 : }
9960 : };
9961 :
9962 31 : bool GDALMDArrayFromRasterBand::IRead(
9963 : const GUInt64 *arrayStartIdx, const size_t *count, const GInt64 *arrayStep,
9964 : const GPtrDiff_t *bufferStride, const GDALExtendedDataType &bufferDataType,
9965 : void *pDstBuffer) const
9966 : {
9967 31 : return ReadWrite(GF_Read, arrayStartIdx, count, arrayStep, bufferStride,
9968 31 : bufferDataType, pDstBuffer);
9969 : }
9970 :
9971 : const std::vector<std::shared_ptr<GDALDimension>> &
9972 3 : GDALMDArrayFromRasterBand::MDIAsAttribute::GetDimensions() const
9973 : {
9974 3 : return m_dims;
9975 : }
9976 :
9977 : /************************************************************************/
9978 : /* ReadWrite() */
9979 : /************************************************************************/
9980 :
9981 32 : bool GDALMDArrayFromRasterBand::ReadWrite(
9982 : GDALRWFlag eRWFlag, const GUInt64 *arrayStartIdx, const size_t *count,
9983 : const GInt64 *arrayStep, const GPtrDiff_t *bufferStride,
9984 : const GDALExtendedDataType &bufferDataType, void *pBuffer) const
9985 : {
9986 32 : constexpr size_t iDimX = 1;
9987 32 : constexpr size_t iDimY = 0;
9988 32 : return GDALMDRasterIOFromBand(m_poBand, eRWFlag, iDimX, iDimY,
9989 : arrayStartIdx, count, arrayStep, bufferStride,
9990 32 : bufferDataType, pBuffer);
9991 : }
9992 :
9993 : /************************************************************************/
9994 : /* GDALMDRasterIOFromBand() */
9995 : /************************************************************************/
9996 :
9997 65 : bool GDALMDRasterIOFromBand(GDALRasterBand *poBand, GDALRWFlag eRWFlag,
9998 : size_t iDimX, size_t iDimY,
9999 : const GUInt64 *arrayStartIdx, const size_t *count,
10000 : const GInt64 *arrayStep,
10001 : const GPtrDiff_t *bufferStride,
10002 : const GDALExtendedDataType &bufferDataType,
10003 : void *pBuffer)
10004 : {
10005 65 : const auto eDT(bufferDataType.GetNumericDataType());
10006 65 : const auto nDTSize(GDALGetDataTypeSizeBytes(eDT));
10007 65 : const int nX =
10008 65 : arrayStep[iDimX] > 0
10009 65 : ? static_cast<int>(arrayStartIdx[iDimX])
10010 2 : : static_cast<int>(arrayStartIdx[iDimX] -
10011 2 : (count[iDimX] - 1) * -arrayStep[iDimX]);
10012 65 : const int nY =
10013 65 : arrayStep[iDimY] > 0
10014 65 : ? static_cast<int>(arrayStartIdx[iDimY])
10015 2 : : static_cast<int>(arrayStartIdx[iDimY] -
10016 2 : (count[iDimY] - 1) * -arrayStep[iDimY]);
10017 65 : const int nSizeX = static_cast<int>(count[iDimX] * ABS(arrayStep[iDimX]));
10018 65 : const int nSizeY = static_cast<int>(count[iDimY] * ABS(arrayStep[iDimY]));
10019 65 : GByte *pabyBuffer = static_cast<GByte *>(pBuffer);
10020 65 : int nStrideXSign = 1;
10021 65 : if (arrayStep[iDimX] < 0)
10022 : {
10023 2 : pabyBuffer += (count[iDimX] - 1) * bufferStride[iDimX] * nDTSize;
10024 2 : nStrideXSign = -1;
10025 : }
10026 65 : int nStrideYSign = 1;
10027 65 : if (arrayStep[iDimY] < 0)
10028 : {
10029 2 : pabyBuffer += (count[iDimY] - 1) * bufferStride[iDimY] * nDTSize;
10030 2 : nStrideYSign = -1;
10031 : }
10032 :
10033 130 : return poBand->RasterIO(eRWFlag, nX, nY, nSizeX, nSizeY, pabyBuffer,
10034 65 : static_cast<int>(count[iDimX]),
10035 65 : static_cast<int>(count[iDimY]), eDT,
10036 : static_cast<GSpacing>(
10037 65 : nStrideXSign * bufferStride[iDimX] * nDTSize),
10038 : static_cast<GSpacing>(
10039 65 : nStrideYSign * bufferStride[iDimY] * nDTSize),
10040 65 : nullptr) == CE_None;
10041 : }
10042 :
10043 : /************************************************************************/
10044 : /* AsMDArray() */
10045 : /************************************************************************/
10046 :
10047 : /** Return a view of this raster band as a 2D multidimensional GDALMDArray.
10048 : *
10049 : * The band must be linked to a GDALDataset. If this dataset is not already
10050 : * marked as shared, it will be, so that the returned array holds a reference
10051 : * to it.
10052 : *
10053 : * If the dataset has a geotransform attached, the X and Y dimensions of the
10054 : * returned array will have an associated indexing variable.
10055 : *
10056 : * This is the same as the C function GDALRasterBandAsMDArray().
10057 : *
10058 : * The "reverse" method is GDALMDArray::AsClassicDataset().
10059 : *
10060 : * @return a new array, or nullptr.
10061 : *
10062 : * @since GDAL 3.1
10063 : */
10064 23 : std::shared_ptr<GDALMDArray> GDALRasterBand::AsMDArray() const
10065 : {
10066 23 : if (!poDS)
10067 : {
10068 0 : CPLError(CE_Failure, CPLE_AppDefined, "Band not attached to a dataset");
10069 0 : return nullptr;
10070 : }
10071 23 : if (!poDS->GetShared())
10072 : {
10073 23 : poDS->MarkAsShared();
10074 : }
10075 : return GDALMDArrayFromRasterBand::Create(
10076 23 : poDS, const_cast<GDALRasterBand *>(this));
10077 : }
10078 :
10079 : /************************************************************************/
10080 : /* InterpolateAtPoint() */
10081 : /************************************************************************/
10082 :
10083 : /**
10084 : * \brief Interpolates the value between pixels using a resampling algorithm,
10085 : * taking pixel/line coordinates as input.
10086 : *
10087 : * @param dfPixel pixel coordinate as a double, where interpolation should be done.
10088 : * @param dfLine line coordinate as a double, where interpolation should be done.
10089 : * @param eInterpolation interpolation type. Only near, bilinear, cubic and cubicspline are allowed.
10090 : * @param pdfRealValue pointer to real part of interpolated value
10091 : * @param pdfImagValue pointer to imaginary part of interpolated value (may be null if not needed)
10092 : *
10093 : * @return CE_None on success, or an error code on failure.
10094 : * @since GDAL 3.10
10095 : */
10096 :
10097 167 : CPLErr GDALRasterBand::InterpolateAtPoint(double dfPixel, double dfLine,
10098 : GDALRIOResampleAlg eInterpolation,
10099 : double *pdfRealValue,
10100 : double *pdfImagValue) const
10101 : {
10102 167 : if (eInterpolation != GRIORA_NearestNeighbour &&
10103 33 : eInterpolation != GRIORA_Bilinear && eInterpolation != GRIORA_Cubic &&
10104 : eInterpolation != GRIORA_CubicSpline)
10105 : {
10106 2 : CPLError(CE_Failure, CPLE_AppDefined,
10107 : "Only nearest, bilinear, cubic and cubicspline interpolation "
10108 : "methods "
10109 : "allowed");
10110 :
10111 2 : return CE_Failure;
10112 : }
10113 :
10114 165 : GDALRasterBand *pBand = const_cast<GDALRasterBand *>(this);
10115 165 : if (!m_poPointsCache)
10116 85 : m_poPointsCache = new GDALDoublePointsCache();
10117 :
10118 : const bool res =
10119 165 : GDALInterpolateAtPoint(pBand, eInterpolation, m_poPointsCache->cache,
10120 : dfPixel, dfLine, pdfRealValue, pdfImagValue);
10121 :
10122 165 : return res ? CE_None : CE_Failure;
10123 : }
10124 :
10125 : /************************************************************************/
10126 : /* GDALRasterInterpolateAtPoint() */
10127 : /************************************************************************/
10128 :
10129 : /**
10130 : * \brief Interpolates the value between pixels using
10131 : * a resampling algorithm
10132 : *
10133 : * @see GDALRasterBand::InterpolateAtPoint()
10134 : * @since GDAL 3.10
10135 : */
10136 :
10137 144 : CPLErr GDALRasterInterpolateAtPoint(GDALRasterBandH hBand, double dfPixel,
10138 : double dfLine,
10139 : GDALRIOResampleAlg eInterpolation,
10140 : double *pdfRealValue, double *pdfImagValue)
10141 : {
10142 144 : VALIDATE_POINTER1(hBand, "GDALRasterInterpolateAtPoint", CE_Failure);
10143 :
10144 144 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
10145 144 : return poBand->InterpolateAtPoint(dfPixel, dfLine, eInterpolation,
10146 144 : pdfRealValue, pdfImagValue);
10147 : }
10148 :
10149 : /************************************************************************/
10150 : /* InterpolateAtGeolocation() */
10151 : /************************************************************************/
10152 :
10153 : /**
10154 : * \brief Interpolates the value between pixels using a resampling algorithm,
10155 : * taking georeferenced coordinates as input.
10156 : *
10157 : * When poSRS is null, those georeferenced coordinates (dfGeolocX, dfGeolocY)
10158 : * must be in the "natural" SRS of the dataset, that is the one returned by
10159 : * GetSpatialRef() if there is a geotransform, GetGCPSpatialRef() if there are
10160 : * GCPs, WGS 84 if there are RPC coefficients, or the SRS of the geolocation
10161 : * array (generally WGS 84) if there is a geolocation array.
10162 : * If that natural SRS is a geographic one, dfGeolocX must be a longitude, and
10163 : * dfGeolocY a latitude. If that natural SRS is a projected one, dfGeolocX must
10164 : * be a easting, and dfGeolocY a northing.
10165 : *
10166 : * When poSRS is set to a non-null value, (dfGeolocX, dfGeolocY) must be
10167 : * expressed in that CRS, and that tuple must be conformant with the
10168 : * data-axis-to-crs-axis setting of poSRS, that is the one returned by
10169 : * the OGRSpatialReference::GetDataAxisToSRSAxisMapping(). If you want to be sure
10170 : * of the axis order, then make sure to call poSRS->SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER)
10171 : * before calling this method, and in that case, dfGeolocX must be a longitude
10172 : * or an easting value, and dfGeolocX a latitude or a northing value.
10173 : *
10174 : * The GDALDataset::GeolocationToPixelLine() will be used to transform from
10175 : * (dfGeolocX,dfGeolocY) georeferenced coordinates to (pixel, line). Refer to
10176 : * it for details on how that transformation is done.
10177 : *
10178 : * @param dfGeolocX X coordinate of the position (longitude or easting if poSRS
10179 : * is null, otherwise consistent with poSRS data-axis-to-crs-axis mapping),
10180 : * where interpolation should be done.
10181 : * @param dfGeolocY Y coordinate of the position (latitude or northing if poSRS
10182 : * is null, otherwise consistent with poSRS data-axis-to-crs-axis mapping),
10183 : * where interpolation should be done.
10184 : * @param poSRS If set, override the natural CRS in which dfGeolocX, dfGeolocY are expressed
10185 : * @param eInterpolation interpolation type. Only near, bilinear, cubic and cubicspline are allowed.
10186 : * @param pdfRealValue pointer to real part of interpolated value
10187 : * @param pdfImagValue pointer to imaginary part of interpolated value (may be null if not needed)
10188 : * @param papszTransformerOptions Options accepted by GDALDataset::GeolocationToPixelLine() (GDALCreateGenImgProjTransformer2()), or nullptr.
10189 : *
10190 : * @return CE_None on success, or an error code on failure.
10191 : * @since GDAL 3.11
10192 : */
10193 :
10194 15 : CPLErr GDALRasterBand::InterpolateAtGeolocation(
10195 : double dfGeolocX, double dfGeolocY, const OGRSpatialReference *poSRS,
10196 : GDALRIOResampleAlg eInterpolation, double *pdfRealValue,
10197 : double *pdfImagValue, CSLConstList papszTransformerOptions) const
10198 : {
10199 : double dfPixel;
10200 : double dfLine;
10201 15 : if (poDS->GeolocationToPixelLine(dfGeolocX, dfGeolocY, poSRS, &dfPixel,
10202 : &dfLine,
10203 15 : papszTransformerOptions) != CE_None)
10204 : {
10205 1 : return CE_Failure;
10206 : }
10207 14 : return InterpolateAtPoint(dfPixel, dfLine, eInterpolation, pdfRealValue,
10208 14 : pdfImagValue);
10209 : }
10210 :
10211 : /************************************************************************/
10212 : /* GDALRasterInterpolateAtGeolocation() */
10213 : /************************************************************************/
10214 :
10215 : /**
10216 : * \brief Interpolates the value between pixels using a resampling algorithm,
10217 : * taking georeferenced coordinates as input.
10218 : *
10219 : * @see GDALRasterBand::InterpolateAtGeolocation()
10220 : * @since GDAL 3.11
10221 : */
10222 :
10223 15 : CPLErr GDALRasterInterpolateAtGeolocation(GDALRasterBandH hBand,
10224 : double dfGeolocX, double dfGeolocY,
10225 : OGRSpatialReferenceH hSRS,
10226 : GDALRIOResampleAlg eInterpolation,
10227 : double *pdfRealValue,
10228 : double *pdfImagValue,
10229 : CSLConstList papszTransformerOptions)
10230 : {
10231 15 : VALIDATE_POINTER1(hBand, "GDALRasterInterpolateAtGeolocation", CE_Failure);
10232 :
10233 15 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
10234 15 : return poBand->InterpolateAtGeolocation(
10235 15 : dfGeolocX, dfGeolocY, OGRSpatialReference::FromHandle(hSRS),
10236 15 : eInterpolation, pdfRealValue, pdfImagValue, papszTransformerOptions);
10237 : }
10238 :
10239 : /************************************************************************/
10240 : /* GDALRasterBand::SplitRasterIO() */
10241 : /************************************************************************/
10242 :
10243 : //! @cond Doxygen_Suppress
10244 :
10245 : /** Implements IRasterIO() by dividing the request in 2.
10246 : *
10247 : * Should only be called when nBufXSize == nXSize && nBufYSize == nYSize
10248 : *
10249 : * Return CE_Warning if the split could not be done, CE_None in case of
10250 : * success and CE_Failure in case of error.
10251 : *
10252 : * @since 3.12
10253 : */
10254 999 : CPLErr GDALRasterBand::SplitRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
10255 : [[maybe_unused]] int nXSize,
10256 : [[maybe_unused]] int nYSize, void *pData,
10257 : int nBufXSize, int nBufYSize,
10258 : GDALDataType eBufType,
10259 : GSpacing nPixelSpace, GSpacing nLineSpace,
10260 : GDALRasterIOExtraArg *psExtraArg)
10261 : {
10262 999 : CPLAssert(nBufXSize == nXSize && nBufYSize == nYSize);
10263 :
10264 999 : GByte *pabyData = static_cast<GByte *>(pData);
10265 999 : if ((nBufXSize == nRasterXSize || nBufYSize >= nBufXSize) && nBufYSize >= 2)
10266 : {
10267 : GDALRasterIOExtraArg sArg;
10268 499 : INIT_RASTERIO_EXTRA_ARG(sArg);
10269 499 : const int nHalfHeight = nBufYSize / 2;
10270 :
10271 499 : sArg.pfnProgress = GDALScaledProgress;
10272 499 : sArg.pProgressData = GDALCreateScaledProgress(
10273 : 0, 0.5, psExtraArg->pfnProgress, psExtraArg->pProgressData);
10274 499 : if (sArg.pProgressData == nullptr)
10275 499 : sArg.pfnProgress = nullptr;
10276 998 : CPLErr eErr = IRasterIO(eRWFlag, nXOff, nYOff, nBufXSize, nHalfHeight,
10277 : pabyData, nBufXSize, nHalfHeight, eBufType,
10278 499 : nPixelSpace, nLineSpace, &sArg);
10279 499 : GDALDestroyScaledProgress(sArg.pProgressData);
10280 :
10281 499 : if (eErr == CE_None)
10282 : {
10283 499 : sArg.pfnProgress = GDALScaledProgress;
10284 499 : sArg.pProgressData = GDALCreateScaledProgress(
10285 : 0.5, 1, psExtraArg->pfnProgress, psExtraArg->pProgressData);
10286 499 : if (sArg.pProgressData == nullptr)
10287 499 : sArg.pfnProgress = nullptr;
10288 998 : eErr = IRasterIO(eRWFlag, nXOff, nYOff + nHalfHeight, nBufXSize,
10289 : nBufYSize - nHalfHeight,
10290 499 : pabyData + nHalfHeight * nLineSpace, nBufXSize,
10291 : nBufYSize - nHalfHeight, eBufType, nPixelSpace,
10292 499 : nLineSpace, &sArg);
10293 499 : GDALDestroyScaledProgress(sArg.pProgressData);
10294 : }
10295 499 : return eErr;
10296 : }
10297 500 : else if (nBufXSize >= 2)
10298 : {
10299 : GDALRasterIOExtraArg sArg;
10300 500 : INIT_RASTERIO_EXTRA_ARG(sArg);
10301 500 : const int nHalfWidth = nBufXSize / 2;
10302 :
10303 500 : sArg.pfnProgress = GDALScaledProgress;
10304 500 : sArg.pProgressData = GDALCreateScaledProgress(
10305 : 0, 0.5, psExtraArg->pfnProgress, psExtraArg->pProgressData);
10306 500 : if (sArg.pProgressData == nullptr)
10307 500 : sArg.pfnProgress = nullptr;
10308 1000 : CPLErr eErr = IRasterIO(eRWFlag, nXOff, nYOff, nHalfWidth, nBufYSize,
10309 : pabyData, nHalfWidth, nBufYSize, eBufType,
10310 500 : nPixelSpace, nLineSpace, &sArg);
10311 500 : GDALDestroyScaledProgress(sArg.pProgressData);
10312 :
10313 500 : if (eErr == CE_None)
10314 : {
10315 500 : sArg.pfnProgress = GDALScaledProgress;
10316 500 : sArg.pProgressData = GDALCreateScaledProgress(
10317 : 0.5, 1, psExtraArg->pfnProgress, psExtraArg->pProgressData);
10318 500 : if (sArg.pProgressData == nullptr)
10319 500 : sArg.pfnProgress = nullptr;
10320 1000 : eErr = IRasterIO(eRWFlag, nXOff + nHalfWidth, nYOff,
10321 : nBufXSize - nHalfWidth, nBufYSize,
10322 500 : pabyData + nHalfWidth * nPixelSpace,
10323 : nBufXSize - nHalfWidth, nBufYSize, eBufType,
10324 500 : nPixelSpace, nLineSpace, &sArg);
10325 500 : GDALDestroyScaledProgress(sArg.pProgressData);
10326 : }
10327 500 : return eErr;
10328 : }
10329 :
10330 0 : return CE_Warning;
10331 : }
10332 :
10333 : //! @endcond
10334 :
10335 : /************************************************************************/
10336 : /* ThrowIfNotSameDimensions() */
10337 : /************************************************************************/
10338 :
10339 : //! @cond Doxygen_Suppress
10340 : /* static */
10341 157 : void GDALRasterBand::ThrowIfNotSameDimensions(const GDALRasterBand &first,
10342 : const GDALRasterBand &second)
10343 : {
10344 297 : if (first.GetXSize() != second.GetXSize() ||
10345 140 : first.GetYSize() != second.GetYSize())
10346 : {
10347 34 : throw std::runtime_error("Bands do not have the same dimensions");
10348 : }
10349 123 : }
10350 :
10351 : //! @endcond
10352 :
10353 : /************************************************************************/
10354 : /* GDALRasterBandUnaryOp() */
10355 : /************************************************************************/
10356 :
10357 : /** Apply a unary operation on this band.
10358 : *
10359 : * The resulting band is lazy evaluated. A reference is taken on the input
10360 : * dataset.
10361 : *
10362 : * @since 3.12
10363 : * @return a handle to free with GDALComputedRasterBandRelease(), or nullptr if error.
10364 : */
10365 : GDALComputedRasterBandH
10366 2 : GDALRasterBandUnaryOp(GDALRasterBandH hBand,
10367 : GDALRasterAlgebraUnaryOperation eOp)
10368 : {
10369 2 : VALIDATE_POINTER1(hBand, __func__, nullptr);
10370 2 : switch (eOp)
10371 : {
10372 2 : case GRAUO_LOGICAL_NOT:
10373 2 : break;
10374 : }
10375 : return new GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_NE,
10376 2 : *(GDALRasterBand::FromHandle(hBand)),
10377 2 : true);
10378 : }
10379 :
10380 : /************************************************************************/
10381 : /* ConvertGDALRasterAlgebraBinaryOperationToCpp() */
10382 : /************************************************************************/
10383 :
10384 : static GDALComputedRasterBand::Operation
10385 117 : ConvertGDALRasterAlgebraBinaryOperationToCpp(
10386 : GDALRasterAlgebraBinaryOperation eOp)
10387 : {
10388 117 : switch (eOp)
10389 : {
10390 26 : case GRABO_ADD:
10391 26 : return GDALComputedRasterBand::Operation::OP_ADD;
10392 2 : case GRABO_SUB:
10393 2 : return GDALComputedRasterBand::Operation::OP_SUBTRACT;
10394 24 : case GRABO_MUL:
10395 24 : return GDALComputedRasterBand::Operation::OP_MULTIPLY;
10396 3 : case GRABO_DIV:
10397 3 : return GDALComputedRasterBand::Operation::OP_DIVIDE;
10398 6 : case GRABO_GT:
10399 6 : return GDALComputedRasterBand::Operation::OP_GT;
10400 8 : case GRABO_GE:
10401 8 : return GDALComputedRasterBand::Operation::OP_GE;
10402 6 : case GRABO_LT:
10403 6 : return GDALComputedRasterBand::Operation::OP_LT;
10404 6 : case GRABO_LE:
10405 6 : return GDALComputedRasterBand::Operation::OP_LE;
10406 6 : case GRABO_EQ:
10407 6 : return GDALComputedRasterBand::Operation::OP_EQ;
10408 6 : case GRABO_NE:
10409 6 : break;
10410 12 : case GRABO_LOGICAL_AND:
10411 12 : return GDALComputedRasterBand::Operation::OP_LOGICAL_AND;
10412 12 : case GRABO_LOGICAL_OR:
10413 12 : return GDALComputedRasterBand::Operation::OP_LOGICAL_OR;
10414 : }
10415 6 : return GDALComputedRasterBand::Operation::OP_NE;
10416 : }
10417 :
10418 : /************************************************************************/
10419 : /* GDALRasterBandBinaryOpBand() */
10420 : /************************************************************************/
10421 :
10422 : /** Apply a binary operation on this band with another one.
10423 : *
10424 : * e.g. GDALRasterBandBinaryOpBand(hBand1, GRABO_SUB, hBand2) performs
10425 : * "hBand1 - hBand2".
10426 : *
10427 : * The resulting band is lazy evaluated. A reference is taken on both input
10428 : * datasets.
10429 : *
10430 : * @since 3.12
10431 : * @return a handle to free with GDALComputedRasterBandRelease(), or nullptr if error.
10432 : */
10433 : GDALComputedRasterBandH
10434 55 : GDALRasterBandBinaryOpBand(GDALRasterBandH hBand,
10435 : GDALRasterAlgebraBinaryOperation eOp,
10436 : GDALRasterBandH hOtherBand)
10437 : {
10438 55 : VALIDATE_POINTER1(hBand, __func__, nullptr);
10439 55 : VALIDATE_POINTER1(hOtherBand, __func__, nullptr);
10440 : #ifndef HAVE_MUPARSER
10441 : if (eOp >= GRABO_GT && eOp <= GRABO_NE)
10442 : {
10443 : CPLError(
10444 : CE_Failure, CPLE_NotSupported,
10445 : "Band comparison operators not available on a GDAL build without "
10446 : "muparser");
10447 : return nullptr;
10448 : }
10449 : #endif
10450 55 : auto &firstBand = *(GDALRasterBand::FromHandle(hBand));
10451 55 : auto &secondBand = *(GDALRasterBand::FromHandle(hOtherBand));
10452 : try
10453 : {
10454 55 : GDALRasterBand::ThrowIfNotSameDimensions(firstBand, secondBand);
10455 : }
10456 12 : catch (const std::exception &e)
10457 : {
10458 12 : CPLError(CE_Failure, CPLE_AppDefined, "%s", e.what());
10459 12 : return nullptr;
10460 : }
10461 : return new GDALComputedRasterBand(
10462 43 : ConvertGDALRasterAlgebraBinaryOperationToCpp(eOp), firstBand,
10463 43 : secondBand);
10464 : }
10465 :
10466 : /************************************************************************/
10467 : /* GDALRasterBandBinaryOpDouble() */
10468 : /************************************************************************/
10469 :
10470 : /** Apply a binary operation on this band with a constant
10471 : *
10472 : * e.g. GDALRasterBandBinaryOpDouble(hBand, GRABO_SUB, constant) performs
10473 : * "hBand - constant".
10474 : *
10475 : * The resulting band is lazy evaluated. A reference is taken on the input
10476 : * dataset.
10477 : *
10478 : * @since 3.12
10479 : * @return a handle to free with GDALComputedRasterBandRelease(), or nullptr if error.
10480 : */
10481 : GDALComputedRasterBandH
10482 58 : GDALRasterBandBinaryOpDouble(GDALRasterBandH hBand,
10483 : GDALRasterAlgebraBinaryOperation eOp,
10484 : double constant)
10485 : {
10486 58 : VALIDATE_POINTER1(hBand, __func__, nullptr);
10487 : #ifndef HAVE_MUPARSER
10488 : if (eOp >= GRABO_GT && eOp <= GRABO_NE)
10489 : {
10490 : CPLError(
10491 : CE_Failure, CPLE_NotSupported,
10492 : "Band comparison operators not available on a GDAL build without "
10493 : "muparser");
10494 : return nullptr;
10495 : }
10496 : #endif
10497 : return new GDALComputedRasterBand(
10498 58 : ConvertGDALRasterAlgebraBinaryOperationToCpp(eOp),
10499 58 : *(GDALRasterBand::FromHandle(hBand)), constant);
10500 : }
10501 :
10502 : /************************************************************************/
10503 : /* GDALRasterBandBinaryOpDoubleToBand() */
10504 : /************************************************************************/
10505 :
10506 : /** Apply a binary operation on the constant with this band
10507 : *
10508 : * e.g. GDALRasterBandBinaryOpDoubleToBand(constant, GRABO_SUB, hBand) performs
10509 : * "constant - hBand".
10510 : *
10511 : * The resulting band is lazy evaluated. A reference is taken on the input
10512 : * dataset.
10513 : *
10514 : * @since 3.12
10515 : * @return a handle to free with GDALComputedRasterBandRelease(), or nullptr if error.
10516 : */
10517 : GDALComputedRasterBandH
10518 17 : GDALRasterBandBinaryOpDoubleToBand(double constant,
10519 : GDALRasterAlgebraBinaryOperation eOp,
10520 : GDALRasterBandH hBand)
10521 : {
10522 17 : VALIDATE_POINTER1(hBand, __func__, nullptr);
10523 : #ifndef HAVE_MUPARSER
10524 : if (eOp >= GRABO_GT && eOp <= GRABO_NE)
10525 : {
10526 : CPLError(
10527 : CE_Failure, CPLE_NotSupported,
10528 : "Band comparison operators not available on a GDAL build without "
10529 : "muparser");
10530 : return nullptr;
10531 : }
10532 : #endif
10533 17 : switch (eOp)
10534 : {
10535 15 : case GRABO_ADD:
10536 : case GRABO_MUL:
10537 : {
10538 : return new GDALComputedRasterBand(
10539 15 : ConvertGDALRasterAlgebraBinaryOperationToCpp(eOp),
10540 15 : *(GDALRasterBand::FromHandle(hBand)), constant);
10541 : }
10542 :
10543 1 : case GRABO_DIV:
10544 : case GRABO_GT:
10545 : case GRABO_GE:
10546 : case GRABO_LT:
10547 : case GRABO_LE:
10548 : case GRABO_EQ:
10549 : case GRABO_NE:
10550 : case GRABO_LOGICAL_AND:
10551 : case GRABO_LOGICAL_OR:
10552 : {
10553 : return new GDALComputedRasterBand(
10554 1 : ConvertGDALRasterAlgebraBinaryOperationToCpp(eOp), constant,
10555 1 : *(GDALRasterBand::FromHandle(hBand)));
10556 : }
10557 :
10558 1 : case GRABO_SUB:
10559 : {
10560 1 : break;
10561 : }
10562 : }
10563 :
10564 : return new GDALComputedRasterBand(
10565 : GDALComputedRasterBand::Operation::OP_ADD,
10566 2 : GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_MULTIPLY,
10567 1 : *(GDALRasterBand::FromHandle(hBand)), -1.0),
10568 1 : constant);
10569 : }
10570 :
10571 : /************************************************************************/
10572 : /* operator+() */
10573 : /************************************************************************/
10574 :
10575 : /** Add this band with another one.
10576 : *
10577 : * The resulting band is lazy evaluated. A reference is taken on both input
10578 : * datasets.
10579 : *
10580 : * @since 3.12
10581 : * @throw std::runtime_error if both bands do not have the same dimensions.
10582 : */
10583 : GDALComputedRasterBand
10584 2 : GDALRasterBand::operator+(const GDALRasterBand &other) const
10585 : {
10586 2 : ThrowIfNotSameDimensions(*this, other);
10587 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_ADD,
10588 1 : *this, other);
10589 : }
10590 :
10591 : /************************************************************************/
10592 : /* operator+() */
10593 : /************************************************************************/
10594 :
10595 : /** Add this band with a constant.
10596 : *
10597 : * The resulting band is lazy evaluated. A reference is taken on the input
10598 : * dataset.
10599 : *
10600 : * @since 3.12
10601 : */
10602 11 : GDALComputedRasterBand GDALRasterBand::operator+(double constant) const
10603 : {
10604 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_ADD,
10605 11 : *this, constant);
10606 : }
10607 :
10608 : /************************************************************************/
10609 : /* operator+() */
10610 : /************************************************************************/
10611 :
10612 : /** Add a band with a constant.
10613 : *
10614 : * The resulting band is lazy evaluated. A reference is taken on the input
10615 : * dataset.
10616 : *
10617 : * @since 3.12
10618 : */
10619 1 : GDALComputedRasterBand operator+(double constant, const GDALRasterBand &other)
10620 : {
10621 1 : return other + constant;
10622 : }
10623 :
10624 : /************************************************************************/
10625 : /* operator-() */
10626 : /************************************************************************/
10627 :
10628 : /** Subtract this band with another one.
10629 : *
10630 : * The resulting band is lazy evaluated. A reference is taken on both input
10631 : * datasets.
10632 : *
10633 : * @since 3.12
10634 : * @throw std::runtime_error if both bands do not have the same dimensions.
10635 : */
10636 : GDALComputedRasterBand
10637 2 : GDALRasterBand::operator-(const GDALRasterBand &other) const
10638 : {
10639 2 : ThrowIfNotSameDimensions(*this, other);
10640 : return GDALComputedRasterBand(
10641 2 : GDALComputedRasterBand::Operation::OP_SUBTRACT, *this, other);
10642 : }
10643 :
10644 : /************************************************************************/
10645 : /* operator-() */
10646 : /************************************************************************/
10647 :
10648 : /** Subtract this band with a constant.
10649 : *
10650 : * The resulting band is lazy evaluated. A reference is taken on the input
10651 : * dataset.
10652 : *
10653 : * @since 3.12
10654 : */
10655 1 : GDALComputedRasterBand GDALRasterBand::operator-(double constant) const
10656 : {
10657 : return GDALComputedRasterBand(
10658 1 : GDALComputedRasterBand::Operation::OP_SUBTRACT, *this, constant);
10659 : }
10660 :
10661 : /************************************************************************/
10662 : /* operator-() */
10663 : /************************************************************************/
10664 :
10665 : /** Subtract a constant with a band.
10666 : *
10667 : * The resulting band is lazy evaluated. A reference is taken on the input
10668 : * dataset.
10669 : *
10670 : * @since 3.12
10671 : */
10672 1 : GDALComputedRasterBand operator-(double constant, const GDALRasterBand &other)
10673 : {
10674 2 : return other * (-1.0) + constant;
10675 : }
10676 :
10677 : /************************************************************************/
10678 : /* operator*() */
10679 : /************************************************************************/
10680 :
10681 : /** Multiply this band with another one.
10682 : *
10683 : * The resulting band is lazy evaluated. A reference is taken on both input
10684 : * datasets.
10685 : *
10686 : * @since 3.12
10687 : * @throw std::runtime_error if both bands do not have the same dimensions.
10688 : */
10689 : GDALComputedRasterBand
10690 1 : GDALRasterBand::operator*(const GDALRasterBand &other) const
10691 : {
10692 1 : ThrowIfNotSameDimensions(*this, other);
10693 : return GDALComputedRasterBand(
10694 1 : GDALComputedRasterBand::Operation::OP_MULTIPLY, *this, other);
10695 : }
10696 :
10697 : /************************************************************************/
10698 : /* operator*() */
10699 : /************************************************************************/
10700 :
10701 : /** Multiply this band by a constant.
10702 : *
10703 : * The resulting band is lazy evaluated. A reference is taken on the input
10704 : * dataset.
10705 : *
10706 : * @since 3.12
10707 : */
10708 12 : GDALComputedRasterBand GDALRasterBand::operator*(double constant) const
10709 : {
10710 : return GDALComputedRasterBand(
10711 12 : GDALComputedRasterBand::Operation::OP_MULTIPLY, *this, constant);
10712 : }
10713 :
10714 : /************************************************************************/
10715 : /* operator*() */
10716 : /************************************************************************/
10717 :
10718 : /** Multiply a band with a constant.
10719 : *
10720 : * The resulting band is lazy evaluated. A reference is taken on the input
10721 : * dataset.
10722 : *
10723 : * @since 3.12
10724 : */
10725 2 : GDALComputedRasterBand operator*(double constant, const GDALRasterBand &other)
10726 : {
10727 2 : return other * constant;
10728 : }
10729 :
10730 : /************************************************************************/
10731 : /* operator/() */
10732 : /************************************************************************/
10733 :
10734 : /** Divide this band with another one.
10735 : *
10736 : * The resulting band is lazy evaluated. A reference is taken on both input
10737 : * datasets.
10738 : *
10739 : * @since 3.12
10740 : * @throw std::runtime_error if both bands do not have the same dimensions.
10741 : */
10742 : GDALComputedRasterBand
10743 1 : GDALRasterBand::operator/(const GDALRasterBand &other) const
10744 : {
10745 1 : ThrowIfNotSameDimensions(*this, other);
10746 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_DIVIDE,
10747 1 : *this, other);
10748 : }
10749 :
10750 : /************************************************************************/
10751 : /* operator/() */
10752 : /************************************************************************/
10753 :
10754 : /** Divide this band by a constant.
10755 : *
10756 : * The resulting band is lazy evaluated. A reference is taken on the input
10757 : * dataset.
10758 : *
10759 : * @since 3.12
10760 : */
10761 1 : GDALComputedRasterBand GDALRasterBand::operator/(double constant) const
10762 : {
10763 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_DIVIDE,
10764 1 : *this, constant);
10765 : }
10766 :
10767 : /************************************************************************/
10768 : /* operator/() */
10769 : /************************************************************************/
10770 :
10771 : /** Divide a constant by a band.
10772 : *
10773 : * The resulting band is lazy evaluated. A reference is taken on the input
10774 : * dataset.
10775 : *
10776 : * @since 3.12
10777 : */
10778 1 : GDALComputedRasterBand operator/(double constant, const GDALRasterBand &other)
10779 : {
10780 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_DIVIDE,
10781 1 : constant, other);
10782 : }
10783 :
10784 : /************************************************************************/
10785 : /* ThrowIfNotMuparser() */
10786 : /************************************************************************/
10787 :
10788 : #ifndef HAVE_MUPARSER
10789 : static GDALComputedRasterBand ThrowIfNotMuparser()
10790 : {
10791 : throw std::runtime_error("Band comparison operators not available on a "
10792 : "GDAL build without muparser");
10793 : }
10794 : #endif
10795 :
10796 : /************************************************************************/
10797 : /* operator>() */
10798 : /************************************************************************/
10799 :
10800 : /** Return a band whose value is 1 if the pixel value of the left operand
10801 : * is greater than the pixel value of the right operand.
10802 : *
10803 : * The resulting band is lazy evaluated. A reference is taken on the input
10804 : * dataset.
10805 : *
10806 : * @since 3.12
10807 : */
10808 : GDALComputedRasterBand
10809 3 : GDALRasterBand::operator>(const GDALRasterBand &other) const
10810 : {
10811 : #ifndef HAVE_MUPARSER
10812 : (void)other;
10813 : return ThrowIfNotMuparser();
10814 : #else
10815 3 : ThrowIfNotSameDimensions(*this, other);
10816 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_GT,
10817 2 : *this, other);
10818 : #endif
10819 : }
10820 :
10821 : /************************************************************************/
10822 : /* operator>() */
10823 : /************************************************************************/
10824 :
10825 : /** Return a band whose value is 1 if the pixel value of the left operand
10826 : * is greater than the constant.
10827 : *
10828 : * The resulting band is lazy evaluated. A reference is taken on the input
10829 : * dataset.
10830 : *
10831 : * @since 3.12
10832 : */
10833 3 : GDALComputedRasterBand GDALRasterBand::operator>(double constant) const
10834 : {
10835 : #ifndef HAVE_MUPARSER
10836 : (void)constant;
10837 : return ThrowIfNotMuparser();
10838 : #else
10839 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_GT,
10840 3 : *this, constant);
10841 : #endif
10842 : }
10843 :
10844 : /************************************************************************/
10845 : /* operator>() */
10846 : /************************************************************************/
10847 :
10848 : /** Return a band whose value is 1 if the constant is greater than the pixel
10849 : * value of the right operand.
10850 : *
10851 : * The resulting band is lazy evaluated. A reference is taken on the input
10852 : * dataset.
10853 : *
10854 : * @since 3.12
10855 : */
10856 2 : GDALComputedRasterBand operator>(double constant, const GDALRasterBand &other)
10857 : {
10858 : #ifndef HAVE_MUPARSER
10859 : (void)constant;
10860 : (void)other;
10861 : return ThrowIfNotMuparser();
10862 : #else
10863 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_GT,
10864 2 : constant, other);
10865 : #endif
10866 : }
10867 :
10868 : /************************************************************************/
10869 : /* operator>=() */
10870 : /************************************************************************/
10871 :
10872 : /** Return a band whose value is 1 if the pixel value of the left operand
10873 : * is greater or equal to the pixel value of the right operand.
10874 : *
10875 : * The resulting band is lazy evaluated. A reference is taken on the input
10876 : * dataset.
10877 : *
10878 : * @since 3.12
10879 : */
10880 : GDALComputedRasterBand
10881 4 : GDALRasterBand::operator>=(const GDALRasterBand &other) const
10882 : {
10883 : #ifndef HAVE_MUPARSER
10884 : (void)other;
10885 : return ThrowIfNotMuparser();
10886 : #else
10887 4 : ThrowIfNotSameDimensions(*this, other);
10888 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_GE,
10889 3 : *this, other);
10890 : #endif
10891 : }
10892 :
10893 : /************************************************************************/
10894 : /* operator>=() */
10895 : /************************************************************************/
10896 :
10897 : /** Return a band whose value is 1 if the pixel value of the left operand
10898 : * is greater or equal to the constant.
10899 : *
10900 : * The resulting band is lazy evaluated. A reference is taken on the input
10901 : * dataset.
10902 : *
10903 : * @since 3.12
10904 : */
10905 3 : GDALComputedRasterBand GDALRasterBand::operator>=(double constant) const
10906 : {
10907 : #ifndef HAVE_MUPARSER
10908 : (void)constant;
10909 : return ThrowIfNotMuparser();
10910 : #else
10911 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_GE,
10912 3 : *this, constant);
10913 : #endif
10914 : }
10915 :
10916 : /************************************************************************/
10917 : /* operator>=() */
10918 : /************************************************************************/
10919 :
10920 : /** Return a band whose value is 1 if the constant is greater or equal to
10921 : * the pixel value of the right operand.
10922 : *
10923 : * The resulting band is lazy evaluated. A reference is taken on the input
10924 : * dataset.
10925 : *
10926 : * @since 3.12
10927 : */
10928 2 : GDALComputedRasterBand operator>=(double constant, const GDALRasterBand &other)
10929 : {
10930 : #ifndef HAVE_MUPARSER
10931 : (void)constant;
10932 : (void)other;
10933 : return ThrowIfNotMuparser();
10934 : #else
10935 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_GE,
10936 2 : constant, other);
10937 : #endif
10938 : }
10939 :
10940 : /************************************************************************/
10941 : /* operator<() */
10942 : /************************************************************************/
10943 :
10944 : /** Return a band whose value is 1 if the pixel value of the left operand
10945 : * is lesser than the pixel value of the right operand.
10946 : *
10947 : * The resulting band is lazy evaluated. A reference is taken on the input
10948 : * dataset.
10949 : *
10950 : * @since 3.12
10951 : */
10952 : GDALComputedRasterBand
10953 3 : GDALRasterBand::operator<(const GDALRasterBand &other) const
10954 : {
10955 : #ifndef HAVE_MUPARSER
10956 : (void)other;
10957 : return ThrowIfNotMuparser();
10958 : #else
10959 3 : ThrowIfNotSameDimensions(*this, other);
10960 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_LT,
10961 2 : *this, other);
10962 : #endif
10963 : }
10964 :
10965 : /************************************************************************/
10966 : /* operator<() */
10967 : /************************************************************************/
10968 :
10969 : /** Return a band whose value is 1 if the pixel value of the left operand
10970 : * is lesser than the constant.
10971 : *
10972 : * The resulting band is lazy evaluated. A reference is taken on the input
10973 : * dataset.
10974 : *
10975 : * @since 3.12
10976 : */
10977 3 : GDALComputedRasterBand GDALRasterBand::operator<(double constant) const
10978 : {
10979 : #ifndef HAVE_MUPARSER
10980 : (void)constant;
10981 : return ThrowIfNotMuparser();
10982 : #else
10983 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_LT,
10984 3 : *this, constant);
10985 : #endif
10986 : }
10987 :
10988 : /************************************************************************/
10989 : /* operator<() */
10990 : /************************************************************************/
10991 :
10992 : /** Return a band whose value is 1 if the constant is lesser than the pixel
10993 : * value of the right operand.
10994 : *
10995 : * The resulting band is lazy evaluated. A reference is taken on the input
10996 : * dataset.
10997 : *
10998 : * @since 3.12
10999 : */
11000 2 : GDALComputedRasterBand operator<(double constant, const GDALRasterBand &other)
11001 : {
11002 : #ifndef HAVE_MUPARSER
11003 : (void)constant;
11004 : (void)other;
11005 : return ThrowIfNotMuparser();
11006 : #else
11007 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_LT,
11008 2 : constant, other);
11009 : #endif
11010 : }
11011 :
11012 : /************************************************************************/
11013 : /* operator<=() */
11014 : /************************************************************************/
11015 :
11016 : /** Return a band whose value is 1 if the pixel value of the left operand
11017 : * is lesser or equal to the pixel value of the right operand.
11018 : *
11019 : * The resulting band is lazy evaluated. A reference is taken on the input
11020 : * dataset.
11021 : *
11022 : * @since 3.12
11023 : */
11024 : GDALComputedRasterBand
11025 4 : GDALRasterBand::operator<=(const GDALRasterBand &other) const
11026 : {
11027 : #ifndef HAVE_MUPARSER
11028 : (void)other;
11029 : return ThrowIfNotMuparser();
11030 : #else
11031 4 : ThrowIfNotSameDimensions(*this, other);
11032 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_LE,
11033 3 : *this, other);
11034 : #endif
11035 : }
11036 :
11037 : /************************************************************************/
11038 : /* operator<=() */
11039 : /************************************************************************/
11040 :
11041 : /** Return a band whose value is 1 if the pixel value of the left operand
11042 : * is lesser or equal to the constant.
11043 : *
11044 : * The resulting band is lazy evaluated. A reference is taken on the input
11045 : * dataset.
11046 : *
11047 : * @since 3.12
11048 : */
11049 3 : GDALComputedRasterBand GDALRasterBand::operator<=(double constant) const
11050 : {
11051 : #ifndef HAVE_MUPARSER
11052 : (void)constant;
11053 : return ThrowIfNotMuparser();
11054 : #else
11055 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_LE,
11056 3 : *this, constant);
11057 : #endif
11058 : }
11059 :
11060 : /************************************************************************/
11061 : /* operator<=() */
11062 : /************************************************************************/
11063 :
11064 : /** Return a band whose value is 1 if the constant is lesser or equal to
11065 : * the pixel value of the right operand.
11066 : *
11067 : * The resulting band is lazy evaluated. A reference is taken on the input
11068 : * dataset.
11069 : *
11070 : * @since 3.12
11071 : */
11072 2 : GDALComputedRasterBand operator<=(double constant, const GDALRasterBand &other)
11073 : {
11074 : #ifndef HAVE_MUPARSER
11075 : (void)constant;
11076 : (void)other;
11077 : return ThrowIfNotMuparser();
11078 : #else
11079 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_LE,
11080 2 : constant, other);
11081 : #endif
11082 : }
11083 :
11084 : /************************************************************************/
11085 : /* operator==() */
11086 : /************************************************************************/
11087 :
11088 : /** Return a band whose value is 1 if the pixel value of the left operand
11089 : * is equal to the pixel value of the right operand.
11090 : *
11091 : * The resulting band is lazy evaluated. A reference is taken on the input
11092 : * dataset.
11093 : *
11094 : * @since 3.12
11095 : */
11096 : GDALComputedRasterBand
11097 3 : GDALRasterBand::operator==(const GDALRasterBand &other) const
11098 : {
11099 : #ifndef HAVE_MUPARSER
11100 : (void)other;
11101 : return ThrowIfNotMuparser();
11102 : #else
11103 3 : ThrowIfNotSameDimensions(*this, other);
11104 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_EQ,
11105 2 : *this, other);
11106 : #endif
11107 : }
11108 :
11109 : /************************************************************************/
11110 : /* operator==() */
11111 : /************************************************************************/
11112 :
11113 : /** Return a band whose value is 1 if the pixel value of the left operand
11114 : * is equal to the constant.
11115 : *
11116 : * The resulting band is lazy evaluated. A reference is taken on the input
11117 : * dataset.
11118 : *
11119 : * @since 3.12
11120 : */
11121 8 : GDALComputedRasterBand GDALRasterBand::operator==(double constant) const
11122 : {
11123 : #ifndef HAVE_MUPARSER
11124 : (void)constant;
11125 : return ThrowIfNotMuparser();
11126 : #else
11127 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_EQ,
11128 8 : *this, constant);
11129 : #endif
11130 : }
11131 :
11132 : /************************************************************************/
11133 : /* operator==() */
11134 : /************************************************************************/
11135 :
11136 : /** Return a band whose value is 1 if the constant is equal to
11137 : * the pixel value of the right operand.
11138 : *
11139 : * The resulting band is lazy evaluated. A reference is taken on the input
11140 : * dataset.
11141 : *
11142 : * @since 3.12
11143 : */
11144 2 : GDALComputedRasterBand operator==(double constant, const GDALRasterBand &other)
11145 : {
11146 : #ifndef HAVE_MUPARSER
11147 : (void)constant;
11148 : (void)other;
11149 : return ThrowIfNotMuparser();
11150 : #else
11151 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_EQ,
11152 2 : constant, other);
11153 : #endif
11154 : }
11155 :
11156 : /************************************************************************/
11157 : /* operator!=() */
11158 : /************************************************************************/
11159 :
11160 : /** Return a band whose value is 1 if the pixel value of the left operand
11161 : * is different from the pixel value of the right operand.
11162 : *
11163 : * The resulting band is lazy evaluated. A reference is taken on the input
11164 : * dataset.
11165 : *
11166 : * @since 3.12
11167 : */
11168 : GDALComputedRasterBand
11169 3 : GDALRasterBand::operator!=(const GDALRasterBand &other) const
11170 : {
11171 : #ifndef HAVE_MUPARSER
11172 : (void)other;
11173 : return ThrowIfNotMuparser();
11174 : #else
11175 3 : ThrowIfNotSameDimensions(*this, other);
11176 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_NE,
11177 2 : *this, other);
11178 : #endif
11179 : }
11180 :
11181 : /************************************************************************/
11182 : /* operator!=() */
11183 : /************************************************************************/
11184 :
11185 : /** Return a band whose value is 1 if the pixel value of the left operand
11186 : * is different from the constant.
11187 : *
11188 : * The resulting band is lazy evaluated. A reference is taken on the input
11189 : * dataset.
11190 : *
11191 : * @since 3.12
11192 : */
11193 6 : GDALComputedRasterBand GDALRasterBand::operator!=(double constant) const
11194 : {
11195 : #ifndef HAVE_MUPARSER
11196 : (void)constant;
11197 : return ThrowIfNotMuparser();
11198 : #else
11199 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_NE,
11200 6 : *this, constant);
11201 : #endif
11202 : }
11203 :
11204 : /************************************************************************/
11205 : /* operator!=() */
11206 : /************************************************************************/
11207 :
11208 : /** Return a band whose value is 1 if the constant is different from
11209 : * the pixel value of the right operand.
11210 : *
11211 : * The resulting band is lazy evaluated. A reference is taken on the input
11212 : * dataset.
11213 : *
11214 : * @since 3.12
11215 : */
11216 2 : GDALComputedRasterBand operator!=(double constant, const GDALRasterBand &other)
11217 : {
11218 : #ifndef HAVE_MUPARSER
11219 : (void)constant;
11220 : (void)other;
11221 : return ThrowIfNotMuparser();
11222 : #else
11223 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_NE,
11224 2 : constant, other);
11225 : #endif
11226 : }
11227 :
11228 : #if defined(__GNUC__)
11229 : #pragma GCC diagnostic push
11230 : #pragma GCC diagnostic ignored "-Weffc++"
11231 : #endif
11232 :
11233 : /************************************************************************/
11234 : /* operator&&() */
11235 : /************************************************************************/
11236 :
11237 : /** Return a band whose value is 1 if the pixel value of the left and right
11238 : * operands is true.
11239 : *
11240 : * The resulting band is lazy evaluated. A reference is taken on the input
11241 : * dataset.
11242 : *
11243 : * @since 3.12
11244 : */
11245 : GDALComputedRasterBand
11246 3 : GDALRasterBand::operator&&(const GDALRasterBand &other) const
11247 : {
11248 : #ifndef HAVE_MUPARSER
11249 : (void)other;
11250 : return ThrowIfNotMuparser();
11251 : #else
11252 3 : ThrowIfNotSameDimensions(*this, other);
11253 : return GDALComputedRasterBand(
11254 2 : GDALComputedRasterBand::Operation::OP_LOGICAL_AND, *this, other);
11255 : #endif
11256 : }
11257 :
11258 : /************************************************************************/
11259 : /* operator&&() */
11260 : /************************************************************************/
11261 :
11262 : /** Return a band whose value is 1 if the pixel value of the left operand
11263 : * is true, as well as the constant
11264 : *
11265 : * The resulting band is lazy evaluated. A reference is taken on the input
11266 : * dataset.
11267 : *
11268 : * @since 3.12
11269 : */
11270 2 : GDALComputedRasterBand GDALRasterBand::operator&&(bool constant) const
11271 : {
11272 : #ifndef HAVE_MUPARSER
11273 : (void)constant;
11274 : return ThrowIfNotMuparser();
11275 : #else
11276 : return GDALComputedRasterBand(
11277 2 : GDALComputedRasterBand::Operation::OP_LOGICAL_AND, *this, constant);
11278 : #endif
11279 : }
11280 :
11281 : /************************************************************************/
11282 : /* operator&&() */
11283 : /************************************************************************/
11284 :
11285 : /** Return a band whose value is 1 if the constant is true, as well as
11286 : * the pixel value of the right operand.
11287 : *
11288 : * The resulting band is lazy evaluated. A reference is taken on the input
11289 : * dataset.
11290 : *
11291 : * @since 3.12
11292 : */
11293 2 : GDALComputedRasterBand operator&&(bool constant, const GDALRasterBand &other)
11294 : {
11295 : #ifndef HAVE_MUPARSER
11296 : (void)constant;
11297 : (void)other;
11298 : return ThrowIfNotMuparser();
11299 : #else
11300 : return GDALComputedRasterBand(
11301 2 : GDALComputedRasterBand::Operation::OP_LOGICAL_AND, constant, other);
11302 : #endif
11303 : }
11304 :
11305 : /************************************************************************/
11306 : /* operator||() */
11307 : /************************************************************************/
11308 :
11309 : /** Return a band whose value is 1 if the pixel value of the left or right
11310 : * operands is true.
11311 : *
11312 : * The resulting band is lazy evaluated. A reference is taken on the input
11313 : * dataset.
11314 : *
11315 : * @since 3.12
11316 : */
11317 : GDALComputedRasterBand
11318 4 : GDALRasterBand::operator||(const GDALRasterBand &other) const
11319 : {
11320 : #ifndef HAVE_MUPARSER
11321 : (void)other;
11322 : return ThrowIfNotMuparser();
11323 : #else
11324 4 : ThrowIfNotSameDimensions(*this, other);
11325 : return GDALComputedRasterBand(
11326 3 : GDALComputedRasterBand::Operation::OP_LOGICAL_OR, *this, other);
11327 : #endif
11328 : }
11329 :
11330 : /************************************************************************/
11331 : /* operator||() */
11332 : /************************************************************************/
11333 :
11334 : /** Return a band whose value is 1 if the pixel value of the left operand
11335 : * is true, or if the constant is true
11336 : *
11337 : * The resulting band is lazy evaluated. A reference is taken on the input
11338 : * dataset.
11339 : *
11340 : * @since 3.12
11341 : */
11342 4 : GDALComputedRasterBand GDALRasterBand::operator||(bool constant) const
11343 : {
11344 : #ifndef HAVE_MUPARSER
11345 : (void)constant;
11346 : return ThrowIfNotMuparser();
11347 : #else
11348 : return GDALComputedRasterBand(
11349 4 : GDALComputedRasterBand::Operation::OP_LOGICAL_OR, *this, constant);
11350 : #endif
11351 : }
11352 :
11353 : /************************************************************************/
11354 : /* operator||() */
11355 : /************************************************************************/
11356 :
11357 : /** Return a band whose value is 1 if the constant is true, or
11358 : * the pixel value of the right operand is true
11359 : *
11360 : * The resulting band is lazy evaluated. A reference is taken on the input
11361 : * dataset.
11362 : *
11363 : * @since 3.12
11364 : */
11365 4 : GDALComputedRasterBand operator||(bool constant, const GDALRasterBand &other)
11366 : {
11367 : #ifndef HAVE_MUPARSER
11368 : (void)constant;
11369 : (void)other;
11370 : return ThrowIfNotMuparser();
11371 : #else
11372 : return GDALComputedRasterBand(
11373 4 : GDALComputedRasterBand::Operation::OP_LOGICAL_OR, constant, other);
11374 : #endif
11375 : }
11376 :
11377 : #if defined(__GNUC__)
11378 : #pragma GCC diagnostic pop
11379 : #endif
11380 :
11381 : /************************************************************************/
11382 : /* operator!() */
11383 : /************************************************************************/
11384 :
11385 : /** Return a band whose value is the logical negation of the pixel value
11386 : *
11387 : * The resulting band is lazy evaluated. A reference is taken on the input
11388 : * dataset.
11389 : *
11390 : * @since 3.12
11391 : */
11392 2 : GDALComputedRasterBand GDALRasterBand::operator!() const
11393 : {
11394 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_NE,
11395 2 : *this, true);
11396 : }
11397 :
11398 : namespace gdal
11399 : {
11400 :
11401 : /************************************************************************/
11402 : /* IfThenElse() */
11403 : /************************************************************************/
11404 :
11405 : /** Return a band whose value is thenBand if the corresponding pixel in condBand
11406 : * is not zero, or the one from elseBand otherwise.
11407 : *
11408 : * Variants of this method exits where thenBand and/or elseBand can be double
11409 : * values.
11410 : *
11411 : * The resulting band is lazy evaluated. A reference is taken on the input
11412 : * datasets.
11413 : *
11414 : * This method is the same as the C function GDALRasterBandIfThenElse()
11415 : *
11416 : * @since 3.12
11417 : */
11418 5 : GDALComputedRasterBand IfThenElse(const GDALRasterBand &condBand,
11419 : const GDALRasterBand &thenBand,
11420 : const GDALRasterBand &elseBand)
11421 : {
11422 : #ifndef HAVE_MUPARSER
11423 : (void)condBand;
11424 : (void)thenBand;
11425 : (void)elseBand;
11426 : return ThrowIfNotMuparser();
11427 : #else
11428 5 : GDALRasterBand::ThrowIfNotSameDimensions(condBand, thenBand);
11429 4 : GDALRasterBand::ThrowIfNotSameDimensions(condBand, elseBand);
11430 : return GDALComputedRasterBand(
11431 : GDALComputedRasterBand::Operation::OP_TERNARY,
11432 6 : std::vector<const GDALRasterBand *>{&condBand, &thenBand, &elseBand});
11433 : #endif
11434 : }
11435 :
11436 : //! @cond Doxygen_Suppress
11437 :
11438 : /************************************************************************/
11439 : /* IfThenElse() */
11440 : /************************************************************************/
11441 :
11442 : /** Return a band whose value is thenValue if the corresponding pixel in condBand
11443 : * is not zero, or the one from elseBand otherwise.
11444 : *
11445 : * The resulting band is lazy evaluated. A reference is taken on the input
11446 : * datasets.
11447 : *
11448 : * This method is the same as the C function GDALRasterBandIfThenElse(),
11449 : * with thenBand = (condBand * 0) + thenValue
11450 : *
11451 : * @since 3.12
11452 : */
11453 1 : GDALComputedRasterBand IfThenElse(const GDALRasterBand &condBand,
11454 : double thenValue,
11455 : const GDALRasterBand &elseBand)
11456 : {
11457 : #ifndef HAVE_MUPARSER
11458 : (void)condBand;
11459 : (void)thenValue;
11460 : (void)elseBand;
11461 : return ThrowIfNotMuparser();
11462 : #else
11463 1 : GDALRasterBand::ThrowIfNotSameDimensions(condBand, elseBand);
11464 : auto thenBand =
11465 1 : (condBand * 0)
11466 2 : .AsType(GDALDataTypeUnionWithValue(GDT_Unknown, thenValue, false)) +
11467 1 : thenValue;
11468 : return GDALComputedRasterBand(
11469 : GDALComputedRasterBand::Operation::OP_TERNARY,
11470 3 : std::vector<const GDALRasterBand *>{&condBand, &thenBand, &elseBand});
11471 : #endif
11472 : }
11473 :
11474 : /************************************************************************/
11475 : /* IfThenElse() */
11476 : /************************************************************************/
11477 :
11478 : /** Return a band whose value is thenBand if the corresponding pixel in condBand
11479 : * is not zero, or the one from elseValue otherwise.
11480 : *
11481 : * The resulting band is lazy evaluated. A reference is taken on the input
11482 : * datasets.
11483 : *
11484 : * This method is the same as the C function GDALRasterBandIfThenElse(),
11485 : * with elseBand = (condBand * 0) + elseValue
11486 :
11487 : * @since 3.12
11488 : */
11489 1 : GDALComputedRasterBand IfThenElse(const GDALRasterBand &condBand,
11490 : const GDALRasterBand &thenBand,
11491 : double elseValue)
11492 : {
11493 : #ifndef HAVE_MUPARSER
11494 : (void)condBand;
11495 : (void)thenBand;
11496 : (void)elseValue;
11497 : return ThrowIfNotMuparser();
11498 : #else
11499 1 : GDALRasterBand::ThrowIfNotSameDimensions(condBand, thenBand);
11500 : auto elseBand =
11501 1 : (condBand * 0)
11502 2 : .AsType(GDALDataTypeUnionWithValue(GDT_Unknown, elseValue, false)) +
11503 1 : elseValue;
11504 : return GDALComputedRasterBand(
11505 : GDALComputedRasterBand::Operation::OP_TERNARY,
11506 3 : std::vector<const GDALRasterBand *>{&condBand, &thenBand, &elseBand});
11507 : #endif
11508 : }
11509 :
11510 : /************************************************************************/
11511 : /* IfThenElse() */
11512 : /************************************************************************/
11513 :
11514 : /** Return a band whose value is thenValue if the corresponding pixel in condBand
11515 : * is not zero, or the one from elseValue otherwise.
11516 : *
11517 : * The resulting band is lazy evaluated. A reference is taken on the input
11518 : * datasets.
11519 : *
11520 : * This method is the same as the C function GDALRasterBandIfThenElse(),
11521 : * with thenBand = (condBand * 0) + thenValue and elseBand = (condBand * 0) + elseValue
11522 : *
11523 : * @since 3.12
11524 : */
11525 3 : GDALComputedRasterBand IfThenElse(const GDALRasterBand &condBand,
11526 : double thenValue, double elseValue)
11527 : {
11528 : #ifndef HAVE_MUPARSER
11529 : (void)condBand;
11530 : (void)thenValue;
11531 : (void)elseValue;
11532 : return ThrowIfNotMuparser();
11533 : #else
11534 : auto thenBand =
11535 3 : (condBand * 0)
11536 6 : .AsType(GDALDataTypeUnionWithValue(GDT_Unknown, thenValue, false)) +
11537 6 : thenValue;
11538 : auto elseBand =
11539 3 : (condBand * 0)
11540 6 : .AsType(GDALDataTypeUnionWithValue(GDT_Unknown, elseValue, false)) +
11541 3 : elseValue;
11542 : return GDALComputedRasterBand(
11543 : GDALComputedRasterBand::Operation::OP_TERNARY,
11544 9 : std::vector<const GDALRasterBand *>{&condBand, &thenBand, &elseBand});
11545 : #endif
11546 : }
11547 :
11548 : //! @endcond
11549 :
11550 : } // namespace gdal
11551 :
11552 : /************************************************************************/
11553 : /* GDALRasterBandIfThenElse() */
11554 : /************************************************************************/
11555 :
11556 : /** Return a band whose value is hThenBand if the corresponding pixel in hCondBand
11557 : * is not zero, or the one from hElseBand otherwise.
11558 : *
11559 : * The resulting band is lazy evaluated. A reference is taken on the input
11560 : * datasets.
11561 : *
11562 : * This function is the same as the C++ method gdal::IfThenElse()
11563 : *
11564 : * @since 3.12
11565 : */
11566 12 : GDALComputedRasterBandH GDALRasterBandIfThenElse(GDALRasterBandH hCondBand,
11567 : GDALRasterBandH hThenBand,
11568 : GDALRasterBandH hElseBand)
11569 : {
11570 12 : VALIDATE_POINTER1(hCondBand, __func__, nullptr);
11571 12 : VALIDATE_POINTER1(hThenBand, __func__, nullptr);
11572 12 : VALIDATE_POINTER1(hElseBand, __func__, nullptr);
11573 : #ifndef HAVE_MUPARSER
11574 : CPLError(CE_Failure, CPLE_NotSupported,
11575 : "Band comparison operators not available on a GDAL build without "
11576 : "muparser");
11577 : return nullptr;
11578 : #else
11579 :
11580 12 : auto &condBand = *(GDALRasterBand::FromHandle(hCondBand));
11581 12 : auto &thenBand = *(GDALRasterBand::FromHandle(hThenBand));
11582 12 : auto &elseBand = *(GDALRasterBand::FromHandle(hElseBand));
11583 : try
11584 : {
11585 12 : GDALRasterBand::ThrowIfNotSameDimensions(condBand, thenBand);
11586 11 : GDALRasterBand::ThrowIfNotSameDimensions(condBand, elseBand);
11587 : }
11588 2 : catch (const std::exception &e)
11589 : {
11590 2 : CPLError(CE_Failure, CPLE_AppDefined, "%s", e.what());
11591 2 : return nullptr;
11592 : }
11593 : return new GDALComputedRasterBand(
11594 : GDALComputedRasterBand::Operation::OP_TERNARY,
11595 10 : std::vector<const GDALRasterBand *>{&condBand, &thenBand, &elseBand});
11596 : #endif
11597 : }
11598 :
11599 : /************************************************************************/
11600 : /* GDALRasterBand::AsType() */
11601 : /************************************************************************/
11602 :
11603 : /** Cast this band to another type.
11604 : *
11605 : * The resulting band is lazy evaluated. A reference is taken on the input
11606 : * dataset.
11607 : *
11608 : * This method is the same as the C function GDALRasterBandAsDataType()
11609 : *
11610 : * @since 3.12
11611 : */
11612 10 : GDALComputedRasterBand GDALRasterBand::AsType(GDALDataType dt) const
11613 : {
11614 10 : if (dt == GDT_Unknown)
11615 : {
11616 1 : throw std::runtime_error("AsType(GDT_Unknown) is not supported");
11617 : }
11618 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_CAST,
11619 9 : *this, dt);
11620 : }
11621 :
11622 : /************************************************************************/
11623 : /* GDALRasterBandAsDataType() */
11624 : /************************************************************************/
11625 :
11626 : /** Cast this band to another type.
11627 : *
11628 : * The resulting band is lazy evaluated. A reference is taken on the input
11629 : * dataset.
11630 : *
11631 : * This function is the same as the C++ method GDALRasterBand::AsType()
11632 : *
11633 : * @since 3.12
11634 : * @return a handle to free with GDALComputedRasterBandRelease(), or nullptr if error.
11635 : */
11636 16 : GDALComputedRasterBandH GDALRasterBandAsDataType(GDALRasterBandH hBand,
11637 : GDALDataType eDT)
11638 : {
11639 16 : VALIDATE_POINTER1(hBand, __func__, nullptr);
11640 16 : if (eDT == GDT_Unknown)
11641 : {
11642 1 : CPLError(CE_Failure, CPLE_NotSupported,
11643 : "GDALRasterBandAsDataType(GDT_Unknown) not supported");
11644 1 : return nullptr;
11645 : }
11646 : return new GDALComputedRasterBand(
11647 : GDALComputedRasterBand::Operation::OP_CAST,
11648 15 : *(GDALRasterBand::FromHandle(hBand)), eDT);
11649 : }
11650 :
11651 : /************************************************************************/
11652 : /* GetBandVector() */
11653 : /************************************************************************/
11654 :
11655 : static std::vector<const GDALRasterBand *>
11656 10 : GetBandVector(size_t nBandCount, GDALRasterBandH *pahBands)
11657 : {
11658 10 : std::vector<const GDALRasterBand *> bands;
11659 27 : for (size_t i = 0; i < nBandCount; ++i)
11660 : {
11661 20 : if (i > 0)
11662 : {
11663 10 : GDALRasterBand::ThrowIfNotSameDimensions(
11664 10 : *(GDALRasterBand::FromHandle(pahBands[0])),
11665 10 : *(GDALRasterBand::FromHandle(pahBands[i])));
11666 : }
11667 17 : bands.push_back(GDALRasterBand::FromHandle(pahBands[i]));
11668 : }
11669 7 : return bands;
11670 : }
11671 :
11672 : /************************************************************************/
11673 : /* GDALOperationOnNBands() */
11674 : /************************************************************************/
11675 :
11676 : static GDALComputedRasterBandH
11677 11 : GDALOperationOnNBands(GDALComputedRasterBand::Operation op, size_t nBandCount,
11678 : GDALRasterBandH *pahBands)
11679 : {
11680 11 : VALIDATE_POINTER1(pahBands, __func__, nullptr);
11681 11 : if (nBandCount == 0)
11682 : {
11683 1 : CPLError(CE_Failure, CPLE_AppDefined,
11684 : "At least one band should be passed");
11685 1 : return nullptr;
11686 : }
11687 :
11688 20 : std::vector<const GDALRasterBand *> bands;
11689 : try
11690 : {
11691 10 : bands = GetBandVector(nBandCount, pahBands);
11692 : }
11693 3 : catch (const std::exception &e)
11694 : {
11695 3 : CPLError(CE_Failure, CPLE_AppDefined, "%s", e.what());
11696 3 : return nullptr;
11697 : }
11698 7 : return GDALRasterBand::ToHandle(new GDALComputedRasterBand(op, bands));
11699 : }
11700 :
11701 : /************************************************************************/
11702 : /* GDALMaximumOfNBands() */
11703 : /************************************************************************/
11704 :
11705 : /** Return a band whose each pixel value is the maximum of the corresponding
11706 : * pixel values in the input bands.
11707 : *
11708 : * The resulting band is lazy evaluated. A reference is taken on input
11709 : * datasets.
11710 : *
11711 : * This function is the same as the C ++ method gdal::max()
11712 : *
11713 : * @since 3.12
11714 : * @return a handle to free with GDALComputedRasterBandRelease(), or nullptr if error.
11715 : */
11716 4 : GDALComputedRasterBandH GDALMaximumOfNBands(size_t nBandCount,
11717 : GDALRasterBandH *pahBands)
11718 : {
11719 4 : return GDALOperationOnNBands(GDALComputedRasterBand::Operation::OP_MAX,
11720 4 : nBandCount, pahBands);
11721 : }
11722 :
11723 : /************************************************************************/
11724 : /* gdal::max() */
11725 : /************************************************************************/
11726 :
11727 : namespace gdal
11728 : {
11729 : /** Return a band whose each pixel value is the maximum of the corresponding
11730 : * pixel values in the inputs (bands or constants)
11731 : *
11732 : * The resulting band is lazy evaluated. A reference is taken on input
11733 : * datasets.
11734 : *
11735 : * Two or more bands can be passed.
11736 : *
11737 : * This method is the same as the C function GDALMaximumOfNBands()
11738 : *
11739 : * @since 3.12
11740 : * @throw std::runtime_error if bands do not have the same dimensions.
11741 : */
11742 1 : GDALComputedRasterBand max(const GDALRasterBand &first,
11743 : const GDALRasterBand &second)
11744 : {
11745 1 : GDALRasterBand::ThrowIfNotSameDimensions(first, second);
11746 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_MAX,
11747 1 : first, second);
11748 : }
11749 : } // namespace gdal
11750 :
11751 : /************************************************************************/
11752 : /* GDALRasterBandMaxConstant() */
11753 : /************************************************************************/
11754 :
11755 : /** Return a band whose each pixel value is the maximum of the corresponding
11756 : * pixel values in the input band and the constant.
11757 : *
11758 : * The resulting band is lazy evaluated. A reference is taken on the input
11759 : * dataset.
11760 : *
11761 : * This function is the same as the C ++ method gdal::max()
11762 : *
11763 : * @since 3.12
11764 : * @return a handle to free with GDALComputedRasterBandRelease(), or nullptr if error.
11765 : */
11766 2 : GDALComputedRasterBandH GDALRasterBandMaxConstant(GDALRasterBandH hBand,
11767 : double dfConstant)
11768 : {
11769 2 : return GDALRasterBand::ToHandle(new GDALComputedRasterBand(
11770 : GDALComputedRasterBand::Operation::OP_MAX,
11771 4 : std::vector<const GDALRasterBand *>{GDALRasterBand::FromHandle(hBand)},
11772 6 : dfConstant));
11773 : }
11774 :
11775 : /************************************************************************/
11776 : /* GDALMinimumOfNBands() */
11777 : /************************************************************************/
11778 :
11779 : /** Return a band whose each pixel value is the minimum of the corresponding
11780 : * pixel values in the input bands.
11781 : *
11782 : * The resulting band is lazy evaluated. A reference is taken on input
11783 : * datasets.
11784 : *
11785 : * This function is the same as the C ++ method gdal::min()
11786 : *
11787 : * @since 3.12
11788 : * @return a handle to free with GDALComputedRasterBandRelease(), or nullptr if error.
11789 : */
11790 4 : GDALComputedRasterBandH GDALMinimumOfNBands(size_t nBandCount,
11791 : GDALRasterBandH *pahBands)
11792 : {
11793 4 : return GDALOperationOnNBands(GDALComputedRasterBand::Operation::OP_MIN,
11794 4 : nBandCount, pahBands);
11795 : }
11796 :
11797 : /************************************************************************/
11798 : /* gdal::min() */
11799 : /************************************************************************/
11800 :
11801 : namespace gdal
11802 : {
11803 : /** Return a band whose each pixel value is the minimum of the corresponding
11804 : * pixel values in the inputs (bands or constants)
11805 : *
11806 : * The resulting band is lazy evaluated. A reference is taken on input
11807 : * datasets.
11808 : *
11809 : * Two or more bands can be passed.
11810 : *
11811 : * This method is the same as the C function GDALMinimumOfNBands()
11812 : *
11813 : * @since 3.12
11814 : * @throw std::runtime_error if bands do not have the same dimensions.
11815 : */
11816 0 : GDALComputedRasterBand min(const GDALRasterBand &first,
11817 : const GDALRasterBand &second)
11818 : {
11819 0 : GDALRasterBand::ThrowIfNotSameDimensions(first, second);
11820 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_MIN,
11821 0 : first, second);
11822 : }
11823 : } // namespace gdal
11824 :
11825 : /************************************************************************/
11826 : /* GDALRasterBandMinConstant() */
11827 : /************************************************************************/
11828 :
11829 : /** Return a band whose each pixel value is the minimum of the corresponding
11830 : * pixel values in the input band and the constant.
11831 : *
11832 : * The resulting band is lazy evaluated. A reference is taken on the input
11833 : * dataset.
11834 : *
11835 : * This function is the same as the C ++ method gdal::min()
11836 : *
11837 : * @since 3.12
11838 : * @return a handle to free with GDALComputedRasterBandRelease(), or nullptr if error.
11839 : */
11840 2 : GDALComputedRasterBandH GDALRasterBandMinConstant(GDALRasterBandH hBand,
11841 : double dfConstant)
11842 : {
11843 2 : return GDALRasterBand::ToHandle(new GDALComputedRasterBand(
11844 : GDALComputedRasterBand::Operation::OP_MIN,
11845 4 : std::vector<const GDALRasterBand *>{GDALRasterBand::FromHandle(hBand)},
11846 6 : dfConstant));
11847 : }
11848 :
11849 : /************************************************************************/
11850 : /* GDALMeanOfNBands() */
11851 : /************************************************************************/
11852 :
11853 : /** Return a band whose each pixel value is the arithmetic mean of the
11854 : * corresponding pixel values in the input bands.
11855 : *
11856 : * The resulting band is lazy evaluated. A reference is taken on input
11857 : * datasets.
11858 : *
11859 : * This function is the same as the C ++ method gdal::mean()
11860 : *
11861 : * @since 3.12
11862 : * @return a handle to free with GDALComputedRasterBandRelease(), or nullptr if error.
11863 : */
11864 3 : GDALComputedRasterBandH GDALMeanOfNBands(size_t nBandCount,
11865 : GDALRasterBandH *pahBands)
11866 : {
11867 3 : return GDALOperationOnNBands(GDALComputedRasterBand::Operation::OP_MEAN,
11868 3 : nBandCount, pahBands);
11869 : }
11870 :
11871 : /************************************************************************/
11872 : /* gdal::mean() */
11873 : /************************************************************************/
11874 :
11875 : namespace gdal
11876 : {
11877 :
11878 : /** Return a band whose each pixel value is the arithmetic mean of the
11879 : * corresponding pixel values in the input bands.
11880 : *
11881 : * The resulting band is lazy evaluated. A reference is taken on input
11882 : * datasets.
11883 : *
11884 : * Two or more bands can be passed.
11885 : *
11886 : * This method is the same as the C function GDALMeanOfNBands()
11887 : *
11888 : * @since 3.12
11889 : * @throw std::runtime_error if bands do not have the same dimensions.
11890 : */
11891 0 : GDALComputedRasterBand mean(const GDALRasterBand &first,
11892 : const GDALRasterBand &second)
11893 : {
11894 0 : GDALRasterBand::ThrowIfNotSameDimensions(first, second);
11895 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_MEAN,
11896 0 : first, second);
11897 : }
11898 : } // namespace gdal
|
