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 :
18 : #include <cassert>
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_abstractbandblockcache.h"
41 : #include "gdalantirecursion.h"
42 : #include "gdal_rat.h"
43 : #include "gdal_rasterband.h"
44 : #include "gdal_priv_templates.hpp"
45 : #include "gdal_interpolateatpoint.h"
46 : #include "gdal_minmax_element.hpp"
47 : #include "gdalmultidim_priv.h"
48 :
49 : #if defined(__AVX2__) || defined(__FMA__)
50 : #include <immintrin.h>
51 : #endif
52 :
53 : /************************************************************************/
54 : /* GDALRasterBand() */
55 : /************************************************************************/
56 :
57 : /*! Constructor. Applications should never create GDALRasterBands directly. */
58 :
59 1571390 : GDALRasterBand::GDALRasterBand()
60 : : GDALRasterBand(
61 1571390 : CPLTestBool(CPLGetConfigOption("GDAL_FORCE_CACHING", "NO")))
62 : {
63 1571330 : }
64 :
65 : /** Constructor. Applications should never create GDALRasterBands directly.
66 : * @param bForceCachedIOIn Whether cached IO should be forced.
67 : */
68 1848770 : GDALRasterBand::GDALRasterBand(int bForceCachedIOIn)
69 1848770 : : bForceCachedIO(bForceCachedIOIn)
70 :
71 : {
72 1848580 : }
73 :
74 : /************************************************************************/
75 : /* ~GDALRasterBand() */
76 : /************************************************************************/
77 :
78 : /*! Destructor. Applications should never destroy GDALRasterBands directly,
79 : instead destroy the GDALDataset. */
80 :
81 1848760 : GDALRasterBand::~GDALRasterBand()
82 :
83 : {
84 1848770 : if (poDS && poDS->IsMarkedSuppressOnClose())
85 : {
86 501 : if (poBandBlockCache)
87 438 : poBandBlockCache->DisableDirtyBlockWriting();
88 : }
89 1848770 : GDALRasterBand::FlushCache(true);
90 :
91 1848770 : delete poBandBlockCache;
92 :
93 1848770 : if (static_cast<GIntBig>(nBlockReads) >
94 1848770 : static_cast<GIntBig>(nBlocksPerRow) * nBlocksPerColumn &&
95 224 : nBand == 1 && poDS != nullptr)
96 : {
97 328 : CPLDebug(
98 : "GDAL", "%d block reads on " CPL_FRMT_GIB " block band 1 of %s.",
99 164 : nBlockReads, static_cast<GIntBig>(nBlocksPerRow) * nBlocksPerColumn,
100 164 : poDS->GetDescription());
101 : }
102 :
103 1848770 : InvalidateMaskBand();
104 1848760 : nBand = -nBand;
105 :
106 1848760 : delete m_poPointsCache;
107 1848760 : }
108 :
109 : /************************************************************************/
110 : /* RasterIO() */
111 : /************************************************************************/
112 :
113 : /**
114 : * \fn GDALRasterBand::IRasterIO( GDALRWFlag eRWFlag,
115 : * int nXOff, int nYOff, int nXSize, int nYSize,
116 : * void * pData, int nBufXSize, int nBufYSize,
117 : * GDALDataType eBufType,
118 : * GSpacing nPixelSpace,
119 : * GSpacing nLineSpace,
120 : * GDALRasterIOExtraArg* psExtraArg )
121 : * \brief Read/write a region of image data for this band.
122 : *
123 : * This method allows reading a region of a GDALRasterBand into a buffer,
124 : * or writing data from a buffer into a region of a GDALRasterBand. It
125 : * automatically takes care of data type translation if the data type
126 : * (eBufType) of the buffer is different than that of the GDALRasterBand.
127 : * The method also takes care of image decimation / replication if the
128 : * buffer size (nBufXSize x nBufYSize) is different than the size of the
129 : * region being accessed (nXSize x nYSize).
130 : *
131 : * The window of interest expressed by (nXOff, nYOff, nXSize, nYSize) should be
132 : * fully within the raster space, that is nXOff >= 0, nYOff >= 0,
133 : * nXOff + nXSize <= GetXSize() and nYOff + nYSize <= GetYSize().
134 : * If reads larger than the raster space are wished, GDALTranslate() might be used.
135 : * Or use nLineSpace and a possibly shifted pData value.
136 : *
137 : * The nPixelSpace and nLineSpace parameters allow reading into or
138 : * writing from unusually organized buffers. This is primarily used
139 : * for buffers containing more than one bands raster data in interleaved
140 : * format.
141 : *
142 : * Some formats may efficiently implement decimation into a buffer by
143 : * reading from lower resolution overview images. The logic of the default
144 : * implementation in the base class GDALRasterBand is the following one. It
145 : * computes a target_downscaling_factor from the window of interest and buffer
146 : * size which is min(nXSize/nBufXSize, nYSize/nBufYSize).
147 : * It then walks through overviews and will select the first one whose
148 : * downscaling factor is greater than target_downscaling_factor / 1.2.
149 : *
150 : * Let's assume we have overviews at downscaling factors 2, 4 and 8.
151 : * The relationship between target_downscaling_factor and the select overview
152 : * level is the following one:
153 : *
154 : * target_downscaling_factor | selected_overview
155 : * ------------------------- | -----------------
156 : * ]0, 2 / 1.2] | full resolution band
157 : * ]2 / 1.2, 4 / 1.2] | 2x downsampled band
158 : * ]4 / 1.2, 8 / 1.2] | 4x downsampled band
159 : * ]8 / 1.2, infinity[ | 8x downsampled band
160 : *
161 : * Note that starting with GDAL 3.9, this 1.2 oversampling factor can be
162 : * modified by setting the GDAL_OVERVIEW_OVERSAMPLING_THRESHOLD configuration
163 : * option. Also note that starting with GDAL 3.9, when the resampling algorithm
164 : * specified in psExtraArg->eResampleAlg is different from GRIORA_NearestNeighbour,
165 : * this oversampling threshold defaults to 1. Consequently if there are overviews
166 : * of downscaling factor 2, 4 and 8, and the desired downscaling factor is
167 : * 7.99, the overview of factor 4 will be selected for a non nearest resampling.
168 : *
169 : * For highest performance full resolution data access, read and write
170 : * on "block boundaries" as returned by GetBlockSize(), or use the
171 : * ReadBlock() and WriteBlock() methods.
172 : *
173 : * This method is the same as the C GDALRasterIO() or GDALRasterIOEx()
174 : * functions.
175 : *
176 : * @param eRWFlag Either GF_Read to read a region of data, or GF_Write to
177 : * write a region of data.
178 : *
179 : * @param nXOff The pixel offset to the top left corner of the region
180 : * of the band to be accessed. This would be zero to start from the left side.
181 : *
182 : * @param nYOff The line offset to the top left corner of the region
183 : * of the band to be accessed. This would be zero to start from the top.
184 : *
185 : * @param nXSize The width of the region of the band to be accessed in pixels.
186 : *
187 : * @param nYSize The height of the region of the band to be accessed in lines.
188 : *
189 : * @param pData The buffer into which the data should be read, or from which
190 : * it should be written. This buffer must contain at least nBufXSize *
191 : * nBufYSize words of type eBufType. It is organized in left to right,
192 : * top to bottom pixel order. Spacing is controlled by the nPixelSpace,
193 : * and nLineSpace parameters.
194 : * Note that even with eRWFlag==GF_Write, the content of the buffer might be
195 : * temporarily modified during the execution of this method (and eventually
196 : * restored back to its original content), so it is not safe to use a buffer
197 : * stored in a read-only section of the calling program.
198 : *
199 : * @param nBufXSize the width of the buffer image into which the desired region
200 : * is to be read, or from which it is to be written.
201 : *
202 : * @param nBufYSize the height of the buffer image into which the desired region
203 : * is to be read, or from which it is to be written.
204 : *
205 : * @param eBufType the type of the pixel values in the pData data buffer. The
206 : * pixel values will automatically be translated to/from the GDALRasterBand
207 : * data type as needed. Most driver implementations will use GDALCopyWords64()
208 : * to perform data type translation.
209 : *
210 : * @param nPixelSpace The byte offset from the start of one pixel value in
211 : * pData to the start of the next pixel value within a scanline. If defaulted
212 : * (0) the size of the datatype eBufType is used.
213 : *
214 : * @param nLineSpace The byte offset from the start of one scanline in
215 : * pData to the start of the next. If defaulted (0) the size of the datatype
216 : * eBufType * nBufXSize is used.
217 : *
218 : * @param psExtraArg Pointer to a GDALRasterIOExtraArg
219 : * structure with additional arguments to specify resampling and progress
220 : * callback, or NULL for default behavior. The GDAL_RASTERIO_RESAMPLING
221 : * configuration option can also be defined to override the default resampling
222 : * to one of BILINEAR, CUBIC, CUBICSPLINE, LANCZOS, AVERAGE or MODE.
223 : *
224 : * @return CE_Failure if the access fails, otherwise CE_None.
225 : */
226 :
227 : /**
228 : * \brief Read/write a region of image data for this band.
229 : *
230 : * This method allows reading a region of a GDALRasterBand into a buffer,
231 : * or writing data from a buffer into a region of a GDALRasterBand. It
232 : * automatically takes care of data type translation if the data type
233 : * (eBufType) of the buffer is different than that of the GDALRasterBand.
234 : * The method also takes care of image decimation / replication if the
235 : * buffer size (nBufXSize x nBufYSize) is different than the size of the
236 : * region being accessed (nXSize x nYSize).
237 : *
238 : * The window of interest expressed by (nXOff, nYOff, nXSize, nYSize) should be
239 : * fully within the raster space, that is nXOff >= 0, nYOff >= 0,
240 : * nXOff + nXSize <= GetXSize() and nYOff + nYSize <= GetYSize().
241 : * If reads larger than the raster space are wished, GDALTranslate() might be used.
242 : * Or use nLineSpace and a possibly shifted pData value.
243 : *
244 : * The nPixelSpace and nLineSpace parameters allow reading into or
245 : * writing from unusually organized buffers. This is primarily used
246 : * for buffers containing more than one bands raster data in interleaved
247 : * format.
248 : *
249 : * Some formats may efficiently implement decimation into a buffer by
250 : * reading from lower resolution overview images. The logic of the default
251 : * implementation in the base class GDALRasterBand is the following one. It
252 : * computes a target_downscaling_factor from the window of interest and buffer
253 : * size which is min(nXSize/nBufXSize, nYSize/nBufYSize).
254 : * It then walks through overviews and will select the first one whose
255 : * downscaling factor is greater than target_downscaling_factor / 1.2.
256 : *
257 : * Let's assume we have overviews at downscaling factors 2, 4 and 8.
258 : * The relationship between target_downscaling_factor and the select overview
259 : * level is the following one:
260 : *
261 : * target_downscaling_factor | selected_overview
262 : * ------------------------- | -----------------
263 : * ]0, 2 / 1.2] | full resolution band
264 : * ]2 / 1.2, 4 / 1.2] | 2x downsampled band
265 : * ]4 / 1.2, 8 / 1.2] | 4x downsampled band
266 : * ]8 / 1.2, infinity[ | 8x downsampled band
267 : *
268 : * For highest performance full resolution data access, read and write
269 : * on "block boundaries" as returned by GetBlockSize(), or use the
270 : * ReadBlock() and WriteBlock() methods.
271 : *
272 : * This method is the same as the C GDALRasterIO() or GDALRasterIOEx()
273 : * functions.
274 : *
275 : * Starting with GDAL 3.10, the GDALRasterBand::ReadRaster() methods may be
276 : * more convenient to use for most common use cases.
277 : *
278 : * As nearly all GDAL methods, this method is *NOT* thread-safe, that is it cannot
279 : * be called on the same GDALRasterBand instance (or another GDALRasterBand
280 : * instance of this dataset) concurrently from several threads.
281 : *
282 : * @param eRWFlag Either GF_Read to read a region of data, or GF_Write to
283 : * write a region of data.
284 : *
285 : * @param nXOff The pixel offset to the top left corner of the region
286 : * of the band to be accessed. This would be zero to start from the left side.
287 : *
288 : * @param nYOff The line offset to the top left corner of the region
289 : * of the band to be accessed. This would be zero to start from the top.
290 : *
291 : * @param nXSize The width of the region of the band to be accessed in pixels.
292 : *
293 : * @param nYSize The height of the region of the band to be accessed in lines.
294 : *
295 : * @param[in,out] pData The buffer into which the data should be read, or from
296 : * which it should be written. This buffer must contain at least nBufXSize *
297 : * nBufYSize words of type eBufType. It is organized in left to right,
298 : * top to bottom pixel order. Spacing is controlled by the nPixelSpace,
299 : * and nLineSpace parameters.
300 : *
301 : * @param nBufXSize the width of the buffer image into which the desired region
302 : * is to be read, or from which it is to be written.
303 : *
304 : * @param nBufYSize the height of the buffer image into which the desired region
305 : * is to be read, or from which it is to be written.
306 : *
307 : * @param eBufType the type of the pixel values in the pData data buffer. The
308 : * pixel values will automatically be translated to/from the GDALRasterBand
309 : * data type as needed.
310 : *
311 : * @param nPixelSpace The byte offset from the start of one pixel value in
312 : * pData to the start of the next pixel value within a scanline. If defaulted
313 : * (0) the size of the datatype eBufType is used.
314 : *
315 : * @param nLineSpace The byte offset from the start of one scanline in
316 : * pData to the start of the next. If defaulted (0) the size of the datatype
317 : * eBufType * nBufXSize is used.
318 : *
319 : * @param[in] psExtraArg Pointer to a GDALRasterIOExtraArg
320 : * structure with additional arguments to specify resampling and progress
321 : * callback, or NULL for default behavior. The GDAL_RASTERIO_RESAMPLING
322 : * configuration option can also be defined to override the default resampling
323 : * to one of BILINEAR, CUBIC, CUBICSPLINE, LANCZOS, AVERAGE or MODE.
324 : *
325 : * @return CE_Failure if the access fails, otherwise CE_None.
326 : *
327 : * @see GDALRasterBand::ReadRaster()
328 : */
329 :
330 4409450 : CPLErr GDALRasterBand::RasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
331 : int nXSize, int nYSize, void *pData,
332 : int nBufXSize, int nBufYSize,
333 : GDALDataType eBufType, GSpacing nPixelSpace,
334 : GSpacing nLineSpace,
335 : GDALRasterIOExtraArg *psExtraArg)
336 :
337 : {
338 : GDALRasterIOExtraArg sExtraArg;
339 4409450 : if (psExtraArg == nullptr)
340 : {
341 3812430 : INIT_RASTERIO_EXTRA_ARG(sExtraArg);
342 3812430 : psExtraArg = &sExtraArg;
343 : }
344 597026 : else if (CPL_UNLIKELY(psExtraArg->nVersion >
345 : RASTERIO_EXTRA_ARG_CURRENT_VERSION))
346 : {
347 0 : ReportError(CE_Failure, CPLE_AppDefined,
348 : "Unhandled version of GDALRasterIOExtraArg");
349 0 : return CE_Failure;
350 : }
351 :
352 4409450 : GDALRasterIOExtraArgSetResampleAlg(psExtraArg, nXSize, nYSize, nBufXSize,
353 : nBufYSize);
354 :
355 4409930 : if (CPL_UNLIKELY(nullptr == pData))
356 : {
357 0 : ReportError(CE_Failure, CPLE_AppDefined,
358 : "The buffer into which the data should be read is null");
359 0 : return CE_Failure;
360 : }
361 :
362 : /* -------------------------------------------------------------------- */
363 : /* Some size values are "noop". Lets just return to avoid */
364 : /* stressing lower level functions. */
365 : /* -------------------------------------------------------------------- */
366 4409930 : if (CPL_UNLIKELY(nXSize < 1 || nYSize < 1 || nBufXSize < 1 ||
367 : nBufYSize < 1))
368 : {
369 2 : CPLDebug("GDAL",
370 : "RasterIO() skipped for odd window or buffer size.\n"
371 : " Window = (%d,%d)x%dx%d\n"
372 : " Buffer = %dx%d\n",
373 : nXOff, nYOff, nXSize, nYSize, nBufXSize, nBufYSize);
374 :
375 2 : return CE_None;
376 : }
377 :
378 4409930 : if (eRWFlag == GF_Write)
379 : {
380 363029 : if (CPL_UNLIKELY(eFlushBlockErr != CE_None))
381 : {
382 0 : ReportError(eFlushBlockErr, CPLE_AppDefined,
383 : "An error occurred while writing a dirty block "
384 : "from GDALRasterBand::RasterIO");
385 0 : CPLErr eErr = eFlushBlockErr;
386 0 : eFlushBlockErr = CE_None;
387 0 : return eErr;
388 : }
389 363029 : if (EmitErrorMessageIfWriteNotSupported("GDALRasterBand::RasterIO()"))
390 : {
391 7 : return CE_Failure;
392 : }
393 : }
394 :
395 : /* -------------------------------------------------------------------- */
396 : /* If pixel and line spacing are defaulted assign reasonable */
397 : /* value assuming a packed buffer. */
398 : /* -------------------------------------------------------------------- */
399 4410060 : if (nPixelSpace == 0)
400 : {
401 4009920 : nPixelSpace = GDALGetDataTypeSizeBytes(eBufType);
402 : }
403 :
404 4409580 : if (nLineSpace == 0)
405 : {
406 3998950 : nLineSpace = nPixelSpace * nBufXSize;
407 : }
408 :
409 : /* -------------------------------------------------------------------- */
410 : /* Do some validation of parameters. */
411 : /* -------------------------------------------------------------------- */
412 4409580 : if (CPL_UNLIKELY(nXOff < 0 || nXOff > INT_MAX - nXSize ||
413 : nXOff + nXSize > nRasterXSize || nYOff < 0 ||
414 : nYOff > INT_MAX - nYSize || nYOff + nYSize > nRasterYSize))
415 : {
416 15 : ReportError(CE_Failure, CPLE_IllegalArg,
417 : "Access window out of range in RasterIO(). Requested\n"
418 : "(%d,%d) of size %dx%d on raster of %dx%d.",
419 : nXOff, nYOff, nXSize, nYSize, nRasterXSize, nRasterYSize);
420 15 : return CE_Failure;
421 : }
422 :
423 4409560 : if (CPL_UNLIKELY(eRWFlag != GF_Read && eRWFlag != GF_Write))
424 : {
425 0 : ReportError(
426 : CE_Failure, CPLE_IllegalArg,
427 : "eRWFlag = %d, only GF_Read (0) and GF_Write (1) are legal.",
428 : eRWFlag);
429 0 : return CE_Failure;
430 : }
431 4409560 : if (CPL_UNLIKELY(eBufType == GDT_Unknown || eBufType == GDT_TypeCount))
432 : {
433 2 : ReportError(CE_Failure, CPLE_IllegalArg,
434 : "Illegal GDT_Unknown/GDT_TypeCount argument");
435 2 : return CE_Failure;
436 : }
437 :
438 4409560 : return RasterIOInternal(eRWFlag, nXOff, nYOff, nXSize, nYSize, pData,
439 : nBufXSize, nBufYSize, eBufType, nPixelSpace,
440 4405900 : nLineSpace, psExtraArg);
441 : }
442 :
443 : /************************************************************************/
444 : /* RasterIOInternal() */
445 : /************************************************************************/
446 :
447 4405870 : CPLErr GDALRasterBand::RasterIOInternal(
448 : GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize,
449 : void *pData, int nBufXSize, int nBufYSize, GDALDataType eBufType,
450 : GSpacing nPixelSpace, GSpacing nLineSpace, GDALRasterIOExtraArg *psExtraArg)
451 : {
452 : /* -------------------------------------------------------------------- */
453 : /* Call the format specific function. */
454 : /* -------------------------------------------------------------------- */
455 :
456 4405870 : const bool bCallLeaveReadWrite = CPL_TO_BOOL(EnterReadWrite(eRWFlag));
457 :
458 : CPLErr eErr;
459 4407560 : if (bForceCachedIO)
460 23 : eErr = GDALRasterBand::IRasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize,
461 : pData, nBufXSize, nBufYSize, eBufType,
462 : nPixelSpace, nLineSpace, psExtraArg);
463 : else
464 : eErr =
465 4410110 : IRasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize,
466 4407540 : nBufYSize, eBufType, nPixelSpace, nLineSpace, psExtraArg);
467 :
468 4410130 : if (bCallLeaveReadWrite)
469 600064 : LeaveReadWrite();
470 :
471 4407820 : return eErr;
472 : }
473 :
474 : /************************************************************************/
475 : /* GDALRasterIO() */
476 : /************************************************************************/
477 :
478 : /**
479 : * \brief Read/write a region of image data for this band.
480 : *
481 : * Use GDALRasterIOEx() if 64 bit spacings or extra arguments (resampling
482 : * resolution, progress callback, etc. are needed)
483 : *
484 : * @see GDALRasterBand::RasterIO()
485 : */
486 :
487 3400920 : CPLErr CPL_STDCALL GDALRasterIO(GDALRasterBandH hBand, GDALRWFlag eRWFlag,
488 : int nXOff, int nYOff, int nXSize, int nYSize,
489 : void *pData, int nBufXSize, int nBufYSize,
490 : GDALDataType eBufType, int nPixelSpace,
491 : int nLineSpace)
492 :
493 : {
494 3400920 : VALIDATE_POINTER1(hBand, "GDALRasterIO", CE_Failure);
495 :
496 3400920 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
497 :
498 3399620 : return (poBand->RasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize, pData,
499 : nBufXSize, nBufYSize, eBufType, nPixelSpace,
500 3395050 : nLineSpace, nullptr));
501 : }
502 :
503 : /************************************************************************/
504 : /* GDALRasterIOEx() */
505 : /************************************************************************/
506 :
507 : /**
508 : * \brief Read/write a region of image data for this band.
509 : *
510 : * @see GDALRasterBand::RasterIO()
511 : */
512 :
513 40381 : CPLErr CPL_STDCALL GDALRasterIOEx(GDALRasterBandH hBand, GDALRWFlag eRWFlag,
514 : int nXOff, int nYOff, int nXSize, int nYSize,
515 : void *pData, int nBufXSize, int nBufYSize,
516 : GDALDataType eBufType, GSpacing nPixelSpace,
517 : GSpacing nLineSpace,
518 : GDALRasterIOExtraArg *psExtraArg)
519 :
520 : {
521 40381 : VALIDATE_POINTER1(hBand, "GDALRasterIOEx", CE_Failure);
522 :
523 40381 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
524 :
525 40381 : return (poBand->RasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize, pData,
526 : nBufXSize, nBufYSize, eBufType, nPixelSpace,
527 40376 : nLineSpace, psExtraArg));
528 : }
529 :
530 : /************************************************************************/
531 : /* GetGDTFromCppType() */
532 : /************************************************************************/
533 :
534 : namespace
535 : {
536 : template <class T> struct GetGDTFromCppType;
537 :
538 : #define DEFINE_GetGDTFromCppType(T, eDT) \
539 : template <> struct GetGDTFromCppType<T> \
540 : { \
541 : static constexpr GDALDataType GDT = eDT; \
542 : }
543 :
544 : DEFINE_GetGDTFromCppType(uint8_t, GDT_Byte);
545 : DEFINE_GetGDTFromCppType(int8_t, GDT_Int8);
546 : DEFINE_GetGDTFromCppType(uint16_t, GDT_UInt16);
547 : DEFINE_GetGDTFromCppType(int16_t, GDT_Int16);
548 : DEFINE_GetGDTFromCppType(uint32_t, GDT_UInt32);
549 : DEFINE_GetGDTFromCppType(int32_t, GDT_Int32);
550 : DEFINE_GetGDTFromCppType(uint64_t, GDT_UInt64);
551 : DEFINE_GetGDTFromCppType(int64_t, GDT_Int64);
552 : DEFINE_GetGDTFromCppType(GFloat16, GDT_Float16);
553 : DEFINE_GetGDTFromCppType(float, GDT_Float32);
554 : DEFINE_GetGDTFromCppType(double, GDT_Float64);
555 : // Not allowed by C++ standard
556 : //DEFINE_GetGDTFromCppType(std::complex<int16_t>, GDT_CInt16);
557 : //DEFINE_GetGDTFromCppType(std::complex<int32_t>, GDT_CInt32);
558 : DEFINE_GetGDTFromCppType(std::complex<float>, GDT_CFloat32);
559 : DEFINE_GetGDTFromCppType(std::complex<double>, GDT_CFloat64);
560 : } // namespace
561 :
562 : /************************************************************************/
563 : /* ReadRaster() */
564 : /************************************************************************/
565 :
566 : // clang-format off
567 : /** Read a region of image data for this band.
568 : *
569 : * This is a slightly more convenient alternative to GDALRasterBand::RasterIO()
570 : * for common use cases, like reading a whole band.
571 : * It infers the GDAL data type of the buffer from the C/C++ type of the buffer.
572 : * This template is instantiated for the following types: [u?]int[8|16|32|64]_t,
573 : * float, double, std::complex<float|double>.
574 : *
575 : * 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>&,
576 : * and can allocate memory automatically.
577 : *
578 : * To read a whole band (assuming it fits into memory), as an array of double:
579 : *
580 : \code{.cpp}
581 : double* myArray = static_cast<double*>(
582 : VSI_MALLOC3_VERBOSE(sizeof(double), poBand->GetXSize(), poBand->GetYSize()));
583 : // TODO: check here that myArray != nullptr
584 : const size_t nArrayEltCount =
585 : static_cast<size_t>(poBand->GetXSize()) * poBand->GetYSize());
586 : if (poBand->ReadRaster(myArray, nArrayEltCount) == CE_None)
587 : {
588 : // do something
589 : }
590 : VSIFree(myArray)
591 : \endcode
592 : *
593 : * To read 128x128 pixels starting at (col=12, line=24) as an array of double:
594 : *
595 : \code{.cpp}
596 : double* myArray = static_cast<double*>(
597 : VSI_MALLOC3_VERBOSE(sizeof(double), 128, 128));
598 : // TODO: check here that myArray != nullptr
599 : const size_t nArrayEltCount = 128 * 128;
600 : if (poBand->ReadRaster(myArray, nArrayEltCount, 12, 24, 128, 128) == CE_None)
601 : {
602 : // do something
603 : }
604 : VSIFree(myArray)
605 : \endcode
606 : *
607 : * As nearly all GDAL methods, this method is *NOT* thread-safe, that is it cannot
608 : * be called on the same GDALRasterBand instance (or another GDALRasterBand
609 : * instance of this dataset) concurrently from several threads.
610 : *
611 : * The window of interest expressed by (dfXOff, dfYOff, dfXSize, dfYSize) should be
612 : * fully within the raster space, that is dfXOff >= 0, dfYOff >= 0,
613 : * dfXOff + dfXSize <= GetXSize() and dfYOff + dfYSize <= GetYSize().
614 : * If reads larger than the raster space are wished, GDALTranslate() might be used.
615 : * Or use nLineSpace and a possibly shifted pData value.
616 : *
617 : * @param[out] pData The buffer into which the data should be written.
618 : * This buffer must contain at least nBufXSize *
619 : * nBufYSize words of type T. It is organized in left to right,
620 : * top to bottom pixel order, and fully packed.
621 : * The type of the buffer does not need to be the one of GetDataType(). The
622 : * method will perform data type translation (with potential rounding, clamping)
623 : * if needed.
624 : *
625 : * @param nArrayEltCount Number of values of pData. If non zero, the method will
626 : * check that it is at least greater or equal to nBufXSize * nBufYSize, and
627 : * return in error if it is not. If set to zero, then pData is trusted to be
628 : * large enough.
629 : *
630 : * @param dfXOff The pixel offset to the top left corner of the region
631 : * of the band to be accessed. This would be zero to start from the left side.
632 : * Defaults to 0.
633 : *
634 : * @param dfYOff The line offset to the top left corner of the region
635 : * of the band to be accessed. This would be zero to start from the top.
636 : * Defaults to 0.
637 : *
638 : * @param dfXSize The width of the region of the band to be accessed in pixels.
639 : * If all of dfXOff, dfYOff, dfXSize and dfYSize are left to their zero default value,
640 : * dfXSize is set to the band width.
641 : *
642 : * @param dfYSize The height of the region of the band to be accessed in lines.
643 : * If all of dfXOff, dfYOff, dfXSize and dfYSize are left to their zero default value,
644 : * dfYSize is set to the band height.
645 : *
646 : * @param nBufXSize the width of the buffer image into which the desired region
647 : * is to be read. If set to zero, and both dfXSize and dfYSize are integer values,
648 : * then nBufXSize is initialized with dfXSize.
649 : *
650 : * @param nBufYSize the height of the buffer image into which the desired region
651 : * is to be read. If set to zero, and both dfXSize and dfYSize are integer values,
652 : * then nBufYSize is initialized with dfYSize.
653 : *
654 : * @param eResampleAlg Resampling algorithm. Defaults to GRIORA_NearestNeighbour.
655 : *
656 : * @param pfnProgress Progress function. May be nullptr.
657 : *
658 : * @param pProgressData User data of pfnProgress. May be nullptr.
659 : *
660 : * @return CE_Failure if the access fails, otherwise CE_None.
661 : *
662 : * @see GDALRasterBand::RasterIO()
663 : * @since GDAL 3.10
664 : */
665 : // clang-format on
666 :
667 : template <class T>
668 20 : CPLErr GDALRasterBand::ReadRaster(T *pData, size_t nArrayEltCount,
669 : double dfXOff, double dfYOff, double dfXSize,
670 : double dfYSize, size_t nBufXSize,
671 : size_t nBufYSize,
672 : GDALRIOResampleAlg eResampleAlg,
673 : GDALProgressFunc pfnProgress,
674 : void *pProgressData) const
675 : {
676 20 : if (((nBufXSize | nBufYSize) >> 31) != 0)
677 : {
678 2 : return CE_Failure;
679 : }
680 :
681 18 : if (dfXOff == 0 && dfYOff == 0 && dfXSize == 0 && dfYSize == 0)
682 : {
683 16 : dfXSize = nRasterXSize;
684 16 : dfYSize = nRasterYSize;
685 : }
686 2 : else if (!(dfXOff >= 0 && dfXOff <= INT_MAX) ||
687 2 : !(dfYOff >= 0 && dfYOff <= INT_MAX) || !(dfXSize >= 0) ||
688 2 : !(dfYSize >= 0) || dfXOff + dfXSize > INT_MAX ||
689 2 : dfYOff + dfYSize > INT_MAX)
690 : {
691 0 : return CE_Failure;
692 : }
693 :
694 : GDALRasterIOExtraArg sExtraArg;
695 18 : sExtraArg.nVersion = 1;
696 18 : sExtraArg.eResampleAlg = eResampleAlg;
697 18 : sExtraArg.pfnProgress = pfnProgress;
698 18 : sExtraArg.pProgressData = pProgressData;
699 18 : sExtraArg.bFloatingPointWindowValidity = true;
700 18 : sExtraArg.dfXOff = dfXOff;
701 18 : sExtraArg.dfYOff = dfYOff;
702 18 : sExtraArg.dfXSize = dfXSize;
703 18 : sExtraArg.dfYSize = dfYSize;
704 18 : const int nXOff = static_cast<int>(dfXOff);
705 18 : const int nYOff = static_cast<int>(dfYOff);
706 18 : const int nXSize = std::max(1, static_cast<int>(dfXSize + 0.5));
707 18 : const int nYSize = std::max(1, static_cast<int>(dfYSize + 0.5));
708 18 : if (nBufXSize == 0 && nBufYSize == 0)
709 : {
710 17 : if (static_cast<int>(dfXSize) == dfXSize &&
711 17 : static_cast<int>(dfYSize) == dfYSize)
712 : {
713 17 : nBufXSize = static_cast<int>(dfXSize);
714 17 : nBufYSize = static_cast<int>(dfYSize);
715 : }
716 : else
717 : {
718 0 : CPLError(CE_Failure, CPLE_AppDefined,
719 : "nBufXSize and nBufYSize must be provided if dfXSize or "
720 : "dfYSize is not an integer value");
721 0 : return CE_Failure;
722 : }
723 : }
724 18 : if (nBufXSize == 0 || nBufYSize == 0)
725 : {
726 0 : CPLDebug("GDAL",
727 : "RasterIO() skipped for odd window or buffer size.\n"
728 : " Window = (%d,%d)x%dx%d\n"
729 : " Buffer = %dx%d\n",
730 : nXOff, nYOff, nXSize, nYSize, static_cast<int>(nBufXSize),
731 : static_cast<int>(nBufYSize));
732 :
733 0 : return CE_None;
734 : }
735 :
736 18 : if (nArrayEltCount > 0 && nBufXSize > nArrayEltCount / nBufYSize)
737 : {
738 1 : CPLError(CE_Failure, CPLE_AppDefined,
739 : "Provided array is not large enough");
740 1 : return CE_Failure;
741 : }
742 :
743 17 : constexpr GSpacing nPixelSpace = sizeof(T);
744 17 : const GSpacing nLineSpace = nPixelSpace * nBufXSize;
745 17 : constexpr GDALDataType eBufType = GetGDTFromCppType<T>::GDT;
746 :
747 17 : GDALRasterBand *pThis = const_cast<GDALRasterBand *>(this);
748 :
749 : return pThis->RasterIOInternal(GF_Read, nXOff, nYOff, nXSize, nYSize, pData,
750 : static_cast<int>(nBufXSize),
751 : static_cast<int>(nBufYSize), eBufType,
752 17 : nPixelSpace, nLineSpace, &sExtraArg);
753 : }
754 :
755 : //! @cond Doxygen_Suppress
756 :
757 : #define INSTANTIATE_READ_RASTER(T) \
758 : template CPLErr CPL_DLL GDALRasterBand::ReadRaster( \
759 : T *vData, size_t nArrayEltCount, double dfXOff, double dfYOff, \
760 : double dfXSize, double dfYSize, size_t nBufXSize, size_t nBufYSize, \
761 : GDALRIOResampleAlg eResampleAlg, GDALProgressFunc pfnProgress, \
762 : void *pProgressData) const;
763 :
764 : INSTANTIATE_READ_RASTER(uint8_t)
765 : INSTANTIATE_READ_RASTER(int8_t)
766 : INSTANTIATE_READ_RASTER(uint16_t)
767 : INSTANTIATE_READ_RASTER(int16_t)
768 : INSTANTIATE_READ_RASTER(uint32_t)
769 : INSTANTIATE_READ_RASTER(int32_t)
770 : INSTANTIATE_READ_RASTER(uint64_t)
771 : INSTANTIATE_READ_RASTER(int64_t)
772 : INSTANTIATE_READ_RASTER(GFloat16)
773 : INSTANTIATE_READ_RASTER(float)
774 : INSTANTIATE_READ_RASTER(double)
775 : // Not allowed by C++ standard
776 : // INSTANTIATE_READ_RASTER(std::complex<int16_t>)
777 : // INSTANTIATE_READ_RASTER(std::complex<int32_t>)
778 : INSTANTIATE_READ_RASTER(std::complex<float>)
779 : INSTANTIATE_READ_RASTER(std::complex<double>)
780 :
781 : //! @endcond
782 :
783 : /************************************************************************/
784 : /* ReadRaster() */
785 : /************************************************************************/
786 :
787 : /** Read a region of image data for this band.
788 : *
789 : * This is a slightly more convenient alternative to GDALRasterBand::RasterIO()
790 : * for common use cases, like reading a whole band.
791 : * It infers the GDAL data type of the buffer from the C/C++ type of the buffer.
792 : * This template is instantiated for the following types: [u?]int[8|16|32|64]_t,
793 : * float, double, std::complex<float|double>.
794 : *
795 : * To read a whole band (assuming it fits into memory), as a vector of double:
796 : *
797 : \code
798 : std::vector<double> myArray;
799 : if (poBand->ReadRaster(myArray) == CE_None)
800 : {
801 : // do something
802 : }
803 : \endcode
804 : *
805 : * To read 128x128 pixels starting at (col=12, line=24) as a vector of double:
806 : *
807 : \code{.cpp}
808 : std::vector<double> myArray;
809 : if (poBand->ReadRaster(myArray, 12, 24, 128, 128) == CE_None)
810 : {
811 : // do something
812 : }
813 : \endcode
814 : *
815 : * As nearly all GDAL methods, this method is *NOT* thread-safe, that is it cannot
816 : * be called on the same GDALRasterBand instance (or another GDALRasterBand
817 : * instance of this dataset) concurrently from several threads.
818 : *
819 : * The window of interest expressed by (dfXOff, dfYOff, dfXSize, dfYSize) should be
820 : * fully within the raster space, that is dfXOff >= 0, dfYOff >= 0,
821 : * dfXOff + dfXSize <= GetXSize() and dfYOff + dfYSize <= GetYSize().
822 : * If reads larger than the raster space are wished, GDALTranslate() might be used.
823 : * Or use nLineSpace and a possibly shifted pData value.
824 : *
825 : * @param[out] vData The vector into which the data should be written.
826 : * The vector will be resized, if needed, to contain at least nBufXSize *
827 : * nBufYSize values. The values in the vector are organized in left to right,
828 : * top to bottom pixel order, and fully packed.
829 : * The type of the vector does not need to be the one of GetDataType(). The
830 : * method will perform data type translation (with potential rounding, clamping)
831 : * if needed.
832 : *
833 : * @param dfXOff The pixel offset to the top left corner of the region
834 : * of the band to be accessed. This would be zero to start from the left side.
835 : * Defaults to 0.
836 : *
837 : * @param dfYOff The line offset to the top left corner of the region
838 : * of the band to be accessed. This would be zero to start from the top.
839 : * Defaults to 0.
840 : *
841 : * @param dfXSize The width of the region of the band to be accessed in pixels.
842 : * If all of dfXOff, dfYOff, dfXSize and dfYSize are left to their zero default value,
843 : * dfXSize is set to the band width.
844 : *
845 : * @param dfYSize The height of the region of the band to be accessed in lines.
846 : * If all of dfXOff, dfYOff, dfXSize and dfYSize are left to their zero default value,
847 : * dfYSize is set to the band height.
848 : *
849 : * @param nBufXSize the width of the buffer image into which the desired region
850 : * is to be read. If set to zero, and both dfXSize and dfYSize are integer values,
851 : * then nBufXSize is initialized with dfXSize.
852 : *
853 : * @param nBufYSize the height of the buffer image into which the desired region
854 : * is to be read. If set to zero, and both dfXSize and dfYSize are integer values,
855 : * then nBufYSize is initialized with dfYSize.
856 : *
857 : * @param eResampleAlg Resampling algorithm. Defaults to GRIORA_NearestNeighbour.
858 : *
859 : * @param pfnProgress Progress function. May be nullptr.
860 : *
861 : * @param pProgressData User data of pfnProgress. May be nullptr.
862 : *
863 : * @return CE_Failure if the access fails, otherwise CE_None.
864 : *
865 : * @see GDALRasterBand::RasterIO()
866 : * @since GDAL 3.10
867 : */
868 : template <class T>
869 22 : CPLErr GDALRasterBand::ReadRaster(std::vector<T> &vData, double dfXOff,
870 : double dfYOff, double dfXSize, double dfYSize,
871 : size_t nBufXSize, size_t nBufYSize,
872 : GDALRIOResampleAlg eResampleAlg,
873 : GDALProgressFunc pfnProgress,
874 : void *pProgressData) const
875 : {
876 22 : if (((nBufXSize | nBufYSize) >> 31) != 0)
877 : {
878 2 : return CE_Failure;
879 : }
880 :
881 20 : if (dfXOff == 0 && dfYOff == 0 && dfXSize == 0 && dfYSize == 0)
882 : {
883 13 : dfXSize = nRasterXSize;
884 13 : dfYSize = nRasterYSize;
885 : }
886 7 : else if (!(dfXOff >= 0 && dfXOff <= INT_MAX) ||
887 7 : !(dfYOff >= 0 && dfYOff <= INT_MAX) || !(dfXSize >= 0) ||
888 7 : !(dfYSize >= 0) || dfXOff + dfXSize > INT_MAX ||
889 7 : dfYOff + dfYSize > INT_MAX)
890 : {
891 0 : return CE_Failure;
892 : }
893 :
894 : GDALRasterIOExtraArg sExtraArg;
895 20 : sExtraArg.nVersion = 1;
896 20 : sExtraArg.eResampleAlg = eResampleAlg;
897 20 : sExtraArg.pfnProgress = pfnProgress;
898 20 : sExtraArg.pProgressData = pProgressData;
899 20 : sExtraArg.bFloatingPointWindowValidity = true;
900 20 : sExtraArg.dfXOff = dfXOff;
901 20 : sExtraArg.dfYOff = dfYOff;
902 20 : sExtraArg.dfXSize = dfXSize;
903 20 : sExtraArg.dfYSize = dfYSize;
904 20 : const int nXOff = static_cast<int>(dfXOff);
905 20 : const int nYOff = static_cast<int>(dfYOff);
906 20 : const int nXSize = std::max(1, static_cast<int>(dfXSize + 0.5));
907 20 : const int nYSize = std::max(1, static_cast<int>(dfYSize + 0.5));
908 20 : if (nBufXSize == 0 && nBufYSize == 0)
909 : {
910 16 : if (static_cast<int>(dfXSize) == dfXSize &&
911 15 : static_cast<int>(dfYSize) == dfYSize)
912 : {
913 15 : nBufXSize = static_cast<int>(dfXSize);
914 15 : nBufYSize = static_cast<int>(dfYSize);
915 : }
916 : else
917 : {
918 1 : CPLError(CE_Failure, CPLE_AppDefined,
919 : "nBufXSize and nBufYSize must be provided if "
920 : "dfXSize or dfYSize is not an integer value");
921 1 : return CE_Failure;
922 : }
923 : }
924 19 : if (nBufXSize == 0 || nBufYSize == 0)
925 : {
926 0 : CPLDebug("GDAL",
927 : "RasterIO() skipped for odd window or buffer size.\n"
928 : " Window = (%d,%d)x%dx%d\n"
929 : " Buffer = %dx%d\n",
930 : nXOff, nYOff, nXSize, nYSize, static_cast<int>(nBufXSize),
931 : static_cast<int>(nBufYSize));
932 :
933 0 : return CE_None;
934 : }
935 :
936 : if constexpr (SIZEOF_VOIDP < 8)
937 : {
938 : if (nBufXSize > std::numeric_limits<size_t>::max() / nBufYSize)
939 : {
940 : CPLError(CE_Failure, CPLE_OutOfMemory, "Too large buffer");
941 : return CE_Failure;
942 : }
943 : }
944 :
945 19 : if (vData.size() < nBufXSize * nBufYSize)
946 : {
947 : try
948 : {
949 17 : vData.resize(nBufXSize * nBufYSize);
950 : }
951 1 : catch (const std::exception &)
952 : {
953 1 : CPLError(CE_Failure, CPLE_OutOfMemory, "Cannot resize array");
954 1 : return CE_Failure;
955 : }
956 : }
957 :
958 18 : constexpr GSpacing nPixelSpace = sizeof(T);
959 18 : const GSpacing nLineSpace = nPixelSpace * nBufXSize;
960 18 : constexpr GDALDataType eBufType = GetGDTFromCppType<T>::GDT;
961 :
962 18 : GDALRasterBand *pThis = const_cast<GDALRasterBand *>(this);
963 :
964 : return pThis->RasterIOInternal(GF_Read, nXOff, nYOff, nXSize, nYSize,
965 : vData.data(), static_cast<int>(nBufXSize),
966 : static_cast<int>(nBufYSize), eBufType,
967 18 : nPixelSpace, nLineSpace, &sExtraArg);
968 : }
969 :
970 : //! @cond Doxygen_Suppress
971 :
972 : #define INSTANTIATE_READ_RASTER_VECTOR(T) \
973 : template CPLErr CPL_DLL GDALRasterBand::ReadRaster( \
974 : std::vector<T> &vData, double dfXOff, double dfYOff, double dfXSize, \
975 : double dfYSize, size_t nBufXSize, size_t nBufYSize, \
976 : GDALRIOResampleAlg eResampleAlg, GDALProgressFunc pfnProgress, \
977 : void *pProgressData) const;
978 :
979 : INSTANTIATE_READ_RASTER_VECTOR(uint8_t)
980 : INSTANTIATE_READ_RASTER_VECTOR(int8_t)
981 : INSTANTIATE_READ_RASTER_VECTOR(uint16_t)
982 : INSTANTIATE_READ_RASTER_VECTOR(int16_t)
983 : INSTANTIATE_READ_RASTER_VECTOR(uint32_t)
984 : INSTANTIATE_READ_RASTER_VECTOR(int32_t)
985 : INSTANTIATE_READ_RASTER_VECTOR(uint64_t)
986 : INSTANTIATE_READ_RASTER_VECTOR(int64_t)
987 : INSTANTIATE_READ_RASTER_VECTOR(GFloat16)
988 : INSTANTIATE_READ_RASTER_VECTOR(float)
989 : INSTANTIATE_READ_RASTER_VECTOR(double)
990 : // Not allowed by C++ standard
991 : // INSTANTIATE_READ_RASTER_VECTOR(std::complex<int16_t>)
992 : // INSTANTIATE_READ_RASTER_VECTOR(std::complex<int32_t>)
993 : INSTANTIATE_READ_RASTER_VECTOR(std::complex<float>)
994 : INSTANTIATE_READ_RASTER_VECTOR(std::complex<double>)
995 :
996 : //! @endcond
997 :
998 : /************************************************************************/
999 : /* ReadBlock() */
1000 : /************************************************************************/
1001 :
1002 : /**
1003 : * \brief Read a block of image data efficiently.
1004 : *
1005 : * This method accesses a "natural" block from the raster band without
1006 : * resampling, or data type conversion. For a more generalized, but
1007 : * potentially less efficient access use RasterIO().
1008 : *
1009 : * This method is the same as the C GDALReadBlock() function.
1010 : *
1011 : * See the GetLockedBlockRef() method for a way of accessing internally cached
1012 : * block oriented data without an extra copy into an application buffer.
1013 : *
1014 : * The following code would efficiently compute a histogram of eight bit
1015 : * raster data. Note that the final block may be partial ... data beyond
1016 : * the edge of the underlying raster band in these edge blocks is of an
1017 : * undetermined value.
1018 : *
1019 : \code{.cpp}
1020 : CPLErr GetHistogram( GDALRasterBand *poBand, GUIntBig *panHistogram )
1021 :
1022 : {
1023 : memset( panHistogram, 0, sizeof(GUIntBig) * 256 );
1024 :
1025 : CPLAssert( poBand->GetRasterDataType() == GDT_Byte );
1026 :
1027 : int nXBlockSize, nYBlockSize;
1028 :
1029 : poBand->GetBlockSize( &nXBlockSize, &nYBlockSize );
1030 : int nXBlocks = DIV_ROUND_UP(poBand->GetXSize(), nXBlockSize);
1031 : int nYBlocks = DIV_ROUND_UP(poBand->GetYSize(), nYBlockSize);
1032 :
1033 : GByte *pabyData = (GByte *) CPLMalloc(nXBlockSize * nYBlockSize);
1034 :
1035 : for( int iYBlock = 0; iYBlock < nYBlocks; iYBlock++ )
1036 : {
1037 : for( int iXBlock = 0; iXBlock < nXBlocks; iXBlock++ )
1038 : {
1039 : int nXValid, nYValid;
1040 :
1041 : poBand->ReadBlock( iXBlock, iYBlock, pabyData );
1042 :
1043 : // Compute the portion of the block that is valid
1044 : // for partial edge blocks.
1045 : poBand->GetActualBlockSize(iXBlock, iYBlock, &nXValid, &nYValid)
1046 :
1047 : // Collect the histogram counts.
1048 : for( int iY = 0; iY < nYValid; iY++ )
1049 : {
1050 : for( int iX = 0; iX < nXValid; iX++ )
1051 : {
1052 : panHistogram[pabyData[iX + iY * nXBlockSize]] += 1;
1053 : }
1054 : }
1055 : }
1056 : }
1057 : }
1058 : \endcode
1059 : *
1060 : * @param nXBlockOff the horizontal block offset, with zero indicating
1061 : * the left most block, 1 the next block and so forth.
1062 : *
1063 : * @param nYBlockOff the vertical block offset, with zero indicating
1064 : * the top most block, 1 the next block and so forth.
1065 : *
1066 : * @param pImage the buffer into which the data will be read. The buffer
1067 : * must be large enough to hold GetBlockXSize()*GetBlockYSize() words
1068 : * of type GetRasterDataType().
1069 : *
1070 : * @return CE_None on success or CE_Failure on an error.
1071 : */
1072 :
1073 894 : CPLErr GDALRasterBand::ReadBlock(int nXBlockOff, int nYBlockOff, void *pImage)
1074 :
1075 : {
1076 : /* -------------------------------------------------------------------- */
1077 : /* Validate arguments. */
1078 : /* -------------------------------------------------------------------- */
1079 894 : CPLAssert(pImage != nullptr);
1080 :
1081 894 : if (!InitBlockInfo())
1082 0 : return CE_Failure;
1083 :
1084 894 : if (nXBlockOff < 0 || nXBlockOff >= nBlocksPerRow)
1085 : {
1086 0 : ReportError(CE_Failure, CPLE_IllegalArg,
1087 : "Illegal nXBlockOff value (%d) in "
1088 : "GDALRasterBand::ReadBlock()\n",
1089 : nXBlockOff);
1090 :
1091 0 : return (CE_Failure);
1092 : }
1093 :
1094 894 : if (nYBlockOff < 0 || nYBlockOff >= nBlocksPerColumn)
1095 : {
1096 0 : ReportError(CE_Failure, CPLE_IllegalArg,
1097 : "Illegal nYBlockOff value (%d) in "
1098 : "GDALRasterBand::ReadBlock()\n",
1099 : nYBlockOff);
1100 :
1101 0 : return (CE_Failure);
1102 : }
1103 :
1104 : /* -------------------------------------------------------------------- */
1105 : /* Invoke underlying implementation method. */
1106 : /* -------------------------------------------------------------------- */
1107 :
1108 894 : int bCallLeaveReadWrite = EnterReadWrite(GF_Read);
1109 894 : CPLErr eErr = IReadBlock(nXBlockOff, nYBlockOff, pImage);
1110 894 : if (bCallLeaveReadWrite)
1111 4 : LeaveReadWrite();
1112 894 : return eErr;
1113 : }
1114 :
1115 : /************************************************************************/
1116 : /* GDALReadBlock() */
1117 : /************************************************************************/
1118 :
1119 : /**
1120 : * \brief Read a block of image data efficiently.
1121 : *
1122 : * @see GDALRasterBand::ReadBlock()
1123 : */
1124 :
1125 77 : CPLErr CPL_STDCALL GDALReadBlock(GDALRasterBandH hBand, int nXOff, int nYOff,
1126 : void *pData)
1127 :
1128 : {
1129 77 : VALIDATE_POINTER1(hBand, "GDALReadBlock", CE_Failure);
1130 :
1131 77 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
1132 77 : return (poBand->ReadBlock(nXOff, nYOff, pData));
1133 : }
1134 :
1135 : /************************************************************************/
1136 : /* IReadBlock() */
1137 : /************************************************************************/
1138 :
1139 : /** \fn GDALRasterBand::IReadBlock( int nBlockXOff, int nBlockYOff, void *pData
1140 : * ) \brief Read a block of data.
1141 : *
1142 : * Default internal implementation ... to be overridden by
1143 : * subclasses that support reading.
1144 : * @param nBlockXOff Block X Offset
1145 : * @param nBlockYOff Block Y Offset
1146 : * @param pData Pixel buffer into which to place read data.
1147 : * @return CE_None on success or CE_Failure on an error.
1148 : */
1149 :
1150 : /************************************************************************/
1151 : /* IWriteBlock() */
1152 : /************************************************************************/
1153 :
1154 : /**
1155 : * \fn GDALRasterBand::IWriteBlock(int, int, void*)
1156 : * Write a block of data.
1157 : *
1158 : * Default internal implementation ... to be overridden by
1159 : * subclasses that support writing.
1160 : * @param nBlockXOff Block X Offset
1161 : * @param nBlockYOff Block Y Offset
1162 : * @param pData Pixel buffer to write
1163 : * @return CE_None on success or CE_Failure on an error.
1164 : */
1165 :
1166 : /**/
1167 : /**/
1168 :
1169 0 : CPLErr GDALRasterBand::IWriteBlock(int /*nBlockXOff*/, int /*nBlockYOff*/,
1170 : void * /*pData*/)
1171 :
1172 : {
1173 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
1174 0 : ReportError(CE_Failure, CPLE_NotSupported,
1175 : "WriteBlock() not supported for this dataset.");
1176 :
1177 0 : return (CE_Failure);
1178 : }
1179 :
1180 : /************************************************************************/
1181 : /* WriteBlock() */
1182 : /************************************************************************/
1183 :
1184 : /**
1185 : * \brief Write a block of image data efficiently.
1186 : *
1187 : * This method accesses a "natural" block from the raster band without
1188 : * resampling, or data type conversion. For a more generalized, but
1189 : * potentially less efficient access use RasterIO().
1190 : *
1191 : * This method is the same as the C GDALWriteBlock() function.
1192 : *
1193 : * See ReadBlock() for an example of block oriented data access.
1194 : *
1195 : * @param nXBlockOff the horizontal block offset, with zero indicating
1196 : * the left most block, 1 the next block and so forth.
1197 : *
1198 : * @param nYBlockOff the vertical block offset, with zero indicating
1199 : * the left most block, 1 the next block and so forth.
1200 : *
1201 : * @param pImage the buffer from which the data will be written. The buffer
1202 : * must be large enough to hold GetBlockXSize()*GetBlockYSize() words
1203 : * of type GetRasterDataType(). Note that the content of the buffer might be
1204 : * temporarily modified during the execution of this method (and eventually
1205 : * restored back to its original content), so it is not safe to use a buffer
1206 : * stored in a read-only section of the calling program.
1207 : *
1208 : * @return CE_None on success or CE_Failure on an error.
1209 : */
1210 :
1211 4883 : CPLErr GDALRasterBand::WriteBlock(int nXBlockOff, int nYBlockOff, void *pImage)
1212 :
1213 : {
1214 : /* -------------------------------------------------------------------- */
1215 : /* Validate arguments. */
1216 : /* -------------------------------------------------------------------- */
1217 4883 : CPLAssert(pImage != nullptr);
1218 :
1219 4883 : if (!InitBlockInfo())
1220 0 : return CE_Failure;
1221 :
1222 4883 : if (nXBlockOff < 0 || nXBlockOff >= nBlocksPerRow)
1223 : {
1224 0 : ReportError(CE_Failure, CPLE_IllegalArg,
1225 : "Illegal nXBlockOff value (%d) in "
1226 : "GDALRasterBand::WriteBlock()\n",
1227 : nXBlockOff);
1228 :
1229 0 : return (CE_Failure);
1230 : }
1231 :
1232 4883 : if (nYBlockOff < 0 || nYBlockOff >= nBlocksPerColumn)
1233 : {
1234 0 : ReportError(CE_Failure, CPLE_IllegalArg,
1235 : "Illegal nYBlockOff value (%d) in "
1236 : "GDALRasterBand::WriteBlock()\n",
1237 : nYBlockOff);
1238 :
1239 0 : return (CE_Failure);
1240 : }
1241 :
1242 4883 : if (EmitErrorMessageIfWriteNotSupported("GDALRasterBand::WriteBlock()"))
1243 : {
1244 0 : return CE_Failure;
1245 : }
1246 :
1247 4883 : if (eFlushBlockErr != CE_None)
1248 : {
1249 0 : ReportError(eFlushBlockErr, CPLE_AppDefined,
1250 : "An error occurred while writing a dirty block "
1251 : "from GDALRasterBand::WriteBlock");
1252 0 : CPLErr eErr = eFlushBlockErr;
1253 0 : eFlushBlockErr = CE_None;
1254 0 : return eErr;
1255 : }
1256 :
1257 : /* -------------------------------------------------------------------- */
1258 : /* Invoke underlying implementation method. */
1259 : /* -------------------------------------------------------------------- */
1260 :
1261 4883 : const bool bCallLeaveReadWrite = CPL_TO_BOOL(EnterReadWrite(GF_Write));
1262 4883 : CPLErr eErr = IWriteBlock(nXBlockOff, nYBlockOff, pImage);
1263 4883 : if (bCallLeaveReadWrite)
1264 4883 : LeaveReadWrite();
1265 :
1266 4883 : return eErr;
1267 : }
1268 :
1269 : /************************************************************************/
1270 : /* GDALWriteBlock() */
1271 : /************************************************************************/
1272 :
1273 : /**
1274 : * \brief Write a block of image data efficiently.
1275 : *
1276 : * @see GDALRasterBand::WriteBlock()
1277 : */
1278 :
1279 0 : CPLErr CPL_STDCALL GDALWriteBlock(GDALRasterBandH hBand, int nXOff, int nYOff,
1280 : void *pData)
1281 :
1282 : {
1283 0 : VALIDATE_POINTER1(hBand, "GDALWriteBlock", CE_Failure);
1284 :
1285 0 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
1286 0 : return (poBand->WriteBlock(nXOff, nYOff, pData));
1287 : }
1288 :
1289 : /************************************************************************/
1290 : /* EmitErrorMessageIfWriteNotSupported() */
1291 : /************************************************************************/
1292 :
1293 : /**
1294 : * Emit an error message if a write operation to this band is not supported.
1295 : *
1296 : * The base implementation will emit an error message if the access mode is
1297 : * read-only. Derived classes may implement it to provide a custom message.
1298 : *
1299 : * @param pszCaller Calling function.
1300 : * @return true if an error message has been emitted.
1301 : */
1302 636802 : bool GDALRasterBand::EmitErrorMessageIfWriteNotSupported(
1303 : const char *pszCaller) const
1304 : {
1305 636802 : if (eAccess == GA_ReadOnly)
1306 : {
1307 4 : ReportError(CE_Failure, CPLE_NoWriteAccess,
1308 : "%s: attempt to write to dataset opened in read-only mode.",
1309 : pszCaller);
1310 :
1311 4 : return true;
1312 : }
1313 636798 : return false;
1314 : }
1315 :
1316 : /************************************************************************/
1317 : /* GetActualBlockSize() */
1318 : /************************************************************************/
1319 : /**
1320 : * \brief Fetch the actual block size for a given block offset.
1321 : *
1322 : * Handles partial blocks at the edges of the raster and returns the true
1323 : * number of pixels
1324 : *
1325 : * @param nXBlockOff the horizontal block offset for which to calculate the
1326 : * number of valid pixels, with zero indicating the left most block, 1 the next
1327 : * block and so forth.
1328 : *
1329 : * @param nYBlockOff the vertical block offset, with zero indicating
1330 : * the top most block, 1 the next block and so forth.
1331 : *
1332 : * @param pnXValid pointer to an integer in which the number of valid pixels in
1333 : * the x direction will be stored
1334 : *
1335 : * @param pnYValid pointer to an integer in which the number of valid pixels in
1336 : * the y direction will be stored
1337 : *
1338 : * @return CE_None if the input parameters are valid, CE_Failure otherwise
1339 : *
1340 : */
1341 52053 : CPLErr GDALRasterBand::GetActualBlockSize(int nXBlockOff, int nYBlockOff,
1342 : int *pnXValid, int *pnYValid) const
1343 : {
1344 104102 : if (nXBlockOff < 0 || nBlockXSize == 0 ||
1345 104095 : nXBlockOff >= DIV_ROUND_UP(nRasterXSize, nBlockXSize) ||
1346 104096 : nYBlockOff < 0 || nBlockYSize == 0 ||
1347 52048 : nYBlockOff >= DIV_ROUND_UP(nRasterYSize, nBlockYSize))
1348 : {
1349 4 : return CE_Failure;
1350 : }
1351 :
1352 52049 : const int nXPixelOff = nXBlockOff * nBlockXSize;
1353 52049 : const int nYPixelOff = nYBlockOff * nBlockYSize;
1354 :
1355 52049 : *pnXValid = nBlockXSize;
1356 52049 : *pnYValid = nBlockYSize;
1357 :
1358 52049 : if (nXPixelOff >= nRasterXSize - nBlockXSize)
1359 : {
1360 50415 : *pnXValid = nRasterXSize - nXPixelOff;
1361 : }
1362 :
1363 52049 : if (nYPixelOff >= nRasterYSize - nBlockYSize)
1364 : {
1365 3776 : *pnYValid = nRasterYSize - nYPixelOff;
1366 : }
1367 :
1368 52049 : return CE_None;
1369 : }
1370 :
1371 : /************************************************************************/
1372 : /* GDALGetActualBlockSize() */
1373 : /************************************************************************/
1374 :
1375 : /**
1376 : * \brief Retrieve the actual block size for a given block offset.
1377 : *
1378 : * @see GDALRasterBand::GetActualBlockSize()
1379 : */
1380 :
1381 6 : CPLErr CPL_STDCALL GDALGetActualBlockSize(GDALRasterBandH hBand, int nXBlockOff,
1382 : int nYBlockOff, int *pnXValid,
1383 : int *pnYValid)
1384 :
1385 : {
1386 6 : VALIDATE_POINTER1(hBand, "GDALGetActualBlockSize", CE_Failure);
1387 :
1388 6 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
1389 : return (
1390 6 : poBand->GetActualBlockSize(nXBlockOff, nYBlockOff, pnXValid, pnYValid));
1391 : }
1392 :
1393 : /************************************************************************/
1394 : /* GetSuggestedBlockAccessPattern() */
1395 : /************************************************************************/
1396 :
1397 : /**
1398 : * \brief Return the suggested/most efficient access pattern to blocks
1399 : * (for read operations).
1400 : *
1401 : * While all GDAL drivers have to expose a block size, not all can guarantee
1402 : * efficient random access (GSBAP_RANDOM) to any block.
1403 : * Some drivers for example decompress sequentially a compressed stream from
1404 : * top raster to bottom (GSBAP_TOP_TO_BOTTOM), in which
1405 : * case best performance will be achieved while reading blocks in that order.
1406 : * (accessing blocks in random access in such rasters typically causes the
1407 : * decoding to be re-initialized from the start if accessing blocks in
1408 : * a non-sequential order)
1409 : *
1410 : * The base implementation returns GSBAP_UNKNOWN, which can also be explicitly
1411 : * returned by drivers that expose a somewhat artificial block size, because
1412 : * they can extract any part of a raster, but in a rather inefficient way.
1413 : *
1414 : * The GSBAP_LARGEST_CHUNK_POSSIBLE value can be combined as a logical bitmask
1415 : * with other enumeration values (GSBAP_UNKNOWN, GSBAP_RANDOM,
1416 : * GSBAP_TOP_TO_BOTTOM, GSBAP_BOTTOM_TO_TOP). When a driver sets this flag, the
1417 : * most efficient strategy is to read as many pixels as possible in the less
1418 : * RasterIO() operations.
1419 : *
1420 : * The return of this method is for example used to determine the swath size
1421 : * used by GDALDatasetCopyWholeRaster() and GDALRasterBandCopyWholeRaster().
1422 : *
1423 : * @since GDAL 3.6
1424 : */
1425 :
1426 : GDALSuggestedBlockAccessPattern
1427 2411 : GDALRasterBand::GetSuggestedBlockAccessPattern() const
1428 : {
1429 2411 : return GSBAP_UNKNOWN;
1430 : }
1431 :
1432 : /************************************************************************/
1433 : /* GetRasterDataType() */
1434 : /************************************************************************/
1435 :
1436 : /**
1437 : * \brief Fetch the pixel data type for this band.
1438 : *
1439 : * This method is the same as the C function GDALGetRasterDataType().
1440 : *
1441 : * @return the data type of pixels for this band.
1442 : */
1443 :
1444 8945190 : GDALDataType GDALRasterBand::GetRasterDataType() const
1445 :
1446 : {
1447 8945190 : return eDataType;
1448 : }
1449 :
1450 : /************************************************************************/
1451 : /* GDALGetRasterDataType() */
1452 : /************************************************************************/
1453 :
1454 : /**
1455 : * \brief Fetch the pixel data type for this band.
1456 : *
1457 : * @see GDALRasterBand::GetRasterDataType()
1458 : */
1459 :
1460 905672 : GDALDataType CPL_STDCALL GDALGetRasterDataType(GDALRasterBandH hBand)
1461 :
1462 : {
1463 905672 : VALIDATE_POINTER1(hBand, "GDALGetRasterDataType", GDT_Unknown);
1464 :
1465 905672 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
1466 905672 : return poBand->GetRasterDataType();
1467 : }
1468 :
1469 : /************************************************************************/
1470 : /* GetBlockSize() */
1471 : /************************************************************************/
1472 :
1473 : /**
1474 : * \brief Fetch the "natural" block size of this band.
1475 : *
1476 : * GDAL contains a concept of the natural block size of rasters so that
1477 : * applications can organized data access efficiently for some file formats.
1478 : * The natural block size is the block size that is most efficient for
1479 : * accessing the format. For many formats this is simple a whole scanline
1480 : * in which case *pnXSize is set to GetXSize(), and *pnYSize is set to 1.
1481 : *
1482 : * However, for tiled images this will typically be the tile size.
1483 : *
1484 : * Note that the X and Y block sizes don't have to divide the image size
1485 : * evenly, meaning that right and bottom edge blocks may be incomplete.
1486 : * See ReadBlock() for an example of code dealing with these issues.
1487 : *
1488 : * This method is the same as the C function GDALGetBlockSize().
1489 : *
1490 : * @param pnXSize integer to put the X block size into or NULL.
1491 : *
1492 : * @param pnYSize integer to put the Y block size into or NULL.
1493 : */
1494 :
1495 5535290 : void GDALRasterBand::GetBlockSize(int *pnXSize, int *pnYSize) const
1496 :
1497 : {
1498 5535290 : if (nBlockXSize <= 0 || nBlockYSize <= 0)
1499 : {
1500 5942 : ReportError(CE_Failure, CPLE_AppDefined,
1501 5942 : "Invalid block dimension : %d * %d", nBlockXSize,
1502 5942 : nBlockYSize);
1503 4 : if (pnXSize != nullptr)
1504 4 : *pnXSize = 0;
1505 4 : if (pnYSize != nullptr)
1506 4 : *pnYSize = 0;
1507 : }
1508 : else
1509 : {
1510 5529350 : if (pnXSize != nullptr)
1511 5526760 : *pnXSize = nBlockXSize;
1512 5529350 : if (pnYSize != nullptr)
1513 5529240 : *pnYSize = nBlockYSize;
1514 : }
1515 5529350 : }
1516 :
1517 : /************************************************************************/
1518 : /* GDALGetBlockSize() */
1519 : /************************************************************************/
1520 :
1521 : /**
1522 : * \brief Fetch the "natural" block size of this band.
1523 : *
1524 : * @see GDALRasterBand::GetBlockSize()
1525 : */
1526 :
1527 41139 : void CPL_STDCALL GDALGetBlockSize(GDALRasterBandH hBand, int *pnXSize,
1528 : int *pnYSize)
1529 :
1530 : {
1531 41139 : VALIDATE_POINTER0(hBand, "GDALGetBlockSize");
1532 :
1533 41139 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
1534 41140 : poBand->GetBlockSize(pnXSize, pnYSize);
1535 : }
1536 :
1537 : /************************************************************************/
1538 : /* InitBlockInfo() */
1539 : /************************************************************************/
1540 :
1541 : //! @cond Doxygen_Suppress
1542 3645540 : int GDALRasterBand::InitBlockInfo()
1543 :
1544 : {
1545 3645540 : if (poBandBlockCache != nullptr)
1546 3406760 : return poBandBlockCache->IsInitOK();
1547 :
1548 : /* Do some validation of raster and block dimensions in case the driver */
1549 : /* would have neglected to do it itself */
1550 238779 : if (nBlockXSize <= 0 || nBlockYSize <= 0)
1551 : {
1552 240 : ReportError(CE_Failure, CPLE_AppDefined,
1553 : "Invalid block dimension : %d * %d", nBlockXSize,
1554 : nBlockYSize);
1555 0 : return FALSE;
1556 : }
1557 :
1558 238539 : if (nRasterXSize <= 0 || nRasterYSize <= 0)
1559 : {
1560 2 : ReportError(CE_Failure, CPLE_AppDefined,
1561 : "Invalid raster dimension : %d * %d", nRasterXSize,
1562 : nRasterYSize);
1563 0 : return FALSE;
1564 : }
1565 :
1566 238537 : const int nDataTypeSize = GDALGetDataTypeSizeBytes(eDataType);
1567 238538 : if (nDataTypeSize == 0)
1568 : {
1569 0 : ReportError(CE_Failure, CPLE_AppDefined, "Invalid data type");
1570 0 : return FALSE;
1571 : }
1572 :
1573 : #if SIZEOF_VOIDP == 4
1574 : if (nBlockXSize >= 10000 || nBlockYSize >= 10000)
1575 : {
1576 : /* As 10000 * 10000 * 16 < INT_MAX, we don't need to do the
1577 : * multiplication in other cases */
1578 : if (nBlockXSize > INT_MAX / nDataTypeSize ||
1579 : nBlockYSize > INT_MAX / (nDataTypeSize * nBlockXSize))
1580 : {
1581 : ReportError(CE_Failure, CPLE_NotSupported,
1582 : "Too big block : %d * %d for 32-bit build", nBlockXSize,
1583 : nBlockYSize);
1584 : return FALSE;
1585 : }
1586 : }
1587 : #endif
1588 :
1589 238538 : nBlocksPerRow = DIV_ROUND_UP(nRasterXSize, nBlockXSize);
1590 238538 : nBlocksPerColumn = DIV_ROUND_UP(nRasterYSize, nBlockYSize);
1591 :
1592 : const char *pszBlockStrategy =
1593 238538 : CPLGetConfigOption("GDAL_BAND_BLOCK_CACHE", nullptr);
1594 238543 : bool bUseArray = true;
1595 238543 : if (pszBlockStrategy == nullptr || EQUAL(pszBlockStrategy, "AUTO"))
1596 : {
1597 238503 : if (poDS == nullptr || (poDS->nOpenFlags & GDAL_OF_BLOCK_ACCESS_MASK) ==
1598 : GDAL_OF_DEFAULT_BLOCK_ACCESS)
1599 : {
1600 238484 : GUIntBig nBlockCount =
1601 238484 : static_cast<GIntBig>(nBlocksPerRow) * nBlocksPerColumn;
1602 238484 : if (poDS != nullptr)
1603 238280 : nBlockCount *= poDS->GetRasterCount();
1604 238484 : bUseArray = (nBlockCount < 1024 * 1024);
1605 : }
1606 19 : else if ((poDS->nOpenFlags & GDAL_OF_BLOCK_ACCESS_MASK) ==
1607 : GDAL_OF_HASHSET_BLOCK_ACCESS)
1608 : {
1609 0 : bUseArray = false;
1610 238503 : }
1611 : }
1612 40 : else if (EQUAL(pszBlockStrategy, "HASHSET"))
1613 40 : bUseArray = false;
1614 0 : else if (!EQUAL(pszBlockStrategy, "ARRAY"))
1615 0 : CPLError(CE_Warning, CPLE_AppDefined, "Unknown block cache method: %s",
1616 : pszBlockStrategy);
1617 :
1618 238543 : if (bUseArray)
1619 238472 : poBandBlockCache = GDALArrayBandBlockCacheCreate(this);
1620 : else
1621 : {
1622 71 : if (nBand == 1)
1623 26 : CPLDebug("GDAL", "Use hashset band block cache");
1624 71 : poBandBlockCache = GDALHashSetBandBlockCacheCreate(this);
1625 : }
1626 238542 : if (poBandBlockCache == nullptr)
1627 0 : return FALSE;
1628 238542 : return poBandBlockCache->Init();
1629 : }
1630 :
1631 : //! @endcond
1632 :
1633 : /************************************************************************/
1634 : /* FlushCache() */
1635 : /************************************************************************/
1636 :
1637 : /**
1638 : * \brief Flush raster data cache.
1639 : *
1640 : * This call will recover memory used to cache data blocks for this raster
1641 : * band, and ensure that new requests are referred to the underlying driver.
1642 : *
1643 : * This method is the same as the C function GDALFlushRasterCache().
1644 : *
1645 : * @param bAtClosing Whether this is called from a GDALDataset destructor
1646 : * @return CE_None on success.
1647 : */
1648 :
1649 5629870 : CPLErr GDALRasterBand::FlushCache(bool bAtClosing)
1650 :
1651 : {
1652 5746780 : if (bAtClosing && poDS && poDS->IsMarkedSuppressOnClose() &&
1653 116916 : poBandBlockCache)
1654 3150 : poBandBlockCache->DisableDirtyBlockWriting();
1655 :
1656 5630550 : CPLErr eGlobalErr = eFlushBlockErr;
1657 :
1658 5630550 : if (eFlushBlockErr != CE_None)
1659 : {
1660 0 : ReportError(
1661 : eFlushBlockErr, CPLE_AppDefined,
1662 : "An error occurred while writing a dirty block from FlushCache");
1663 0 : eFlushBlockErr = CE_None;
1664 : }
1665 :
1666 5630550 : if (poBandBlockCache == nullptr || !poBandBlockCache->IsInitOK())
1667 4868860 : return eGlobalErr;
1668 :
1669 761688 : return poBandBlockCache->FlushCache();
1670 : }
1671 :
1672 : /************************************************************************/
1673 : /* GDALFlushRasterCache() */
1674 : /************************************************************************/
1675 :
1676 : /**
1677 : * \brief Flush raster data cache.
1678 : *
1679 : * @see GDALRasterBand::FlushCache()
1680 : */
1681 :
1682 487 : CPLErr CPL_STDCALL GDALFlushRasterCache(GDALRasterBandH hBand)
1683 :
1684 : {
1685 487 : VALIDATE_POINTER1(hBand, "GDALFlushRasterCache", CE_Failure);
1686 :
1687 487 : return GDALRasterBand::FromHandle(hBand)->FlushCache(false);
1688 : }
1689 :
1690 : /************************************************************************/
1691 : /* DropCache() */
1692 : /************************************************************************/
1693 :
1694 : /**
1695 : * \brief Drop raster data cache : data in cache will be lost.
1696 : *
1697 : * This call will recover memory used to cache data blocks for this raster
1698 : * band, and ensure that new requests are referred to the underlying driver.
1699 : *
1700 : * This method is the same as the C function GDALDropRasterCache().
1701 : *
1702 : * @return CE_None on success.
1703 : * @since 3.9
1704 : */
1705 :
1706 1 : CPLErr GDALRasterBand::DropCache()
1707 :
1708 : {
1709 1 : CPLErr result = CE_None;
1710 :
1711 1 : if (poBandBlockCache)
1712 1 : poBandBlockCache->DisableDirtyBlockWriting();
1713 :
1714 1 : CPLErr eGlobalErr = eFlushBlockErr;
1715 :
1716 1 : if (eFlushBlockErr != CE_None)
1717 : {
1718 0 : ReportError(
1719 : eFlushBlockErr, CPLE_AppDefined,
1720 : "An error occurred while writing a dirty block from DropCache");
1721 0 : eFlushBlockErr = CE_None;
1722 : }
1723 :
1724 1 : if (poBandBlockCache == nullptr || !poBandBlockCache->IsInitOK())
1725 0 : result = eGlobalErr;
1726 : else
1727 1 : result = poBandBlockCache->FlushCache();
1728 :
1729 1 : if (poBandBlockCache)
1730 1 : poBandBlockCache->EnableDirtyBlockWriting();
1731 :
1732 1 : return result;
1733 : }
1734 :
1735 : /************************************************************************/
1736 : /* GDALDropRasterCache() */
1737 : /************************************************************************/
1738 :
1739 : /**
1740 : * \brief Drop raster data cache.
1741 : *
1742 : * @see GDALRasterBand::DropCache()
1743 : * @since 3.9
1744 : */
1745 :
1746 0 : CPLErr CPL_STDCALL GDALDropRasterCache(GDALRasterBandH hBand)
1747 :
1748 : {
1749 0 : VALIDATE_POINTER1(hBand, "GDALDropRasterCache", CE_Failure);
1750 :
1751 0 : return GDALRasterBand::FromHandle(hBand)->DropCache();
1752 : }
1753 :
1754 : /************************************************************************/
1755 : /* UnreferenceBlock() */
1756 : /* */
1757 : /* Unreference the block from our array of blocks */
1758 : /* This method should only be called by */
1759 : /* GDALRasterBlock::Internalize() and FlushCacheBlock() (and under */
1760 : /* the block cache mutex) */
1761 : /************************************************************************/
1762 :
1763 29583 : CPLErr GDALRasterBand::UnreferenceBlock(GDALRasterBlock *poBlock)
1764 : {
1765 : #ifdef notdef
1766 : if (poBandBlockCache == nullptr || !poBandBlockCache->IsInitOK())
1767 : {
1768 : if (poBandBlockCache == nullptr)
1769 : printf("poBandBlockCache == NULL\n"); /*ok*/
1770 : else
1771 : printf("!poBandBlockCache->IsInitOK()\n"); /*ok*/
1772 : printf("caller = %s\n", pszCaller); /*ok*/
1773 : printf("GDALRasterBand: %p\n", this); /*ok*/
1774 : printf("GDALRasterBand: nBand=%d\n", nBand); /*ok*/
1775 : printf("nRasterXSize = %d\n", nRasterXSize); /*ok*/
1776 : printf("nRasterYSize = %d\n", nRasterYSize); /*ok*/
1777 : printf("nBlockXSize = %d\n", nBlockXSize); /*ok*/
1778 : printf("nBlockYSize = %d\n", nBlockYSize); /*ok*/
1779 : poBlock->DumpBlock();
1780 : if (GetDataset() != nullptr)
1781 : printf("Dataset: %s\n", GetDataset()->GetDescription()); /*ok*/
1782 : GDALRasterBlock::Verify();
1783 : abort();
1784 : }
1785 : #endif
1786 29583 : CPLAssert(poBandBlockCache && poBandBlockCache->IsInitOK());
1787 29583 : return poBandBlockCache->UnreferenceBlock(poBlock);
1788 : }
1789 :
1790 : /************************************************************************/
1791 : /* AddBlockToFreeList() */
1792 : /* */
1793 : /* When GDALRasterBlock::Internalize() or FlushCacheBlock() are */
1794 : /* finished with a block about to be free'd, they pass it to that */
1795 : /* method. */
1796 : /************************************************************************/
1797 :
1798 : //! @cond Doxygen_Suppress
1799 29583 : void GDALRasterBand::AddBlockToFreeList(GDALRasterBlock *poBlock)
1800 : {
1801 29583 : CPLAssert(poBandBlockCache && poBandBlockCache->IsInitOK());
1802 29583 : return poBandBlockCache->AddBlockToFreeList(poBlock);
1803 : }
1804 :
1805 : //! @endcond
1806 :
1807 : /************************************************************************/
1808 : /* HasDirtyBlocks() */
1809 : /************************************************************************/
1810 :
1811 : //! @cond Doxygen_Suppress
1812 17 : bool GDALRasterBand::HasDirtyBlocks() const
1813 : {
1814 17 : return poBandBlockCache && poBandBlockCache->HasDirtyBlocks();
1815 : }
1816 :
1817 : //! @endcond
1818 :
1819 : /************************************************************************/
1820 : /* FlushBlock() */
1821 : /************************************************************************/
1822 :
1823 : /** Flush a block out of the block cache.
1824 : * @param nXBlockOff block x offset
1825 : * @param nYBlockOff blocky offset
1826 : * @param bWriteDirtyBlock whether the block should be written to disk if dirty.
1827 : * @return CE_None in case of success, an error code otherwise.
1828 : */
1829 2311 : CPLErr GDALRasterBand::FlushBlock(int nXBlockOff, int nYBlockOff,
1830 : int bWriteDirtyBlock)
1831 :
1832 : {
1833 2311 : if (poBandBlockCache == nullptr || !poBandBlockCache->IsInitOK())
1834 0 : return (CE_Failure);
1835 :
1836 : /* -------------------------------------------------------------------- */
1837 : /* Validate the request */
1838 : /* -------------------------------------------------------------------- */
1839 2311 : if (nXBlockOff < 0 || nXBlockOff >= nBlocksPerRow)
1840 : {
1841 0 : ReportError(CE_Failure, CPLE_IllegalArg,
1842 : "Illegal nBlockXOff value (%d) in "
1843 : "GDALRasterBand::FlushBlock()\n",
1844 : nXBlockOff);
1845 :
1846 0 : return (CE_Failure);
1847 : }
1848 :
1849 2311 : if (nYBlockOff < 0 || nYBlockOff >= nBlocksPerColumn)
1850 : {
1851 0 : ReportError(CE_Failure, CPLE_IllegalArg,
1852 : "Illegal nBlockYOff value (%d) in "
1853 : "GDALRasterBand::FlushBlock()\n",
1854 : nYBlockOff);
1855 :
1856 0 : return (CE_Failure);
1857 : }
1858 :
1859 2311 : return poBandBlockCache->FlushBlock(nXBlockOff, nYBlockOff,
1860 2311 : bWriteDirtyBlock);
1861 : }
1862 :
1863 : /************************************************************************/
1864 : /* TryGetLockedBlockRef() */
1865 : /************************************************************************/
1866 :
1867 : /**
1868 : * \brief Try fetching block ref.
1869 : *
1870 : * This method will returned the requested block (locked) if it is already
1871 : * in the block cache for the layer. If not, nullptr is returned.
1872 : *
1873 : * If a non-NULL value is returned, then a lock for the block will have been
1874 : * acquired on behalf of the caller. It is absolutely imperative that the
1875 : * caller release this lock (with GDALRasterBlock::DropLock()) or else
1876 : * severe problems may result.
1877 : *
1878 : * @param nXBlockOff the horizontal block offset, with zero indicating
1879 : * the left most block, 1 the next block and so forth.
1880 : *
1881 : * @param nYBlockOff the vertical block offset, with zero indicating
1882 : * the top most block, 1 the next block and so forth.
1883 : *
1884 : * @return NULL if block not available, or locked block pointer.
1885 : */
1886 :
1887 10639100 : GDALRasterBlock *GDALRasterBand::TryGetLockedBlockRef(int nXBlockOff,
1888 : int nYBlockOff)
1889 :
1890 : {
1891 10639100 : if (poBandBlockCache == nullptr || !poBandBlockCache->IsInitOK())
1892 172384 : return nullptr;
1893 :
1894 : /* -------------------------------------------------------------------- */
1895 : /* Validate the request */
1896 : /* -------------------------------------------------------------------- */
1897 10466700 : if (nXBlockOff < 0 || nXBlockOff >= nBlocksPerRow)
1898 : {
1899 0 : ReportError(CE_Failure, CPLE_IllegalArg,
1900 : "Illegal nBlockXOff value (%d) in "
1901 : "GDALRasterBand::TryGetLockedBlockRef()\n",
1902 : nXBlockOff);
1903 :
1904 0 : return (nullptr);
1905 : }
1906 :
1907 10466700 : if (nYBlockOff < 0 || nYBlockOff >= nBlocksPerColumn)
1908 : {
1909 0 : ReportError(CE_Failure, CPLE_IllegalArg,
1910 : "Illegal nBlockYOff value (%d) in "
1911 : "GDALRasterBand::TryGetLockedBlockRef()\n",
1912 : nYBlockOff);
1913 :
1914 0 : return (nullptr);
1915 : }
1916 :
1917 10466700 : return poBandBlockCache->TryGetLockedBlockRef(nXBlockOff, nYBlockOff);
1918 : }
1919 :
1920 : /************************************************************************/
1921 : /* GetLockedBlockRef() */
1922 : /************************************************************************/
1923 :
1924 : /**
1925 : * \brief Fetch a pointer to an internally cached raster block.
1926 : *
1927 : * This method will returned the requested block (locked) if it is already
1928 : * in the block cache for the layer. If not, the block will be read from
1929 : * the driver, and placed in the layer block cached, then returned. If an
1930 : * error occurs reading the block from the driver, a NULL value will be
1931 : * returned.
1932 : *
1933 : * If a non-NULL value is returned, then a lock for the block will have been
1934 : * acquired on behalf of the caller. It is absolutely imperative that the
1935 : * caller release this lock (with GDALRasterBlock::DropLock()) or else
1936 : * severe problems may result.
1937 : *
1938 : * Note that calling GetLockedBlockRef() on a previously uncached band will
1939 : * enable caching.
1940 : *
1941 : * @param nXBlockOff the horizontal block offset, with zero indicating
1942 : * the left most block, 1 the next block and so forth.
1943 : *
1944 : * @param nYBlockOff the vertical block offset, with zero indicating
1945 : * the top most block, 1 the next block and so forth.
1946 : *
1947 : * @param bJustInitialize If TRUE the block will be allocated and initialized,
1948 : * but not actually read from the source. This is useful when it will just
1949 : * be completely set and written back.
1950 : *
1951 : * @return pointer to the block object, or NULL on failure.
1952 : */
1953 :
1954 10329400 : GDALRasterBlock *GDALRasterBand::GetLockedBlockRef(int nXBlockOff,
1955 : int nYBlockOff,
1956 : int bJustInitialize)
1957 :
1958 : {
1959 : /* -------------------------------------------------------------------- */
1960 : /* Try and fetch from cache. */
1961 : /* -------------------------------------------------------------------- */
1962 10329400 : GDALRasterBlock *poBlock = TryGetLockedBlockRef(nXBlockOff, nYBlockOff);
1963 :
1964 : /* -------------------------------------------------------------------- */
1965 : /* If we didn't find it in our memory cache, instantiate a */
1966 : /* block (potentially load from disk) and "adopt" it into the */
1967 : /* cache. */
1968 : /* -------------------------------------------------------------------- */
1969 10329600 : if (poBlock == nullptr)
1970 : {
1971 3368600 : if (!InitBlockInfo())
1972 0 : return (nullptr);
1973 :
1974 : /* --------------------------------------------------------------------
1975 : */
1976 : /* Validate the request */
1977 : /* --------------------------------------------------------------------
1978 : */
1979 3368600 : if (nXBlockOff < 0 || nXBlockOff >= nBlocksPerRow)
1980 : {
1981 8 : ReportError(CE_Failure, CPLE_IllegalArg,
1982 : "Illegal nBlockXOff value (%d) in "
1983 : "GDALRasterBand::GetLockedBlockRef()\n",
1984 : nXBlockOff);
1985 :
1986 0 : return (nullptr);
1987 : }
1988 :
1989 3368590 : if (nYBlockOff < 0 || nYBlockOff >= nBlocksPerColumn)
1990 : {
1991 3 : ReportError(CE_Failure, CPLE_IllegalArg,
1992 : "Illegal nBlockYOff value (%d) in "
1993 : "GDALRasterBand::GetLockedBlockRef()\n",
1994 : nYBlockOff);
1995 :
1996 0 : return (nullptr);
1997 : }
1998 :
1999 3368590 : poBlock = poBandBlockCache->CreateBlock(nXBlockOff, nYBlockOff);
2000 3368590 : if (poBlock == nullptr)
2001 0 : return nullptr;
2002 :
2003 3368590 : poBlock->AddLock();
2004 :
2005 : /* We need to temporarily drop the read-write lock in the following */
2006 : /*scenario. Imagine 2 threads T1 and T2 that respectively write dataset
2007 : */
2008 : /* D1 and D2. T1 will take the mutex on D1 and T2 on D2. Now when the */
2009 : /* block cache fills, T1 might need to flush dirty blocks of D2 in the
2010 : */
2011 : /* below Internalize(), which will cause GDALRasterBlock::Write() to be
2012 : */
2013 : /* called and attempt at taking the lock on T2 (already taken).
2014 : * Similarly */
2015 : /* for T2 with D1, hence a deadlock situation (#6163) */
2016 : /* But this may open the door to other problems... */
2017 3368600 : if (poDS)
2018 3367860 : poDS->TemporarilyDropReadWriteLock();
2019 : /* allocate data space */
2020 3368590 : CPLErr eErr = poBlock->Internalize();
2021 3368620 : if (poDS)
2022 3367870 : poDS->ReacquireReadWriteLock();
2023 3368610 : if (eErr != CE_None)
2024 : {
2025 0 : poBlock->DropLock();
2026 0 : delete poBlock;
2027 0 : return nullptr;
2028 : }
2029 :
2030 3368610 : if (poBandBlockCache->AdoptBlock(poBlock) != CE_None)
2031 : {
2032 0 : poBlock->DropLock();
2033 0 : delete poBlock;
2034 0 : return nullptr;
2035 : }
2036 :
2037 3368610 : if (!bJustInitialize)
2038 : {
2039 2882780 : const GUInt32 nErrorCounter = CPLGetErrorCounter();
2040 2882770 : int bCallLeaveReadWrite = EnterReadWrite(GF_Read);
2041 2882770 : eErr = IReadBlock(nXBlockOff, nYBlockOff, poBlock->GetDataRef());
2042 2882770 : if (bCallLeaveReadWrite)
2043 130214 : LeaveReadWrite();
2044 2882760 : if (eErr != CE_None)
2045 : {
2046 1161 : poBlock->DropLock();
2047 1161 : FlushBlock(nXBlockOff, nYBlockOff);
2048 1161 : ReportError(CE_Failure, CPLE_AppDefined,
2049 : "IReadBlock failed at X offset %d, Y offset %d%s",
2050 : nXBlockOff, nYBlockOff,
2051 1161 : (nErrorCounter != CPLGetErrorCounter())
2052 1159 : ? CPLSPrintf(": %s", CPLGetLastErrorMsg())
2053 : : "");
2054 1161 : return nullptr;
2055 : }
2056 :
2057 2881600 : nBlockReads++;
2058 2881600 : if (static_cast<GIntBig>(nBlockReads) ==
2059 2881600 : static_cast<GIntBig>(nBlocksPerRow) * nBlocksPerColumn +
2060 224 : 1 &&
2061 224 : nBand == 1 && poDS != nullptr)
2062 : {
2063 164 : CPLDebug("GDAL", "Potential thrashing on band %d of %s.", nBand,
2064 164 : poDS->GetDescription());
2065 : }
2066 : }
2067 : }
2068 :
2069 10328400 : return poBlock;
2070 : }
2071 :
2072 : /************************************************************************/
2073 : /* Fill() */
2074 : /************************************************************************/
2075 :
2076 : /**
2077 : * \brief Fill this band with a constant value.
2078 : *
2079 : * GDAL makes no guarantees
2080 : * about what values pixels in newly created files are set to, so this
2081 : * method can be used to clear a band to a specified "default" value.
2082 : * The fill value is passed in as a double but this will be converted
2083 : * to the underlying type before writing to the file. An optional
2084 : * second argument allows the imaginary component of a complex
2085 : * constant value to be specified.
2086 : *
2087 : * This method is the same as the C function GDALFillRaster().
2088 : *
2089 : * @param dfRealValue Real component of fill value
2090 : * @param dfImaginaryValue Imaginary component of fill value, defaults to zero
2091 : *
2092 : * @return CE_Failure if the write fails, otherwise CE_None
2093 : */
2094 268829 : CPLErr GDALRasterBand::Fill(double dfRealValue, double dfImaginaryValue)
2095 : {
2096 :
2097 : // General approach is to construct a source block of the file's
2098 : // native type containing the appropriate value and then copy this
2099 : // to each block in the image via the RasterBlock cache. Using
2100 : // the cache means we avoid file I/O if it is not necessary, at the
2101 : // expense of some extra memcpy's (since we write to the
2102 : // RasterBlock cache, which is then at some point written to the
2103 : // underlying file, rather than simply directly to the underlying
2104 : // file.)
2105 :
2106 : // Check we can write to the file.
2107 268829 : if (EmitErrorMessageIfWriteNotSupported("GDALRasterBand::Fill()"))
2108 : {
2109 6 : return CE_Failure;
2110 : }
2111 :
2112 : // Make sure block parameters are set.
2113 268823 : if (!InitBlockInfo())
2114 0 : return CE_Failure;
2115 :
2116 : // Allocate the source block.
2117 268823 : auto blockSize = static_cast<GPtrDiff_t>(nBlockXSize) * nBlockYSize;
2118 268823 : int elementSize = GDALGetDataTypeSizeBytes(eDataType);
2119 268823 : auto blockByteSize = blockSize * elementSize;
2120 : unsigned char *srcBlock =
2121 268823 : static_cast<unsigned char *>(VSIMalloc(blockByteSize));
2122 268823 : if (srcBlock == nullptr)
2123 : {
2124 0 : ReportError(CE_Failure, CPLE_OutOfMemory,
2125 : "GDALRasterBand::Fill(): Out of memory "
2126 : "allocating " CPL_FRMT_GUIB " bytes.\n",
2127 : static_cast<GUIntBig>(blockByteSize));
2128 0 : return CE_Failure;
2129 : }
2130 :
2131 : // Initialize the source block.
2132 268823 : double complexSrc[2] = {dfRealValue, dfImaginaryValue};
2133 268823 : GDALCopyWords64(complexSrc, GDT_CFloat64, 0, srcBlock, eDataType,
2134 : elementSize, blockSize);
2135 :
2136 268823 : const bool bCallLeaveReadWrite = CPL_TO_BOOL(EnterReadWrite(GF_Write));
2137 :
2138 : // Write block to block cache
2139 872262 : for (int j = 0; j < nBlocksPerColumn; ++j)
2140 : {
2141 1501220 : for (int i = 0; i < nBlocksPerRow; ++i)
2142 : {
2143 897786 : GDALRasterBlock *destBlock = GetLockedBlockRef(i, j, TRUE);
2144 897786 : if (destBlock == nullptr)
2145 : {
2146 0 : ReportError(CE_Failure, CPLE_OutOfMemory,
2147 : "GDALRasterBand::Fill(): Error "
2148 : "while retrieving cache block.");
2149 0 : VSIFree(srcBlock);
2150 0 : return CE_Failure;
2151 : }
2152 897786 : memcpy(destBlock->GetDataRef(), srcBlock, blockByteSize);
2153 897786 : destBlock->MarkDirty();
2154 897786 : destBlock->DropLock();
2155 : }
2156 : }
2157 :
2158 268823 : if (bCallLeaveReadWrite)
2159 267647 : LeaveReadWrite();
2160 :
2161 : // Free up the source block
2162 268823 : VSIFree(srcBlock);
2163 :
2164 268823 : return CE_None;
2165 : }
2166 :
2167 : /************************************************************************/
2168 : /* GDALFillRaster() */
2169 : /************************************************************************/
2170 :
2171 : /**
2172 : * \brief Fill this band with a constant value.
2173 : *
2174 : * @see GDALRasterBand::Fill()
2175 : */
2176 268633 : CPLErr CPL_STDCALL GDALFillRaster(GDALRasterBandH hBand, double dfRealValue,
2177 : double dfImaginaryValue)
2178 : {
2179 268633 : VALIDATE_POINTER1(hBand, "GDALFillRaster", CE_Failure);
2180 :
2181 268633 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2182 268633 : return poBand->Fill(dfRealValue, dfImaginaryValue);
2183 : }
2184 :
2185 : /************************************************************************/
2186 : /* GetAccess() */
2187 : /************************************************************************/
2188 :
2189 : /**
2190 : * \brief Find out if we have update permission for this band.
2191 : *
2192 : * This method is the same as the C function GDALGetRasterAccess().
2193 : *
2194 : * @return Either GA_Update or GA_ReadOnly.
2195 : */
2196 :
2197 2995 : GDALAccess GDALRasterBand::GetAccess()
2198 :
2199 : {
2200 2995 : return eAccess;
2201 : }
2202 :
2203 : /************************************************************************/
2204 : /* GDALGetRasterAccess() */
2205 : /************************************************************************/
2206 :
2207 : /**
2208 : * \brief Find out if we have update permission for this band.
2209 : *
2210 : * @see GDALRasterBand::GetAccess()
2211 : */
2212 :
2213 2337 : GDALAccess CPL_STDCALL GDALGetRasterAccess(GDALRasterBandH hBand)
2214 :
2215 : {
2216 2337 : VALIDATE_POINTER1(hBand, "GDALGetRasterAccess", GA_ReadOnly);
2217 :
2218 2337 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2219 2337 : return poBand->GetAccess();
2220 : }
2221 :
2222 : /************************************************************************/
2223 : /* GetCategoryNames() */
2224 : /************************************************************************/
2225 :
2226 : /**
2227 : * \brief Fetch the list of category names for this raster.
2228 : *
2229 : * The return list is a "StringList" in the sense of the CPL functions.
2230 : * That is a NULL terminated array of strings. Raster values without
2231 : * associated names will have an empty string in the returned list. The
2232 : * first entry in the list is for raster values of zero, and so on.
2233 : *
2234 : * The returned stringlist should not be altered or freed by the application.
2235 : * It may change on the next GDAL call, so please copy it if it is needed
2236 : * for any period of time.
2237 : *
2238 : * This method is the same as the C function GDALGetRasterCategoryNames().
2239 : *
2240 : * @return list of names, or NULL if none.
2241 : */
2242 :
2243 262 : char **GDALRasterBand::GetCategoryNames()
2244 :
2245 : {
2246 262 : return nullptr;
2247 : }
2248 :
2249 : /************************************************************************/
2250 : /* GDALGetRasterCategoryNames() */
2251 : /************************************************************************/
2252 :
2253 : /**
2254 : * \brief Fetch the list of category names for this raster.
2255 : *
2256 : * @see GDALRasterBand::GetCategoryNames()
2257 : */
2258 :
2259 201 : char **CPL_STDCALL GDALGetRasterCategoryNames(GDALRasterBandH hBand)
2260 :
2261 : {
2262 201 : VALIDATE_POINTER1(hBand, "GDALGetRasterCategoryNames", nullptr);
2263 :
2264 201 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2265 201 : return poBand->GetCategoryNames();
2266 : }
2267 :
2268 : /************************************************************************/
2269 : /* SetCategoryNames() */
2270 : /************************************************************************/
2271 :
2272 : /**
2273 : * \fn GDALRasterBand::SetCategoryNames(char**)
2274 : * \brief Set the category names for this band.
2275 : *
2276 : * See the GetCategoryNames() method for more on the interpretation of
2277 : * category names.
2278 : *
2279 : * This method is the same as the C function GDALSetRasterCategoryNames().
2280 : *
2281 : * @param papszNames the NULL terminated StringList of category names. May
2282 : * be NULL to just clear the existing list.
2283 : *
2284 : * @return CE_None on success of CE_Failure on failure. If unsupported
2285 : * by the driver CE_Failure is returned, but no error message is reported.
2286 : */
2287 :
2288 : /**/
2289 : /**/
2290 :
2291 0 : CPLErr GDALRasterBand::SetCategoryNames(char ** /*papszNames*/)
2292 : {
2293 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
2294 0 : ReportError(CE_Failure, CPLE_NotSupported,
2295 : "SetCategoryNames() not supported for this dataset.");
2296 :
2297 0 : return CE_Failure;
2298 : }
2299 :
2300 : /************************************************************************/
2301 : /* GDALSetCategoryNames() */
2302 : /************************************************************************/
2303 :
2304 : /**
2305 : * \brief Set the category names for this band.
2306 : *
2307 : * @see GDALRasterBand::SetCategoryNames()
2308 : */
2309 :
2310 2 : CPLErr CPL_STDCALL GDALSetRasterCategoryNames(GDALRasterBandH hBand,
2311 : CSLConstList papszNames)
2312 :
2313 : {
2314 2 : VALIDATE_POINTER1(hBand, "GDALSetRasterCategoryNames", CE_Failure);
2315 :
2316 2 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2317 2 : return poBand->SetCategoryNames(const_cast<char **>(papszNames));
2318 : }
2319 :
2320 : /************************************************************************/
2321 : /* GetNoDataValue() */
2322 : /************************************************************************/
2323 :
2324 : /**
2325 : * \brief Fetch the no data value for this band.
2326 : *
2327 : * If there is no out of data value, an out of range value will generally
2328 : * be returned. The no data value for a band is generally a special marker
2329 : * value used to mark pixels that are not valid data. Such pixels should
2330 : * generally not be displayed, nor contribute to analysis operations.
2331 : *
2332 : * The no data value returned is 'raw', meaning that it has no offset and
2333 : * scale applied.
2334 : *
2335 : * For rasters of type GDT_Int64 or GDT_UInt64, using this method might be
2336 : * lossy if the nodata value cannot exactly been represented by a double.
2337 : * Use GetNoDataValueAsInt64() or GetNoDataValueAsUInt64() instead.
2338 : *
2339 : * This method is the same as the C function GDALGetRasterNoDataValue().
2340 : *
2341 : * @param pbSuccess pointer to a boolean to use to indicate if a value
2342 : * is actually associated with this layer. May be NULL (default).
2343 : *
2344 : * @return the nodata value for this band.
2345 : */
2346 :
2347 13079 : double GDALRasterBand::GetNoDataValue(int *pbSuccess)
2348 :
2349 : {
2350 13079 : if (pbSuccess != nullptr)
2351 13079 : *pbSuccess = FALSE;
2352 :
2353 13079 : return -1e10;
2354 : }
2355 :
2356 : /************************************************************************/
2357 : /* GDALGetRasterNoDataValue() */
2358 : /************************************************************************/
2359 :
2360 : /**
2361 : * \brief Fetch the no data value for this band.
2362 : *
2363 : * @see GDALRasterBand::GetNoDataValue()
2364 : */
2365 :
2366 414438 : double CPL_STDCALL GDALGetRasterNoDataValue(GDALRasterBandH hBand,
2367 : int *pbSuccess)
2368 :
2369 : {
2370 414438 : VALIDATE_POINTER1(hBand, "GDALGetRasterNoDataValue", 0);
2371 :
2372 414438 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2373 414438 : return poBand->GetNoDataValue(pbSuccess);
2374 : }
2375 :
2376 : /************************************************************************/
2377 : /* GetNoDataValueAsInt64() */
2378 : /************************************************************************/
2379 :
2380 : /**
2381 : * \brief Fetch the no data value for this band.
2382 : *
2383 : * This method should ONLY be called on rasters whose data type is GDT_Int64.
2384 : *
2385 : * If there is no out of data value, an out of range value will generally
2386 : * be returned. The no data value for a band is generally a special marker
2387 : * value used to mark pixels that are not valid data. Such pixels should
2388 : * generally not be displayed, nor contribute to analysis operations.
2389 : *
2390 : * The no data value returned is 'raw', meaning that it has no offset and
2391 : * scale applied.
2392 : *
2393 : * This method is the same as the C function GDALGetRasterNoDataValueAsInt64().
2394 : *
2395 : * @param pbSuccess pointer to a boolean to use to indicate if a value
2396 : * is actually associated with this layer. May be NULL (default).
2397 : *
2398 : * @return the nodata value for this band.
2399 : *
2400 : * @since GDAL 3.5
2401 : */
2402 :
2403 3 : int64_t GDALRasterBand::GetNoDataValueAsInt64(int *pbSuccess)
2404 :
2405 : {
2406 3 : if (pbSuccess != nullptr)
2407 3 : *pbSuccess = FALSE;
2408 :
2409 3 : return std::numeric_limits<int64_t>::min();
2410 : }
2411 :
2412 : /************************************************************************/
2413 : /* GDALGetRasterNoDataValueAsInt64() */
2414 : /************************************************************************/
2415 :
2416 : /**
2417 : * \brief Fetch the no data value for this band.
2418 : *
2419 : * This function should ONLY be called on rasters whose data type is GDT_Int64.
2420 : *
2421 : * @see GDALRasterBand::GetNoDataValueAsInt64()
2422 : *
2423 : * @since GDAL 3.5
2424 : */
2425 :
2426 31 : int64_t CPL_STDCALL GDALGetRasterNoDataValueAsInt64(GDALRasterBandH hBand,
2427 : int *pbSuccess)
2428 :
2429 : {
2430 31 : VALIDATE_POINTER1(hBand, "GDALGetRasterNoDataValueAsInt64",
2431 : std::numeric_limits<int64_t>::min());
2432 :
2433 31 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2434 31 : return poBand->GetNoDataValueAsInt64(pbSuccess);
2435 : }
2436 :
2437 : /************************************************************************/
2438 : /* GetNoDataValueAsUInt64() */
2439 : /************************************************************************/
2440 :
2441 : /**
2442 : * \brief Fetch the no data value for this band.
2443 : *
2444 : * This method should ONLY be called on rasters whose data type is GDT_UInt64.
2445 : *
2446 : * If there is no out of data value, an out of range value will generally
2447 : * be returned. The no data value for a band is generally a special marker
2448 : * value used to mark pixels that are not valid data. Such pixels should
2449 : * generally not be displayed, nor contribute to analysis operations.
2450 : *
2451 : * The no data value returned is 'raw', meaning that it has no offset and
2452 : * scale applied.
2453 : *
2454 : * This method is the same as the C function GDALGetRasterNoDataValueAsUInt64().
2455 : *
2456 : * @param pbSuccess pointer to a boolean to use to indicate if a value
2457 : * is actually associated with this layer. May be NULL (default).
2458 : *
2459 : * @return the nodata value for this band.
2460 : *
2461 : * @since GDAL 3.5
2462 : */
2463 :
2464 2 : uint64_t GDALRasterBand::GetNoDataValueAsUInt64(int *pbSuccess)
2465 :
2466 : {
2467 2 : if (pbSuccess != nullptr)
2468 2 : *pbSuccess = FALSE;
2469 :
2470 2 : return std::numeric_limits<uint64_t>::max();
2471 : }
2472 :
2473 : /************************************************************************/
2474 : /* GDALGetRasterNoDataValueAsUInt64() */
2475 : /************************************************************************/
2476 :
2477 : /**
2478 : * \brief Fetch the no data value for this band.
2479 : *
2480 : * This function should ONLY be called on rasters whose data type is GDT_UInt64.
2481 : *
2482 : * @see GDALRasterBand::GetNoDataValueAsUInt64()
2483 : *
2484 : * @since GDAL 3.5
2485 : */
2486 :
2487 22 : uint64_t CPL_STDCALL GDALGetRasterNoDataValueAsUInt64(GDALRasterBandH hBand,
2488 : int *pbSuccess)
2489 :
2490 : {
2491 22 : VALIDATE_POINTER1(hBand, "GDALGetRasterNoDataValueAsUInt64",
2492 : std::numeric_limits<uint64_t>::max());
2493 :
2494 22 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2495 22 : return poBand->GetNoDataValueAsUInt64(pbSuccess);
2496 : }
2497 :
2498 : /************************************************************************/
2499 : /* SetNoDataValueAsString() */
2500 : /************************************************************************/
2501 :
2502 : /**
2503 : * \brief Set the no data value for this band.
2504 : *
2505 : * Depending on drivers, changing the no data value may or may not have an
2506 : * effect on the pixel values of a raster that has just been created. It is
2507 : * thus advised to explicitly called Fill() if the intent is to initialize
2508 : * the raster to the nodata value.
2509 : * In any case, changing an existing no data value, when one already exists and
2510 : * the dataset exists or has been initialized, has no effect on the pixel whose
2511 : * value matched the previous nodata value.
2512 : *
2513 : * To clear the nodata value, use DeleteNoDataValue().
2514 : *
2515 : * @param pszNoData the value to set.
2516 : * @param[out] pbCannotBeExactlyRepresented Pointer to a boolean, or nullptr.
2517 : * If the value cannot be exactly represented on the output data
2518 : * type, *pbCannotBeExactlyRepresented will be set to true.
2519 : *
2520 : * @return CE_None on success, or CE_Failure on failure. If unsupported
2521 : * by the driver, CE_Failure is returned but no error message will have
2522 : * been emitted.
2523 : *
2524 : * @since 3.11
2525 : */
2526 :
2527 : CPLErr
2528 123 : GDALRasterBand::SetNoDataValueAsString(const char *pszNoData,
2529 : bool *pbCannotBeExactlyRepresented)
2530 : {
2531 123 : if (pbCannotBeExactlyRepresented)
2532 123 : *pbCannotBeExactlyRepresented = false;
2533 123 : if (eDataType == GDT_Int64)
2534 : {
2535 8 : if (strchr(pszNoData, '.') ||
2536 3 : CPLGetValueType(pszNoData) == CPL_VALUE_STRING)
2537 : {
2538 2 : char *endptr = nullptr;
2539 2 : const double dfVal = CPLStrtod(pszNoData, &endptr);
2540 4 : if (endptr == pszNoData + strlen(pszNoData) &&
2541 2 : GDALIsValueExactAs<int64_t>(dfVal))
2542 : {
2543 0 : return SetNoDataValueAsInt64(static_cast<int64_t>(dfVal));
2544 : }
2545 : }
2546 : else
2547 : {
2548 : try
2549 : {
2550 7 : const auto val = std::stoll(pszNoData);
2551 1 : return SetNoDataValueAsInt64(static_cast<int64_t>(val));
2552 : }
2553 2 : catch (const std::exception &)
2554 : {
2555 : }
2556 : }
2557 : }
2558 118 : else if (eDataType == GDT_UInt64)
2559 : {
2560 2 : if (strchr(pszNoData, '.') ||
2561 1 : CPLGetValueType(pszNoData) == CPL_VALUE_STRING)
2562 : {
2563 0 : char *endptr = nullptr;
2564 0 : const double dfVal = CPLStrtod(pszNoData, &endptr);
2565 0 : if (endptr == pszNoData + strlen(pszNoData) &&
2566 0 : GDALIsValueExactAs<uint64_t>(dfVal))
2567 : {
2568 0 : return SetNoDataValueAsUInt64(static_cast<uint64_t>(dfVal));
2569 : }
2570 : }
2571 : else
2572 : {
2573 : try
2574 : {
2575 1 : const auto val = std::stoull(pszNoData);
2576 1 : return SetNoDataValueAsUInt64(static_cast<uint64_t>(val));
2577 : }
2578 0 : catch (const std::exception &)
2579 : {
2580 : }
2581 : }
2582 : }
2583 117 : else if (eDataType == GDT_Float32)
2584 : {
2585 10 : char *endptr = nullptr;
2586 10 : const float fVal = CPLStrtof(pszNoData, &endptr);
2587 10 : if (endptr == pszNoData + strlen(pszNoData))
2588 : {
2589 10 : return SetNoDataValue(double(fVal));
2590 : }
2591 : }
2592 : else
2593 : {
2594 107 : char *endptr = nullptr;
2595 107 : const double dfVal = CPLStrtod(pszNoData, &endptr);
2596 214 : if (endptr == pszNoData + strlen(pszNoData) &&
2597 107 : GDALIsValueExactAs(dfVal, eDataType))
2598 : {
2599 106 : return SetNoDataValue(dfVal);
2600 : }
2601 : }
2602 5 : if (pbCannotBeExactlyRepresented)
2603 5 : *pbCannotBeExactlyRepresented = true;
2604 5 : return CE_Failure;
2605 : }
2606 :
2607 : /************************************************************************/
2608 : /* SetNoDataValue() */
2609 : /************************************************************************/
2610 :
2611 : /**
2612 : * \fn GDALRasterBand::SetNoDataValue(double)
2613 : * \brief Set the no data value for this band.
2614 : *
2615 : * Depending on drivers, changing the no data value may or may not have an
2616 : * effect on the pixel values of a raster that has just been created. It is
2617 : * thus advised to explicitly called Fill() if the intent is to initialize
2618 : * the raster to the nodata value.
2619 : * In any case, changing an existing no data value, when one already exists and
2620 : * the dataset exists or has been initialized, has no effect on the pixel whose
2621 : * value matched the previous nodata value.
2622 : *
2623 : * For rasters of type GDT_Int64 or GDT_UInt64, whose nodata value cannot always
2624 : * be represented by a double, use SetNoDataValueAsInt64() or
2625 : * SetNoDataValueAsUInt64() instead.
2626 : *
2627 : * To clear the nodata value, use DeleteNoDataValue().
2628 : *
2629 : * This method is the same as the C function GDALSetRasterNoDataValue().
2630 : *
2631 : * @param dfNoData the value to set.
2632 : *
2633 : * @return CE_None on success, or CE_Failure on failure. If unsupported
2634 : * by the driver, CE_Failure is returned but no error message will have
2635 : * been emitted.
2636 : */
2637 :
2638 : /**/
2639 : /**/
2640 :
2641 0 : CPLErr GDALRasterBand::SetNoDataValue(double /*dfNoData*/)
2642 :
2643 : {
2644 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
2645 0 : ReportError(CE_Failure, CPLE_NotSupported,
2646 : "SetNoDataValue() not supported for this dataset.");
2647 :
2648 0 : return CE_Failure;
2649 : }
2650 :
2651 : /************************************************************************/
2652 : /* GDALSetRasterNoDataValue() */
2653 : /************************************************************************/
2654 :
2655 : /**
2656 : * \brief Set the no data value for this band.
2657 : *
2658 : * Depending on drivers, changing the no data value may or may not have an
2659 : * effect on the pixel values of a raster that has just been created. It is
2660 : * thus advised to explicitly called Fill() if the intent is to initialize
2661 : * the raster to the nodata value.
2662 : * In any case, changing an existing no data value, when one already exists and
2663 : * the dataset exists or has been initialized, has no effect on the pixel whose
2664 : * value matched the previous nodata value.
2665 : *
2666 : * For rasters of type GDT_Int64 or GDT_UInt64, whose nodata value cannot always
2667 : * be represented by a double, use GDALSetRasterNoDataValueAsInt64() or
2668 : * GDALSetRasterNoDataValueAsUInt64() instead.
2669 : *
2670 : * @see GDALRasterBand::SetNoDataValue()
2671 : */
2672 :
2673 968 : CPLErr CPL_STDCALL GDALSetRasterNoDataValue(GDALRasterBandH hBand,
2674 : double dfValue)
2675 :
2676 : {
2677 968 : VALIDATE_POINTER1(hBand, "GDALSetRasterNoDataValue", CE_Failure);
2678 :
2679 968 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2680 968 : return poBand->SetNoDataValue(dfValue);
2681 : }
2682 :
2683 : /************************************************************************/
2684 : /* SetNoDataValueAsInt64() */
2685 : /************************************************************************/
2686 :
2687 : /**
2688 : * \brief Set the no data value for this band.
2689 : *
2690 : * This method should ONLY be called on rasters whose data type is GDT_Int64.
2691 : *
2692 : * Depending on drivers, changing the no data value may or may not have an
2693 : * effect on the pixel values of a raster that has just been created. It is
2694 : * thus advised to explicitly called Fill() if the intent is to initialize
2695 : * the raster to the nodata value.
2696 : * In ay case, changing an existing no data value, when one already exists and
2697 : * the dataset exists or has been initialized, has no effect on the pixel whose
2698 : * value matched the previous nodata value.
2699 : *
2700 : * To clear the nodata value, use DeleteNoDataValue().
2701 : *
2702 : * This method is the same as the C function GDALSetRasterNoDataValueAsInt64().
2703 : *
2704 : * @param nNoDataValue the value to set.
2705 : *
2706 : * @return CE_None on success, or CE_Failure on failure. If unsupported
2707 : * by the driver, CE_Failure is returned but no error message will have
2708 : * been emitted.
2709 : *
2710 : * @since GDAL 3.5
2711 : */
2712 :
2713 0 : CPLErr GDALRasterBand::SetNoDataValueAsInt64(CPL_UNUSED int64_t nNoDataValue)
2714 :
2715 : {
2716 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
2717 0 : ReportError(CE_Failure, CPLE_NotSupported,
2718 : "SetNoDataValueAsInt64() not supported for this dataset.");
2719 :
2720 0 : return CE_Failure;
2721 : }
2722 :
2723 : /************************************************************************/
2724 : /* GDALSetRasterNoDataValueAsInt64() */
2725 : /************************************************************************/
2726 :
2727 : /**
2728 : * \brief Set the no data value for this band.
2729 : *
2730 : * This function should ONLY be called on rasters whose data type is GDT_Int64.
2731 : *
2732 : * Depending on drivers, changing the no data value may or may not have an
2733 : * effect on the pixel values of a raster that has just been created. It is
2734 : * thus advised to explicitly called Fill() if the intent is to initialize
2735 : * the raster to the nodata value.
2736 : * In ay case, changing an existing no data value, when one already exists and
2737 : * the dataset exists or has been initialized, has no effect on the pixel whose
2738 : * value matched the previous nodata value.
2739 : *
2740 : * @see GDALRasterBand::SetNoDataValueAsInt64()
2741 : *
2742 : * @since GDAL 3.5
2743 : */
2744 :
2745 22 : CPLErr CPL_STDCALL GDALSetRasterNoDataValueAsInt64(GDALRasterBandH hBand,
2746 : int64_t nValue)
2747 :
2748 : {
2749 22 : VALIDATE_POINTER1(hBand, "GDALSetRasterNoDataValueAsInt64", CE_Failure);
2750 :
2751 22 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2752 22 : return poBand->SetNoDataValueAsInt64(nValue);
2753 : }
2754 :
2755 : /************************************************************************/
2756 : /* SetNoDataValueAsUInt64() */
2757 : /************************************************************************/
2758 :
2759 : /**
2760 : * \brief Set the no data value for this band.
2761 : *
2762 : * This method should ONLY be called on rasters whose data type is GDT_UInt64.
2763 : *
2764 : * Depending on drivers, changing the no data value may or may not have an
2765 : * effect on the pixel values of a raster that has just been created. It is
2766 : * thus advised to explicitly called Fill() if the intent is to initialize
2767 : * the raster to the nodata value.
2768 : * In ay case, changing an existing no data value, when one already exists and
2769 : * the dataset exists or has been initialized, has no effect on the pixel whose
2770 : * value matched the previous nodata value.
2771 : *
2772 : * To clear the nodata value, use DeleteNoDataValue().
2773 : *
2774 : * This method is the same as the C function GDALSetRasterNoDataValueAsUInt64().
2775 : *
2776 : * @param nNoDataValue the value to set.
2777 : *
2778 : * @return CE_None on success, or CE_Failure on failure. If unsupported
2779 : * by the driver, CE_Failure is returned but no error message will have
2780 : * been emitted.
2781 : *
2782 : * @since GDAL 3.5
2783 : */
2784 :
2785 0 : CPLErr GDALRasterBand::SetNoDataValueAsUInt64(CPL_UNUSED uint64_t nNoDataValue)
2786 :
2787 : {
2788 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
2789 0 : ReportError(CE_Failure, CPLE_NotSupported,
2790 : "SetNoDataValueAsUInt64() not supported for this dataset.");
2791 :
2792 0 : return CE_Failure;
2793 : }
2794 :
2795 : /************************************************************************/
2796 : /* GDALSetRasterNoDataValueAsUInt64() */
2797 : /************************************************************************/
2798 :
2799 : /**
2800 : * \brief Set the no data value for this band.
2801 : *
2802 : * This function should ONLY be called on rasters whose data type is GDT_UInt64.
2803 : *
2804 : * Depending on drivers, changing the no data value may or may not have an
2805 : * effect on the pixel values of a raster that has just been created. It is
2806 : * thus advised to explicitly called Fill() if the intent is to initialize
2807 : * the raster to the nodata value.
2808 : * In ay case, changing an existing no data value, when one already exists and
2809 : * the dataset exists or has been initialized, has no effect on the pixel whose
2810 : * value matched the previous nodata value.
2811 : *
2812 : * @see GDALRasterBand::SetNoDataValueAsUInt64()
2813 : *
2814 : * @since GDAL 3.5
2815 : */
2816 :
2817 20 : CPLErr CPL_STDCALL GDALSetRasterNoDataValueAsUInt64(GDALRasterBandH hBand,
2818 : uint64_t nValue)
2819 :
2820 : {
2821 20 : VALIDATE_POINTER1(hBand, "GDALSetRasterNoDataValueAsUInt64", CE_Failure);
2822 :
2823 20 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2824 20 : return poBand->SetNoDataValueAsUInt64(nValue);
2825 : }
2826 :
2827 : /************************************************************************/
2828 : /* DeleteNoDataValue() */
2829 : /************************************************************************/
2830 :
2831 : /**
2832 : * \brief Remove the no data value for this band.
2833 : *
2834 : * This method is the same as the C function GDALDeleteRasterNoDataValue().
2835 : *
2836 : * @return CE_None on success, or CE_Failure on failure. If unsupported
2837 : * by the driver, CE_Failure is returned but no error message will have
2838 : * been emitted.
2839 : *
2840 : */
2841 :
2842 0 : CPLErr GDALRasterBand::DeleteNoDataValue()
2843 :
2844 : {
2845 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
2846 0 : ReportError(CE_Failure, CPLE_NotSupported,
2847 : "DeleteNoDataValue() not supported for this dataset.");
2848 :
2849 0 : return CE_Failure;
2850 : }
2851 :
2852 : /************************************************************************/
2853 : /* GDALDeleteRasterNoDataValue() */
2854 : /************************************************************************/
2855 :
2856 : /**
2857 : * \brief Remove the no data value for this band.
2858 : *
2859 : * @see GDALRasterBand::DeleteNoDataValue()
2860 : *
2861 : */
2862 :
2863 53 : CPLErr CPL_STDCALL GDALDeleteRasterNoDataValue(GDALRasterBandH hBand)
2864 :
2865 : {
2866 53 : VALIDATE_POINTER1(hBand, "GDALDeleteRasterNoDataValue", CE_Failure);
2867 :
2868 53 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2869 53 : return poBand->DeleteNoDataValue();
2870 : }
2871 :
2872 : /************************************************************************/
2873 : /* GetMaximum() */
2874 : /************************************************************************/
2875 :
2876 : /**
2877 : * \brief Fetch the maximum value for this band.
2878 : *
2879 : * For file formats that don't know this intrinsically, the maximum supported
2880 : * value for the data type will generally be returned.
2881 : *
2882 : * This method is the same as the C function GDALGetRasterMaximum().
2883 : *
2884 : * @param pbSuccess pointer to a boolean to use to indicate if the
2885 : * returned value is a tight maximum or not. May be NULL (default).
2886 : *
2887 : * @return the maximum raster value (excluding no data pixels)
2888 : */
2889 :
2890 534 : double GDALRasterBand::GetMaximum(int *pbSuccess)
2891 :
2892 : {
2893 534 : const char *pszValue = nullptr;
2894 :
2895 534 : if ((pszValue = GetMetadataItem("STATISTICS_MAXIMUM")) != nullptr)
2896 : {
2897 47 : if (pbSuccess != nullptr)
2898 42 : *pbSuccess = TRUE;
2899 :
2900 47 : return CPLAtofM(pszValue);
2901 : }
2902 :
2903 487 : if (pbSuccess != nullptr)
2904 483 : *pbSuccess = FALSE;
2905 :
2906 487 : switch (eDataType)
2907 : {
2908 336 : case GDT_Byte:
2909 : {
2910 336 : EnablePixelTypeSignedByteWarning(false);
2911 : const char *pszPixelType =
2912 336 : GetMetadataItem("PIXELTYPE", "IMAGE_STRUCTURE");
2913 336 : EnablePixelTypeSignedByteWarning(true);
2914 336 : if (pszPixelType != nullptr && EQUAL(pszPixelType, "SIGNEDBYTE"))
2915 0 : return 127;
2916 :
2917 336 : return 255;
2918 : }
2919 :
2920 1 : case GDT_Int8:
2921 1 : return 127;
2922 :
2923 21 : case GDT_UInt16:
2924 21 : return 65535;
2925 :
2926 24 : case GDT_Int16:
2927 : case GDT_CInt16:
2928 24 : return 32767;
2929 :
2930 39 : case GDT_Int32:
2931 : case GDT_CInt32:
2932 39 : return 2147483647.0;
2933 :
2934 12 : case GDT_UInt32:
2935 12 : return 4294967295.0;
2936 :
2937 1 : case GDT_Int64:
2938 1 : return static_cast<double>(std::numeric_limits<GInt64>::max());
2939 :
2940 1 : case GDT_UInt64:
2941 1 : return static_cast<double>(std::numeric_limits<GUInt64>::max());
2942 :
2943 0 : case GDT_Float16:
2944 : case GDT_CFloat16:
2945 0 : return 65504.0;
2946 :
2947 30 : case GDT_Float32:
2948 : case GDT_CFloat32:
2949 30 : return 4294967295.0; // Not actually accurate.
2950 :
2951 22 : case GDT_Float64:
2952 : case GDT_CFloat64:
2953 22 : return 4294967295.0; // Not actually accurate.
2954 :
2955 0 : case GDT_Unknown:
2956 : case GDT_TypeCount:
2957 0 : break;
2958 : }
2959 0 : return 4294967295.0; // Not actually accurate.
2960 : }
2961 :
2962 : /************************************************************************/
2963 : /* GDALGetRasterMaximum() */
2964 : /************************************************************************/
2965 :
2966 : /**
2967 : * \brief Fetch the maximum value for this band.
2968 : *
2969 : * @see GDALRasterBand::GetMaximum()
2970 : */
2971 :
2972 334 : double CPL_STDCALL GDALGetRasterMaximum(GDALRasterBandH hBand, int *pbSuccess)
2973 :
2974 : {
2975 334 : VALIDATE_POINTER1(hBand, "GDALGetRasterMaximum", 0);
2976 :
2977 334 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
2978 334 : return poBand->GetMaximum(pbSuccess);
2979 : }
2980 :
2981 : /************************************************************************/
2982 : /* GetMinimum() */
2983 : /************************************************************************/
2984 :
2985 : /**
2986 : * \brief Fetch the minimum value for this band.
2987 : *
2988 : * For file formats that don't know this intrinsically, the minimum supported
2989 : * value for the data type will generally be returned.
2990 : *
2991 : * This method is the same as the C function GDALGetRasterMinimum().
2992 : *
2993 : * @param pbSuccess pointer to a boolean to use to indicate if the
2994 : * returned value is a tight minimum or not. May be NULL (default).
2995 : *
2996 : * @return the minimum raster value (excluding no data pixels)
2997 : */
2998 :
2999 542 : double GDALRasterBand::GetMinimum(int *pbSuccess)
3000 :
3001 : {
3002 542 : const char *pszValue = nullptr;
3003 :
3004 542 : if ((pszValue = GetMetadataItem("STATISTICS_MINIMUM")) != nullptr)
3005 : {
3006 52 : if (pbSuccess != nullptr)
3007 47 : *pbSuccess = TRUE;
3008 :
3009 52 : return CPLAtofM(pszValue);
3010 : }
3011 :
3012 490 : if (pbSuccess != nullptr)
3013 486 : *pbSuccess = FALSE;
3014 :
3015 490 : switch (eDataType)
3016 : {
3017 339 : case GDT_Byte:
3018 : {
3019 339 : EnablePixelTypeSignedByteWarning(false);
3020 : const char *pszPixelType =
3021 339 : GetMetadataItem("PIXELTYPE", "IMAGE_STRUCTURE");
3022 339 : EnablePixelTypeSignedByteWarning(true);
3023 339 : if (pszPixelType != nullptr && EQUAL(pszPixelType, "SIGNEDBYTE"))
3024 0 : return -128;
3025 :
3026 339 : return 0;
3027 : }
3028 :
3029 1 : case GDT_Int8:
3030 1 : return -128;
3031 :
3032 21 : case GDT_UInt16:
3033 21 : return 0;
3034 :
3035 24 : case GDT_Int16:
3036 : case GDT_CInt16:
3037 24 : return -32768;
3038 :
3039 39 : case GDT_Int32:
3040 : case GDT_CInt32:
3041 39 : return -2147483648.0;
3042 :
3043 12 : case GDT_UInt32:
3044 12 : return 0;
3045 :
3046 1 : case GDT_Int64:
3047 1 : return static_cast<double>(std::numeric_limits<GInt64>::lowest());
3048 :
3049 1 : case GDT_UInt64:
3050 1 : return 0;
3051 :
3052 0 : case GDT_Float16:
3053 : case GDT_CFloat16:
3054 0 : return -65504.0;
3055 :
3056 30 : case GDT_Float32:
3057 : case GDT_CFloat32:
3058 30 : return -4294967295.0; // Not actually accurate.
3059 :
3060 22 : case GDT_Float64:
3061 : case GDT_CFloat64:
3062 22 : return -4294967295.0; // Not actually accurate.
3063 :
3064 0 : case GDT_Unknown:
3065 : case GDT_TypeCount:
3066 0 : break;
3067 : }
3068 0 : return -4294967295.0; // Not actually accurate.
3069 : }
3070 :
3071 : /************************************************************************/
3072 : /* GDALGetRasterMinimum() */
3073 : /************************************************************************/
3074 :
3075 : /**
3076 : * \brief Fetch the minimum value for this band.
3077 : *
3078 : * @see GDALRasterBand::GetMinimum()
3079 : */
3080 :
3081 344 : double CPL_STDCALL GDALGetRasterMinimum(GDALRasterBandH hBand, int *pbSuccess)
3082 :
3083 : {
3084 344 : VALIDATE_POINTER1(hBand, "GDALGetRasterMinimum", 0);
3085 :
3086 344 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3087 344 : return poBand->GetMinimum(pbSuccess);
3088 : }
3089 :
3090 : /************************************************************************/
3091 : /* GetColorInterpretation() */
3092 : /************************************************************************/
3093 :
3094 : /**
3095 : * \brief How should this band be interpreted as color?
3096 : *
3097 : * GCI_Undefined is returned when the format doesn't know anything
3098 : * about the color interpretation.
3099 : *
3100 : * This method is the same as the C function
3101 : * GDALGetRasterColorInterpretation().
3102 : *
3103 : * @return color interpretation value for band.
3104 : */
3105 :
3106 163 : GDALColorInterp GDALRasterBand::GetColorInterpretation()
3107 :
3108 : {
3109 163 : return GCI_Undefined;
3110 : }
3111 :
3112 : /************************************************************************/
3113 : /* GDALGetRasterColorInterpretation() */
3114 : /************************************************************************/
3115 :
3116 : /**
3117 : * \brief How should this band be interpreted as color?
3118 : *
3119 : * @see GDALRasterBand::GetColorInterpretation()
3120 : */
3121 :
3122 : GDALColorInterp CPL_STDCALL
3123 5693 : GDALGetRasterColorInterpretation(GDALRasterBandH hBand)
3124 :
3125 : {
3126 5693 : VALIDATE_POINTER1(hBand, "GDALGetRasterColorInterpretation", GCI_Undefined);
3127 :
3128 5693 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3129 5693 : return poBand->GetColorInterpretation();
3130 : }
3131 :
3132 : /************************************************************************/
3133 : /* SetColorInterpretation() */
3134 : /************************************************************************/
3135 :
3136 : /**
3137 : * \fn GDALRasterBand::SetColorInterpretation(GDALColorInterp)
3138 : * \brief Set color interpretation of a band.
3139 : *
3140 : * This method is the same as the C function GDALSetRasterColorInterpretation().
3141 : *
3142 : * @param eColorInterp the new color interpretation to apply to this band.
3143 : *
3144 : * @return CE_None on success or CE_Failure if method is unsupported by format.
3145 : */
3146 :
3147 : /**/
3148 : /**/
3149 :
3150 3 : CPLErr GDALRasterBand::SetColorInterpretation(GDALColorInterp /*eColorInterp*/)
3151 :
3152 : {
3153 3 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
3154 3 : ReportError(CE_Failure, CPLE_NotSupported,
3155 : "SetColorInterpretation() not supported for this dataset.");
3156 3 : return CE_Failure;
3157 : }
3158 :
3159 : /************************************************************************/
3160 : /* GDALSetRasterColorInterpretation() */
3161 : /************************************************************************/
3162 :
3163 : /**
3164 : * \brief Set color interpretation of a band.
3165 : *
3166 : * @see GDALRasterBand::SetColorInterpretation()
3167 : */
3168 :
3169 1857 : CPLErr CPL_STDCALL GDALSetRasterColorInterpretation(
3170 : GDALRasterBandH hBand, GDALColorInterp eColorInterp)
3171 :
3172 : {
3173 1857 : VALIDATE_POINTER1(hBand, "GDALSetRasterColorInterpretation", CE_Failure);
3174 :
3175 1857 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3176 1857 : return poBand->SetColorInterpretation(eColorInterp);
3177 : }
3178 :
3179 : /************************************************************************/
3180 : /* GetColorTable() */
3181 : /************************************************************************/
3182 :
3183 : /**
3184 : * \brief Fetch the color table associated with band.
3185 : *
3186 : * If there is no associated color table, the return result is NULL. The
3187 : * returned color table remains owned by the GDALRasterBand, and can't
3188 : * be depended on for long, nor should it ever be modified by the caller.
3189 : *
3190 : * This method is the same as the C function GDALGetRasterColorTable().
3191 : *
3192 : * @return internal color table, or NULL.
3193 : */
3194 :
3195 213 : GDALColorTable *GDALRasterBand::GetColorTable()
3196 :
3197 : {
3198 213 : return nullptr;
3199 : }
3200 :
3201 : /************************************************************************/
3202 : /* GDALGetRasterColorTable() */
3203 : /************************************************************************/
3204 :
3205 : /**
3206 : * \brief Fetch the color table associated with band.
3207 : *
3208 : * @see GDALRasterBand::GetColorTable()
3209 : */
3210 :
3211 1984 : GDALColorTableH CPL_STDCALL GDALGetRasterColorTable(GDALRasterBandH hBand)
3212 :
3213 : {
3214 1984 : VALIDATE_POINTER1(hBand, "GDALGetRasterColorTable", nullptr);
3215 :
3216 1984 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3217 1984 : return GDALColorTable::ToHandle(poBand->GetColorTable());
3218 : }
3219 :
3220 : /************************************************************************/
3221 : /* SetColorTable() */
3222 : /************************************************************************/
3223 :
3224 : /**
3225 : * \fn GDALRasterBand::SetColorTable(GDALColorTable*)
3226 : * \brief Set the raster color table.
3227 : *
3228 : * The driver will make a copy of all desired data in the colortable. It
3229 : * remains owned by the caller after the call.
3230 : *
3231 : * This method is the same as the C function GDALSetRasterColorTable().
3232 : *
3233 : * @param poCT the color table to apply. This may be NULL to clear the color
3234 : * table (where supported).
3235 : *
3236 : * @return CE_None on success, or CE_Failure on failure. If the action is
3237 : * unsupported by the driver, a value of CE_Failure is returned, but no
3238 : * error is issued.
3239 : */
3240 :
3241 : /**/
3242 : /**/
3243 :
3244 0 : CPLErr GDALRasterBand::SetColorTable(GDALColorTable * /*poCT*/)
3245 :
3246 : {
3247 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
3248 0 : ReportError(CE_Failure, CPLE_NotSupported,
3249 : "SetColorTable() not supported for this dataset.");
3250 0 : return CE_Failure;
3251 : }
3252 :
3253 : /************************************************************************/
3254 : /* GDALSetRasterColorTable() */
3255 : /************************************************************************/
3256 :
3257 : /**
3258 : * \brief Set the raster color table.
3259 : *
3260 : * @see GDALRasterBand::SetColorTable()
3261 : */
3262 :
3263 78 : CPLErr CPL_STDCALL GDALSetRasterColorTable(GDALRasterBandH hBand,
3264 : GDALColorTableH hCT)
3265 :
3266 : {
3267 78 : VALIDATE_POINTER1(hBand, "GDALSetRasterColorTable", CE_Failure);
3268 :
3269 78 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3270 78 : return poBand->SetColorTable(GDALColorTable::FromHandle(hCT));
3271 : }
3272 :
3273 : /************************************************************************/
3274 : /* HasArbitraryOverviews() */
3275 : /************************************************************************/
3276 :
3277 : /**
3278 : * \brief Check for arbitrary overviews.
3279 : *
3280 : * This returns TRUE if the underlying datastore can compute arbitrary
3281 : * overviews efficiently, such as is the case with OGDI over a network.
3282 : * Datastores with arbitrary overviews don't generally have any fixed
3283 : * overviews, but the RasterIO() method can be used in downsampling mode
3284 : * to get overview data efficiently.
3285 : *
3286 : * This method is the same as the C function GDALHasArbitraryOverviews(),
3287 : *
3288 : * @return TRUE if arbitrary overviews available (efficiently), otherwise
3289 : * FALSE.
3290 : */
3291 :
3292 270 : int GDALRasterBand::HasArbitraryOverviews()
3293 :
3294 : {
3295 270 : return FALSE;
3296 : }
3297 :
3298 : /************************************************************************/
3299 : /* GDALHasArbitraryOverviews() */
3300 : /************************************************************************/
3301 :
3302 : /**
3303 : * \brief Check for arbitrary overviews.
3304 : *
3305 : * @see GDALRasterBand::HasArbitraryOverviews()
3306 : */
3307 :
3308 191 : int CPL_STDCALL GDALHasArbitraryOverviews(GDALRasterBandH hBand)
3309 :
3310 : {
3311 191 : VALIDATE_POINTER1(hBand, "GDALHasArbitraryOverviews", 0);
3312 :
3313 191 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3314 191 : return poBand->HasArbitraryOverviews();
3315 : }
3316 :
3317 : /************************************************************************/
3318 : /* GetOverviewCount() */
3319 : /************************************************************************/
3320 :
3321 : /**
3322 : * \brief Return the number of overview layers available.
3323 : *
3324 : * This method is the same as the C function GDALGetOverviewCount().
3325 : *
3326 : * @return overview count, zero if none.
3327 : */
3328 :
3329 1066290 : int GDALRasterBand::GetOverviewCount()
3330 :
3331 : {
3332 1722970 : if (poDS != nullptr && poDS->oOvManager.IsInitialized() &&
3333 656681 : poDS->AreOverviewsEnabled())
3334 656681 : return poDS->oOvManager.GetOverviewCount(nBand);
3335 :
3336 409608 : return 0;
3337 : }
3338 :
3339 : /************************************************************************/
3340 : /* GDALGetOverviewCount() */
3341 : /************************************************************************/
3342 :
3343 : /**
3344 : * \brief Return the number of overview layers available.
3345 : *
3346 : * @see GDALRasterBand::GetOverviewCount()
3347 : */
3348 :
3349 3300 : int CPL_STDCALL GDALGetOverviewCount(GDALRasterBandH hBand)
3350 :
3351 : {
3352 3300 : VALIDATE_POINTER1(hBand, "GDALGetOverviewCount", 0);
3353 :
3354 3300 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3355 3300 : return poBand->GetOverviewCount();
3356 : }
3357 :
3358 : /************************************************************************/
3359 : /* GetOverview() */
3360 : /************************************************************************/
3361 :
3362 : /**
3363 : * \brief Fetch overview raster band object.
3364 : *
3365 : * This method is the same as the C function GDALGetOverview().
3366 : *
3367 : * @param i overview index between 0 and GetOverviewCount()-1.
3368 : *
3369 : * @return overview GDALRasterBand.
3370 : */
3371 :
3372 942 : GDALRasterBand *GDALRasterBand::GetOverview(int i)
3373 :
3374 : {
3375 1732 : if (poDS != nullptr && poDS->oOvManager.IsInitialized() &&
3376 790 : poDS->AreOverviewsEnabled())
3377 790 : return poDS->oOvManager.GetOverview(nBand, i);
3378 :
3379 152 : return nullptr;
3380 : }
3381 :
3382 : /************************************************************************/
3383 : /* GDALGetOverview() */
3384 : /************************************************************************/
3385 :
3386 : /**
3387 : * \brief Fetch overview raster band object.
3388 : *
3389 : * @see GDALRasterBand::GetOverview()
3390 : */
3391 :
3392 5643 : GDALRasterBandH CPL_STDCALL GDALGetOverview(GDALRasterBandH hBand, int i)
3393 :
3394 : {
3395 5643 : VALIDATE_POINTER1(hBand, "GDALGetOverview", nullptr);
3396 :
3397 5643 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3398 5643 : return GDALRasterBand::ToHandle(poBand->GetOverview(i));
3399 : }
3400 :
3401 : /************************************************************************/
3402 : /* GetRasterSampleOverview() */
3403 : /************************************************************************/
3404 :
3405 : /**
3406 : * \brief Fetch best sampling overview.
3407 : *
3408 : * Returns the most reduced overview of the given band that still satisfies
3409 : * the desired number of samples. This function can be used with zero
3410 : * as the number of desired samples to fetch the most reduced overview.
3411 : * The same band as was passed in will be returned if it has not overviews,
3412 : * or if none of the overviews have enough samples.
3413 : *
3414 : * This method is the same as the C functions GDALGetRasterSampleOverview()
3415 : * and GDALGetRasterSampleOverviewEx().
3416 : *
3417 : * @param nDesiredSamples the returned band will have at least this many
3418 : * pixels.
3419 : *
3420 : * @return optimal overview or the band itself.
3421 : */
3422 :
3423 : GDALRasterBand *
3424 2006 : GDALRasterBand::GetRasterSampleOverview(GUIntBig nDesiredSamples)
3425 :
3426 : {
3427 2006 : GDALRasterBand *poBestBand = this;
3428 :
3429 2006 : double dfBestSamples = GetXSize() * static_cast<double>(GetYSize());
3430 :
3431 4023 : for (int iOverview = 0; iOverview < GetOverviewCount(); iOverview++)
3432 : {
3433 2017 : GDALRasterBand *poOBand = GetOverview(iOverview);
3434 :
3435 2017 : if (poOBand == nullptr)
3436 0 : continue;
3437 :
3438 : const double dfOSamples =
3439 2017 : poOBand->GetXSize() * static_cast<double>(poOBand->GetYSize());
3440 :
3441 2017 : if (dfOSamples < dfBestSamples && dfOSamples > nDesiredSamples)
3442 : {
3443 2014 : dfBestSamples = dfOSamples;
3444 2014 : poBestBand = poOBand;
3445 : }
3446 : }
3447 :
3448 2006 : return poBestBand;
3449 : }
3450 :
3451 : /************************************************************************/
3452 : /* GDALGetRasterSampleOverview() */
3453 : /************************************************************************/
3454 :
3455 : /**
3456 : * \brief Fetch best sampling overview.
3457 : *
3458 : * Use GDALGetRasterSampleOverviewEx() to be able to specify more than 2
3459 : * billion samples.
3460 : *
3461 : * @see GDALRasterBand::GetRasterSampleOverview()
3462 : * @see GDALGetRasterSampleOverviewEx()
3463 : */
3464 :
3465 0 : GDALRasterBandH CPL_STDCALL GDALGetRasterSampleOverview(GDALRasterBandH hBand,
3466 : int nDesiredSamples)
3467 :
3468 : {
3469 0 : VALIDATE_POINTER1(hBand, "GDALGetRasterSampleOverview", nullptr);
3470 :
3471 0 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3472 0 : return GDALRasterBand::ToHandle(poBand->GetRasterSampleOverview(
3473 0 : nDesiredSamples < 0 ? 0 : static_cast<GUIntBig>(nDesiredSamples)));
3474 : }
3475 :
3476 : /************************************************************************/
3477 : /* GDALGetRasterSampleOverviewEx() */
3478 : /************************************************************************/
3479 :
3480 : /**
3481 : * \brief Fetch best sampling overview.
3482 : *
3483 : * @see GDALRasterBand::GetRasterSampleOverview()
3484 : */
3485 :
3486 : GDALRasterBandH CPL_STDCALL
3487 2000 : GDALGetRasterSampleOverviewEx(GDALRasterBandH hBand, GUIntBig nDesiredSamples)
3488 :
3489 : {
3490 2000 : VALIDATE_POINTER1(hBand, "GDALGetRasterSampleOverviewEx", nullptr);
3491 :
3492 2000 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3493 2000 : return GDALRasterBand::ToHandle(
3494 4000 : poBand->GetRasterSampleOverview(nDesiredSamples));
3495 : }
3496 :
3497 : /************************************************************************/
3498 : /* BuildOverviews() */
3499 : /************************************************************************/
3500 :
3501 : /**
3502 : * \fn GDALRasterBand::BuildOverviews(const char*, int, const int*,
3503 : * GDALProgressFunc, void*) \brief Build raster overview(s)
3504 : *
3505 : * If the operation is unsupported for the indicated dataset, then
3506 : * CE_Failure is returned, and CPLGetLastErrorNo() will return
3507 : * CPLE_NotSupported.
3508 : *
3509 : * WARNING: Most formats don't support per-band overview computation, but
3510 : * require that overviews are computed for all bands of a dataset, using
3511 : * GDALDataset::BuildOverviews(). The only exception for official GDAL drivers
3512 : * is the HFA driver which supports this method.
3513 : *
3514 : * @param pszResampling one of "NEAREST", "GAUSS", "CUBIC", "AVERAGE", "MODE",
3515 : * "AVERAGE_MAGPHASE" "RMS" or "NONE" controlling the downsampling method
3516 : * applied.
3517 : * @param nOverviews number of overviews to build.
3518 : * @param panOverviewList the list of overview decimation factors to build.
3519 : * @param pfnProgress a function to call to report progress, or NULL.
3520 : * @param pProgressData application data to pass to the progress function.
3521 : * @param papszOptions (GDAL >= 3.6) NULL terminated list of options as
3522 : * key=value pairs, or NULL
3523 : *
3524 : * @return CE_None on success or CE_Failure if the operation doesn't work.
3525 : */
3526 :
3527 : /**/
3528 : /**/
3529 :
3530 0 : CPLErr GDALRasterBand::BuildOverviews(const char * /*pszResampling*/,
3531 : int /*nOverviews*/,
3532 : const int * /*panOverviewList*/,
3533 : GDALProgressFunc /*pfnProgress*/,
3534 : void * /*pProgressData*/,
3535 : CSLConstList /* papszOptions */)
3536 :
3537 : {
3538 0 : ReportError(CE_Failure, CPLE_NotSupported,
3539 : "BuildOverviews() not supported for this dataset.");
3540 :
3541 0 : return (CE_Failure);
3542 : }
3543 :
3544 : /************************************************************************/
3545 : /* GetOffset() */
3546 : /************************************************************************/
3547 :
3548 : /**
3549 : * \brief Fetch the raster value offset.
3550 : *
3551 : * This value (in combination with the GetScale() value) can be used to
3552 : * transform raw pixel values into the units returned by GetUnitType().
3553 : * For example this might be used to store elevations in GUInt16 bands
3554 : * with a precision of 0.1, and starting from -100.
3555 : *
3556 : * Units value = (raw value * scale) + offset
3557 : *
3558 : * Note that applying scale and offset is of the responsibility of the user,
3559 : * and is not done by methods such as RasterIO() or ReadBlock().
3560 : *
3561 : * For file formats that don't know this intrinsically a value of zero
3562 : * is returned.
3563 : *
3564 : * This method is the same as the C function GDALGetRasterOffset().
3565 : *
3566 : * @param pbSuccess pointer to a boolean to use to indicate if the
3567 : * returned value is meaningful or not. May be NULL (default).
3568 : *
3569 : * @return the raster offset.
3570 : */
3571 :
3572 445 : double GDALRasterBand::GetOffset(int *pbSuccess)
3573 :
3574 : {
3575 445 : if (pbSuccess != nullptr)
3576 336 : *pbSuccess = FALSE;
3577 :
3578 445 : return 0.0;
3579 : }
3580 :
3581 : /************************************************************************/
3582 : /* GDALGetRasterOffset() */
3583 : /************************************************************************/
3584 :
3585 : /**
3586 : * \brief Fetch the raster value offset.
3587 : *
3588 : * @see GDALRasterBand::GetOffset()
3589 : */
3590 :
3591 395 : double CPL_STDCALL GDALGetRasterOffset(GDALRasterBandH hBand, int *pbSuccess)
3592 :
3593 : {
3594 395 : VALIDATE_POINTER1(hBand, "GDALGetRasterOffset", 0);
3595 :
3596 395 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3597 395 : return poBand->GetOffset(pbSuccess);
3598 : }
3599 :
3600 : /************************************************************************/
3601 : /* SetOffset() */
3602 : /************************************************************************/
3603 :
3604 : /**
3605 : * \fn GDALRasterBand::SetOffset(double)
3606 : * \brief Set scaling offset.
3607 : *
3608 : * Very few formats implement this method. When not implemented it will
3609 : * issue a CPLE_NotSupported error and return CE_Failure.
3610 : *
3611 : * This method is the same as the C function GDALSetRasterOffset().
3612 : *
3613 : * @param dfNewOffset the new offset.
3614 : *
3615 : * @return CE_None or success or CE_Failure on failure.
3616 : */
3617 :
3618 : /**/
3619 : /**/
3620 :
3621 0 : CPLErr GDALRasterBand::SetOffset(double /*dfNewOffset*/)
3622 : {
3623 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
3624 0 : ReportError(CE_Failure, CPLE_NotSupported,
3625 : "SetOffset() not supported on this raster band.");
3626 :
3627 0 : return CE_Failure;
3628 : }
3629 :
3630 : /************************************************************************/
3631 : /* GDALSetRasterOffset() */
3632 : /************************************************************************/
3633 :
3634 : /**
3635 : * \brief Set scaling offset.
3636 : *
3637 : * @see GDALRasterBand::SetOffset()
3638 : */
3639 :
3640 86 : CPLErr CPL_STDCALL GDALSetRasterOffset(GDALRasterBandH hBand,
3641 : double dfNewOffset)
3642 :
3643 : {
3644 86 : VALIDATE_POINTER1(hBand, "GDALSetRasterOffset", CE_Failure);
3645 :
3646 86 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3647 86 : return poBand->SetOffset(dfNewOffset);
3648 : }
3649 :
3650 : /************************************************************************/
3651 : /* GetScale() */
3652 : /************************************************************************/
3653 :
3654 : /**
3655 : * \brief Fetch the raster value scale.
3656 : *
3657 : * This value (in combination with the GetOffset() value) can be used to
3658 : * transform raw pixel values into the units returned by GetUnitType().
3659 : * For example this might be used to store elevations in GUInt16 bands
3660 : * with a precision of 0.1, and starting from -100.
3661 : *
3662 : * Units value = (raw value * scale) + offset
3663 : *
3664 : * Note that applying scale and offset is of the responsibility of the user,
3665 : * and is not done by methods such as RasterIO() or ReadBlock().
3666 : *
3667 : * For file formats that don't know this intrinsically a value of one
3668 : * is returned.
3669 : *
3670 : * This method is the same as the C function GDALGetRasterScale().
3671 : *
3672 : * @param pbSuccess pointer to a boolean to use to indicate if the
3673 : * returned value is meaningful or not. May be NULL (default).
3674 : *
3675 : * @return the raster scale.
3676 : */
3677 :
3678 445 : double GDALRasterBand::GetScale(int *pbSuccess)
3679 :
3680 : {
3681 445 : if (pbSuccess != nullptr)
3682 336 : *pbSuccess = FALSE;
3683 :
3684 445 : return 1.0;
3685 : }
3686 :
3687 : /************************************************************************/
3688 : /* GDALGetRasterScale() */
3689 : /************************************************************************/
3690 :
3691 : /**
3692 : * \brief Fetch the raster value scale.
3693 : *
3694 : * @see GDALRasterBand::GetScale()
3695 : */
3696 :
3697 393 : double CPL_STDCALL GDALGetRasterScale(GDALRasterBandH hBand, int *pbSuccess)
3698 :
3699 : {
3700 393 : VALIDATE_POINTER1(hBand, "GDALGetRasterScale", 0);
3701 :
3702 393 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3703 393 : return poBand->GetScale(pbSuccess);
3704 : }
3705 :
3706 : /************************************************************************/
3707 : /* SetScale() */
3708 : /************************************************************************/
3709 :
3710 : /**
3711 : * \fn GDALRasterBand::SetScale(double)
3712 : * \brief Set scaling ratio.
3713 : *
3714 : * Very few formats implement this method. When not implemented it will
3715 : * issue a CPLE_NotSupported error and return CE_Failure.
3716 : *
3717 : * This method is the same as the C function GDALSetRasterScale().
3718 : *
3719 : * @param dfNewScale the new scale.
3720 : *
3721 : * @return CE_None or success or CE_Failure on failure.
3722 : */
3723 :
3724 : /**/
3725 : /**/
3726 :
3727 0 : CPLErr GDALRasterBand::SetScale(double /*dfNewScale*/)
3728 :
3729 : {
3730 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
3731 0 : ReportError(CE_Failure, CPLE_NotSupported,
3732 : "SetScale() not supported on this raster band.");
3733 :
3734 0 : return CE_Failure;
3735 : }
3736 :
3737 : /************************************************************************/
3738 : /* GDALSetRasterScale() */
3739 : /************************************************************************/
3740 :
3741 : /**
3742 : * \brief Set scaling ratio.
3743 : *
3744 : * @see GDALRasterBand::SetScale()
3745 : */
3746 :
3747 87 : CPLErr CPL_STDCALL GDALSetRasterScale(GDALRasterBandH hBand, double dfNewOffset)
3748 :
3749 : {
3750 87 : VALIDATE_POINTER1(hBand, "GDALSetRasterScale", CE_Failure);
3751 :
3752 87 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3753 87 : return poBand->SetScale(dfNewOffset);
3754 : }
3755 :
3756 : /************************************************************************/
3757 : /* GetUnitType() */
3758 : /************************************************************************/
3759 :
3760 : /**
3761 : * \brief Return raster unit type.
3762 : *
3763 : * Return a name for the units of this raster's values. For instance, it
3764 : * might be "m" for an elevation model in meters, or "ft" for feet. If no
3765 : * units are available, a value of "" will be returned. The returned string
3766 : * should not be modified, nor freed by the calling application.
3767 : *
3768 : * This method is the same as the C function GDALGetRasterUnitType().
3769 : *
3770 : * @return unit name string.
3771 : */
3772 :
3773 165 : const char *GDALRasterBand::GetUnitType()
3774 :
3775 : {
3776 165 : return "";
3777 : }
3778 :
3779 : /************************************************************************/
3780 : /* GDALGetRasterUnitType() */
3781 : /************************************************************************/
3782 :
3783 : /**
3784 : * \brief Return raster unit type.
3785 : *
3786 : * @see GDALRasterBand::GetUnitType()
3787 : */
3788 :
3789 1477 : const char *CPL_STDCALL GDALGetRasterUnitType(GDALRasterBandH hBand)
3790 :
3791 : {
3792 1477 : VALIDATE_POINTER1(hBand, "GDALGetRasterUnitType", nullptr);
3793 :
3794 1477 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3795 1477 : return poBand->GetUnitType();
3796 : }
3797 :
3798 : /************************************************************************/
3799 : /* SetUnitType() */
3800 : /************************************************************************/
3801 :
3802 : /**
3803 : * \fn GDALRasterBand::SetUnitType(const char*)
3804 : * \brief Set unit type.
3805 : *
3806 : * Set the unit type for a raster band. Values should be one of
3807 : * "" (the default indicating it is unknown), "m" indicating meters,
3808 : * or "ft" indicating feet, though other nonstandard values are allowed.
3809 : *
3810 : * This method is the same as the C function GDALSetRasterUnitType().
3811 : *
3812 : * @param pszNewValue the new unit type value.
3813 : *
3814 : * @return CE_None on success or CE_Failure if not successful, or
3815 : * unsupported.
3816 : */
3817 :
3818 : /**/
3819 : /**/
3820 :
3821 0 : CPLErr GDALRasterBand::SetUnitType(const char * /*pszNewValue*/)
3822 :
3823 : {
3824 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
3825 0 : ReportError(CE_Failure, CPLE_NotSupported,
3826 : "SetUnitType() not supported on this raster band.");
3827 0 : return CE_Failure;
3828 : }
3829 :
3830 : /************************************************************************/
3831 : /* GDALSetRasterUnitType() */
3832 : /************************************************************************/
3833 :
3834 : /**
3835 : * \brief Set unit type.
3836 : *
3837 : * @see GDALRasterBand::SetUnitType()
3838 : *
3839 : */
3840 :
3841 95 : CPLErr CPL_STDCALL GDALSetRasterUnitType(GDALRasterBandH hBand,
3842 : const char *pszNewValue)
3843 :
3844 : {
3845 95 : VALIDATE_POINTER1(hBand, "GDALSetRasterUnitType", CE_Failure);
3846 :
3847 95 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3848 95 : return poBand->SetUnitType(pszNewValue);
3849 : }
3850 :
3851 : /************************************************************************/
3852 : /* GetXSize() */
3853 : /************************************************************************/
3854 :
3855 : /**
3856 : * \brief Fetch XSize of raster.
3857 : *
3858 : * This method is the same as the C function GDALGetRasterBandXSize().
3859 : *
3860 : * @return the width in pixels of this band.
3861 : */
3862 :
3863 8452040 : int GDALRasterBand::GetXSize() const
3864 :
3865 : {
3866 8452040 : return nRasterXSize;
3867 : }
3868 :
3869 : /************************************************************************/
3870 : /* GDALGetRasterBandXSize() */
3871 : /************************************************************************/
3872 :
3873 : /**
3874 : * \brief Fetch XSize of raster.
3875 : *
3876 : * @see GDALRasterBand::GetXSize()
3877 : */
3878 :
3879 57849 : int CPL_STDCALL GDALGetRasterBandXSize(GDALRasterBandH hBand)
3880 :
3881 : {
3882 57849 : VALIDATE_POINTER1(hBand, "GDALGetRasterBandXSize", 0);
3883 :
3884 57849 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3885 57849 : return poBand->GetXSize();
3886 : }
3887 :
3888 : /************************************************************************/
3889 : /* GetYSize() */
3890 : /************************************************************************/
3891 :
3892 : /**
3893 : * \brief Fetch YSize of raster.
3894 : *
3895 : * This method is the same as the C function GDALGetRasterBandYSize().
3896 : *
3897 : * @return the height in pixels of this band.
3898 : */
3899 :
3900 4684050 : int GDALRasterBand::GetYSize() const
3901 :
3902 : {
3903 4684050 : return nRasterYSize;
3904 : }
3905 :
3906 : /************************************************************************/
3907 : /* GDALGetRasterBandYSize() */
3908 : /************************************************************************/
3909 :
3910 : /**
3911 : * \brief Fetch YSize of raster.
3912 : *
3913 : * @see GDALRasterBand::GetYSize()
3914 : */
3915 :
3916 56712 : int CPL_STDCALL GDALGetRasterBandYSize(GDALRasterBandH hBand)
3917 :
3918 : {
3919 56712 : VALIDATE_POINTER1(hBand, "GDALGetRasterBandYSize", 0);
3920 :
3921 56712 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3922 56712 : return poBand->GetYSize();
3923 : }
3924 :
3925 : /************************************************************************/
3926 : /* GetBand() */
3927 : /************************************************************************/
3928 :
3929 : /**
3930 : * \brief Fetch the band number.
3931 : *
3932 : * This method returns the band that this GDALRasterBand objects represents
3933 : * within its dataset. This method may return a value of 0 to indicate
3934 : * GDALRasterBand objects without an apparently relationship to a dataset,
3935 : * such as GDALRasterBands serving as overviews.
3936 : *
3937 : * This method is the same as the C function GDALGetBandNumber().
3938 : *
3939 : * @return band number (1+) or 0 if the band number isn't known.
3940 : */
3941 :
3942 150743 : int GDALRasterBand::GetBand() const
3943 :
3944 : {
3945 150743 : return nBand;
3946 : }
3947 :
3948 : /************************************************************************/
3949 : /* GDALGetBandNumber() */
3950 : /************************************************************************/
3951 :
3952 : /**
3953 : * \brief Fetch the band number.
3954 : *
3955 : * @see GDALRasterBand::GetBand()
3956 : */
3957 :
3958 208 : int CPL_STDCALL GDALGetBandNumber(GDALRasterBandH hBand)
3959 :
3960 : {
3961 208 : VALIDATE_POINTER1(hBand, "GDALGetBandNumber", 0);
3962 :
3963 208 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
3964 208 : return poBand->GetBand();
3965 : }
3966 :
3967 : /************************************************************************/
3968 : /* GetDataset() */
3969 : /************************************************************************/
3970 :
3971 : /**
3972 : * \brief Fetch the owning dataset handle.
3973 : *
3974 : * Note that some GDALRasterBands are not considered to be a part of a dataset,
3975 : * such as overviews or other "freestanding" bands.
3976 : *
3977 : * This method is the same as the C function GDALGetBandDataset().
3978 : *
3979 : * @return the pointer to the GDALDataset to which this band belongs, or
3980 : * NULL if this cannot be determined.
3981 : */
3982 :
3983 5286460 : GDALDataset *GDALRasterBand::GetDataset() const
3984 :
3985 : {
3986 5286460 : return poDS;
3987 : }
3988 :
3989 : /************************************************************************/
3990 : /* GDALGetBandDataset() */
3991 : /************************************************************************/
3992 :
3993 : /**
3994 : * \brief Fetch the owning dataset handle.
3995 : *
3996 : * @see GDALRasterBand::GetDataset()
3997 : */
3998 :
3999 355 : GDALDatasetH CPL_STDCALL GDALGetBandDataset(GDALRasterBandH hBand)
4000 :
4001 : {
4002 355 : VALIDATE_POINTER1(hBand, "GDALGetBandDataset", nullptr);
4003 :
4004 355 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
4005 355 : return GDALDataset::ToHandle(poBand->GetDataset());
4006 : }
4007 :
4008 : /************************************************************************/
4009 : /* ComputeFloat16NoDataValue() */
4010 : /************************************************************************/
4011 :
4012 2286 : static inline void ComputeFloat16NoDataValue(GDALDataType eDataType,
4013 : double dfNoDataValue,
4014 : int &bGotNoDataValue,
4015 : GFloat16 &fNoDataValue,
4016 : bool &bGotFloat16NoDataValue)
4017 : {
4018 2286 : if (eDataType == GDT_Float16 && bGotNoDataValue)
4019 : {
4020 0 : dfNoDataValue = GDALAdjustNoDataCloseToFloatMax(dfNoDataValue);
4021 0 : if (GDALIsValueInRange<GFloat16>(dfNoDataValue))
4022 : {
4023 0 : fNoDataValue = static_cast<GFloat16>(dfNoDataValue);
4024 0 : bGotFloat16NoDataValue = true;
4025 0 : bGotNoDataValue = false;
4026 : }
4027 : }
4028 2286 : }
4029 :
4030 : /************************************************************************/
4031 : /* ComputeFloatNoDataValue() */
4032 : /************************************************************************/
4033 :
4034 2287 : static inline void ComputeFloatNoDataValue(GDALDataType eDataType,
4035 : double dfNoDataValue,
4036 : int &bGotNoDataValue,
4037 : float &fNoDataValue,
4038 : bool &bGotFloatNoDataValue)
4039 : {
4040 2287 : if (eDataType == GDT_Float32 && bGotNoDataValue)
4041 : {
4042 90 : dfNoDataValue = GDALAdjustNoDataCloseToFloatMax(dfNoDataValue);
4043 90 : if (GDALIsValueInRange<float>(dfNoDataValue))
4044 : {
4045 90 : fNoDataValue = static_cast<float>(dfNoDataValue);
4046 90 : bGotFloatNoDataValue = true;
4047 90 : bGotNoDataValue = false;
4048 : }
4049 : }
4050 2287 : }
4051 :
4052 : /************************************************************************/
4053 : /* struct GDALNoDataValues */
4054 : /************************************************************************/
4055 :
4056 : /**
4057 : * \brief No-data-values for all types
4058 : *
4059 : * The functions below pass various no-data-values around. To avoid
4060 : * long argument lists, this struct collects the no-data-values for
4061 : * all types into a single, convenient place.
4062 : **/
4063 :
4064 : struct GDALNoDataValues
4065 : {
4066 : int bGotNoDataValue;
4067 : double dfNoDataValue;
4068 :
4069 : bool bGotInt64NoDataValue;
4070 : int64_t nInt64NoDataValue;
4071 :
4072 : bool bGotUInt64NoDataValue;
4073 : uint64_t nUInt64NoDataValue;
4074 :
4075 : bool bGotFloatNoDataValue;
4076 : float fNoDataValue;
4077 :
4078 : bool bGotFloat16NoDataValue;
4079 : GFloat16 hfNoDataValue;
4080 :
4081 2331 : GDALNoDataValues(GDALRasterBand *poRasterBand, GDALDataType eDataType)
4082 2331 : : bGotNoDataValue(FALSE), dfNoDataValue(0.0),
4083 : bGotInt64NoDataValue(false), nInt64NoDataValue(0),
4084 : bGotUInt64NoDataValue(false), nUInt64NoDataValue(0),
4085 : bGotFloatNoDataValue(false), fNoDataValue(0.0f),
4086 2331 : bGotFloat16NoDataValue(false), hfNoDataValue(GFloat16(0.0f))
4087 : {
4088 2331 : if (eDataType == GDT_Int64)
4089 : {
4090 29 : int nGot = false;
4091 29 : nInt64NoDataValue = poRasterBand->GetNoDataValueAsInt64(&nGot);
4092 28 : bGotInt64NoDataValue = CPL_TO_BOOL(nGot);
4093 28 : if (bGotInt64NoDataValue)
4094 : {
4095 3 : dfNoDataValue = static_cast<double>(nInt64NoDataValue);
4096 3 : bGotNoDataValue =
4097 3 : nInt64NoDataValue <=
4098 6 : std::numeric_limits<int64_t>::max() - 1024 &&
4099 3 : static_cast<int64_t>(dfNoDataValue) == nInt64NoDataValue;
4100 : }
4101 : else
4102 25 : dfNoDataValue = poRasterBand->GetNoDataValue(&bGotNoDataValue);
4103 : }
4104 2302 : else if (eDataType == GDT_UInt64)
4105 : {
4106 16 : int nGot = false;
4107 16 : nUInt64NoDataValue = poRasterBand->GetNoDataValueAsUInt64(&nGot);
4108 16 : bGotUInt64NoDataValue = CPL_TO_BOOL(nGot);
4109 16 : if (bGotUInt64NoDataValue)
4110 : {
4111 3 : dfNoDataValue = static_cast<double>(nUInt64NoDataValue);
4112 3 : bGotNoDataValue =
4113 3 : nUInt64NoDataValue <=
4114 6 : std::numeric_limits<uint64_t>::max() - 2048 &&
4115 3 : static_cast<uint64_t>(dfNoDataValue) == nUInt64NoDataValue;
4116 : }
4117 : else
4118 13 : dfNoDataValue = poRasterBand->GetNoDataValue(&bGotNoDataValue);
4119 : }
4120 : else
4121 : {
4122 2286 : dfNoDataValue = poRasterBand->GetNoDataValue(&bGotNoDataValue);
4123 2287 : bGotNoDataValue = bGotNoDataValue && !std::isnan(dfNoDataValue);
4124 :
4125 2287 : ComputeFloatNoDataValue(eDataType, dfNoDataValue, bGotNoDataValue,
4126 2287 : fNoDataValue, bGotFloatNoDataValue);
4127 :
4128 2287 : ComputeFloat16NoDataValue(eDataType, dfNoDataValue, bGotNoDataValue,
4129 2287 : hfNoDataValue, bGotFloat16NoDataValue);
4130 : }
4131 2330 : }
4132 : };
4133 :
4134 : /************************************************************************/
4135 : /* ARE_REAL_EQUAL() */
4136 : /************************************************************************/
4137 :
4138 0 : inline bool ARE_REAL_EQUAL(GFloat16 dfVal1, GFloat16 dfVal2, int ulp = 2)
4139 : {
4140 : using std::abs;
4141 0 : return dfVal1 == dfVal2 || /* Should cover infinity */
4142 0 : abs(dfVal1 - dfVal2) < cpl::NumericLimits<GFloat16>::epsilon() *
4143 0 : abs(dfVal1 + dfVal2) * ulp;
4144 : }
4145 :
4146 : /************************************************************************/
4147 : /* GetHistogram() */
4148 : /************************************************************************/
4149 :
4150 : /**
4151 : * \brief Compute raster histogram.
4152 : *
4153 : * Note that the bucket size is (dfMax-dfMin) / nBuckets.
4154 : *
4155 : * For example to compute a simple 256 entry histogram of eight bit data,
4156 : * the following would be suitable. The unusual bounds are to ensure that
4157 : * bucket boundaries don't fall right on integer values causing possible errors
4158 : * due to rounding after scaling.
4159 : \code{.cpp}
4160 : GUIntBig anHistogram[256];
4161 :
4162 : poBand->GetHistogram( -0.5, 255.5, 256, anHistogram, FALSE, FALSE,
4163 : GDALDummyProgress, nullptr );
4164 : \endcode
4165 : *
4166 : * Note that setting bApproxOK will generally result in a subsampling of the
4167 : * file, and will utilize overviews if available. It should generally
4168 : * produce a representative histogram for the data that is suitable for use
4169 : * in generating histogram based luts for instance. Generally bApproxOK is
4170 : * much faster than an exactly computed histogram.
4171 : *
4172 : * This method is the same as the C functions GDALGetRasterHistogram() and
4173 : * GDALGetRasterHistogramEx().
4174 : *
4175 : * @param dfMin the lower bound of the histogram.
4176 : * @param dfMax the upper bound of the histogram.
4177 : * @param nBuckets the number of buckets in panHistogram.
4178 : * @param panHistogram array into which the histogram totals are placed.
4179 : * @param bIncludeOutOfRange if TRUE values below the histogram range will
4180 : * mapped into panHistogram[0], and values above will be mapped into
4181 : * panHistogram[nBuckets-1] otherwise out of range values are discarded.
4182 : * @param bApproxOK TRUE if an approximate, or incomplete histogram OK.
4183 : * @param pfnProgress function to report progress to completion.
4184 : * @param pProgressData application data to pass to pfnProgress.
4185 : *
4186 : * @return CE_None on success, or CE_Failure if something goes wrong.
4187 : */
4188 :
4189 45 : CPLErr GDALRasterBand::GetHistogram(double dfMin, double dfMax, int nBuckets,
4190 : GUIntBig *panHistogram,
4191 : int bIncludeOutOfRange, int bApproxOK,
4192 : GDALProgressFunc pfnProgress,
4193 : void *pProgressData)
4194 :
4195 : {
4196 45 : CPLAssert(nullptr != panHistogram);
4197 :
4198 45 : if (pfnProgress == nullptr)
4199 29 : pfnProgress = GDALDummyProgress;
4200 :
4201 : /* -------------------------------------------------------------------- */
4202 : /* If we have overviews, use them for the histogram. */
4203 : /* -------------------------------------------------------------------- */
4204 45 : if (bApproxOK && GetOverviewCount() > 0 && !HasArbitraryOverviews())
4205 : {
4206 : // FIXME: should we use the most reduced overview here or use some
4207 : // minimum number of samples like GDALRasterBand::ComputeStatistics()
4208 : // does?
4209 0 : GDALRasterBand *poBestOverview = GetRasterSampleOverview(0);
4210 :
4211 0 : if (poBestOverview != this)
4212 : {
4213 0 : return poBestOverview->GetHistogram(
4214 : dfMin, dfMax, nBuckets, panHistogram, bIncludeOutOfRange,
4215 0 : bApproxOK, pfnProgress, pProgressData);
4216 : }
4217 : }
4218 :
4219 : /* -------------------------------------------------------------------- */
4220 : /* Read actual data and build histogram. */
4221 : /* -------------------------------------------------------------------- */
4222 45 : if (!pfnProgress(0.0, "Compute Histogram", pProgressData))
4223 : {
4224 0 : ReportError(CE_Failure, CPLE_UserInterrupt, "User terminated");
4225 0 : return CE_Failure;
4226 : }
4227 :
4228 : // Written this way to deal with NaN
4229 45 : if (!(dfMax > dfMin))
4230 : {
4231 5 : ReportError(CE_Failure, CPLE_IllegalArg,
4232 : "dfMax should be strictly greater than dfMin");
4233 5 : return CE_Failure;
4234 : }
4235 :
4236 : GDALRasterIOExtraArg sExtraArg;
4237 40 : INIT_RASTERIO_EXTRA_ARG(sExtraArg);
4238 :
4239 40 : const double dfScale = nBuckets / (dfMax - dfMin);
4240 40 : if (dfScale == 0 || !std::isfinite(dfScale))
4241 : {
4242 5 : ReportError(CE_Failure, CPLE_IllegalArg,
4243 : "dfMin and dfMax should be finite values such that "
4244 : "nBuckets / (dfMax - dfMin) is non-zero");
4245 5 : return CE_Failure;
4246 : }
4247 35 : memset(panHistogram, 0, sizeof(GUIntBig) * nBuckets);
4248 :
4249 35 : GDALNoDataValues sNoDataValues(this, eDataType);
4250 35 : GDALRasterBand *poMaskBand = nullptr;
4251 35 : if (!sNoDataValues.bGotNoDataValue)
4252 : {
4253 34 : const int l_nMaskFlags = GetMaskFlags();
4254 36 : if (l_nMaskFlags != GMF_ALL_VALID &&
4255 2 : GetColorInterpretation() != GCI_AlphaBand)
4256 : {
4257 2 : poMaskBand = GetMaskBand();
4258 : }
4259 : }
4260 :
4261 35 : bool bSignedByte = false;
4262 35 : if (eDataType == GDT_Byte)
4263 : {
4264 26 : EnablePixelTypeSignedByteWarning(false);
4265 : const char *pszPixelType =
4266 26 : GetMetadataItem("PIXELTYPE", "IMAGE_STRUCTURE");
4267 26 : EnablePixelTypeSignedByteWarning(true);
4268 26 : bSignedByte =
4269 26 : pszPixelType != nullptr && EQUAL(pszPixelType, "SIGNEDBYTE");
4270 : }
4271 :
4272 35 : if (bApproxOK && HasArbitraryOverviews())
4273 : {
4274 : /* --------------------------------------------------------------------
4275 : */
4276 : /* Figure out how much the image should be reduced to get an */
4277 : /* approximate value. */
4278 : /* --------------------------------------------------------------------
4279 : */
4280 : const double dfReduction =
4281 0 : sqrt(static_cast<double>(nRasterXSize) * nRasterYSize /
4282 : GDALSTAT_APPROX_NUMSAMPLES);
4283 :
4284 0 : int nXReduced = nRasterXSize;
4285 0 : int nYReduced = nRasterYSize;
4286 0 : if (dfReduction > 1.0)
4287 : {
4288 0 : nXReduced = static_cast<int>(nRasterXSize / dfReduction);
4289 0 : nYReduced = static_cast<int>(nRasterYSize / dfReduction);
4290 :
4291 : // Catch the case of huge resizing ratios here
4292 0 : if (nXReduced == 0)
4293 0 : nXReduced = 1;
4294 0 : if (nYReduced == 0)
4295 0 : nYReduced = 1;
4296 : }
4297 :
4298 0 : void *pData = VSI_MALLOC3_VERBOSE(GDALGetDataTypeSizeBytes(eDataType),
4299 : nXReduced, nYReduced);
4300 0 : if (!pData)
4301 0 : return CE_Failure;
4302 :
4303 : const CPLErr eErr =
4304 0 : IRasterIO(GF_Read, 0, 0, nRasterXSize, nRasterYSize, pData,
4305 0 : nXReduced, nYReduced, eDataType, 0, 0, &sExtraArg);
4306 0 : if (eErr != CE_None)
4307 : {
4308 0 : CPLFree(pData);
4309 0 : return eErr;
4310 : }
4311 :
4312 0 : GByte *pabyMaskData = nullptr;
4313 0 : if (poMaskBand)
4314 : {
4315 : pabyMaskData =
4316 0 : static_cast<GByte *>(VSI_MALLOC2_VERBOSE(nXReduced, nYReduced));
4317 0 : if (!pabyMaskData)
4318 : {
4319 0 : CPLFree(pData);
4320 0 : return CE_Failure;
4321 : }
4322 :
4323 0 : if (poMaskBand->RasterIO(GF_Read, 0, 0, nRasterXSize, nRasterYSize,
4324 : pabyMaskData, nXReduced, nYReduced,
4325 0 : GDT_Byte, 0, 0, nullptr) != CE_None)
4326 : {
4327 0 : CPLFree(pData);
4328 0 : CPLFree(pabyMaskData);
4329 0 : return CE_Failure;
4330 : }
4331 : }
4332 :
4333 : // This isn't the fastest way to do this, but is easier for now.
4334 0 : for (int iY = 0; iY < nYReduced; iY++)
4335 : {
4336 0 : for (int iX = 0; iX < nXReduced; iX++)
4337 : {
4338 0 : const int iOffset = iX + iY * nXReduced;
4339 0 : double dfValue = 0.0;
4340 :
4341 0 : if (pabyMaskData && pabyMaskData[iOffset] == 0)
4342 0 : continue;
4343 :
4344 0 : switch (eDataType)
4345 : {
4346 0 : case GDT_Byte:
4347 : {
4348 0 : if (bSignedByte)
4349 0 : dfValue =
4350 0 : static_cast<signed char *>(pData)[iOffset];
4351 : else
4352 0 : dfValue = static_cast<GByte *>(pData)[iOffset];
4353 0 : break;
4354 : }
4355 0 : case GDT_Int8:
4356 0 : dfValue = static_cast<GInt8 *>(pData)[iOffset];
4357 0 : break;
4358 0 : case GDT_UInt16:
4359 0 : dfValue = static_cast<GUInt16 *>(pData)[iOffset];
4360 0 : break;
4361 0 : case GDT_Int16:
4362 0 : dfValue = static_cast<GInt16 *>(pData)[iOffset];
4363 0 : break;
4364 0 : case GDT_UInt32:
4365 0 : dfValue = static_cast<GUInt32 *>(pData)[iOffset];
4366 0 : break;
4367 0 : case GDT_Int32:
4368 0 : dfValue = static_cast<GInt32 *>(pData)[iOffset];
4369 0 : break;
4370 0 : case GDT_UInt64:
4371 0 : dfValue = static_cast<double>(
4372 0 : static_cast<GUInt64 *>(pData)[iOffset]);
4373 0 : break;
4374 0 : case GDT_Int64:
4375 0 : dfValue = static_cast<double>(
4376 0 : static_cast<GInt64 *>(pData)[iOffset]);
4377 0 : break;
4378 0 : case GDT_Float16:
4379 : {
4380 : using namespace std;
4381 0 : const GFloat16 hfValue =
4382 0 : static_cast<GFloat16 *>(pData)[iOffset];
4383 0 : if (isnan(hfValue) ||
4384 0 : (sNoDataValues.bGotFloat16NoDataValue &&
4385 0 : ARE_REAL_EQUAL(hfValue,
4386 : sNoDataValues.hfNoDataValue)))
4387 0 : continue;
4388 0 : dfValue = hfValue;
4389 0 : break;
4390 : }
4391 0 : case GDT_Float32:
4392 : {
4393 0 : const float fValue =
4394 0 : static_cast<float *>(pData)[iOffset];
4395 0 : if (std::isnan(fValue) ||
4396 0 : (sNoDataValues.bGotFloatNoDataValue &&
4397 0 : ARE_REAL_EQUAL(fValue,
4398 : sNoDataValues.fNoDataValue)))
4399 0 : continue;
4400 0 : dfValue = double(fValue);
4401 0 : break;
4402 : }
4403 0 : case GDT_Float64:
4404 0 : dfValue = static_cast<double *>(pData)[iOffset];
4405 0 : if (std::isnan(dfValue))
4406 0 : continue;
4407 0 : break;
4408 0 : case GDT_CInt16:
4409 : {
4410 0 : const double dfReal =
4411 0 : static_cast<GInt16 *>(pData)[iOffset * 2];
4412 0 : const double dfImag =
4413 0 : static_cast<GInt16 *>(pData)[iOffset * 2 + 1];
4414 0 : if (std::isnan(dfReal) || std::isnan(dfImag))
4415 0 : continue;
4416 0 : dfValue = sqrt(dfReal * dfReal + dfImag * dfImag);
4417 : }
4418 0 : break;
4419 0 : case GDT_CInt32:
4420 : {
4421 0 : const double dfReal =
4422 0 : static_cast<GInt32 *>(pData)[iOffset * 2];
4423 0 : const double dfImag =
4424 0 : static_cast<GInt32 *>(pData)[iOffset * 2 + 1];
4425 0 : if (std::isnan(dfReal) || std::isnan(dfImag))
4426 0 : continue;
4427 0 : dfValue = sqrt(dfReal * dfReal + dfImag * dfImag);
4428 : }
4429 0 : break;
4430 0 : case GDT_CFloat16:
4431 : {
4432 : const double dfReal =
4433 0 : static_cast<GFloat16 *>(pData)[iOffset * 2];
4434 : const double dfImag =
4435 0 : static_cast<GFloat16 *>(pData)[iOffset * 2 + 1];
4436 0 : if (std::isnan(dfReal) || std::isnan(dfImag))
4437 0 : continue;
4438 0 : dfValue = sqrt(dfReal * dfReal + dfImag * dfImag);
4439 0 : break;
4440 : }
4441 0 : case GDT_CFloat32:
4442 : {
4443 0 : const double dfReal =
4444 0 : double(static_cast<float *>(pData)[iOffset * 2]);
4445 0 : const double dfImag = double(
4446 0 : static_cast<float *>(pData)[iOffset * 2 + 1]);
4447 0 : if (std::isnan(dfReal) || std::isnan(dfImag))
4448 0 : continue;
4449 0 : dfValue = sqrt(dfReal * dfReal + dfImag * dfImag);
4450 0 : break;
4451 : }
4452 0 : case GDT_CFloat64:
4453 : {
4454 0 : const double dfReal =
4455 0 : static_cast<double *>(pData)[iOffset * 2];
4456 0 : const double dfImag =
4457 0 : static_cast<double *>(pData)[iOffset * 2 + 1];
4458 0 : if (std::isnan(dfReal) || std::isnan(dfImag))
4459 0 : continue;
4460 0 : dfValue = sqrt(dfReal * dfReal + dfImag * dfImag);
4461 0 : break;
4462 : }
4463 0 : case GDT_Unknown:
4464 : case GDT_TypeCount:
4465 0 : CPLAssert(false);
4466 : }
4467 :
4468 0 : if (eDataType != GDT_Float16 && eDataType != GDT_Float32 &&
4469 0 : sNoDataValues.bGotNoDataValue &&
4470 0 : ARE_REAL_EQUAL(dfValue, sNoDataValues.dfNoDataValue))
4471 0 : continue;
4472 :
4473 : // Given that dfValue and dfMin are not NaN, and dfScale > 0 and
4474 : // finite, the result of the multiplication cannot be NaN
4475 0 : const double dfIndex = floor((dfValue - dfMin) * dfScale);
4476 :
4477 0 : if (dfIndex < 0)
4478 : {
4479 0 : if (bIncludeOutOfRange)
4480 0 : panHistogram[0]++;
4481 : }
4482 0 : else if (dfIndex >= nBuckets)
4483 : {
4484 0 : if (bIncludeOutOfRange)
4485 0 : ++panHistogram[nBuckets - 1];
4486 : }
4487 : else
4488 : {
4489 0 : ++panHistogram[static_cast<int>(dfIndex)];
4490 : }
4491 : }
4492 : }
4493 :
4494 0 : CPLFree(pData);
4495 0 : CPLFree(pabyMaskData);
4496 : }
4497 : else // No arbitrary overviews.
4498 : {
4499 35 : if (!InitBlockInfo())
4500 0 : return CE_Failure;
4501 :
4502 : /* --------------------------------------------------------------------
4503 : */
4504 : /* Figure out the ratio of blocks we will read to get an */
4505 : /* approximate value. */
4506 : /* --------------------------------------------------------------------
4507 : */
4508 :
4509 35 : int nSampleRate = 1;
4510 35 : if (bApproxOK)
4511 : {
4512 8 : nSampleRate = static_cast<int>(std::max(
4513 16 : 1.0,
4514 8 : sqrt(static_cast<double>(nBlocksPerRow) * nBlocksPerColumn)));
4515 : // We want to avoid probing only the first column of blocks for
4516 : // a square shaped raster, because it is not unlikely that it may
4517 : // be padding only (#6378).
4518 8 : if (nSampleRate == nBlocksPerRow && nBlocksPerRow > 1)
4519 1 : nSampleRate += 1;
4520 : }
4521 :
4522 35 : GByte *pabyMaskData = nullptr;
4523 35 : if (poMaskBand)
4524 : {
4525 : pabyMaskData = static_cast<GByte *>(
4526 2 : VSI_MALLOC2_VERBOSE(nBlockXSize, nBlockYSize));
4527 2 : if (!pabyMaskData)
4528 : {
4529 0 : return CE_Failure;
4530 : }
4531 : }
4532 :
4533 : /* --------------------------------------------------------------------
4534 : */
4535 : /* Read the blocks, and add to histogram. */
4536 : /* --------------------------------------------------------------------
4537 : */
4538 35 : for (GIntBig iSampleBlock = 0;
4539 160 : iSampleBlock <
4540 160 : static_cast<GIntBig>(nBlocksPerRow) * nBlocksPerColumn;
4541 125 : iSampleBlock += nSampleRate)
4542 : {
4543 125 : if (!pfnProgress(
4544 125 : static_cast<double>(iSampleBlock) /
4545 125 : (static_cast<double>(nBlocksPerRow) * nBlocksPerColumn),
4546 : "Compute Histogram", pProgressData))
4547 : {
4548 0 : CPLFree(pabyMaskData);
4549 0 : return CE_Failure;
4550 : }
4551 :
4552 125 : const int iYBlock = static_cast<int>(iSampleBlock / nBlocksPerRow);
4553 125 : const int iXBlock = static_cast<int>(iSampleBlock % nBlocksPerRow);
4554 :
4555 125 : int nXCheck = 0, nYCheck = 0;
4556 125 : GetActualBlockSize(iXBlock, iYBlock, &nXCheck, &nYCheck);
4557 :
4558 127 : if (poMaskBand &&
4559 2 : poMaskBand->RasterIO(GF_Read, iXBlock * nBlockXSize,
4560 2 : iYBlock * nBlockYSize, nXCheck, nYCheck,
4561 : pabyMaskData, nXCheck, nYCheck, GDT_Byte,
4562 2 : 0, nBlockXSize, nullptr) != CE_None)
4563 : {
4564 0 : CPLFree(pabyMaskData);
4565 0 : return CE_Failure;
4566 : }
4567 :
4568 125 : GDALRasterBlock *poBlock = GetLockedBlockRef(iXBlock, iYBlock);
4569 125 : if (poBlock == nullptr)
4570 : {
4571 0 : CPLFree(pabyMaskData);
4572 0 : return CE_Failure;
4573 : }
4574 :
4575 125 : void *pData = poBlock->GetDataRef();
4576 :
4577 : // this is a special case for a common situation.
4578 125 : if (eDataType == GDT_Byte && !bSignedByte && dfScale == 1.0 &&
4579 89 : (dfMin >= -0.5 && dfMin <= 0.5) && nYCheck == nBlockYSize &&
4580 86 : nXCheck == nBlockXSize && nBuckets == 256)
4581 : {
4582 86 : const GPtrDiff_t nPixels =
4583 86 : static_cast<GPtrDiff_t>(nXCheck) * nYCheck;
4584 86 : GByte *pabyData = static_cast<GByte *>(pData);
4585 :
4586 79640 : for (GPtrDiff_t i = 0; i < nPixels; i++)
4587 : {
4588 79554 : if (pabyMaskData && pabyMaskData[i] == 0)
4589 0 : continue;
4590 79554 : if (!(sNoDataValues.bGotNoDataValue &&
4591 512 : (pabyData[i] ==
4592 512 : static_cast<GByte>(sNoDataValues.dfNoDataValue))))
4593 : {
4594 79298 : panHistogram[pabyData[i]]++;
4595 : }
4596 : }
4597 :
4598 86 : poBlock->DropLock();
4599 86 : continue; // To next sample block.
4600 : }
4601 :
4602 : // This isn't the fastest way to do this, but is easier for now.
4603 257 : for (int iY = 0; iY < nYCheck; iY++)
4604 : {
4605 36389 : for (int iX = 0; iX < nXCheck; iX++)
4606 : {
4607 36171 : const GPtrDiff_t iOffset =
4608 36171 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
4609 :
4610 36171 : if (pabyMaskData && pabyMaskData[iOffset] == 0)
4611 2 : continue;
4612 :
4613 36169 : double dfValue = 0.0;
4614 :
4615 36169 : switch (eDataType)
4616 : {
4617 19716 : case GDT_Byte:
4618 : {
4619 19716 : if (bSignedByte)
4620 0 : dfValue =
4621 0 : static_cast<signed char *>(pData)[iOffset];
4622 : else
4623 19716 : dfValue = static_cast<GByte *>(pData)[iOffset];
4624 19716 : break;
4625 : }
4626 1 : case GDT_Int8:
4627 1 : dfValue = static_cast<GInt8 *>(pData)[iOffset];
4628 1 : break;
4629 16384 : case GDT_UInt16:
4630 16384 : dfValue = static_cast<GUInt16 *>(pData)[iOffset];
4631 16384 : break;
4632 3 : case GDT_Int16:
4633 3 : dfValue = static_cast<GInt16 *>(pData)[iOffset];
4634 3 : break;
4635 0 : case GDT_UInt32:
4636 0 : dfValue = static_cast<GUInt32 *>(pData)[iOffset];
4637 0 : break;
4638 60 : case GDT_Int32:
4639 60 : dfValue = static_cast<GInt32 *>(pData)[iOffset];
4640 60 : break;
4641 0 : case GDT_UInt64:
4642 0 : dfValue = static_cast<double>(
4643 0 : static_cast<GUInt64 *>(pData)[iOffset]);
4644 0 : break;
4645 0 : case GDT_Int64:
4646 0 : dfValue = static_cast<double>(
4647 0 : static_cast<GInt64 *>(pData)[iOffset]);
4648 0 : break;
4649 0 : case GDT_Float16:
4650 : {
4651 : using namespace std;
4652 0 : const GFloat16 hfValue =
4653 0 : static_cast<GFloat16 *>(pData)[iOffset];
4654 0 : if (isnan(hfValue) ||
4655 0 : (sNoDataValues.bGotFloat16NoDataValue &&
4656 0 : ARE_REAL_EQUAL(hfValue,
4657 : sNoDataValues.hfNoDataValue)))
4658 0 : continue;
4659 0 : dfValue = hfValue;
4660 0 : break;
4661 : }
4662 3 : case GDT_Float32:
4663 : {
4664 3 : const float fValue =
4665 3 : static_cast<float *>(pData)[iOffset];
4666 6 : if (std::isnan(fValue) ||
4667 6 : (sNoDataValues.bGotFloatNoDataValue &&
4668 3 : ARE_REAL_EQUAL(fValue,
4669 : sNoDataValues.fNoDataValue)))
4670 0 : continue;
4671 3 : dfValue = double(fValue);
4672 3 : break;
4673 : }
4674 2 : case GDT_Float64:
4675 2 : dfValue = static_cast<double *>(pData)[iOffset];
4676 2 : if (std::isnan(dfValue))
4677 0 : continue;
4678 2 : break;
4679 0 : case GDT_CInt16:
4680 : {
4681 0 : double dfReal =
4682 0 : static_cast<GInt16 *>(pData)[iOffset * 2];
4683 0 : double dfImag =
4684 0 : static_cast<GInt16 *>(pData)[iOffset * 2 + 1];
4685 0 : dfValue = sqrt(dfReal * dfReal + dfImag * dfImag);
4686 0 : break;
4687 : }
4688 0 : case GDT_CInt32:
4689 : {
4690 0 : double dfReal =
4691 0 : static_cast<GInt32 *>(pData)[iOffset * 2];
4692 0 : double dfImag =
4693 0 : static_cast<GInt32 *>(pData)[iOffset * 2 + 1];
4694 0 : dfValue = sqrt(dfReal * dfReal + dfImag * dfImag);
4695 0 : break;
4696 : }
4697 0 : case GDT_CFloat16:
4698 : {
4699 : double dfReal =
4700 0 : static_cast<GFloat16 *>(pData)[iOffset * 2];
4701 : double dfImag =
4702 0 : static_cast<GFloat16 *>(pData)[iOffset * 2 + 1];
4703 0 : if (std::isnan(dfReal) || std::isnan(dfImag))
4704 0 : continue;
4705 0 : dfValue = sqrt(dfReal * dfReal + dfImag * dfImag);
4706 0 : break;
4707 : }
4708 0 : case GDT_CFloat32:
4709 : {
4710 0 : double dfReal = double(
4711 0 : static_cast<float *>(pData)[iOffset * 2]);
4712 0 : double dfImag = double(
4713 0 : static_cast<float *>(pData)[iOffset * 2 + 1]);
4714 0 : if (std::isnan(dfReal) || std::isnan(dfImag))
4715 0 : continue;
4716 0 : dfValue = sqrt(dfReal * dfReal + dfImag * dfImag);
4717 0 : break;
4718 : }
4719 0 : case GDT_CFloat64:
4720 : {
4721 0 : double dfReal =
4722 0 : static_cast<double *>(pData)[iOffset * 2];
4723 0 : double dfImag =
4724 0 : static_cast<double *>(pData)[iOffset * 2 + 1];
4725 0 : if (std::isnan(dfReal) || std::isnan(dfImag))
4726 0 : continue;
4727 0 : dfValue = sqrt(dfReal * dfReal + dfImag * dfImag);
4728 0 : break;
4729 : }
4730 0 : case GDT_Unknown:
4731 : case GDT_TypeCount:
4732 0 : CPLAssert(false);
4733 : CPLFree(pabyMaskData);
4734 : return CE_Failure;
4735 : }
4736 :
4737 36169 : if (eDataType != GDT_Float16 && eDataType != GDT_Float32 &&
4738 72338 : sNoDataValues.bGotNoDataValue &&
4739 0 : ARE_REAL_EQUAL(dfValue, sNoDataValues.dfNoDataValue))
4740 0 : continue;
4741 :
4742 : // Given that dfValue and dfMin are not NaN, and dfScale > 0
4743 : // and finite, the result of the multiplication cannot be
4744 : // NaN
4745 36169 : const double dfIndex = floor((dfValue - dfMin) * dfScale);
4746 :
4747 36169 : if (dfIndex < 0)
4748 : {
4749 1 : if (bIncludeOutOfRange)
4750 1 : panHistogram[0]++;
4751 : }
4752 36168 : else if (dfIndex >= nBuckets)
4753 : {
4754 7 : if (bIncludeOutOfRange)
4755 4 : ++panHistogram[nBuckets - 1];
4756 : }
4757 : else
4758 : {
4759 36161 : ++panHistogram[static_cast<int>(dfIndex)];
4760 : }
4761 : }
4762 : }
4763 :
4764 39 : poBlock->DropLock();
4765 : }
4766 :
4767 35 : CPLFree(pabyMaskData);
4768 : }
4769 :
4770 35 : pfnProgress(1.0, "Compute Histogram", pProgressData);
4771 :
4772 35 : return CE_None;
4773 : }
4774 :
4775 : /************************************************************************/
4776 : /* GDALGetRasterHistogram() */
4777 : /************************************************************************/
4778 :
4779 : /**
4780 : * \brief Compute raster histogram.
4781 : *
4782 : * Use GDALGetRasterHistogramEx() instead to get correct counts for values
4783 : * exceeding 2 billion.
4784 : *
4785 : * @see GDALRasterBand::GetHistogram()
4786 : * @see GDALGetRasterHistogramEx()
4787 : */
4788 :
4789 0 : CPLErr CPL_STDCALL GDALGetRasterHistogram(GDALRasterBandH hBand, double dfMin,
4790 : double dfMax, int nBuckets,
4791 : int *panHistogram,
4792 : int bIncludeOutOfRange, int bApproxOK,
4793 : GDALProgressFunc pfnProgress,
4794 : void *pProgressData)
4795 :
4796 : {
4797 0 : VALIDATE_POINTER1(hBand, "GDALGetRasterHistogram", CE_Failure);
4798 0 : VALIDATE_POINTER1(panHistogram, "GDALGetRasterHistogram", CE_Failure);
4799 :
4800 0 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
4801 :
4802 : GUIntBig *panHistogramTemp =
4803 0 : static_cast<GUIntBig *>(VSIMalloc2(sizeof(GUIntBig), nBuckets));
4804 0 : if (panHistogramTemp == nullptr)
4805 : {
4806 0 : poBand->ReportError(CE_Failure, CPLE_OutOfMemory,
4807 : "Out of memory in GDALGetRasterHistogram().");
4808 0 : return CE_Failure;
4809 : }
4810 :
4811 0 : CPLErr eErr = poBand->GetHistogram(dfMin, dfMax, nBuckets, panHistogramTemp,
4812 : bIncludeOutOfRange, bApproxOK,
4813 0 : pfnProgress, pProgressData);
4814 :
4815 0 : if (eErr == CE_None)
4816 : {
4817 0 : for (int i = 0; i < nBuckets; i++)
4818 : {
4819 0 : if (panHistogramTemp[i] > INT_MAX)
4820 : {
4821 0 : CPLError(CE_Warning, CPLE_AppDefined,
4822 : "Count for bucket %d, which is " CPL_FRMT_GUIB
4823 : " exceeds maximum 32 bit value",
4824 0 : i, panHistogramTemp[i]);
4825 0 : panHistogram[i] = INT_MAX;
4826 : }
4827 : else
4828 : {
4829 0 : panHistogram[i] = static_cast<int>(panHistogramTemp[i]);
4830 : }
4831 : }
4832 : }
4833 :
4834 0 : CPLFree(panHistogramTemp);
4835 :
4836 0 : return eErr;
4837 : }
4838 :
4839 : /************************************************************************/
4840 : /* GDALGetRasterHistogramEx() */
4841 : /************************************************************************/
4842 :
4843 : /**
4844 : * \brief Compute raster histogram.
4845 : *
4846 : * @see GDALRasterBand::GetHistogram()
4847 : *
4848 : */
4849 :
4850 26 : CPLErr CPL_STDCALL GDALGetRasterHistogramEx(
4851 : GDALRasterBandH hBand, double dfMin, double dfMax, int nBuckets,
4852 : GUIntBig *panHistogram, int bIncludeOutOfRange, int bApproxOK,
4853 : GDALProgressFunc pfnProgress, void *pProgressData)
4854 :
4855 : {
4856 26 : VALIDATE_POINTER1(hBand, "GDALGetRasterHistogramEx", CE_Failure);
4857 26 : VALIDATE_POINTER1(panHistogram, "GDALGetRasterHistogramEx", CE_Failure);
4858 :
4859 26 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
4860 :
4861 26 : return poBand->GetHistogram(dfMin, dfMax, nBuckets, panHistogram,
4862 : bIncludeOutOfRange, bApproxOK, pfnProgress,
4863 26 : pProgressData);
4864 : }
4865 :
4866 : /************************************************************************/
4867 : /* GetDefaultHistogram() */
4868 : /************************************************************************/
4869 :
4870 : /**
4871 : * \brief Fetch default raster histogram.
4872 : *
4873 : * The default method in GDALRasterBand will compute a default histogram. This
4874 : * method is overridden by derived classes (such as GDALPamRasterBand,
4875 : * VRTDataset, HFADataset...) that may be able to fetch efficiently an already
4876 : * stored histogram.
4877 : *
4878 : * This method is the same as the C functions GDALGetDefaultHistogram() and
4879 : * GDALGetDefaultHistogramEx().
4880 : *
4881 : * @param pdfMin pointer to double value that will contain the lower bound of
4882 : * the histogram.
4883 : * @param pdfMax pointer to double value that will contain the upper bound of
4884 : * the histogram.
4885 : * @param pnBuckets pointer to int value that will contain the number of buckets
4886 : * in *ppanHistogram.
4887 : * @param ppanHistogram pointer to array into which the histogram totals are
4888 : * placed. To be freed with VSIFree
4889 : * @param bForce TRUE to force the computation. If FALSE and no default
4890 : * histogram is available, the method will return CE_Warning
4891 : * @param pfnProgress function to report progress to completion.
4892 : * @param pProgressData application data to pass to pfnProgress.
4893 : *
4894 : * @return CE_None on success, CE_Failure if something goes wrong, or
4895 : * CE_Warning if no default histogram is available.
4896 : */
4897 :
4898 27 : CPLErr GDALRasterBand::GetDefaultHistogram(double *pdfMin, double *pdfMax,
4899 : int *pnBuckets,
4900 : GUIntBig **ppanHistogram, int bForce,
4901 : GDALProgressFunc pfnProgress,
4902 : void *pProgressData)
4903 :
4904 : {
4905 27 : CPLAssert(nullptr != pnBuckets);
4906 27 : CPLAssert(nullptr != ppanHistogram);
4907 27 : CPLAssert(nullptr != pdfMin);
4908 27 : CPLAssert(nullptr != pdfMax);
4909 :
4910 27 : *pnBuckets = 0;
4911 27 : *ppanHistogram = nullptr;
4912 :
4913 27 : if (!bForce)
4914 5 : return CE_Warning;
4915 :
4916 22 : int nBuckets = 256;
4917 :
4918 22 : bool bSignedByte = false;
4919 22 : if (eDataType == GDT_Byte)
4920 : {
4921 20 : EnablePixelTypeSignedByteWarning(false);
4922 : const char *pszPixelType =
4923 20 : GetMetadataItem("PIXELTYPE", "IMAGE_STRUCTURE");
4924 20 : EnablePixelTypeSignedByteWarning(true);
4925 20 : bSignedByte =
4926 20 : pszPixelType != nullptr && EQUAL(pszPixelType, "SIGNEDBYTE");
4927 : }
4928 :
4929 22 : if (GetRasterDataType() == GDT_Byte && !bSignedByte)
4930 : {
4931 20 : *pdfMin = -0.5;
4932 20 : *pdfMax = 255.5;
4933 : }
4934 2 : else if (GetRasterDataType() == GDT_Int8)
4935 : {
4936 1 : *pdfMin = -128 - 0.5;
4937 1 : *pdfMax = 127 + 0.5;
4938 : }
4939 : else
4940 : {
4941 :
4942 : const CPLErr eErr =
4943 1 : GetStatistics(TRUE, TRUE, pdfMin, pdfMax, nullptr, nullptr);
4944 1 : if (eErr != CE_None)
4945 0 : return eErr;
4946 1 : if (*pdfMin == *pdfMax)
4947 : {
4948 1 : nBuckets = 1;
4949 1 : *pdfMin -= 0.5;
4950 1 : *pdfMax += 0.5;
4951 : }
4952 : else
4953 : {
4954 0 : const double dfHalfBucket =
4955 0 : (*pdfMax - *pdfMin) / (2 * (nBuckets - 1));
4956 0 : *pdfMin -= dfHalfBucket;
4957 0 : *pdfMax += dfHalfBucket;
4958 : }
4959 : }
4960 :
4961 22 : *ppanHistogram =
4962 22 : static_cast<GUIntBig *>(VSICalloc(sizeof(GUIntBig), nBuckets));
4963 22 : if (*ppanHistogram == nullptr)
4964 : {
4965 0 : ReportError(CE_Failure, CPLE_OutOfMemory,
4966 : "Out of memory in InitBlockInfo().");
4967 0 : return CE_Failure;
4968 : }
4969 :
4970 22 : *pnBuckets = nBuckets;
4971 44 : CPLErr eErr = GetHistogram(*pdfMin, *pdfMax, *pnBuckets, *ppanHistogram,
4972 22 : TRUE, FALSE, pfnProgress, pProgressData);
4973 22 : if (eErr != CE_None)
4974 : {
4975 0 : *pnBuckets = 0;
4976 : }
4977 22 : return eErr;
4978 : }
4979 :
4980 : /************************************************************************/
4981 : /* GDALGetDefaultHistogram() */
4982 : /************************************************************************/
4983 :
4984 : /**
4985 : * \brief Fetch default raster histogram.
4986 : *
4987 : * Use GDALGetRasterHistogramEx() instead to get correct counts for values
4988 : * exceeding 2 billion.
4989 : *
4990 : * @see GDALRasterBand::GDALGetDefaultHistogram()
4991 : * @see GDALGetRasterHistogramEx()
4992 : */
4993 :
4994 0 : CPLErr CPL_STDCALL GDALGetDefaultHistogram(GDALRasterBandH hBand,
4995 : double *pdfMin, double *pdfMax,
4996 : int *pnBuckets, int **ppanHistogram,
4997 : int bForce,
4998 : GDALProgressFunc pfnProgress,
4999 : void *pProgressData)
5000 :
5001 : {
5002 0 : VALIDATE_POINTER1(hBand, "GDALGetDefaultHistogram", CE_Failure);
5003 0 : VALIDATE_POINTER1(pdfMin, "GDALGetDefaultHistogram", CE_Failure);
5004 0 : VALIDATE_POINTER1(pdfMax, "GDALGetDefaultHistogram", CE_Failure);
5005 0 : VALIDATE_POINTER1(pnBuckets, "GDALGetDefaultHistogram", CE_Failure);
5006 0 : VALIDATE_POINTER1(ppanHistogram, "GDALGetDefaultHistogram", CE_Failure);
5007 :
5008 0 : GDALRasterBand *const poBand = GDALRasterBand::FromHandle(hBand);
5009 0 : GUIntBig *panHistogramTemp = nullptr;
5010 0 : CPLErr eErr = poBand->GetDefaultHistogram(pdfMin, pdfMax, pnBuckets,
5011 : &panHistogramTemp, bForce,
5012 0 : pfnProgress, pProgressData);
5013 0 : if (eErr == CE_None)
5014 : {
5015 0 : const int nBuckets = *pnBuckets;
5016 0 : *ppanHistogram = static_cast<int *>(VSIMalloc2(sizeof(int), nBuckets));
5017 0 : if (*ppanHistogram == nullptr)
5018 : {
5019 0 : poBand->ReportError(CE_Failure, CPLE_OutOfMemory,
5020 : "Out of memory in GDALGetDefaultHistogram().");
5021 0 : VSIFree(panHistogramTemp);
5022 0 : return CE_Failure;
5023 : }
5024 :
5025 0 : for (int i = 0; i < nBuckets; ++i)
5026 : {
5027 0 : if (panHistogramTemp[i] > INT_MAX)
5028 : {
5029 0 : CPLError(CE_Warning, CPLE_AppDefined,
5030 : "Count for bucket %d, which is " CPL_FRMT_GUIB
5031 : " exceeds maximum 32 bit value",
5032 0 : i, panHistogramTemp[i]);
5033 0 : (*ppanHistogram)[i] = INT_MAX;
5034 : }
5035 : else
5036 : {
5037 0 : (*ppanHistogram)[i] = static_cast<int>(panHistogramTemp[i]);
5038 : }
5039 : }
5040 :
5041 0 : CPLFree(panHistogramTemp);
5042 : }
5043 : else
5044 : {
5045 0 : *ppanHistogram = nullptr;
5046 : }
5047 :
5048 0 : return eErr;
5049 : }
5050 :
5051 : /************************************************************************/
5052 : /* GDALGetDefaultHistogramEx() */
5053 : /************************************************************************/
5054 :
5055 : /**
5056 : * \brief Fetch default raster histogram.
5057 : *
5058 : * @see GDALRasterBand::GetDefaultHistogram()
5059 : *
5060 : */
5061 :
5062 : CPLErr CPL_STDCALL
5063 30 : GDALGetDefaultHistogramEx(GDALRasterBandH hBand, double *pdfMin, double *pdfMax,
5064 : int *pnBuckets, GUIntBig **ppanHistogram, int bForce,
5065 : GDALProgressFunc pfnProgress, void *pProgressData)
5066 :
5067 : {
5068 30 : VALIDATE_POINTER1(hBand, "GDALGetDefaultHistogram", CE_Failure);
5069 30 : VALIDATE_POINTER1(pdfMin, "GDALGetDefaultHistogram", CE_Failure);
5070 30 : VALIDATE_POINTER1(pdfMax, "GDALGetDefaultHistogram", CE_Failure);
5071 30 : VALIDATE_POINTER1(pnBuckets, "GDALGetDefaultHistogram", CE_Failure);
5072 30 : VALIDATE_POINTER1(ppanHistogram, "GDALGetDefaultHistogram", CE_Failure);
5073 :
5074 30 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
5075 30 : return poBand->GetDefaultHistogram(pdfMin, pdfMax, pnBuckets, ppanHistogram,
5076 30 : bForce, pfnProgress, pProgressData);
5077 : }
5078 :
5079 : /************************************************************************/
5080 : /* AdviseRead() */
5081 : /************************************************************************/
5082 :
5083 : /**
5084 : * \fn GDALRasterBand::AdviseRead(int,int,int,int,int,int,GDALDataType,char**)
5085 : * \brief Advise driver of upcoming read requests.
5086 : *
5087 : * Some GDAL drivers operate more efficiently if they know in advance what
5088 : * set of upcoming read requests will be made. The AdviseRead() method allows
5089 : * an application to notify the driver of the region of interest,
5090 : * and at what resolution the region will be read.
5091 : *
5092 : * Many drivers just ignore the AdviseRead() call, but it can dramatically
5093 : * accelerate access via some drivers.
5094 : *
5095 : * Depending on call paths, drivers might receive several calls to
5096 : * AdviseRead() with the same parameters.
5097 : *
5098 : * @param nXOff The pixel offset to the top left corner of the region
5099 : * of the band to be accessed. This would be zero to start from the left side.
5100 : *
5101 : * @param nYOff The line offset to the top left corner of the region
5102 : * of the band to be accessed. This would be zero to start from the top.
5103 : *
5104 : * @param nXSize The width of the region of the band to be accessed in pixels.
5105 : *
5106 : * @param nYSize The height of the region of the band to be accessed in lines.
5107 : *
5108 : * @param nBufXSize the width of the buffer image into which the desired region
5109 : * is to be read, or from which it is to be written.
5110 : *
5111 : * @param nBufYSize the height of the buffer image into which the desired
5112 : * region is to be read, or from which it is to be written.
5113 : *
5114 : * @param eBufType the type of the pixel values in the pData data buffer. The
5115 : * pixel values will automatically be translated to/from the GDALRasterBand
5116 : * data type as needed.
5117 : *
5118 : * @param papszOptions a list of name=value strings with special control
5119 : * options. Normally this is NULL.
5120 : *
5121 : * @return CE_Failure if the request is invalid and CE_None if it works or
5122 : * is ignored.
5123 : */
5124 :
5125 : /**/
5126 : /**/
5127 :
5128 113762 : CPLErr GDALRasterBand::AdviseRead(int /*nXOff*/, int /*nYOff*/, int /*nXSize*/,
5129 : int /*nYSize*/, int /*nBufXSize*/,
5130 : int /*nBufYSize*/, GDALDataType /*eBufType*/,
5131 : char ** /*papszOptions*/)
5132 : {
5133 113762 : return CE_None;
5134 : }
5135 :
5136 : /************************************************************************/
5137 : /* GDALRasterAdviseRead() */
5138 : /************************************************************************/
5139 :
5140 : /**
5141 : * \brief Advise driver of upcoming read requests.
5142 : *
5143 : * @see GDALRasterBand::AdviseRead()
5144 : */
5145 :
5146 2 : CPLErr CPL_STDCALL GDALRasterAdviseRead(GDALRasterBandH hBand, int nXOff,
5147 : int nYOff, int nXSize, int nYSize,
5148 : int nBufXSize, int nBufYSize,
5149 : GDALDataType eDT,
5150 : CSLConstList papszOptions)
5151 :
5152 : {
5153 2 : VALIDATE_POINTER1(hBand, "GDALRasterAdviseRead", CE_Failure);
5154 :
5155 2 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
5156 2 : return poBand->AdviseRead(nXOff, nYOff, nXSize, nYSize, nBufXSize,
5157 : nBufYSize, eDT,
5158 2 : const_cast<char **>(papszOptions));
5159 : }
5160 :
5161 : /************************************************************************/
5162 : /* GetStatistics() */
5163 : /************************************************************************/
5164 :
5165 : /**
5166 : * \brief Fetch image statistics.
5167 : *
5168 : * Returns the minimum, maximum, mean and standard deviation of all
5169 : * pixel values in this band. If approximate statistics are sufficient,
5170 : * the bApproxOK flag can be set to true in which case overviews, or a
5171 : * subset of image tiles may be used in computing the statistics.
5172 : *
5173 : * If bForce is FALSE results will only be returned if it can be done
5174 : * quickly (i.e. without scanning the image, typically by using pre-existing
5175 : * STATISTICS_xxx metadata items). If bForce is FALSE and results cannot be
5176 : * returned efficiently, the method will return CE_Warning but no warning will
5177 : * be issued. This is a non-standard use of the CE_Warning return value
5178 : * to indicate "nothing done".
5179 : *
5180 : * If bForce is TRUE, and results are quickly available without scanning the
5181 : * image, they will be used. If bForce is TRUE and results are not quickly
5182 : * available, GetStatistics() forwards the computation to ComputeStatistics(),
5183 : * which will scan the image.
5184 : *
5185 : * To always force recomputation of statistics, use ComputeStatistics() instead
5186 : * of this method.
5187 : *
5188 : * Note that file formats using PAM (Persistent Auxiliary Metadata) services
5189 : * will generally cache statistics in the .pam file allowing fast fetch
5190 : * after the first request.
5191 : *
5192 : * This method is the same as the C function GDALGetRasterStatistics().
5193 : *
5194 : * @param bApproxOK If TRUE statistics may be computed based on overviews
5195 : * or a subset of all tiles.
5196 : *
5197 : * @param bForce If FALSE statistics will only be returned if it can
5198 : * be done without rescanning the image. If TRUE, statistics computation will
5199 : * be forced if pre-existing values are not quickly available.
5200 : *
5201 : * @param pdfMin Location into which to load image minimum (may be NULL).
5202 : *
5203 : * @param pdfMax Location into which to load image maximum (may be NULL).-
5204 : *
5205 : * @param pdfMean Location into which to load image mean (may be NULL).
5206 : *
5207 : * @param pdfStdDev Location into which to load image standard deviation
5208 : * (may be NULL).
5209 : *
5210 : * @return CE_None on success, CE_Warning if no values returned,
5211 : * CE_Failure if an error occurs.
5212 : */
5213 :
5214 666 : CPLErr GDALRasterBand::GetStatistics(int bApproxOK, int bForce, double *pdfMin,
5215 : double *pdfMax, double *pdfMean,
5216 : double *pdfStdDev)
5217 :
5218 : {
5219 : /* -------------------------------------------------------------------- */
5220 : /* Do we already have metadata items for the requested values? */
5221 : /* -------------------------------------------------------------------- */
5222 1332 : if ((pdfMin == nullptr ||
5223 666 : GetMetadataItem("STATISTICS_MINIMUM") != nullptr) &&
5224 205 : (pdfMax == nullptr ||
5225 205 : GetMetadataItem("STATISTICS_MAXIMUM") != nullptr) &&
5226 1537 : (pdfMean == nullptr || GetMetadataItem("STATISTICS_MEAN") != nullptr) &&
5227 205 : (pdfStdDev == nullptr ||
5228 205 : GetMetadataItem("STATISTICS_STDDEV") != nullptr))
5229 : {
5230 205 : if (!(GetMetadataItem("STATISTICS_APPROXIMATE") && !bApproxOK))
5231 : {
5232 198 : if (pdfMin != nullptr)
5233 198 : *pdfMin = CPLAtofM(GetMetadataItem("STATISTICS_MINIMUM"));
5234 198 : if (pdfMax != nullptr)
5235 198 : *pdfMax = CPLAtofM(GetMetadataItem("STATISTICS_MAXIMUM"));
5236 198 : if (pdfMean != nullptr)
5237 198 : *pdfMean = CPLAtofM(GetMetadataItem("STATISTICS_MEAN"));
5238 198 : if (pdfStdDev != nullptr)
5239 198 : *pdfStdDev = CPLAtofM(GetMetadataItem("STATISTICS_STDDEV"));
5240 :
5241 198 : return CE_None;
5242 : }
5243 : }
5244 :
5245 : /* -------------------------------------------------------------------- */
5246 : /* Does the driver already know the min/max? */
5247 : /* -------------------------------------------------------------------- */
5248 468 : if (bApproxOK && pdfMean == nullptr && pdfStdDev == nullptr)
5249 : {
5250 1 : int bSuccessMin = FALSE;
5251 1 : int bSuccessMax = FALSE;
5252 :
5253 1 : const double dfMin = GetMinimum(&bSuccessMin);
5254 1 : const double dfMax = GetMaximum(&bSuccessMax);
5255 :
5256 1 : if (bSuccessMin && bSuccessMax)
5257 : {
5258 0 : if (pdfMin != nullptr)
5259 0 : *pdfMin = dfMin;
5260 0 : if (pdfMax != nullptr)
5261 0 : *pdfMax = dfMax;
5262 0 : return CE_None;
5263 : }
5264 : }
5265 :
5266 : /* -------------------------------------------------------------------- */
5267 : /* Either return without results, or force computation. */
5268 : /* -------------------------------------------------------------------- */
5269 468 : if (!bForce)
5270 186 : return CE_Warning;
5271 : else
5272 282 : return ComputeStatistics(bApproxOK, pdfMin, pdfMax, pdfMean, pdfStdDev,
5273 282 : GDALDummyProgress, nullptr);
5274 : }
5275 :
5276 : /************************************************************************/
5277 : /* GDALGetRasterStatistics() */
5278 : /************************************************************************/
5279 :
5280 : /**
5281 : * \brief Fetch image statistics.
5282 : *
5283 : * @see GDALRasterBand::GetStatistics()
5284 : */
5285 :
5286 314 : CPLErr CPL_STDCALL GDALGetRasterStatistics(GDALRasterBandH hBand, int bApproxOK,
5287 : int bForce, double *pdfMin,
5288 : double *pdfMax, double *pdfMean,
5289 : double *pdfStdDev)
5290 :
5291 : {
5292 314 : VALIDATE_POINTER1(hBand, "GDALGetRasterStatistics", CE_Failure);
5293 :
5294 314 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
5295 314 : return poBand->GetStatistics(bApproxOK, bForce, pdfMin, pdfMax, pdfMean,
5296 314 : pdfStdDev);
5297 : }
5298 :
5299 : /************************************************************************/
5300 : /* GDALUInt128 */
5301 : /************************************************************************/
5302 :
5303 : #ifdef HAVE_UINT128_T
5304 : class GDALUInt128
5305 : {
5306 : __uint128_t val;
5307 :
5308 1158 : explicit GDALUInt128(__uint128_t valIn) : val(valIn)
5309 : {
5310 1158 : }
5311 :
5312 : public:
5313 774 : static GDALUInt128 Mul(GUIntBig first, GUIntBig second)
5314 : {
5315 : // Evaluates to just a single mul on x86_64
5316 774 : return GDALUInt128(static_cast<__uint128_t>(first) * second);
5317 : }
5318 :
5319 386 : GDALUInt128 operator-(const GDALUInt128 &other) const
5320 : {
5321 386 : return GDALUInt128(val - other.val);
5322 : }
5323 :
5324 378 : operator double() const
5325 : {
5326 378 : return static_cast<double>(val);
5327 : }
5328 : };
5329 : #else
5330 :
5331 : #if defined(_MSC_VER) && defined(_M_X64)
5332 : #include <intrin.h>
5333 : #endif
5334 :
5335 : class GDALUInt128
5336 : {
5337 : GUIntBig low, high;
5338 :
5339 : GDALUInt128(GUIntBig lowIn, GUIntBig highIn) : low(lowIn), high(highIn)
5340 : {
5341 : }
5342 :
5343 : public:
5344 : static GDALUInt128 Mul(GUIntBig first, GUIntBig second)
5345 : {
5346 : #if defined(_MSC_VER) && defined(_M_X64)
5347 : GUIntBig highRes;
5348 : GUIntBig lowRes = _umul128(first, second, &highRes);
5349 : return GDALUInt128(lowRes, highRes);
5350 : #else
5351 : const GUInt32 firstLow = static_cast<GUInt32>(first);
5352 : const GUInt32 firstHigh = static_cast<GUInt32>(first >> 32);
5353 : const GUInt32 secondLow = static_cast<GUInt32>(second);
5354 : const GUInt32 secondHigh = static_cast<GUInt32>(second >> 32);
5355 : GUIntBig highRes = 0;
5356 : const GUIntBig firstLowSecondHigh =
5357 : static_cast<GUIntBig>(firstLow) * secondHigh;
5358 : const GUIntBig firstHighSecondLow =
5359 : static_cast<GUIntBig>(firstHigh) * secondLow;
5360 : const GUIntBig middleTerm = firstLowSecondHigh + firstHighSecondLow;
5361 : if (middleTerm < firstLowSecondHigh) // check for overflow
5362 : highRes += static_cast<GUIntBig>(1) << 32;
5363 : const GUIntBig firstLowSecondLow =
5364 : static_cast<GUIntBig>(firstLow) * secondLow;
5365 : GUIntBig lowRes = firstLowSecondLow + (middleTerm << 32);
5366 : if (lowRes < firstLowSecondLow) // check for overflow
5367 : highRes++;
5368 : highRes +=
5369 : (middleTerm >> 32) + static_cast<GUIntBig>(firstHigh) * secondHigh;
5370 : return GDALUInt128(lowRes, highRes);
5371 : #endif
5372 : }
5373 :
5374 : GDALUInt128 operator-(const GDALUInt128 &other) const
5375 : {
5376 : GUIntBig highRes = high - other.high;
5377 : GUIntBig lowRes = low - other.low;
5378 : if (lowRes > low) // check for underflow
5379 : --highRes;
5380 : return GDALUInt128(lowRes, highRes);
5381 : }
5382 :
5383 : operator double() const
5384 : {
5385 : const double twoPow64 = 18446744073709551616.0;
5386 : return high * twoPow64 + low;
5387 : }
5388 : };
5389 : #endif
5390 :
5391 : /************************************************************************/
5392 : /* ComputeStatisticsInternal() */
5393 : /************************************************************************/
5394 :
5395 : // Just to make coverity scan happy w.r.t overflow_before_widen, but otherwise
5396 : // not needed.
5397 : #define static_cast_for_coverity_scan static_cast
5398 :
5399 : // The rationale for below optimizations is detailed in statistics.txt
5400 :
5401 : // Use with T = GByte or GUInt16 only !
5402 : template <class T, bool COMPUTE_OTHER_STATS>
5403 : struct ComputeStatisticsInternalGeneric
5404 : {
5405 249 : static void f(int nXCheck, int nBlockXSize, int nYCheck, const T *pData,
5406 : bool bHasNoData, GUInt32 nNoDataValue, GUInt32 &nMin,
5407 : GUInt32 &nMax, GUIntBig &nSum, GUIntBig &nSumSquare,
5408 : GUIntBig &nSampleCount, GUIntBig &nValidCount)
5409 : {
5410 : static_assert(std::is_same<T, GByte>::value ||
5411 : std::is_same<T, GUInt16>::value,
5412 : "bad type for T");
5413 249 : if (bHasNoData)
5414 : {
5415 : // General case
5416 606 : for (int iY = 0; iY < nYCheck; iY++)
5417 : {
5418 161751 : for (int iX = 0; iX < nXCheck; iX++)
5419 : {
5420 161268 : const GPtrDiff_t iOffset =
5421 161268 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
5422 161268 : const GUInt32 nValue = pData[iOffset];
5423 161268 : if (nValue == nNoDataValue)
5424 318 : continue;
5425 160950 : if (nValue < nMin)
5426 34 : nMin = nValue;
5427 160950 : if (nValue > nMax)
5428 71 : nMax = nValue;
5429 : if constexpr (COMPUTE_OTHER_STATS)
5430 : {
5431 159314 : nValidCount++;
5432 159314 : nSum += nValue;
5433 159314 : nSumSquare +=
5434 159314 : static_cast_for_coverity_scan<GUIntBig>(nValue) *
5435 159314 : nValue;
5436 : }
5437 : }
5438 : }
5439 : if constexpr (COMPUTE_OTHER_STATS)
5440 : {
5441 40 : nSampleCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
5442 : }
5443 : }
5444 144 : else if (nMin == std::numeric_limits<T>::lowest() &&
5445 18 : nMax == std::numeric_limits<T>::max())
5446 : {
5447 : if constexpr (COMPUTE_OTHER_STATS)
5448 : {
5449 : // Optimization when there is no nodata and we know we have already
5450 : // reached the min and max
5451 416 : for (int iY = 0; iY < nYCheck; iY++)
5452 : {
5453 : int iX;
5454 2004 : for (iX = 0; iX + 3 < nXCheck; iX += 4)
5455 : {
5456 1600 : const GPtrDiff_t iOffset =
5457 1600 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
5458 1600 : const GUIntBig nValue = pData[iOffset];
5459 1600 : const GUIntBig nValue2 = pData[iOffset + 1];
5460 1600 : const GUIntBig nValue3 = pData[iOffset + 2];
5461 1600 : const GUIntBig nValue4 = pData[iOffset + 3];
5462 1600 : nSum += nValue;
5463 1600 : nSumSquare += nValue * nValue;
5464 1600 : nSum += nValue2;
5465 1600 : nSumSquare += nValue2 * nValue2;
5466 1600 : nSum += nValue3;
5467 1600 : nSumSquare += nValue3 * nValue3;
5468 1600 : nSum += nValue4;
5469 1600 : nSumSquare += nValue4 * nValue4;
5470 : }
5471 414 : for (; iX < nXCheck; ++iX)
5472 : {
5473 10 : const GPtrDiff_t iOffset =
5474 10 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
5475 10 : const GUIntBig nValue = pData[iOffset];
5476 10 : nSum += nValue;
5477 10 : nSumSquare += nValue * nValue;
5478 : }
5479 : }
5480 12 : nSampleCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
5481 12 : nValidCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
5482 : }
5483 : }
5484 : else
5485 : {
5486 6019 : for (int iY = 0; iY < nYCheck; iY++)
5487 : {
5488 : int iX;
5489 1270510 : for (iX = 0; iX + 1 < nXCheck; iX += 2)
5490 : {
5491 1264611 : const GPtrDiff_t iOffset =
5492 1264611 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
5493 1264611 : const GUInt32 nValue = pData[iOffset];
5494 1264611 : const GUInt32 nValue2 = pData[iOffset + 1];
5495 1264611 : if (nValue < nValue2)
5496 : {
5497 2324 : if (nValue < nMin)
5498 50 : nMin = nValue;
5499 2324 : if (nValue2 > nMax)
5500 118 : nMax = nValue2;
5501 : }
5502 : else
5503 : {
5504 1262285 : if (nValue2 < nMin)
5505 67 : nMin = nValue2;
5506 1262285 : if (nValue > nMax)
5507 216 : nMax = nValue;
5508 : }
5509 : if constexpr (COMPUTE_OTHER_STATS)
5510 : {
5511 1257560 : nSum += nValue;
5512 1257560 : nSumSquare +=
5513 1257560 : static_cast_for_coverity_scan<GUIntBig>(nValue) *
5514 1257560 : nValue;
5515 1257560 : nSum += nValue2;
5516 1257560 : nSumSquare +=
5517 1257560 : static_cast_for_coverity_scan<GUIntBig>(nValue2) *
5518 1257560 : nValue2;
5519 : }
5520 : }
5521 5905 : if (iX < nXCheck)
5522 : {
5523 27 : const GPtrDiff_t iOffset =
5524 27 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
5525 27 : const GUInt32 nValue = pData[iOffset];
5526 27 : if (nValue < nMin)
5527 19 : nMin = nValue;
5528 27 : if (nValue > nMax)
5529 20 : nMax = nValue;
5530 : if (COMPUTE_OTHER_STATS)
5531 : {
5532 19 : nSum += nValue;
5533 19 : nSumSquare +=
5534 19 : static_cast_for_coverity_scan<GUIntBig>(nValue) *
5535 19 : nValue;
5536 : }
5537 : }
5538 : }
5539 : if constexpr (COMPUTE_OTHER_STATS)
5540 : {
5541 60 : nSampleCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
5542 60 : nValidCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
5543 : }
5544 : }
5545 249 : }
5546 : };
5547 :
5548 : // Specialization for Byte that is mostly 32 bit friendly as it avoids
5549 : // using 64bit accumulators in internal loops. This also slightly helps in
5550 : // 64bit mode.
5551 : template <bool COMPUTE_OTHER_STATS>
5552 : struct ComputeStatisticsInternalGeneric<GByte, COMPUTE_OTHER_STATS>
5553 : {
5554 13740 : static void f(int nXCheck, int nBlockXSize, int nYCheck, const GByte *pData,
5555 : bool bHasNoData, GUInt32 nNoDataValue, GUInt32 &nMin,
5556 : GUInt32 &nMax, GUIntBig &nSum, GUIntBig &nSumSquare,
5557 : GUIntBig &nSampleCount, GUIntBig &nValidCount)
5558 : {
5559 13740 : int nOuterLoops = nXCheck / 65536;
5560 13740 : if (nXCheck % 65536)
5561 13740 : nOuterLoops++;
5562 :
5563 13740 : if (bHasNoData)
5564 : {
5565 : // General case
5566 23755 : for (int iY = 0; iY < nYCheck; iY++)
5567 : {
5568 13179 : int iX = 0;
5569 26358 : for (int k = 0; k < nOuterLoops; k++)
5570 : {
5571 13179 : int iMax = iX + 65536;
5572 13179 : if (iMax > nXCheck)
5573 13179 : iMax = nXCheck;
5574 13179 : GUInt32 nSum32bit = 0;
5575 13179 : GUInt32 nSumSquare32bit = 0;
5576 13179 : GUInt32 nValidCount32bit = 0;
5577 13179 : GUInt32 nSampleCount32bit = 0;
5578 20722708 : for (; iX < iMax; iX++)
5579 : {
5580 20709578 : const GPtrDiff_t iOffset =
5581 20709578 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
5582 20709578 : const GUInt32 nValue = pData[iOffset];
5583 :
5584 20709578 : nSampleCount32bit++;
5585 20709578 : if (nValue == nNoDataValue)
5586 20353425 : continue;
5587 356098 : if (nValue < nMin)
5588 371 : nMin = nValue;
5589 356098 : if (nValue > nMax)
5590 834 : nMax = nValue;
5591 : if constexpr (COMPUTE_OTHER_STATS)
5592 : {
5593 32353 : nValidCount32bit++;
5594 32353 : nSum32bit += nValue;
5595 32353 : nSumSquare32bit += nValue * nValue;
5596 : }
5597 : }
5598 : if constexpr (COMPUTE_OTHER_STATS)
5599 : {
5600 930 : nSampleCount += nSampleCount32bit;
5601 930 : nValidCount += nValidCount32bit;
5602 930 : nSum += nSum32bit;
5603 930 : nSumSquare += nSumSquare32bit;
5604 : }
5605 : }
5606 : }
5607 : }
5608 3164 : else if (nMin == 0 && nMax == 255)
5609 : {
5610 : if constexpr (COMPUTE_OTHER_STATS)
5611 : {
5612 : // Optimization when there is no nodata and we know we have already
5613 : // reached the min and max
5614 2850 : for (int iY = 0; iY < nYCheck; iY++)
5615 : {
5616 2818 : int iX = 0;
5617 5636 : for (int k = 0; k < nOuterLoops; k++)
5618 : {
5619 2818 : int iMax = iX + 65536;
5620 2818 : if (iMax > nXCheck)
5621 2818 : iMax = nXCheck;
5622 2818 : GUInt32 nSum32bit = 0;
5623 2818 : GUInt32 nSumSquare32bit = 0;
5624 177298 : for (; iX + 3 < iMax; iX += 4)
5625 : {
5626 174480 : const GPtrDiff_t iOffset =
5627 174480 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
5628 174480 : const GUInt32 nValue = pData[iOffset];
5629 174480 : const GUInt32 nValue2 = pData[iOffset + 1];
5630 174480 : const GUInt32 nValue3 = pData[iOffset + 2];
5631 174480 : const GUInt32 nValue4 = pData[iOffset + 3];
5632 174480 : nSum32bit += nValue;
5633 174480 : nSumSquare32bit += nValue * nValue;
5634 174480 : nSum32bit += nValue2;
5635 174480 : nSumSquare32bit += nValue2 * nValue2;
5636 174480 : nSum32bit += nValue3;
5637 174480 : nSumSquare32bit += nValue3 * nValue3;
5638 174480 : nSum32bit += nValue4;
5639 174480 : nSumSquare32bit += nValue4 * nValue4;
5640 : }
5641 2818 : nSum += nSum32bit;
5642 2818 : nSumSquare += nSumSquare32bit;
5643 : }
5644 2824 : for (; iX < nXCheck; ++iX)
5645 : {
5646 6 : const GPtrDiff_t iOffset =
5647 6 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
5648 6 : const GUIntBig nValue = pData[iOffset];
5649 6 : nSum += nValue;
5650 6 : nSumSquare += nValue * nValue;
5651 : }
5652 : }
5653 32 : nSampleCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
5654 32 : nValidCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
5655 32 : }
5656 : }
5657 : else
5658 : {
5659 8460 : for (int iY = 0; iY < nYCheck; iY++)
5660 : {
5661 5328 : int iX = 0;
5662 10656 : for (int k = 0; k < nOuterLoops; k++)
5663 : {
5664 5328 : int iMax = iX + 65536;
5665 5328 : if (iMax > nXCheck)
5666 5327 : iMax = nXCheck;
5667 5328 : GUInt32 nSum32bit = 0;
5668 5328 : GUInt32 nSumSquare32bit = 0;
5669 284976 : for (; iX + 1 < iMax; iX += 2)
5670 : {
5671 279648 : const GPtrDiff_t iOffset =
5672 279648 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
5673 279648 : const GUInt32 nValue = pData[iOffset];
5674 279648 : const GUInt32 nValue2 = pData[iOffset + 1];
5675 279648 : if (nValue < nValue2)
5676 : {
5677 8109 : if (nValue < nMin)
5678 233 : nMin = nValue;
5679 8109 : if (nValue2 > nMax)
5680 219 : nMax = nValue2;
5681 : }
5682 : else
5683 : {
5684 271539 : if (nValue2 < nMin)
5685 363 : nMin = nValue2;
5686 271539 : if (nValue > nMax)
5687 833 : nMax = nValue;
5688 : }
5689 : if constexpr (COMPUTE_OTHER_STATS)
5690 : {
5691 257511 : nSum32bit += nValue;
5692 257511 : nSumSquare32bit += nValue * nValue;
5693 257511 : nSum32bit += nValue2;
5694 257511 : nSumSquare32bit += nValue2 * nValue2;
5695 : }
5696 : }
5697 : if constexpr (COMPUTE_OTHER_STATS)
5698 : {
5699 2142 : nSum += nSum32bit;
5700 2142 : nSumSquare += nSumSquare32bit;
5701 : }
5702 : }
5703 5328 : if (iX < nXCheck)
5704 : {
5705 1529 : const GPtrDiff_t iOffset =
5706 1529 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
5707 1529 : const GUInt32 nValue = pData[iOffset];
5708 1529 : if (nValue < nMin)
5709 117 : nMin = nValue;
5710 1529 : if (nValue > nMax)
5711 101 : nMax = nValue;
5712 : if constexpr (COMPUTE_OTHER_STATS)
5713 : {
5714 318 : nSum += nValue;
5715 318 : nSumSquare +=
5716 318 : static_cast_for_coverity_scan<GUIntBig>(nValue) *
5717 318 : nValue;
5718 : }
5719 : }
5720 : }
5721 : if constexpr (COMPUTE_OTHER_STATS)
5722 : {
5723 936 : nSampleCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
5724 936 : nValidCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
5725 : }
5726 : }
5727 13740 : }
5728 : };
5729 :
5730 : template <class T, bool COMPUTE_OTHER_STATS> struct ComputeStatisticsInternal
5731 : {
5732 : static void f(int nXCheck, int nBlockXSize, int nYCheck, const T *pData,
5733 : bool bHasNoData, GUInt32 nNoDataValue, GUInt32 &nMin,
5734 : GUInt32 &nMax, GUIntBig &nSum, GUIntBig &nSumSquare,
5735 : GUIntBig &nSampleCount, GUIntBig &nValidCount)
5736 : {
5737 : ComputeStatisticsInternalGeneric<T, COMPUTE_OTHER_STATS>::f(
5738 : nXCheck, nBlockXSize, nYCheck, pData, bHasNoData, nNoDataValue,
5739 : nMin, nMax, nSum, nSumSquare, nSampleCount, nValidCount);
5740 : }
5741 : };
5742 :
5743 : #if (defined(__x86_64__) || defined(_M_X64)) && \
5744 : (defined(__GNUC__) || defined(_MSC_VER))
5745 :
5746 : #include "gdal_avx2_emulation.hpp"
5747 :
5748 : #define ZERO256 GDALmm256_setzero_si256()
5749 :
5750 : template <bool COMPUTE_MIN, bool COMPUTE_MAX, bool COMPUTE_OTHER_STATS>
5751 : static void
5752 21346 : ComputeStatisticsByteNoNodata(GPtrDiff_t nBlockPixels,
5753 : // assumed to be aligned on 256 bits
5754 : const GByte *pData, GUInt32 &nMin, GUInt32 &nMax,
5755 : GUIntBig &nSum, GUIntBig &nSumSquare,
5756 : GUIntBig &nSampleCount, GUIntBig &nValidCount)
5757 : {
5758 : // 32-byte alignment may not be enforced by linker, so do it at hand
5759 : GByte
5760 : aby32ByteUnaligned[32 + 32 + 32 + (COMPUTE_OTHER_STATS ? 32 + 32 : 0)];
5761 21346 : GByte *paby32ByteAligned =
5762 : aby32ByteUnaligned +
5763 21346 : (32 - (reinterpret_cast<GUIntptr_t>(aby32ByteUnaligned) % 32));
5764 21346 : GByte *pabyMin = paby32ByteAligned;
5765 21346 : GByte *pabyMax = paby32ByteAligned + 32;
5766 21346 : GUInt32 *panSum =
5767 : COMPUTE_OTHER_STATS
5768 : ? reinterpret_cast<GUInt32 *>(paby32ByteAligned + 32 * 2)
5769 : : nullptr;
5770 21346 : GUInt32 *panSumSquare =
5771 : COMPUTE_OTHER_STATS
5772 : ? reinterpret_cast<GUInt32 *>(paby32ByteAligned + 32 * 3)
5773 : : nullptr;
5774 :
5775 21346 : CPLAssert((reinterpret_cast<uintptr_t>(pData) % 32) == 0);
5776 :
5777 21346 : GPtrDiff_t i = 0;
5778 : // Make sure that sumSquare can fit on uint32
5779 : // * 8 since we can hold 8 sums per vector register
5780 21346 : const int nMaxIterationsPerInnerLoop =
5781 : 8 * ((std::numeric_limits<GUInt32>::max() / (255 * 255)) & ~31);
5782 21346 : GPtrDiff_t nOuterLoops = nBlockPixels / nMaxIterationsPerInnerLoop;
5783 21346 : if ((nBlockPixels % nMaxIterationsPerInnerLoop) != 0)
5784 21346 : nOuterLoops++;
5785 :
5786 : GDALm256i ymm_min =
5787 21346 : GDALmm256_load_si256(reinterpret_cast<const GDALm256i *>(pData + i));
5788 21346 : GDALm256i ymm_max = ymm_min;
5789 21346 : [[maybe_unused]] const auto ymm_mask_8bits = GDALmm256_set1_epi16(0xFF);
5790 :
5791 42692 : for (GPtrDiff_t k = 0; k < nOuterLoops; k++)
5792 : {
5793 21346 : const auto iMax =
5794 21346 : std::min(nBlockPixels, i + nMaxIterationsPerInnerLoop);
5795 :
5796 : // holds 4 uint32 sums in [0], [2], [4] and [6]
5797 21346 : [[maybe_unused]] GDALm256i ymm_sum = ZERO256;
5798 : [[maybe_unused]] GDALm256i ymm_sumsquare =
5799 21346 : ZERO256; // holds 8 uint32 sums
5800 724785 : for (; i + 31 < iMax; i += 32)
5801 : {
5802 703439 : const GDALm256i ymm = GDALmm256_load_si256(
5803 703439 : reinterpret_cast<const GDALm256i *>(pData + i));
5804 : if (COMPUTE_MIN)
5805 : {
5806 243330 : ymm_min = GDALmm256_min_epu8(ymm_min, ymm);
5807 : }
5808 : if (COMPUTE_MAX)
5809 : {
5810 612140 : ymm_max = GDALmm256_max_epu8(ymm_max, ymm);
5811 : }
5812 :
5813 : if constexpr (COMPUTE_OTHER_STATS)
5814 : {
5815 : // Extract even-8bit values
5816 : const GDALm256i ymm_even =
5817 504167 : GDALmm256_and_si256(ymm, ymm_mask_8bits);
5818 : // Compute square of those 16 values as 32 bit result
5819 : // and add adjacent pairs
5820 : const GDALm256i ymm_even_square =
5821 504167 : GDALmm256_madd_epi16(ymm_even, ymm_even);
5822 : // Add to the sumsquare accumulator
5823 : ymm_sumsquare =
5824 504167 : GDALmm256_add_epi32(ymm_sumsquare, ymm_even_square);
5825 :
5826 : // Extract odd-8bit values
5827 504167 : const GDALm256i ymm_odd = GDALmm256_srli_epi16(ymm, 8);
5828 : const GDALm256i ymm_odd_square =
5829 504167 : GDALmm256_madd_epi16(ymm_odd, ymm_odd);
5830 : ymm_sumsquare =
5831 504167 : GDALmm256_add_epi32(ymm_sumsquare, ymm_odd_square);
5832 :
5833 : // Now compute the sums
5834 504167 : ymm_sum = GDALmm256_add_epi32(ymm_sum,
5835 : GDALmm256_sad_epu8(ymm, ZERO256));
5836 : }
5837 : }
5838 :
5839 : if constexpr (COMPUTE_OTHER_STATS)
5840 : {
5841 10677 : GDALmm256_store_si256(reinterpret_cast<GDALm256i *>(panSum),
5842 : ymm_sum);
5843 10677 : GDALmm256_store_si256(reinterpret_cast<GDALm256i *>(panSumSquare),
5844 : ymm_sumsquare);
5845 :
5846 10677 : nSum += panSum[0] + panSum[2] + panSum[4] + panSum[6];
5847 10677 : nSumSquare += static_cast<GUIntBig>(panSumSquare[0]) +
5848 10677 : panSumSquare[1] + panSumSquare[2] + panSumSquare[3] +
5849 10677 : panSumSquare[4] + panSumSquare[5] + panSumSquare[6] +
5850 : panSumSquare[7];
5851 : }
5852 : }
5853 :
5854 : if constexpr (COMPUTE_MIN)
5855 : {
5856 8449 : GDALmm256_store_si256(reinterpret_cast<GDALm256i *>(pabyMin), ymm_min);
5857 : }
5858 : if constexpr (COMPUTE_MAX)
5859 : {
5860 17334 : GDALmm256_store_si256(reinterpret_cast<GDALm256i *>(pabyMax), ymm_max);
5861 : }
5862 : if constexpr (COMPUTE_MIN || COMPUTE_MAX)
5863 : {
5864 589281 : for (int j = 0; j < 32; j++)
5865 : {
5866 : if constexpr (COMPUTE_MIN)
5867 : {
5868 270368 : if (pabyMin[j] < nMin)
5869 1236 : nMin = pabyMin[j];
5870 : }
5871 : if constexpr (COMPUTE_MAX)
5872 : {
5873 554688 : if (pabyMax[j] > nMax)
5874 1799 : nMax = pabyMax[j];
5875 : }
5876 : }
5877 : }
5878 :
5879 234348 : for (; i < nBlockPixels; i++)
5880 : {
5881 213002 : const GUInt32 nValue = pData[i];
5882 : if constexpr (COMPUTE_MIN)
5883 : {
5884 88326 : if (nValue < nMin)
5885 2 : nMin = nValue;
5886 : }
5887 : if constexpr (COMPUTE_MAX)
5888 : {
5889 210227 : if (nValue > nMax)
5890 1150 : nMax = nValue;
5891 : }
5892 : if constexpr (COMPUTE_OTHER_STATS)
5893 : {
5894 77203 : nSum += nValue;
5895 77203 : nSumSquare +=
5896 77203 : static_cast_for_coverity_scan<GUIntBig>(nValue) * nValue;
5897 : }
5898 : }
5899 :
5900 : if constexpr (COMPUTE_OTHER_STATS)
5901 : {
5902 10677 : nSampleCount += static_cast<GUIntBig>(nBlockPixels);
5903 10677 : nValidCount += static_cast<GUIntBig>(nBlockPixels);
5904 : }
5905 21346 : }
5906 :
5907 : // SSE2/AVX2 optimization for GByte case
5908 : // In pure SSE2, this relies on gdal_avx2_emulation.hpp. There is no
5909 : // penaly in using the emulation, because, given the mm256 intrinsics used here,
5910 : // there are strictly equivalent to 2 parallel SSE2 streams.
5911 : template <bool COMPUTE_OTHER_STATS>
5912 : struct ComputeStatisticsInternal<GByte, COMPUTE_OTHER_STATS>
5913 : {
5914 30254 : static void f(int nXCheck, int nBlockXSize, int nYCheck,
5915 : // assumed to be aligned on 256 bits
5916 : const GByte *pData, bool bHasNoData, GUInt32 nNoDataValue,
5917 : GUInt32 &nMin, GUInt32 &nMax, GUIntBig &nSum,
5918 : GUIntBig &nSumSquare, GUIntBig &nSampleCount,
5919 : GUIntBig &nValidCount)
5920 : {
5921 30254 : const auto nBlockPixels = static_cast<GPtrDiff_t>(nXCheck) * nYCheck;
5922 30254 : if (bHasNoData && nXCheck == nBlockXSize && nBlockPixels >= 32 &&
5923 11610 : nMin <= nMax)
5924 : {
5925 : // 32-byte alignment may not be enforced by linker, so do it at hand
5926 : GByte aby32ByteUnaligned[32 + 32 + 32 + 32 + 32];
5927 1492 : GByte *paby32ByteAligned =
5928 : aby32ByteUnaligned +
5929 1492 : (32 - (reinterpret_cast<GUIntptr_t>(aby32ByteUnaligned) % 32));
5930 1492 : GByte *pabyMin = paby32ByteAligned;
5931 1492 : GByte *pabyMax = paby32ByteAligned + 32;
5932 1492 : GUInt32 *panSum =
5933 : reinterpret_cast<GUInt32 *>(paby32ByteAligned + 32 * 2);
5934 1492 : GUInt32 *panSumSquare =
5935 : reinterpret_cast<GUInt32 *>(paby32ByteAligned + 32 * 3);
5936 :
5937 1492 : CPLAssert((reinterpret_cast<uintptr_t>(pData) % 32) == 0);
5938 :
5939 1492 : GPtrDiff_t i = 0;
5940 : // Make sure that sumSquare can fit on uint32
5941 : // * 8 since we can hold 8 sums per vector register
5942 1492 : const int nMaxIterationsPerInnerLoop =
5943 : 8 * ((std::numeric_limits<GUInt32>::max() / (255 * 255)) & ~31);
5944 1492 : auto nOuterLoops = nBlockPixels / nMaxIterationsPerInnerLoop;
5945 1492 : if ((nBlockPixels % nMaxIterationsPerInnerLoop) != 0)
5946 1492 : nOuterLoops++;
5947 :
5948 : const GDALm256i ymm_nodata =
5949 1492 : GDALmm256_set1_epi8(static_cast<GByte>(nNoDataValue));
5950 : // any non noData value in [min,max] would do.
5951 : const GDALm256i ymm_neutral =
5952 1492 : GDALmm256_set1_epi8(static_cast<GByte>(nMin));
5953 1492 : GDALm256i ymm_min = ymm_neutral;
5954 1492 : GDALm256i ymm_max = ymm_neutral;
5955 : [[maybe_unused]] const auto ymm_mask_8bits =
5956 1492 : GDALmm256_set1_epi16(0xFF);
5957 :
5958 1492 : const GUInt32 nMinThreshold = (nNoDataValue == 0) ? 1 : 0;
5959 1492 : const GUInt32 nMaxThreshold = (nNoDataValue == 255) ? 254 : 255;
5960 1492 : const bool bComputeMinMax =
5961 1492 : nMin > nMinThreshold || nMax < nMaxThreshold;
5962 :
5963 2984 : for (GPtrDiff_t k = 0; k < nOuterLoops; k++)
5964 : {
5965 1492 : const auto iMax =
5966 1492 : std::min(nBlockPixels, i + nMaxIterationsPerInnerLoop);
5967 :
5968 : // holds 4 uint32 sums in [0], [2], [4] and [6]
5969 1492 : [[maybe_unused]] GDALm256i ymm_sum = ZERO256;
5970 : // holds 8 uint32 sums
5971 1492 : [[maybe_unused]] GDALm256i ymm_sumsquare = ZERO256;
5972 : // holds 4 uint32 sums in [0], [2], [4] and [6]
5973 1492 : [[maybe_unused]] GDALm256i ymm_count_nodata_mul_255 = ZERO256;
5974 1492 : const auto iInit = i;
5975 18982 : for (; i + 31 < iMax; i += 32)
5976 : {
5977 17490 : const GDALm256i ymm = GDALmm256_load_si256(
5978 17490 : reinterpret_cast<const GDALm256i *>(pData + i));
5979 :
5980 : // Check which values are nodata
5981 : const GDALm256i ymm_eq_nodata =
5982 17490 : GDALmm256_cmpeq_epi8(ymm, ymm_nodata);
5983 : if constexpr (COMPUTE_OTHER_STATS)
5984 : {
5985 : // Count how many values are nodata (due to cmpeq
5986 : // putting 255 when condition is met, this will actually
5987 : // be 255 times the number of nodata value, spread in 4
5988 : // 64 bits words). We can use add_epi32 as the counter
5989 : // will not overflow uint32
5990 9148 : ymm_count_nodata_mul_255 = GDALmm256_add_epi32(
5991 : ymm_count_nodata_mul_255,
5992 : GDALmm256_sad_epu8(ymm_eq_nodata, ZERO256));
5993 : }
5994 : // Replace all nodata values by zero for the purpose of sum
5995 : // and sumquare.
5996 : const GDALm256i ymm_nodata_by_zero =
5997 17490 : GDALmm256_andnot_si256(ymm_eq_nodata, ymm);
5998 17490 : if (bComputeMinMax)
5999 : {
6000 : // Replace all nodata values by a neutral value for the
6001 : // purpose of min and max.
6002 : const GDALm256i ymm_nodata_by_neutral =
6003 8720 : GDALmm256_or_si256(
6004 : GDALmm256_and_si256(ymm_eq_nodata, ymm_neutral),
6005 : ymm_nodata_by_zero);
6006 :
6007 : ymm_min =
6008 8720 : GDALmm256_min_epu8(ymm_min, ymm_nodata_by_neutral);
6009 : ymm_max =
6010 8720 : GDALmm256_max_epu8(ymm_max, ymm_nodata_by_neutral);
6011 : }
6012 :
6013 : if constexpr (COMPUTE_OTHER_STATS)
6014 : {
6015 : // Extract even-8bit values
6016 9148 : const GDALm256i ymm_even = GDALmm256_and_si256(
6017 : ymm_nodata_by_zero, ymm_mask_8bits);
6018 : // Compute square of those 16 values as 32 bit result
6019 : // and add adjacent pairs
6020 : const GDALm256i ymm_even_square =
6021 9148 : GDALmm256_madd_epi16(ymm_even, ymm_even);
6022 : // Add to the sumsquare accumulator
6023 : ymm_sumsquare =
6024 9148 : GDALmm256_add_epi32(ymm_sumsquare, ymm_even_square);
6025 :
6026 : // Extract odd-8bit values
6027 : const GDALm256i ymm_odd =
6028 9148 : GDALmm256_srli_epi16(ymm_nodata_by_zero, 8);
6029 : const GDALm256i ymm_odd_square =
6030 9148 : GDALmm256_madd_epi16(ymm_odd, ymm_odd);
6031 : ymm_sumsquare =
6032 9148 : GDALmm256_add_epi32(ymm_sumsquare, ymm_odd_square);
6033 :
6034 : // Now compute the sums
6035 9148 : ymm_sum = GDALmm256_add_epi32(
6036 : ymm_sum,
6037 : GDALmm256_sad_epu8(ymm_nodata_by_zero, ZERO256));
6038 : }
6039 : }
6040 :
6041 : if constexpr (COMPUTE_OTHER_STATS)
6042 : {
6043 186 : GUInt32 *panCoutNoDataMul255 = panSum;
6044 186 : GDALmm256_store_si256(
6045 : reinterpret_cast<GDALm256i *>(panCoutNoDataMul255),
6046 : ymm_count_nodata_mul_255);
6047 :
6048 186 : nSampleCount += (i - iInit);
6049 :
6050 186 : nValidCount +=
6051 186 : (i - iInit) -
6052 186 : (panCoutNoDataMul255[0] + panCoutNoDataMul255[2] +
6053 186 : panCoutNoDataMul255[4] + panCoutNoDataMul255[6]) /
6054 : 255;
6055 :
6056 186 : GDALmm256_store_si256(reinterpret_cast<GDALm256i *>(panSum),
6057 : ymm_sum);
6058 186 : GDALmm256_store_si256(
6059 : reinterpret_cast<GDALm256i *>(panSumSquare),
6060 : ymm_sumsquare);
6061 186 : nSum += panSum[0] + panSum[2] + panSum[4] + panSum[6];
6062 186 : nSumSquare += static_cast<GUIntBig>(panSumSquare[0]) +
6063 186 : panSumSquare[1] + panSumSquare[2] +
6064 186 : panSumSquare[3] + panSumSquare[4] +
6065 186 : panSumSquare[5] + panSumSquare[6] +
6066 : panSumSquare[7];
6067 : }
6068 : }
6069 :
6070 1492 : if (bComputeMinMax)
6071 : {
6072 1430 : GDALmm256_store_si256(reinterpret_cast<GDALm256i *>(pabyMin),
6073 : ymm_min);
6074 1430 : GDALmm256_store_si256(reinterpret_cast<GDALm256i *>(pabyMax),
6075 : ymm_max);
6076 47190 : for (int j = 0; j < 32; j++)
6077 : {
6078 45760 : if (pabyMin[j] < nMin)
6079 40 : nMin = pabyMin[j];
6080 45760 : if (pabyMax[j] > nMax)
6081 161 : nMax = pabyMax[j];
6082 : }
6083 : }
6084 :
6085 : if constexpr (COMPUTE_OTHER_STATS)
6086 : {
6087 186 : nSampleCount += nBlockPixels - i;
6088 : }
6089 34048 : for (; i < nBlockPixels; i++)
6090 : {
6091 32556 : const GUInt32 nValue = pData[i];
6092 32556 : if (nValue == nNoDataValue)
6093 24923 : continue;
6094 7633 : if (nValue < nMin)
6095 2 : nMin = nValue;
6096 7633 : if (nValue > nMax)
6097 14 : nMax = nValue;
6098 : if constexpr (COMPUTE_OTHER_STATS)
6099 : {
6100 3700 : nValidCount++;
6101 3700 : nSum += nValue;
6102 3700 : nSumSquare +=
6103 3700 : static_cast_for_coverity_scan<GUIntBig>(nValue) *
6104 3700 : nValue;
6105 : }
6106 1492 : }
6107 : }
6108 28762 : else if (!bHasNoData && nXCheck == nBlockXSize && nBlockPixels >= 32)
6109 : {
6110 14990 : if (nMin > 0)
6111 : {
6112 2093 : if (nMax < 255)
6113 : {
6114 : ComputeStatisticsByteNoNodata<true, true,
6115 1570 : COMPUTE_OTHER_STATS>(
6116 : nBlockPixels, pData, nMin, nMax, nSum, nSumSquare,
6117 : nSampleCount, nValidCount);
6118 : }
6119 : else
6120 : {
6121 : ComputeStatisticsByteNoNodata<true, false,
6122 523 : COMPUTE_OTHER_STATS>(
6123 : nBlockPixels, pData, nMin, nMax, nSum, nSumSquare,
6124 : nSampleCount, nValidCount);
6125 : }
6126 : }
6127 : else
6128 : {
6129 12897 : if (nMax < 255)
6130 : {
6131 : ComputeStatisticsByteNoNodata<false, true,
6132 9408 : COMPUTE_OTHER_STATS>(
6133 : nBlockPixels, pData, nMin, nMax, nSum, nSumSquare,
6134 : nSampleCount, nValidCount);
6135 : }
6136 : else
6137 : {
6138 : ComputeStatisticsByteNoNodata<false, false,
6139 3489 : COMPUTE_OTHER_STATS>(
6140 : nBlockPixels, pData, nMin, nMax, nSum, nSumSquare,
6141 : nSampleCount, nValidCount);
6142 : }
6143 : }
6144 : }
6145 12484 : else if (!COMPUTE_OTHER_STATS && !bHasNoData && nXCheck >= 32 &&
6146 33 : (nBlockXSize % 32) == 0)
6147 : {
6148 6389 : for (int iY = 0; iY < nYCheck; iY++)
6149 : {
6150 6356 : ComputeStatisticsByteNoNodata<true, true, COMPUTE_OTHER_STATS>(
6151 6356 : nXCheck, pData + static_cast<size_t>(iY) * nBlockXSize,
6152 : nMin, nMax, nSum, nSumSquare, nSampleCount, nValidCount);
6153 33 : }
6154 : }
6155 : else
6156 : {
6157 13739 : ComputeStatisticsInternalGeneric<GByte, COMPUTE_OTHER_STATS>::f(
6158 : nXCheck, nBlockXSize, nYCheck, pData, bHasNoData, nNoDataValue,
6159 : nMin, nMax, nSum, nSumSquare, nSampleCount, nValidCount);
6160 : }
6161 30257 : }
6162 : };
6163 :
6164 : CPL_NOSANITIZE_UNSIGNED_INT_OVERFLOW
6165 570 : static void UnshiftSumSquare(GUIntBig &nSumSquare, GUIntBig nSumThis,
6166 : GUIntBig i)
6167 : {
6168 570 : nSumSquare += 32768 * (2 * nSumThis - i * 32768);
6169 570 : }
6170 :
6171 : // AVX2/SSE2 optimization for GUInt16 case
6172 : template <bool COMPUTE_OTHER_STATS>
6173 : struct ComputeStatisticsInternal<GUInt16, COMPUTE_OTHER_STATS>
6174 : {
6175 2093 : static void f(int nXCheck, int nBlockXSize, int nYCheck,
6176 : // assumed to be aligned on 128 bits
6177 : const GUInt16 *pData, bool bHasNoData, GUInt32 nNoDataValue,
6178 : GUInt32 &nMin, GUInt32 &nMax, GUIntBig &nSum,
6179 : GUIntBig &nSumSquare, GUIntBig &nSampleCount,
6180 : GUIntBig &nValidCount)
6181 : {
6182 2093 : const auto nBlockPixels = static_cast<GPtrDiff_t>(nXCheck) * nYCheck;
6183 2093 : if (!bHasNoData && nXCheck == nBlockXSize && nBlockPixels >= 16)
6184 : {
6185 1844 : CPLAssert((reinterpret_cast<uintptr_t>(pData) % 16) == 0);
6186 :
6187 1844 : GPtrDiff_t i = 0;
6188 : // In SSE2, min_epu16 and max_epu16 do not exist, so shift from
6189 : // UInt16 to SInt16 to be able to use min_epi16 and max_epi16.
6190 : // Furthermore the shift is also needed to use madd_epi16
6191 1844 : const GDALm256i ymm_m32768 = GDALmm256_set1_epi16(-32768);
6192 1844 : GDALm256i ymm_min = GDALmm256_load_si256(
6193 1844 : reinterpret_cast<const GDALm256i *>(pData + i));
6194 1844 : ymm_min = GDALmm256_add_epi16(ymm_min, ymm_m32768);
6195 1844 : GDALm256i ymm_max = ymm_min;
6196 : [[maybe_unused]] GDALm256i ymm_sumsquare =
6197 1844 : ZERO256; // holds 4 uint64 sums
6198 :
6199 : // Make sure that sum can fit on uint32
6200 : // * 8 since we can hold 8 sums per vector register
6201 1844 : const int nMaxIterationsPerInnerLoop =
6202 : 8 * ((std::numeric_limits<GUInt32>::max() / 65535) & ~15);
6203 1844 : GPtrDiff_t nOuterLoops = nBlockPixels / nMaxIterationsPerInnerLoop;
6204 1844 : if ((nBlockPixels % nMaxIterationsPerInnerLoop) != 0)
6205 1844 : nOuterLoops++;
6206 :
6207 1844 : const bool bComputeMinMax = nMin > 0 || nMax < 65535;
6208 : [[maybe_unused]] const auto ymm_mask_16bits =
6209 1844 : GDALmm256_set1_epi32(0xFFFF);
6210 : [[maybe_unused]] const auto ymm_mask_32bits =
6211 1844 : GDALmm256_set1_epi64x(0xFFFFFFFF);
6212 :
6213 1844 : GUIntBig nSumThis = 0;
6214 3712 : for (int k = 0; k < nOuterLoops; k++)
6215 : {
6216 1868 : const auto iMax =
6217 1868 : std::min(nBlockPixels, i + nMaxIterationsPerInnerLoop);
6218 :
6219 : [[maybe_unused]] GDALm256i ymm_sum =
6220 1868 : ZERO256; // holds 8 uint32 sums
6221 1057198 : for (; i + 15 < iMax; i += 16)
6222 : {
6223 1055330 : const GDALm256i ymm = GDALmm256_load_si256(
6224 1055330 : reinterpret_cast<const GDALm256i *>(pData + i));
6225 : const GDALm256i ymm_shifted =
6226 1055330 : GDALmm256_add_epi16(ymm, ymm_m32768);
6227 1055330 : if (bComputeMinMax)
6228 : {
6229 1037292 : ymm_min = GDALmm256_min_epi16(ymm_min, ymm_shifted);
6230 1037292 : ymm_max = GDALmm256_max_epi16(ymm_max, ymm_shifted);
6231 : }
6232 :
6233 : if constexpr (COMPUTE_OTHER_STATS)
6234 : {
6235 : // Note: the int32 range can overflow for (0-32768)^2 +
6236 : // (0-32768)^2 = 0x80000000, but as we know the result
6237 : // is positive, this is OK as we interpret is a uint32.
6238 : const GDALm256i ymm_square =
6239 188312 : GDALmm256_madd_epi16(ymm_shifted, ymm_shifted);
6240 188312 : ymm_sumsquare = GDALmm256_add_epi64(
6241 : ymm_sumsquare,
6242 : GDALmm256_and_si256(ymm_square, ymm_mask_32bits));
6243 188312 : ymm_sumsquare = GDALmm256_add_epi64(
6244 : ymm_sumsquare,
6245 : GDALmm256_srli_epi64(ymm_square, 32));
6246 :
6247 : // Now compute the sums
6248 188312 : ymm_sum = GDALmm256_add_epi32(
6249 : ymm_sum, GDALmm256_and_si256(ymm, ymm_mask_16bits));
6250 188312 : ymm_sum = GDALmm256_add_epi32(
6251 : ymm_sum, GDALmm256_srli_epi32(ymm, 16));
6252 : }
6253 : }
6254 :
6255 : if constexpr (COMPUTE_OTHER_STATS)
6256 : {
6257 : GUInt32 anSum[8];
6258 570 : GDALmm256_storeu_si256(reinterpret_cast<GDALm256i *>(anSum),
6259 : ymm_sum);
6260 570 : nSumThis += static_cast<GUIntBig>(anSum[0]) + anSum[1] +
6261 570 : anSum[2] + anSum[3] + anSum[4] + anSum[5] +
6262 570 : anSum[6] + anSum[7];
6263 : }
6264 : }
6265 :
6266 1844 : if (bComputeMinMax)
6267 : {
6268 : GUInt16 anMin[16];
6269 : GUInt16 anMax[16];
6270 :
6271 : // Unshift the result
6272 1762 : ymm_min = GDALmm256_sub_epi16(ymm_min, ymm_m32768);
6273 1762 : ymm_max = GDALmm256_sub_epi16(ymm_max, ymm_m32768);
6274 1762 : GDALmm256_storeu_si256(reinterpret_cast<GDALm256i *>(anMin),
6275 : ymm_min);
6276 1762 : GDALmm256_storeu_si256(reinterpret_cast<GDALm256i *>(anMax),
6277 : ymm_max);
6278 29954 : for (int j = 0; j < 16; j++)
6279 : {
6280 28192 : if (anMin[j] < nMin)
6281 389 : nMin = anMin[j];
6282 28192 : if (anMax[j] > nMax)
6283 567 : nMax = anMax[j];
6284 : }
6285 : }
6286 :
6287 : if constexpr (COMPUTE_OTHER_STATS)
6288 : {
6289 : GUIntBig anSumSquare[4];
6290 570 : GDALmm256_storeu_si256(
6291 : reinterpret_cast<GDALm256i *>(anSumSquare), ymm_sumsquare);
6292 570 : nSumSquare += anSumSquare[0] + anSumSquare[1] + anSumSquare[2] +
6293 : anSumSquare[3];
6294 :
6295 : // Unshift the sum of squares
6296 570 : UnshiftSumSquare(nSumSquare, nSumThis,
6297 : static_cast<GUIntBig>(i));
6298 :
6299 570 : nSum += nSumThis;
6300 :
6301 1014 : for (; i < nBlockPixels; i++)
6302 : {
6303 444 : const GUInt32 nValue = pData[i];
6304 444 : if (nValue < nMin)
6305 2 : nMin = nValue;
6306 444 : if (nValue > nMax)
6307 2 : nMax = nValue;
6308 444 : nSum += nValue;
6309 444 : nSumSquare +=
6310 444 : static_cast_for_coverity_scan<GUIntBig>(nValue) *
6311 444 : nValue;
6312 : }
6313 :
6314 570 : nSampleCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
6315 570 : nValidCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
6316 1844 : }
6317 : }
6318 : else
6319 : {
6320 249 : ComputeStatisticsInternalGeneric<GUInt16, COMPUTE_OTHER_STATS>::f(
6321 : nXCheck, nBlockXSize, nYCheck, pData, bHasNoData, nNoDataValue,
6322 : nMin, nMax, nSum, nSumSquare, nSampleCount, nValidCount);
6323 : }
6324 2093 : }
6325 : };
6326 :
6327 : #endif
6328 : // (defined(__x86_64__) || defined(_M_X64)) && (defined(__GNUC__) ||
6329 : // defined(_MSC_VER))
6330 :
6331 : /************************************************************************/
6332 : /* GetPixelValue() */
6333 : /************************************************************************/
6334 :
6335 19453000 : static inline double GetPixelValue(GDALDataType eDataType, bool bSignedByte,
6336 : const void *pData, GPtrDiff_t iOffset,
6337 : const GDALNoDataValues &sNoDataValues,
6338 : bool &bValid)
6339 : {
6340 19453000 : bValid = true;
6341 19453000 : double dfValue = 0;
6342 19453000 : switch (eDataType)
6343 : {
6344 1400770 : case GDT_Byte:
6345 : {
6346 1400770 : if (bSignedByte)
6347 192 : dfValue = static_cast<const signed char *>(pData)[iOffset];
6348 : else
6349 1400580 : dfValue = static_cast<const GByte *>(pData)[iOffset];
6350 1400770 : break;
6351 : }
6352 10409 : case GDT_Int8:
6353 10409 : dfValue = static_cast<const GInt8 *>(pData)[iOffset];
6354 10409 : break;
6355 200608 : case GDT_UInt16:
6356 200608 : dfValue = static_cast<const GUInt16 *>(pData)[iOffset];
6357 200608 : break;
6358 60193 : case GDT_Int16:
6359 60193 : dfValue = static_cast<const GInt16 *>(pData)[iOffset];
6360 60193 : break;
6361 27600 : case GDT_UInt32:
6362 27600 : dfValue = static_cast<const GUInt32 *>(pData)[iOffset];
6363 27600 : break;
6364 456810 : case GDT_Int32:
6365 456810 : dfValue = static_cast<const GInt32 *>(pData)[iOffset];
6366 456810 : break;
6367 2604 : case GDT_UInt64:
6368 2604 : dfValue = static_cast<double>(
6369 2604 : static_cast<const std::uint64_t *>(pData)[iOffset]);
6370 2604 : break;
6371 7404 : case GDT_Int64:
6372 7404 : dfValue = static_cast<double>(
6373 7404 : static_cast<const std::int64_t *>(pData)[iOffset]);
6374 7404 : break;
6375 0 : case GDT_Float16:
6376 : {
6377 : using namespace std;
6378 0 : const GFloat16 hfValue =
6379 0 : static_cast<const GFloat16 *>(pData)[iOffset];
6380 0 : if (isnan(hfValue) ||
6381 0 : (sNoDataValues.bGotFloat16NoDataValue &&
6382 0 : ARE_REAL_EQUAL(hfValue, sNoDataValues.hfNoDataValue)))
6383 : {
6384 0 : bValid = false;
6385 0 : return 0.0;
6386 : }
6387 0 : dfValue = hfValue;
6388 0 : return dfValue;
6389 : }
6390 13494500 : case GDT_Float32:
6391 : {
6392 13494500 : const float fValue = static_cast<const float *>(pData)[iOffset];
6393 26962000 : if (std::isnan(fValue) ||
6394 26736400 : (sNoDataValues.bGotFloatNoDataValue &&
6395 13268800 : ARE_REAL_EQUAL(fValue, sNoDataValues.fNoDataValue)))
6396 : {
6397 26877 : bValid = false;
6398 26877 : return 0.0;
6399 : }
6400 13467600 : dfValue = double(fValue);
6401 13467600 : return dfValue;
6402 : }
6403 3775010 : case GDT_Float64:
6404 3775010 : dfValue = static_cast<const double *>(pData)[iOffset];
6405 3775010 : if (std::isnan(dfValue))
6406 : {
6407 6 : bValid = false;
6408 6 : return 0.0;
6409 : }
6410 3775000 : break;
6411 2692 : case GDT_CInt16:
6412 2692 : dfValue = static_cast<const GInt16 *>(pData)[iOffset * 2];
6413 2692 : break;
6414 2692 : case GDT_CInt32:
6415 2692 : dfValue = static_cast<const GInt32 *>(pData)[iOffset * 2];
6416 2692 : break;
6417 0 : case GDT_CFloat16:
6418 0 : dfValue = static_cast<const GFloat16 *>(pData)[iOffset * 2];
6419 0 : if (std::isnan(dfValue))
6420 : {
6421 0 : bValid = false;
6422 0 : return 0.0;
6423 : }
6424 0 : break;
6425 5812 : case GDT_CFloat32:
6426 5812 : dfValue = double(static_cast<const float *>(pData)[iOffset * 2]);
6427 5812 : if (std::isnan(dfValue))
6428 : {
6429 0 : bValid = false;
6430 0 : return 0.0;
6431 : }
6432 5812 : break;
6433 5892 : case GDT_CFloat64:
6434 5892 : dfValue = static_cast<const double *>(pData)[iOffset * 2];
6435 5892 : if (std::isnan(dfValue))
6436 : {
6437 0 : bValid = false;
6438 0 : return 0.0;
6439 : }
6440 5892 : break;
6441 0 : case GDT_Unknown:
6442 : case GDT_TypeCount:
6443 0 : CPLAssert(false);
6444 : break;
6445 : }
6446 :
6447 9719860 : if (sNoDataValues.bGotNoDataValue &&
6448 3761370 : ARE_REAL_EQUAL(dfValue, sNoDataValues.dfNoDataValue))
6449 : {
6450 3338720 : bValid = false;
6451 3338720 : return 0.0;
6452 : }
6453 2619770 : return dfValue;
6454 : }
6455 :
6456 : /************************************************************************/
6457 : /* SetValidPercent() */
6458 : /************************************************************************/
6459 :
6460 : //! @cond Doxygen_Suppress
6461 : /**
6462 : * \brief Set percentage of valid (not nodata) pixels.
6463 : *
6464 : * Stores the percentage of valid pixels in the metadata item
6465 : * STATISTICS_VALID_PERCENT
6466 : *
6467 : * @param nSampleCount Number of sampled pixels.
6468 : *
6469 : * @param nValidCount Number of valid pixels.
6470 : */
6471 :
6472 534 : void GDALRasterBand::SetValidPercent(GUIntBig nSampleCount,
6473 : GUIntBig nValidCount)
6474 : {
6475 534 : if (nValidCount == 0)
6476 : {
6477 12 : SetMetadataItem("STATISTICS_VALID_PERCENT", "0");
6478 : }
6479 522 : else if (nValidCount == nSampleCount)
6480 : {
6481 464 : SetMetadataItem("STATISTICS_VALID_PERCENT", "100");
6482 : }
6483 : else /* nValidCount < nSampleCount */
6484 : {
6485 58 : char szValue[128] = {0};
6486 :
6487 : /* percentage is only an indicator: limit precision */
6488 58 : CPLsnprintf(szValue, sizeof(szValue), "%.4g",
6489 58 : 100. * static_cast<double>(nValidCount) / nSampleCount);
6490 :
6491 58 : if (EQUAL(szValue, "100"))
6492 : {
6493 : /* don't set 100 percent valid
6494 : * because some of the sampled pixels were nodata */
6495 4 : SetMetadataItem("STATISTICS_VALID_PERCENT", "99.999");
6496 : }
6497 : else
6498 : {
6499 54 : SetMetadataItem("STATISTICS_VALID_PERCENT", szValue);
6500 : }
6501 : }
6502 533 : }
6503 :
6504 : //! @endcond
6505 :
6506 : #if (defined(__x86_64__) || defined(_M_X64))
6507 :
6508 : #ifdef __AVX2__
6509 :
6510 : #define setzero_si _mm256_setzero_si256
6511 : #define setzero_ps _mm256_setzero_ps
6512 : #define set1_ps _mm256_set1_ps
6513 : #define set1_epi32 _mm256_set1_epi32
6514 : #define add_epi32 _mm256_add_epi32
6515 : #define loadu_ps _mm256_loadu_ps
6516 : #define or_ps _mm256_or_ps
6517 : #define min_ps _mm256_min_ps
6518 : #define max_ps _mm256_max_ps
6519 : #define cmpeq_ps(x, y) _mm256_cmp_ps((x), (y), _CMP_EQ_OQ)
6520 : #define cmpneq_ps(x, y) _mm256_cmp_ps((x), (y), _CMP_NEQ_OQ)
6521 : #define cmpunord_ps(x, y) _mm256_cmp_ps((x), (y), _CMP_UNORD_Q)
6522 : #define movemask_ps _mm256_movemask_ps
6523 : #define add_ps _mm256_add_ps
6524 : #define sub_ps _mm256_sub_ps
6525 : #define mul_ps _mm256_mul_ps
6526 : #define div_ps _mm256_div_ps
6527 : #define storeu_ps _mm256_storeu_ps
6528 : #define cvtepi32_ps _mm256_cvtepi32_ps
6529 : #define cvtsi_si32(x) _mm256_extract_epi32((x), 0)
6530 : #define blendv_ps _mm256_blendv_ps
6531 : #ifdef __FMA__
6532 : #define fmadd_ps _mm256_fmadd_ps
6533 : #else
6534 : #define fmadd_ps(a, b, c) add_ps(mul_ps((a), (b)), (c))
6535 : #endif
6536 :
6537 : #else
6538 :
6539 : #define setzero_si _mm_setzero_si128
6540 : #define setzero_ps _mm_setzero_ps
6541 : #define set1_ps _mm_set1_ps
6542 : #define set1_epi32 _mm_set1_epi32
6543 : #define add_epi32 _mm_add_epi32
6544 : #define loadu_ps _mm_loadu_ps
6545 : #define or_ps _mm_or_ps
6546 : #define min_ps _mm_min_ps
6547 : #define max_ps _mm_max_ps
6548 : #define cmpeq_ps _mm_cmpeq_ps
6549 : #define cmpneq_ps _mm_cmpneq_ps
6550 : #define cmpunord_ps _mm_cmpunord_ps
6551 : #define movemask_ps _mm_movemask_ps
6552 : #define add_ps _mm_add_ps
6553 : #define sub_ps _mm_sub_ps
6554 : #define mul_ps _mm_mul_ps
6555 : #define div_ps _mm_div_ps
6556 : #define storeu_ps _mm_storeu_ps
6557 : #define cvtepi32_ps _mm_cvtepi32_ps
6558 : #define cvtsi_si32 _mm_cvtsi128_si32
6559 : #ifdef __FMA__
6560 : #define fmadd_ps _mm_fmadd_ps
6561 : #else
6562 : #define fmadd_ps(a, b, c) add_ps(mul_ps((a), (b)), (c))
6563 : #endif
6564 :
6565 2065850 : inline __m128 blendv_ps(__m128 a, __m128 b, __m128 mask)
6566 : {
6567 : #if defined(__SSE4_1__) || defined(__AVX__) || defined(USE_NEON_OPTIMIZATIONS)
6568 : return _mm_blendv_ps(a, b, mask);
6569 : #else
6570 6197540 : return _mm_or_ps(_mm_andnot_ps(mask, a), _mm_and_ps(mask, b));
6571 : #endif
6572 : }
6573 : #endif
6574 :
6575 : template <bool CHECK_MIN_NOT_SAME_AS_MAX, bool HAS_NODATA>
6576 : #if defined(__GNUC__)
6577 : __attribute__((noinline))
6578 : #endif
6579 : static int
6580 4889 : ComputeStatisticsFloat32_SSE2(const float *pafData,
6581 : [[maybe_unused]] float fNoDataValue, int iX,
6582 : int nCount, float &fMin, float &fMax,
6583 : float &fBlockMean, float &fBlockM2,
6584 : int &nBlockValidCount)
6585 : {
6586 4889 : auto vValidCount = setzero_si();
6587 4889 : const auto vOne = set1_epi32(1);
6588 4889 : [[maybe_unused]] const auto vNoData = set1_ps(fNoDataValue);
6589 :
6590 4889 : auto vMin_lo = set1_ps(fMin);
6591 9778 : auto vMax_lo = set1_ps(fMax);
6592 4889 : auto vMean_lo = setzero_ps();
6593 4889 : auto vM2_lo = setzero_ps();
6594 :
6595 4889 : auto vMin_hi = vMin_lo;
6596 4889 : auto vMax_hi = vMax_lo;
6597 4889 : auto vMean_hi = setzero_ps();
6598 4889 : auto vM2_hi = setzero_ps();
6599 :
6600 4889 : constexpr int VALS_PER_LOOP =
6601 : 2 * static_cast<int>(sizeof(vOne) / sizeof(float));
6602 590671 : for (; iX <= nCount - VALS_PER_LOOP; iX += VALS_PER_LOOP)
6603 : {
6604 585783 : const auto vValues_lo = loadu_ps(pafData + iX);
6605 1171568 : const auto vValues_hi = loadu_ps(pafData + iX + VALS_PER_LOOP / 2);
6606 : // Check if there's at least one NaN in both vectors
6607 585783 : auto isNaNOrNoData = cmpunord_ps(vValues_lo, vValues_hi);
6608 : if constexpr (HAS_NODATA)
6609 : {
6610 : isNaNOrNoData =
6611 0 : or_ps(isNaNOrNoData, or_ps(cmpeq_ps(vValues_lo, vNoData),
6612 : cmpeq_ps(vValues_hi, vNoData)));
6613 : }
6614 585783 : if (movemask_ps(isNaNOrNoData))
6615 : {
6616 1 : break;
6617 : }
6618 :
6619 585782 : vValidCount = add_epi32(vValidCount, vOne);
6620 585782 : const auto vValidCountFloat32 = cvtepi32_ps(vValidCount);
6621 :
6622 585782 : vMin_lo = min_ps(vMin_lo, vValues_lo);
6623 585782 : vMax_lo = max_ps(vMax_lo, vValues_lo);
6624 585782 : const auto vDelta_lo = sub_ps(vValues_lo, vMean_lo);
6625 : const auto vNewMean_lo =
6626 1102213 : add_ps(vMean_lo, div_ps(vDelta_lo, vValidCountFloat32));
6627 : if constexpr (CHECK_MIN_NOT_SAME_AS_MAX)
6628 : {
6629 516429 : const auto vMinNotSameAsMax_lo = cmpneq_ps(vMin_lo, vMax_lo);
6630 516429 : vMean_lo = blendv_ps(vMin_lo, vNewMean_lo, vMinNotSameAsMax_lo);
6631 : const auto vNewM2_lo =
6632 1032860 : fmadd_ps(vDelta_lo, sub_ps(vValues_lo, vMean_lo), vM2_lo);
6633 516429 : vM2_lo = blendv_ps(vM2_lo, vNewM2_lo, vMinNotSameAsMax_lo);
6634 : }
6635 : else
6636 : {
6637 69353 : vMean_lo = vNewMean_lo;
6638 208059 : vM2_lo = fmadd_ps(vDelta_lo, sub_ps(vValues_lo, vMean_lo), vM2_lo);
6639 : }
6640 :
6641 585782 : vMin_hi = min_ps(vMin_hi, vValues_hi);
6642 585782 : vMax_hi = max_ps(vMax_hi, vValues_hi);
6643 585782 : const auto vDelta_hi = sub_ps(vValues_hi, vMean_hi);
6644 : const auto vNewMean_hi =
6645 1102213 : add_ps(vMean_hi, div_ps(vDelta_hi, vValidCountFloat32));
6646 : if constexpr (CHECK_MIN_NOT_SAME_AS_MAX)
6647 : {
6648 516429 : const auto vMinNotSameAsMax_hi = cmpneq_ps(vMin_hi, vMax_hi);
6649 516429 : vMean_hi = blendv_ps(vMin_hi, vNewMean_hi, vMinNotSameAsMax_hi);
6650 : const auto vNewM2_hi =
6651 1032860 : fmadd_ps(vDelta_hi, sub_ps(vValues_hi, vMean_hi), vM2_hi);
6652 516429 : vM2_hi = blendv_ps(vM2_hi, vNewM2_hi, vMinNotSameAsMax_hi);
6653 : }
6654 : else
6655 : {
6656 69353 : vMean_hi = vNewMean_hi;
6657 208059 : vM2_hi = fmadd_ps(vDelta_hi, sub_ps(vValues_hi, vMean_hi), vM2_hi);
6658 : }
6659 : }
6660 4889 : const int nValidVectorCount = cvtsi_si32(vValidCount);
6661 4889 : if (nValidVectorCount)
6662 : {
6663 : float afMin[VALS_PER_LOOP], afMax[VALS_PER_LOOP], afMean[VALS_PER_LOOP],
6664 : afM2[VALS_PER_LOOP];
6665 : storeu_ps(afMin, vMin_lo);
6666 : storeu_ps(afMax, vMax_lo);
6667 : storeu_ps(afMean, vMean_lo);
6668 : storeu_ps(afM2, vM2_lo);
6669 4631 : storeu_ps(afMin + VALS_PER_LOOP / 2, vMin_hi);
6670 4631 : storeu_ps(afMax + VALS_PER_LOOP / 2, vMax_hi);
6671 4631 : storeu_ps(afMean + VALS_PER_LOOP / 2, vMean_hi);
6672 4631 : storeu_ps(afM2 + VALS_PER_LOOP / 2, vM2_hi);
6673 :
6674 41679 : for (int i = 0; i < VALS_PER_LOOP; ++i)
6675 : {
6676 37048 : fMin = std::min(fMin, afMin[i]);
6677 37048 : fMax = std::max(fMax, afMax[i]);
6678 37048 : const auto nNewValidCount = nBlockValidCount + nValidVectorCount;
6679 37048 : if (afMean[i] != fBlockMean)
6680 : {
6681 17864 : const float fDelta = afMean[i] - fBlockMean;
6682 17864 : fBlockMean += fDelta * nValidVectorCount / nNewValidCount;
6683 17864 : fBlockM2 += afM2[i] + fDelta * fDelta * nBlockValidCount *
6684 17864 : nValidVectorCount / nNewValidCount;
6685 : }
6686 37048 : nBlockValidCount = nNewValidCount;
6687 : }
6688 : }
6689 :
6690 4889 : return iX;
6691 : }
6692 :
6693 : #ifdef __AVX2__
6694 :
6695 : #define setzero_pd _mm256_setzero_pd
6696 : #define set1_pd _mm256_set1_pd
6697 : #define loadu_pd _mm256_loadu_pd
6698 : #define or_pd _mm256_or_pd
6699 : #define min_pd _mm256_min_pd
6700 : #define max_pd _mm256_max_pd
6701 : #define cmpeq_pd(x, y) _mm256_cmp_pd((x), (y), _CMP_EQ_OQ)
6702 : #define cmpneq_pd(x, y) _mm256_cmp_pd((x), (y), _CMP_NEQ_OQ)
6703 : #define cmpunord_pd(x, y) _mm256_cmp_pd((x), (y), _CMP_UNORD_Q)
6704 : #define movemask_pd _mm256_movemask_pd
6705 : #define add_pd _mm256_add_pd
6706 : #define sub_pd _mm256_sub_pd
6707 : #define mul_pd _mm256_mul_pd
6708 : #define div_pd _mm256_div_pd
6709 : #define storeu_pd _mm256_storeu_pd
6710 : #define cvtsd_f64(x) _mm_cvtsd_f64(_mm256_castpd256_pd128((x)))
6711 : #define blendv_pd _mm256_blendv_pd
6712 : #ifdef __FMA__
6713 : #define fmadd_pd _mm256_fmadd_pd
6714 : #else
6715 : #define fmadd_pd(a, b, c) add_pd(mul_pd((a), (b)), (c))
6716 : #endif
6717 :
6718 : #else
6719 :
6720 : #define setzero_pd _mm_setzero_pd
6721 : #define set1_pd _mm_set1_pd
6722 : #define loadu_pd _mm_loadu_pd
6723 : #define or_pd _mm_or_pd
6724 : #define min_pd _mm_min_pd
6725 : #define max_pd _mm_max_pd
6726 : #define cmpeq_pd _mm_cmpeq_pd
6727 : #define cmpneq_pd _mm_cmpneq_pd
6728 : #define cmpunord_pd _mm_cmpunord_pd
6729 : #define movemask_pd _mm_movemask_pd
6730 : #define add_pd _mm_add_pd
6731 : #define sub_pd _mm_sub_pd
6732 : #define mul_pd _mm_mul_pd
6733 : #define div_pd _mm_div_pd
6734 : #define storeu_pd _mm_storeu_pd
6735 : #define cvtsd_f64 _mm_cvtsd_f64
6736 : #ifdef __FMA__
6737 : #define fmadd_pd _mm_fmadd_pd
6738 : #else
6739 : #define fmadd_pd(a, b, c) add_pd(mul_pd((a), (b)), (c))
6740 : #endif
6741 :
6742 103928 : inline __m128d blendv_pd(__m128d a, __m128d b, __m128d mask)
6743 : {
6744 : #if defined(__SSE4_1__) || defined(__AVX__) || defined(USE_NEON_OPTIMIZATIONS)
6745 : return _mm_blendv_pd(a, b, mask);
6746 : #else
6747 311784 : return _mm_or_pd(_mm_andnot_pd(mask, a), _mm_and_pd(mask, b));
6748 : #endif
6749 : }
6750 : #endif
6751 :
6752 : template <bool CHECK_MIN_NOT_SAME_AS_MAX, bool HAS_NODATA>
6753 : #if defined(__GNUC__)
6754 : __attribute__((noinline))
6755 : #endif
6756 : static int
6757 1351 : ComputeStatisticsFloat64_SSE2(const double *padfData,
6758 : [[maybe_unused]] double dfNoDataValue, int iX,
6759 : int nCount, double &dfMin, double &dfMax,
6760 : double &dfBlockMean, double &dfBlockM2,
6761 : double &dfBlockValidCount)
6762 : {
6763 1351 : auto vValidCount = setzero_pd();
6764 1351 : const auto vOne = set1_pd(1);
6765 1351 : [[maybe_unused]] const auto vNoData = set1_pd(dfNoDataValue);
6766 :
6767 1351 : auto vMin_lo = set1_pd(dfMin);
6768 2702 : auto vMax_lo = set1_pd(dfMax);
6769 1351 : auto vMean_lo = setzero_pd();
6770 1351 : auto vM2_lo = setzero_pd();
6771 :
6772 1351 : auto vMin_hi = vMin_lo;
6773 1351 : auto vMax_hi = vMax_lo;
6774 1351 : auto vMean_hi = setzero_pd();
6775 1351 : auto vM2_hi = setzero_pd();
6776 :
6777 1351 : constexpr int VALS_PER_LOOP =
6778 : 2 * static_cast<int>(sizeof(vOne) / sizeof(double));
6779 43687 : for (; iX <= nCount - VALS_PER_LOOP; iX += VALS_PER_LOOP)
6780 : {
6781 42379 : const auto vValues_lo = loadu_pd(padfData + iX);
6782 84758 : const auto vValues_hi = loadu_pd(padfData + iX + VALS_PER_LOOP / 2);
6783 : // Check if there's at least one NaN in both vectors
6784 42379 : auto isNaNOrNoData = cmpunord_pd(vValues_lo, vValues_hi);
6785 : if constexpr (HAS_NODATA)
6786 : {
6787 : isNaNOrNoData =
6788 103248 : or_pd(isNaNOrNoData, or_pd(cmpeq_pd(vValues_lo, vNoData),
6789 : cmpeq_pd(vValues_hi, vNoData)));
6790 : }
6791 42379 : if (movemask_pd(isNaNOrNoData))
6792 : {
6793 43 : break;
6794 : }
6795 :
6796 42336 : vValidCount = add_pd(vValidCount, vOne);
6797 42336 : const auto vInvValidCount = div_pd(vOne, vValidCount);
6798 :
6799 42336 : vMin_lo = min_pd(vMin_lo, vValues_lo);
6800 42336 : vMax_lo = max_pd(vMax_lo, vValues_lo);
6801 42336 : const auto vDelta_lo = sub_pd(vValues_lo, vMean_lo);
6802 68318 : const auto vNewMean_lo = fmadd_pd(vDelta_lo, vInvValidCount, vMean_lo);
6803 : if constexpr (CHECK_MIN_NOT_SAME_AS_MAX)
6804 : {
6805 25982 : const auto vMinNotSameAsMax_lo = cmpneq_pd(vMin_lo, vMax_lo);
6806 25982 : vMean_lo = blendv_pd(vMin_lo, vNewMean_lo, vMinNotSameAsMax_lo);
6807 : const auto vNewM2_lo =
6808 51964 : fmadd_pd(vDelta_lo, sub_pd(vValues_lo, vMean_lo), vM2_lo);
6809 25982 : vM2_lo = blendv_pd(vM2_lo, vNewM2_lo, vMinNotSameAsMax_lo);
6810 : }
6811 : else
6812 : {
6813 16354 : vMean_lo = vNewMean_lo;
6814 49062 : vM2_lo = fmadd_pd(vDelta_lo, sub_pd(vValues_lo, vMean_lo), vM2_lo);
6815 : }
6816 :
6817 42336 : vMin_hi = min_pd(vMin_hi, vValues_hi);
6818 42336 : vMax_hi = max_pd(vMax_hi, vValues_hi);
6819 42336 : const auto vDelta_hi = sub_pd(vValues_hi, vMean_hi);
6820 68318 : const auto vNewMean_hi = fmadd_pd(vDelta_hi, vInvValidCount, vMean_hi);
6821 : if constexpr (CHECK_MIN_NOT_SAME_AS_MAX)
6822 : {
6823 25982 : const auto vMinNotSameAsMax_hi = cmpneq_pd(vMin_hi, vMax_hi);
6824 25982 : vMean_hi = blendv_pd(vMin_hi, vNewMean_hi, vMinNotSameAsMax_hi);
6825 : const auto vNewM2_hi =
6826 51964 : fmadd_pd(vDelta_hi, sub_pd(vValues_hi, vMean_hi), vM2_hi);
6827 25982 : vM2_hi = blendv_pd(vM2_hi, vNewM2_hi, vMinNotSameAsMax_hi);
6828 : }
6829 : else
6830 : {
6831 16354 : vMean_hi = vNewMean_hi;
6832 49062 : vM2_hi = fmadd_pd(vDelta_hi, sub_pd(vValues_hi, vMean_hi), vM2_hi);
6833 : }
6834 : }
6835 1351 : const double dfValidVectorCount = cvtsd_f64(vValidCount);
6836 1351 : if (dfValidVectorCount > 0)
6837 : {
6838 : double adfMin[VALS_PER_LOOP], adfMax[VALS_PER_LOOP],
6839 : adfMean[VALS_PER_LOOP], adfM2[VALS_PER_LOOP];
6840 : storeu_pd(adfMin, vMin_lo);
6841 : storeu_pd(adfMax, vMax_lo);
6842 : storeu_pd(adfMean, vMean_lo);
6843 : storeu_pd(adfM2, vM2_lo);
6844 801 : storeu_pd(adfMin + VALS_PER_LOOP / 2, vMin_hi);
6845 801 : storeu_pd(adfMax + VALS_PER_LOOP / 2, vMax_hi);
6846 801 : storeu_pd(adfMean + VALS_PER_LOOP / 2, vMean_hi);
6847 801 : storeu_pd(adfM2 + VALS_PER_LOOP / 2, vM2_hi);
6848 :
6849 4005 : for (int i = 0; i < VALS_PER_LOOP; ++i)
6850 : {
6851 3204 : dfMin = std::min(dfMin, adfMin[i]);
6852 3204 : dfMax = std::max(dfMax, adfMax[i]);
6853 3204 : const auto dfNewValidCount = dfBlockValidCount + dfValidVectorCount;
6854 3204 : if (adfMean[i] != dfBlockMean)
6855 : {
6856 1874 : const double dfDelta = adfMean[i] - dfBlockMean;
6857 1874 : dfBlockMean += dfDelta * dfValidVectorCount / dfNewValidCount;
6858 1874 : dfBlockM2 += adfM2[i] + dfDelta * dfDelta * dfBlockValidCount *
6859 1874 : dfValidVectorCount /
6860 : dfNewValidCount;
6861 : }
6862 3204 : dfBlockValidCount = dfNewValidCount;
6863 : }
6864 : }
6865 :
6866 1351 : return iX;
6867 : }
6868 :
6869 : #endif
6870 :
6871 : /************************************************************************/
6872 : /* ComputeStatistics() */
6873 : /************************************************************************/
6874 :
6875 : /**
6876 : * \brief Compute image statistics.
6877 : *
6878 : * Returns the minimum, maximum, mean and standard deviation of all
6879 : * pixel values in this band. If approximate statistics are sufficient,
6880 : * the bApproxOK flag can be set to true in which case overviews, or a
6881 : * subset of image tiles may be used in computing the statistics.
6882 : *
6883 : * Once computed, the statistics will generally be "set" back on the
6884 : * raster band using SetStatistics().
6885 : *
6886 : * Cached statistics can be cleared with GDALDataset::ClearStatistics().
6887 : *
6888 : * This method is the same as the C function GDALComputeRasterStatistics().
6889 : *
6890 : * @param bApproxOK If TRUE statistics may be computed based on overviews
6891 : * or a subset of all tiles.
6892 : *
6893 : * @param pdfMin Location into which to load image minimum (may be NULL).
6894 : *
6895 : * @param pdfMax Location into which to load image maximum (may be NULL).-
6896 : *
6897 : * @param pdfMean Location into which to load image mean (may be NULL).
6898 : *
6899 : * @param pdfStdDev Location into which to load image standard deviation
6900 : * (may be NULL).
6901 : *
6902 : * @param pfnProgress a function to call to report progress, or NULL.
6903 : *
6904 : * @param pProgressData application data to pass to the progress function.
6905 : *
6906 : * @return CE_None on success, or CE_Failure if an error occurs or processing
6907 : * is terminated by the user.
6908 : */
6909 :
6910 512 : CPLErr GDALRasterBand::ComputeStatistics(int bApproxOK, double *pdfMin,
6911 : double *pdfMax, double *pdfMean,
6912 : double *pdfStdDev,
6913 : GDALProgressFunc pfnProgress,
6914 : void *pProgressData)
6915 :
6916 : {
6917 512 : if (pfnProgress == nullptr)
6918 183 : pfnProgress = GDALDummyProgress;
6919 :
6920 : /* -------------------------------------------------------------------- */
6921 : /* If we have overview bands, use them for statistics. */
6922 : /* -------------------------------------------------------------------- */
6923 512 : if (bApproxOK && GetOverviewCount() > 0 && !HasArbitraryOverviews())
6924 : {
6925 : GDALRasterBand *poBand =
6926 3 : GetRasterSampleOverview(GDALSTAT_APPROX_NUMSAMPLES);
6927 :
6928 3 : if (poBand != this)
6929 : {
6930 6 : CPLErr eErr = poBand->ComputeStatistics(FALSE, pdfMin, pdfMax,
6931 : pdfMean, pdfStdDev,
6932 3 : pfnProgress, pProgressData);
6933 3 : if (eErr == CE_None)
6934 : {
6935 3 : if (pdfMin && pdfMax && pdfMean && pdfStdDev)
6936 : {
6937 3 : SetMetadataItem("STATISTICS_APPROXIMATE", "YES");
6938 3 : SetStatistics(*pdfMin, *pdfMax, *pdfMean, *pdfStdDev);
6939 : }
6940 :
6941 : /* transfer metadata from overview band to this */
6942 : const char *pszPercentValid =
6943 3 : poBand->GetMetadataItem("STATISTICS_VALID_PERCENT");
6944 :
6945 3 : if (pszPercentValid != nullptr)
6946 : {
6947 3 : SetMetadataItem("STATISTICS_VALID_PERCENT",
6948 3 : pszPercentValid);
6949 : }
6950 : }
6951 3 : return eErr;
6952 : }
6953 : }
6954 :
6955 509 : if (!pfnProgress(0.0, "Compute Statistics", pProgressData))
6956 : {
6957 0 : ReportError(CE_Failure, CPLE_UserInterrupt, "User terminated");
6958 0 : return CE_Failure;
6959 : }
6960 :
6961 : /* -------------------------------------------------------------------- */
6962 : /* Read actual data and compute statistics. */
6963 : /* -------------------------------------------------------------------- */
6964 : // Using Welford algorithm:
6965 : // http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
6966 : // to compute standard deviation in a more numerically robust way than
6967 : // the difference of the sum of square values with the square of the sum.
6968 : // dfMean and dfM2 are updated at each sample.
6969 : // dfM2 is the sum of square of differences to the current mean.
6970 509 : double dfMin = std::numeric_limits<double>::infinity();
6971 509 : double dfMax = -std::numeric_limits<double>::infinity();
6972 509 : double dfMean = 0.0;
6973 509 : double dfM2 = 0.0;
6974 :
6975 : GDALRasterIOExtraArg sExtraArg;
6976 509 : INIT_RASTERIO_EXTRA_ARG(sExtraArg);
6977 :
6978 509 : GDALNoDataValues sNoDataValues(this, eDataType);
6979 508 : GDALRasterBand *poMaskBand = nullptr;
6980 508 : if (!sNoDataValues.bGotNoDataValue)
6981 : {
6982 475 : const int l_nMaskFlags = GetMaskFlags();
6983 521 : if (l_nMaskFlags != GMF_ALL_VALID &&
6984 46 : GetColorInterpretation() != GCI_AlphaBand)
6985 : {
6986 46 : poMaskBand = GetMaskBand();
6987 : }
6988 : }
6989 :
6990 508 : bool bSignedByte = false;
6991 508 : if (eDataType == GDT_Byte)
6992 : {
6993 211 : EnablePixelTypeSignedByteWarning(false);
6994 : const char *pszPixelType =
6995 212 : GetMetadataItem("PIXELTYPE", "IMAGE_STRUCTURE");
6996 210 : EnablePixelTypeSignedByteWarning(true);
6997 210 : bSignedByte =
6998 210 : pszPixelType != nullptr && EQUAL(pszPixelType, "SIGNEDBYTE");
6999 : }
7000 :
7001 507 : GUIntBig nSampleCount = 0;
7002 507 : GUIntBig nValidCount = 0;
7003 :
7004 507 : if (bApproxOK && HasArbitraryOverviews())
7005 : {
7006 : /* --------------------------------------------------------------------
7007 : */
7008 : /* Figure out how much the image should be reduced to get an */
7009 : /* approximate value. */
7010 : /* --------------------------------------------------------------------
7011 : */
7012 0 : double dfReduction = sqrt(static_cast<double>(nRasterXSize) *
7013 0 : nRasterYSize / GDALSTAT_APPROX_NUMSAMPLES);
7014 :
7015 0 : int nXReduced = nRasterXSize;
7016 0 : int nYReduced = nRasterYSize;
7017 0 : if (dfReduction > 1.0)
7018 : {
7019 0 : nXReduced = static_cast<int>(nRasterXSize / dfReduction);
7020 0 : nYReduced = static_cast<int>(nRasterYSize / dfReduction);
7021 :
7022 : // Catch the case of huge resizing ratios here
7023 0 : if (nXReduced == 0)
7024 0 : nXReduced = 1;
7025 0 : if (nYReduced == 0)
7026 0 : nYReduced = 1;
7027 : }
7028 :
7029 0 : void *pData = CPLMalloc(cpl::fits_on<int>(
7030 0 : GDALGetDataTypeSizeBytes(eDataType) * nXReduced * nYReduced));
7031 :
7032 : const CPLErr eErr =
7033 0 : IRasterIO(GF_Read, 0, 0, nRasterXSize, nRasterYSize, pData,
7034 0 : nXReduced, nYReduced, eDataType, 0, 0, &sExtraArg);
7035 0 : if (eErr != CE_None)
7036 : {
7037 0 : CPLFree(pData);
7038 0 : return eErr;
7039 : }
7040 :
7041 0 : GByte *pabyMaskData = nullptr;
7042 0 : if (poMaskBand)
7043 : {
7044 : pabyMaskData =
7045 0 : static_cast<GByte *>(VSI_MALLOC2_VERBOSE(nXReduced, nYReduced));
7046 0 : if (!pabyMaskData)
7047 : {
7048 0 : CPLFree(pData);
7049 0 : return CE_Failure;
7050 : }
7051 :
7052 0 : if (poMaskBand->RasterIO(GF_Read, 0, 0, nRasterXSize, nRasterYSize,
7053 : pabyMaskData, nXReduced, nYReduced,
7054 0 : GDT_Byte, 0, 0, nullptr) != CE_None)
7055 : {
7056 0 : CPLFree(pData);
7057 0 : CPLFree(pabyMaskData);
7058 0 : return CE_Failure;
7059 : }
7060 : }
7061 :
7062 : /* this isn't the fastest way to do this, but is easier for now */
7063 0 : for (int iY = 0; iY < nYReduced; iY++)
7064 : {
7065 0 : for (int iX = 0; iX < nXReduced; iX++)
7066 : {
7067 0 : const int iOffset = iX + iY * nXReduced;
7068 0 : if (pabyMaskData && pabyMaskData[iOffset] == 0)
7069 0 : continue;
7070 :
7071 0 : bool bValid = true;
7072 0 : double dfValue = GetPixelValue(eDataType, bSignedByte, pData,
7073 0 : iOffset, sNoDataValues, bValid);
7074 0 : if (!bValid)
7075 0 : continue;
7076 :
7077 0 : dfMin = std::min(dfMin, dfValue);
7078 0 : dfMax = std::max(dfMax, dfValue);
7079 :
7080 0 : nValidCount++;
7081 0 : if (dfMin == dfMax)
7082 : {
7083 0 : if (nValidCount == 1)
7084 0 : dfMean = dfMin;
7085 : }
7086 : else
7087 : {
7088 0 : const double dfDelta = dfValue - dfMean;
7089 0 : dfMean += dfDelta / nValidCount;
7090 0 : dfM2 += dfDelta * (dfValue - dfMean);
7091 : }
7092 : }
7093 : }
7094 :
7095 0 : nSampleCount = static_cast<GUIntBig>(nXReduced) * nYReduced;
7096 :
7097 0 : CPLFree(pData);
7098 0 : CPLFree(pabyMaskData);
7099 : }
7100 :
7101 : else // No arbitrary overviews.
7102 : {
7103 507 : if (!InitBlockInfo())
7104 240 : return CE_Failure;
7105 :
7106 : /* --------------------------------------------------------------------
7107 : */
7108 : /* Figure out the ratio of blocks we will read to get an */
7109 : /* approximate value. */
7110 : /* --------------------------------------------------------------------
7111 : */
7112 509 : int nSampleRate = 1;
7113 509 : if (bApproxOK)
7114 : {
7115 43 : nSampleRate = static_cast<int>(std::max(
7116 86 : 1.0,
7117 43 : sqrt(static_cast<double>(nBlocksPerRow) * nBlocksPerColumn)));
7118 : // We want to avoid probing only the first column of blocks for
7119 : // a square shaped raster, because it is not unlikely that it may
7120 : // be padding only (#6378)
7121 43 : if (nSampleRate == nBlocksPerRow && nBlocksPerRow > 1)
7122 1 : nSampleRate += 1;
7123 : }
7124 509 : if (nSampleRate == 1)
7125 473 : bApproxOK = false;
7126 :
7127 : // Particular case for GDT_Byte and GUInt16 that only use integral types
7128 : // for each block, and possibly for the whole raster.
7129 509 : if (!poMaskBand && ((eDataType == GDT_Byte && !bSignedByte) ||
7130 267 : eDataType == GDT_UInt16))
7131 : {
7132 : // We can do integer computation on the whole raster in the Byte case
7133 : // only if the number of pixels explored is lower than
7134 : // GUINTBIG_MAX / (255*255), so that nSumSquare can fit on a uint64.
7135 : // Should be 99.99999% of cases.
7136 : // For GUInt16, this limits to raster of 4 giga pixels
7137 :
7138 : const bool bIntegerStats =
7139 436 : ((eDataType == GDT_Byte &&
7140 194 : static_cast<GUIntBig>(nBlocksPerRow) * nBlocksPerColumn /
7141 194 : nSampleRate <
7142 194 : GUINTBIG_MAX / (255U * 255U) /
7143 194 : (static_cast<GUInt64>(nBlockXSize) *
7144 194 : static_cast<GUInt64>(nBlockYSize))) ||
7145 48 : (eDataType == GDT_UInt16 &&
7146 47 : static_cast<GUIntBig>(nBlocksPerRow) * nBlocksPerColumn /
7147 47 : nSampleRate <
7148 47 : GUINTBIG_MAX / (65535U * 65535U) /
7149 47 : (static_cast<GUInt64>(nBlockXSize) *
7150 532 : static_cast<GUInt64>(nBlockYSize)))) &&
7151 : // Can be set to NO for easier debugging of the !bIntegerStats
7152 : // case which requires huge rasters to trigger
7153 242 : CPLTestBool(
7154 242 : CPLGetConfigOption("GDAL_STATS_USE_INTEGER_STATS", "YES"));
7155 :
7156 242 : const GUInt32 nMaxValueType = (eDataType == GDT_Byte) ? 255 : 65535;
7157 242 : GUInt32 nMin = nMaxValueType;
7158 242 : GUInt32 nMax = 0;
7159 242 : GUIntBig nSum = 0;
7160 242 : GUIntBig nSumSquare = 0;
7161 : // If no valid nodata, map to invalid value (256 for Byte)
7162 242 : const GUInt32 nNoDataValue =
7163 269 : (sNoDataValues.bGotNoDataValue &&
7164 27 : sNoDataValues.dfNoDataValue >= 0 &&
7165 27 : sNoDataValues.dfNoDataValue <= nMaxValueType &&
7166 27 : fabs(sNoDataValues.dfNoDataValue -
7167 27 : static_cast<GUInt32>(sNoDataValues.dfNoDataValue +
7168 : 1e-10)) < 1e-10)
7169 269 : ? static_cast<GUInt32>(sNoDataValues.dfNoDataValue + 1e-10)
7170 : : nMaxValueType + 1;
7171 :
7172 242 : for (GIntBig iSampleBlock = 0;
7173 13077 : iSampleBlock <
7174 13077 : static_cast<GIntBig>(nBlocksPerRow) * nBlocksPerColumn;
7175 12835 : iSampleBlock += nSampleRate)
7176 : {
7177 12835 : const int iYBlock =
7178 12835 : static_cast<int>(iSampleBlock / nBlocksPerRow);
7179 12835 : const int iXBlock =
7180 12835 : static_cast<int>(iSampleBlock % nBlocksPerRow);
7181 :
7182 : GDALRasterBlock *const poBlock =
7183 12835 : GetLockedBlockRef(iXBlock, iYBlock);
7184 12836 : if (poBlock == nullptr)
7185 0 : return CE_Failure;
7186 :
7187 12836 : void *const pData = poBlock->GetDataRef();
7188 :
7189 12831 : int nXCheck = 0, nYCheck = 0;
7190 12831 : GetActualBlockSize(iXBlock, iYBlock, &nXCheck, &nYCheck);
7191 :
7192 12832 : GUIntBig nBlockSum = 0;
7193 12832 : GUIntBig nBlockSumSquare = 0;
7194 12832 : GUIntBig nBlockSampleCount = 0;
7195 12832 : GUIntBig nBlockValidCount = 0;
7196 12832 : GUIntBig &nBlockSumRef = bIntegerStats ? nSum : nBlockSum;
7197 12832 : GUIntBig &nBlockSumSquareRef =
7198 : bIntegerStats ? nSumSquare : nBlockSumSquare;
7199 12832 : GUIntBig &nBlockSampleCountRef =
7200 : bIntegerStats ? nSampleCount : nBlockSampleCount;
7201 12832 : GUIntBig &nBlockValidCountRef =
7202 : bIntegerStats ? nValidCount : nBlockValidCount;
7203 :
7204 12832 : if (eDataType == GDT_Byte)
7205 : {
7206 : ComputeStatisticsInternal<
7207 : GByte, /* COMPUTE_OTHER_STATS = */ true>::
7208 12145 : f(nXCheck, nBlockXSize, nYCheck,
7209 : static_cast<const GByte *>(pData),
7210 : nNoDataValue <= nMaxValueType, nNoDataValue, nMin,
7211 : nMax, nBlockSumRef, nBlockSumSquareRef,
7212 : nBlockSampleCountRef, nBlockValidCountRef);
7213 : }
7214 : else
7215 : {
7216 : ComputeStatisticsInternal<
7217 : GUInt16, /* COMPUTE_OTHER_STATS = */ true>::
7218 687 : f(nXCheck, nBlockXSize, nYCheck,
7219 : static_cast<const GUInt16 *>(pData),
7220 : nNoDataValue <= nMaxValueType, nNoDataValue, nMin,
7221 : nMax, nBlockSumRef, nBlockSumSquareRef,
7222 : nBlockSampleCountRef, nBlockValidCountRef);
7223 : }
7224 :
7225 12833 : poBlock->DropLock();
7226 :
7227 12835 : if (!bIntegerStats)
7228 : {
7229 169 : nSampleCount += nBlockSampleCount;
7230 169 : if (nBlockValidCount)
7231 : {
7232 : // Update the global mean and M2 (the difference of the
7233 : // square to the mean) from the values of the block
7234 : // using https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Parallel_algorithm
7235 169 : const double dfBlockValidCount =
7236 169 : static_cast<double>(nBlockValidCount);
7237 169 : const double dfBlockMean =
7238 169 : static_cast<double>(nBlockSum) / dfBlockValidCount;
7239 : const double dfBlockM2 =
7240 169 : static_cast<double>(
7241 169 : GDALUInt128::Mul(nBlockSumSquare,
7242 169 : nBlockValidCount) -
7243 338 : GDALUInt128::Mul(nBlockSum, nBlockSum)) /
7244 169 : dfBlockValidCount;
7245 169 : const double dfDelta = dfBlockMean - dfMean;
7246 169 : const auto nNewValidCount =
7247 169 : nValidCount + nBlockValidCount;
7248 169 : const double dfNewValidCount =
7249 : static_cast<double>(nNewValidCount);
7250 169 : dfMean +=
7251 169 : dfDelta * (dfBlockValidCount / dfNewValidCount);
7252 169 : dfM2 +=
7253 169 : dfBlockM2 + dfDelta * dfDelta *
7254 169 : static_cast<double>(nValidCount) *
7255 169 : dfBlockValidCount / dfNewValidCount;
7256 169 : nValidCount = nNewValidCount;
7257 : }
7258 : }
7259 :
7260 12835 : if (!pfnProgress(static_cast<double>(iSampleBlock) /
7261 12835 : (static_cast<double>(nBlocksPerRow) *
7262 12835 : nBlocksPerColumn),
7263 : "Compute Statistics", pProgressData))
7264 : {
7265 0 : ReportError(CE_Failure, CPLE_UserInterrupt,
7266 : "User terminated");
7267 0 : return CE_Failure;
7268 : }
7269 : }
7270 :
7271 242 : if (!pfnProgress(1.0, "Compute Statistics", pProgressData))
7272 : {
7273 0 : ReportError(CE_Failure, CPLE_UserInterrupt, "User terminated");
7274 0 : return CE_Failure;
7275 : }
7276 :
7277 242 : double dfStdDev = 0;
7278 242 : if (bIntegerStats)
7279 : {
7280 218 : if (nValidCount)
7281 209 : dfMean = static_cast<double>(nSum) / nValidCount;
7282 :
7283 : // To avoid potential precision issues when doing the difference,
7284 : // we need to do that computation on 128 bit rather than casting
7285 : // to double
7286 : const GDALUInt128 nTmpForStdDev(
7287 218 : GDALUInt128::Mul(nSumSquare, nValidCount) -
7288 436 : GDALUInt128::Mul(nSum, nSum));
7289 216 : dfStdDev =
7290 217 : nValidCount > 0
7291 217 : ? sqrt(static_cast<double>(nTmpForStdDev)) / nValidCount
7292 : : 0.0;
7293 : }
7294 24 : else if (nValidCount > 0)
7295 : {
7296 24 : dfStdDev = sqrt(dfM2 / static_cast<double>(nValidCount));
7297 : }
7298 :
7299 : /// Save computed information
7300 240 : if (nValidCount > 0)
7301 : {
7302 232 : if (bApproxOK)
7303 : {
7304 24 : SetMetadataItem("STATISTICS_APPROXIMATE", "YES");
7305 : }
7306 208 : else if (GetMetadataItem("STATISTICS_APPROXIMATE"))
7307 : {
7308 3 : SetMetadataItem("STATISTICS_APPROXIMATE", nullptr);
7309 : }
7310 233 : SetStatistics(nMin, nMax, dfMean, dfStdDev);
7311 : }
7312 :
7313 241 : SetValidPercent(nSampleCount, nValidCount);
7314 :
7315 : /* --------------------------------------------------------------------
7316 : */
7317 : /* Record results. */
7318 : /* --------------------------------------------------------------------
7319 : */
7320 241 : if (pdfMin != nullptr)
7321 239 : *pdfMin = nValidCount ? nMin : 0;
7322 241 : if (pdfMax != nullptr)
7323 237 : *pdfMax = nValidCount ? nMax : 0;
7324 :
7325 241 : if (pdfMean != nullptr)
7326 233 : *pdfMean = dfMean;
7327 :
7328 241 : if (pdfStdDev != nullptr)
7329 233 : *pdfStdDev = dfStdDev;
7330 :
7331 241 : if (nValidCount > 0)
7332 231 : return CE_None;
7333 :
7334 10 : ReportError(CE_Failure, CPLE_AppDefined,
7335 : "Failed to compute statistics, no valid pixels found "
7336 : "in sampling.");
7337 9 : return CE_Failure;
7338 : }
7339 :
7340 267 : GByte *pabyMaskData = nullptr;
7341 267 : if (poMaskBand)
7342 : {
7343 : pabyMaskData = static_cast<GByte *>(
7344 46 : VSI_MALLOC2_VERBOSE(nBlockXSize, nBlockYSize));
7345 46 : if (!pabyMaskData)
7346 : {
7347 0 : return CE_Failure;
7348 : }
7349 : }
7350 :
7351 267 : float fMin = std::numeric_limits<float>::infinity();
7352 267 : float fMax = -std::numeric_limits<float>::infinity();
7353 : const bool bFloat32Optim =
7354 44 : eDataType == GDT_Float32 && !pabyMaskData &&
7355 329 : nBlockXSize < std::numeric_limits<int>::max() / nBlockYSize &&
7356 18 : CPLTestBool(
7357 267 : CPLGetConfigOption("GDAL_STATS_USE_FLOAT32_OPTIM", "YES"));
7358 :
7359 : #if (defined(__x86_64__) || defined(_M_X64))
7360 : const bool bFloat64Optim =
7361 13 : eDataType == GDT_Float64 && !pabyMaskData &&
7362 293 : nBlockXSize < std::numeric_limits<int>::max() / nBlockYSize &&
7363 13 : CPLTestBool(
7364 267 : CPLGetConfigOption("GDAL_STATS_USE_FLOAT64_OPTIM", "YES"));
7365 : #endif
7366 :
7367 267 : for (GIntBig iSampleBlock = 0;
7368 5918 : iSampleBlock <
7369 5918 : static_cast<GIntBig>(nBlocksPerRow) * nBlocksPerColumn;
7370 5651 : iSampleBlock += nSampleRate)
7371 : {
7372 5651 : const int iYBlock = static_cast<int>(iSampleBlock / nBlocksPerRow);
7373 5651 : const int iXBlock = static_cast<int>(iSampleBlock % nBlocksPerRow);
7374 :
7375 5651 : int nXCheck = 0, nYCheck = 0;
7376 5651 : GetActualBlockSize(iXBlock, iYBlock, &nXCheck, &nYCheck);
7377 :
7378 6224 : if (poMaskBand &&
7379 573 : poMaskBand->RasterIO(GF_Read, iXBlock * nBlockXSize,
7380 573 : iYBlock * nBlockYSize, nXCheck, nYCheck,
7381 : pabyMaskData, nXCheck, nYCheck, GDT_Byte,
7382 573 : 0, nBlockXSize, nullptr) != CE_None)
7383 : {
7384 0 : CPLFree(pabyMaskData);
7385 0 : return CE_Failure;
7386 : }
7387 :
7388 : GDALRasterBlock *const poBlock =
7389 5651 : GetLockedBlockRef(iXBlock, iYBlock);
7390 5651 : if (poBlock == nullptr)
7391 : {
7392 0 : CPLFree(pabyMaskData);
7393 0 : return CE_Failure;
7394 : }
7395 :
7396 5651 : const void *const pData = poBlock->GetDataRef();
7397 :
7398 5651 : if (bFloat32Optim)
7399 : {
7400 2330 : const bool bHasNoData = sNoDataValues.bGotFloatNoDataValue &&
7401 0 : !std::isnan(sNoDataValues.fNoDataValue);
7402 2330 : float fBlockMean = 0.0f;
7403 2330 : float fBlockM2 = 0.0f;
7404 2330 : int nBlockValidCount = 0;
7405 7219 : for (int iY = 0; iY < nYCheck; iY++)
7406 : {
7407 4889 : const int iOffset = iY * nBlockXSize;
7408 4889 : if (nBlockValidCount && fMin != fMax)
7409 : {
7410 2432 : int iX = 0;
7411 : #if (defined(__x86_64__) || defined(_M_X64))
7412 2432 : if (bHasNoData)
7413 : {
7414 : iX = ComputeStatisticsFloat32_SSE2<
7415 : /* bCheckMinEqMax = */ false,
7416 0 : /* bHasNoData = */ true>(
7417 0 : static_cast<const float *>(pData) + iOffset,
7418 : sNoDataValues.fNoDataValue, iX, nXCheck, fMin,
7419 : fMax, fBlockMean, fBlockM2, nBlockValidCount);
7420 : }
7421 : else
7422 : {
7423 : iX = ComputeStatisticsFloat32_SSE2<
7424 : /* bCheckMinEqMax = */ false,
7425 2432 : /* bHasNoData = */ false>(
7426 2432 : static_cast<const float *>(pData) + iOffset,
7427 : sNoDataValues.fNoDataValue, iX, nXCheck, fMin,
7428 : fMax, fBlockMean, fBlockM2, nBlockValidCount);
7429 : }
7430 : #endif
7431 2961 : for (; iX < nXCheck; iX++)
7432 : {
7433 529 : const float fValue =
7434 529 : static_cast<const float *>(pData)[iOffset + iX];
7435 529 : if (std::isnan(fValue) ||
7436 0 : (bHasNoData &&
7437 0 : fValue == sNoDataValues.fNoDataValue))
7438 11 : continue;
7439 518 : fMin = std::min(fMin, fValue);
7440 518 : fMax = std::max(fMax, fValue);
7441 518 : ++nBlockValidCount;
7442 518 : const float fDelta = fValue - fBlockMean;
7443 518 : fBlockMean +=
7444 518 : fDelta / static_cast<float>(nBlockValidCount);
7445 518 : fBlockM2 += fDelta * (fValue - fBlockMean);
7446 2432 : }
7447 : }
7448 : else
7449 : {
7450 2457 : int iX = 0;
7451 2457 : if (nBlockValidCount == 0)
7452 : {
7453 2330 : for (; iX < nXCheck; iX++)
7454 : {
7455 2330 : const float fValue = static_cast<const float *>(
7456 2330 : pData)[iOffset + iX];
7457 2330 : if (std::isnan(fValue) ||
7458 0 : (bHasNoData &&
7459 0 : fValue == sNoDataValues.fNoDataValue))
7460 0 : continue;
7461 2330 : fMin = std::min(fMin, fValue);
7462 2330 : fMax = std::max(fMax, fValue);
7463 2330 : nBlockValidCount = 1;
7464 2330 : fBlockMean = fValue;
7465 2330 : iX++;
7466 2330 : break;
7467 : }
7468 : }
7469 : #if (defined(__x86_64__) || defined(_M_X64))
7470 2457 : if (bHasNoData)
7471 : {
7472 : iX = ComputeStatisticsFloat32_SSE2<
7473 : /* bCheckMinEqMax = */ true,
7474 0 : /* bHasNoData = */ true>(
7475 0 : static_cast<const float *>(pData) + iOffset,
7476 : sNoDataValues.fNoDataValue, iX, nXCheck, fMin,
7477 : fMax, fBlockMean, fBlockM2, nBlockValidCount);
7478 : }
7479 : else
7480 : {
7481 : iX = ComputeStatisticsFloat32_SSE2<
7482 : /* bCheckMinEqMax = */ true,
7483 2457 : /* bHasNoData = */ false>(
7484 2457 : static_cast<const float *>(pData) + iOffset,
7485 : sNoDataValues.fNoDataValue, iX, nXCheck, fMin,
7486 : fMax, fBlockMean, fBlockM2, nBlockValidCount);
7487 : }
7488 : #endif
7489 17534 : for (; iX < nXCheck; iX++)
7490 : {
7491 15077 : const float fValue =
7492 15077 : static_cast<const float *>(pData)[iOffset + iX];
7493 15077 : if (std::isnan(fValue) ||
7494 0 : (bHasNoData &&
7495 0 : fValue == sNoDataValues.fNoDataValue))
7496 1 : continue;
7497 15076 : fMin = std::min(fMin, fValue);
7498 15076 : fMax = std::max(fMax, fValue);
7499 15076 : ++nBlockValidCount;
7500 15076 : if (fMin != fMax)
7501 : {
7502 7123 : const float fDelta = fValue - fBlockMean;
7503 7123 : fBlockMean += fDelta / static_cast<float>(
7504 : nBlockValidCount);
7505 7123 : fBlockM2 += fDelta * (fValue - fBlockMean);
7506 : }
7507 : }
7508 : }
7509 : }
7510 :
7511 2330 : if (nBlockValidCount)
7512 : {
7513 : // Update the global mean and M2 (the difference of the
7514 : // square to the mean) from the values of the block
7515 : // using https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Parallel_algorithm
7516 2330 : const auto nNewValidCount = nValidCount + nBlockValidCount;
7517 2330 : const double dfBlockMean = static_cast<double>(fBlockMean);
7518 2330 : if (dfBlockMean != dfMean)
7519 : {
7520 1066 : const double dfBlockM2 = static_cast<double>(fBlockM2);
7521 1066 : if (nValidCount == 0)
7522 : {
7523 13 : dfMean = dfBlockMean;
7524 13 : dfM2 = dfBlockM2;
7525 : }
7526 : else
7527 : {
7528 1053 : const double dfBlockValidCount =
7529 1053 : static_cast<double>(nBlockValidCount);
7530 1053 : const double dfDelta = dfBlockMean - dfMean;
7531 1053 : const double dfNewValidCount =
7532 : static_cast<double>(nNewValidCount);
7533 1053 : dfMean +=
7534 1053 : dfDelta * (dfBlockValidCount / dfNewValidCount);
7535 1053 : dfM2 += dfBlockM2 +
7536 1053 : dfDelta * dfDelta *
7537 1053 : static_cast<double>(nValidCount) *
7538 1053 : dfBlockValidCount / dfNewValidCount;
7539 : }
7540 : }
7541 2330 : nValidCount = nNewValidCount;
7542 : }
7543 : }
7544 :
7545 : #if (defined(__x86_64__) || defined(_M_X64))
7546 3321 : else if (bFloat64Optim)
7547 : {
7548 : const bool bHasNoData =
7549 545 : sNoDataValues.bGotNoDataValue &&
7550 263 : !std::isnan(sNoDataValues.dfNoDataValue);
7551 282 : double dfBlockMean = 0;
7552 282 : double dfBlockM2 = 0;
7553 282 : double dfBlockValidCount = 0;
7554 1633 : for (int iY = 0; iY < nYCheck; iY++)
7555 : {
7556 1351 : const int iOffset = iY * nBlockXSize;
7557 1351 : if (dfBlockValidCount != 0 && dfMin != dfMax)
7558 : {
7559 813 : int iX = 0;
7560 813 : if (bHasNoData)
7561 : {
7562 : iX = ComputeStatisticsFloat64_SSE2<
7563 : /* bCheckMinEqMax = */ false,
7564 381 : /* bHasNoData = */ true>(
7565 381 : static_cast<const double *>(pData) + iOffset,
7566 : sNoDataValues.dfNoDataValue, iX, nXCheck, dfMin,
7567 : dfMax, dfBlockMean, dfBlockM2,
7568 : dfBlockValidCount);
7569 : }
7570 : else
7571 : {
7572 : iX = ComputeStatisticsFloat64_SSE2<
7573 : /* bCheckMinEqMax = */ false,
7574 432 : /* bHasNoData = */ false>(
7575 432 : static_cast<const double *>(pData) + iOffset,
7576 : sNoDataValues.dfNoDataValue, iX, nXCheck, dfMin,
7577 : dfMax, dfBlockMean, dfBlockM2,
7578 : dfBlockValidCount);
7579 : }
7580 1931 : for (; iX < nXCheck; iX++)
7581 : {
7582 1118 : const double dfValue = static_cast<const double *>(
7583 1118 : pData)[iOffset + iX];
7584 1625 : if (std::isnan(dfValue) ||
7585 507 : (bHasNoData &&
7586 507 : dfValue == sNoDataValues.dfNoDataValue))
7587 53 : continue;
7588 1065 : dfMin = std::min(dfMin, dfValue);
7589 1065 : dfMax = std::max(dfMax, dfValue);
7590 1065 : dfBlockValidCount += 1.0;
7591 1065 : const double dfDelta = dfValue - dfBlockMean;
7592 1065 : dfBlockMean += dfDelta / dfBlockValidCount;
7593 1065 : dfBlockM2 += dfDelta * (dfValue - dfBlockMean);
7594 813 : }
7595 : }
7596 : else
7597 : {
7598 538 : int iX = 0;
7599 538 : if (dfBlockValidCount == 0)
7600 : {
7601 7661 : for (; iX < nXCheck; iX++)
7602 : {
7603 7627 : const double dfValue =
7604 : static_cast<const double *>(
7605 7627 : pData)[iOffset + iX];
7606 15235 : if (std::isnan(dfValue) ||
7607 7608 : (bHasNoData &&
7608 7608 : dfValue == sNoDataValues.dfNoDataValue))
7609 7377 : continue;
7610 250 : dfMin = std::min(dfMin, dfValue);
7611 250 : dfMax = std::max(dfMax, dfValue);
7612 250 : dfBlockValidCount = 1;
7613 250 : dfBlockMean = dfValue;
7614 250 : iX++;
7615 250 : break;
7616 : }
7617 : }
7618 538 : if (bHasNoData)
7619 : {
7620 : iX = ComputeStatisticsFloat64_SSE2<
7621 : /* bCheckMinEqMax = */ true,
7622 392 : /* bHasNoData = */ true>(
7623 392 : static_cast<const double *>(pData) + iOffset,
7624 : sNoDataValues.dfNoDataValue, iX, nXCheck, dfMin,
7625 : dfMax, dfBlockMean, dfBlockM2,
7626 : dfBlockValidCount);
7627 : }
7628 : else
7629 : {
7630 : iX = ComputeStatisticsFloat64_SSE2<
7631 : /* bCheckMinEqMax = */ true,
7632 146 : /* bHasNoData = */ false>(
7633 146 : static_cast<const double *>(pData) + iOffset,
7634 : sNoDataValues.dfNoDataValue, iX, nXCheck, dfMin,
7635 : dfMax, dfBlockMean, dfBlockM2,
7636 : dfBlockValidCount);
7637 : }
7638 1081 : for (; iX < nXCheck; iX++)
7639 : {
7640 543 : const double dfValue = static_cast<const double *>(
7641 543 : pData)[iOffset + iX];
7642 1065 : if (std::isnan(dfValue) ||
7643 522 : (bHasNoData &&
7644 522 : dfValue == sNoDataValues.dfNoDataValue))
7645 140 : continue;
7646 403 : dfMin = std::min(dfMin, dfValue);
7647 403 : dfMax = std::max(dfMax, dfValue);
7648 403 : dfBlockValidCount += 1.0;
7649 403 : if (dfMin != dfMax)
7650 : {
7651 128 : const double dfDelta = dfValue - dfBlockMean;
7652 128 : dfBlockMean += dfDelta / dfBlockValidCount;
7653 128 : dfBlockM2 += dfDelta * (dfValue - dfBlockMean);
7654 : }
7655 : }
7656 : }
7657 : }
7658 :
7659 282 : if (dfBlockValidCount > 0)
7660 : {
7661 : // Update the global mean and M2 (the difference of the
7662 : // square to the mean) from the values of the block
7663 : // using https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Parallel_algorithm
7664 250 : const auto nNewValidCount =
7665 250 : nValidCount + static_cast<int>(dfBlockValidCount);
7666 250 : if (dfBlockMean != dfMean)
7667 : {
7668 237 : if (nValidCount == 0)
7669 : {
7670 11 : dfMean = dfBlockMean;
7671 11 : dfM2 = dfBlockM2;
7672 : }
7673 : else
7674 : {
7675 226 : const double dfDelta = dfBlockMean - dfMean;
7676 226 : const double dfNewValidCount =
7677 : static_cast<double>(nNewValidCount);
7678 226 : dfMean +=
7679 226 : dfDelta * (dfBlockValidCount / dfNewValidCount);
7680 226 : dfM2 += dfBlockM2 +
7681 226 : dfDelta * dfDelta *
7682 226 : static_cast<double>(nValidCount) *
7683 226 : dfBlockValidCount / dfNewValidCount;
7684 : }
7685 : }
7686 250 : nValidCount = nNewValidCount;
7687 : }
7688 : }
7689 : #endif // (defined(__x86_64__) || defined(_M_X64))
7690 :
7691 : else
7692 : {
7693 : // This isn't the fastest way to do this, but is easier for now.
7694 8754 : for (int iY = 0; iY < nYCheck; iY++)
7695 : {
7696 5715 : if (nValidCount && dfMin != dfMax)
7697 : {
7698 212546 : for (int iX = 0; iX < nXCheck; iX++)
7699 : {
7700 209962 : const GPtrDiff_t iOffset =
7701 209962 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
7702 209962 : if (pabyMaskData && pabyMaskData[iOffset] == 0)
7703 9635 : continue;
7704 :
7705 200339 : bool bValid = true;
7706 : double dfValue =
7707 200339 : GetPixelValue(eDataType, bSignedByte, pData,
7708 200339 : iOffset, sNoDataValues, bValid);
7709 :
7710 200339 : if (!bValid)
7711 12 : continue;
7712 :
7713 200327 : dfMin = std::min(dfMin, dfValue);
7714 200327 : dfMax = std::max(dfMax, dfValue);
7715 :
7716 200327 : nValidCount++;
7717 200327 : const double dfDelta = dfValue - dfMean;
7718 200327 : dfMean += dfDelta / nValidCount;
7719 200327 : dfM2 += dfDelta * (dfValue - dfMean);
7720 2584 : }
7721 : }
7722 : else
7723 : {
7724 3131 : int iX = 0;
7725 3131 : if (nValidCount == 0)
7726 : {
7727 94577 : for (; iX < nXCheck; iX++)
7728 : {
7729 94520 : const GPtrDiff_t iOffset =
7730 94520 : iX +
7731 94520 : static_cast<GPtrDiff_t>(iY) * nBlockXSize;
7732 94520 : if (pabyMaskData && pabyMaskData[iOffset] == 0)
7733 94282 : continue;
7734 :
7735 239 : bool bValid = true;
7736 239 : double dfValue = GetPixelValue(
7737 : eDataType, bSignedByte, pData, iOffset,
7738 : sNoDataValues, bValid);
7739 :
7740 239 : if (!bValid)
7741 1 : continue;
7742 :
7743 238 : dfMin = dfValue;
7744 238 : dfMax = dfValue;
7745 238 : dfMean = dfValue;
7746 238 : nValidCount = 1;
7747 238 : iX++;
7748 238 : break;
7749 : }
7750 : }
7751 227675 : for (; iX < nXCheck; iX++)
7752 : {
7753 224544 : const GPtrDiff_t iOffset =
7754 224544 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
7755 224544 : if (pabyMaskData && pabyMaskData[iOffset] == 0)
7756 358 : continue;
7757 :
7758 224187 : bool bValid = true;
7759 : double dfValue =
7760 224187 : GetPixelValue(eDataType, bSignedByte, pData,
7761 224187 : iOffset, sNoDataValues, bValid);
7762 :
7763 224187 : if (!bValid)
7764 1 : continue;
7765 :
7766 224186 : dfMin = std::min(dfMin, dfValue);
7767 224186 : dfMax = std::max(dfMax, dfValue);
7768 :
7769 224186 : nValidCount++;
7770 224186 : if (dfMin != dfMax)
7771 : {
7772 2170 : const double dfDelta = dfValue - dfMean;
7773 2170 : dfMean += dfDelta / nValidCount;
7774 2170 : dfM2 += dfDelta * (dfValue - dfMean);
7775 : }
7776 : }
7777 : }
7778 : }
7779 : }
7780 :
7781 5651 : nSampleCount += static_cast<GUIntBig>(nXCheck) * nYCheck;
7782 :
7783 5651 : poBlock->DropLock();
7784 :
7785 5651 : if (!pfnProgress(
7786 5651 : static_cast<double>(iSampleBlock) /
7787 5651 : (static_cast<double>(nBlocksPerRow) * nBlocksPerColumn),
7788 : "Compute Statistics", pProgressData))
7789 : {
7790 0 : ReportError(CE_Failure, CPLE_UserInterrupt, "User terminated");
7791 0 : CPLFree(pabyMaskData);
7792 0 : return CE_Failure;
7793 : }
7794 : }
7795 :
7796 267 : if (bFloat32Optim)
7797 : {
7798 17 : dfMin = static_cast<double>(fMin);
7799 17 : dfMax = static_cast<double>(fMax);
7800 : }
7801 267 : CPLFree(pabyMaskData);
7802 : }
7803 :
7804 267 : if (!pfnProgress(1.0, "Compute Statistics", pProgressData))
7805 : {
7806 0 : ReportError(CE_Failure, CPLE_UserInterrupt, "User terminated");
7807 0 : return CE_Failure;
7808 : }
7809 :
7810 : /* -------------------------------------------------------------------- */
7811 : /* Save computed information. */
7812 : /* -------------------------------------------------------------------- */
7813 267 : const double dfStdDev = nValidCount > 0 ? sqrt(dfM2 / nValidCount) : 0.0;
7814 :
7815 267 : if (nValidCount > 0)
7816 : {
7817 266 : if (bApproxOK)
7818 : {
7819 8 : SetMetadataItem("STATISTICS_APPROXIMATE", "YES");
7820 : }
7821 258 : else if (GetMetadataItem("STATISTICS_APPROXIMATE"))
7822 : {
7823 2 : SetMetadataItem("STATISTICS_APPROXIMATE", nullptr);
7824 : }
7825 266 : SetStatistics(dfMin, dfMax, dfMean, dfStdDev);
7826 : }
7827 : else
7828 : {
7829 1 : dfMin = 0.0;
7830 1 : dfMax = 0.0;
7831 : }
7832 :
7833 267 : SetValidPercent(nSampleCount, nValidCount);
7834 :
7835 : /* -------------------------------------------------------------------- */
7836 : /* Record results. */
7837 : /* -------------------------------------------------------------------- */
7838 267 : if (pdfMin != nullptr)
7839 264 : *pdfMin = dfMin;
7840 267 : if (pdfMax != nullptr)
7841 264 : *pdfMax = dfMax;
7842 :
7843 267 : if (pdfMean != nullptr)
7844 261 : *pdfMean = dfMean;
7845 :
7846 267 : if (pdfStdDev != nullptr)
7847 261 : *pdfStdDev = dfStdDev;
7848 :
7849 267 : if (nValidCount > 0)
7850 266 : return CE_None;
7851 :
7852 1 : ReportError(
7853 : CE_Failure, CPLE_AppDefined,
7854 : "Failed to compute statistics, no valid pixels found in sampling.");
7855 1 : return CE_Failure;
7856 : }
7857 :
7858 : /************************************************************************/
7859 : /* GDALComputeRasterStatistics() */
7860 : /************************************************************************/
7861 :
7862 : /**
7863 : * \brief Compute image statistics.
7864 : *
7865 : * @see GDALRasterBand::ComputeStatistics()
7866 : */
7867 :
7868 169 : CPLErr CPL_STDCALL GDALComputeRasterStatistics(GDALRasterBandH hBand,
7869 : int bApproxOK, double *pdfMin,
7870 : double *pdfMax, double *pdfMean,
7871 : double *pdfStdDev,
7872 : GDALProgressFunc pfnProgress,
7873 : void *pProgressData)
7874 :
7875 : {
7876 169 : VALIDATE_POINTER1(hBand, "GDALComputeRasterStatistics", CE_Failure);
7877 :
7878 169 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
7879 :
7880 169 : return poBand->ComputeStatistics(bApproxOK, pdfMin, pdfMax, pdfMean,
7881 169 : pdfStdDev, pfnProgress, pProgressData);
7882 : }
7883 :
7884 : /************************************************************************/
7885 : /* SetStatistics() */
7886 : /************************************************************************/
7887 :
7888 : /**
7889 : * \brief Set statistics on band.
7890 : *
7891 : * This method can be used to store min/max/mean/standard deviation
7892 : * statistics on a raster band.
7893 : *
7894 : * The default implementation stores them as metadata, and will only work
7895 : * on formats that can save arbitrary metadata. This method cannot detect
7896 : * whether metadata will be properly saved and so may return CE_None even
7897 : * if the statistics will never be saved.
7898 : *
7899 : * This method is the same as the C function GDALSetRasterStatistics().
7900 : *
7901 : * @param dfMin minimum pixel value.
7902 : *
7903 : * @param dfMax maximum pixel value.
7904 : *
7905 : * @param dfMean mean (average) of all pixel values.
7906 : *
7907 : * @param dfStdDev Standard deviation of all pixel values.
7908 : *
7909 : * @return CE_None on success or CE_Failure on failure.
7910 : */
7911 :
7912 532 : CPLErr GDALRasterBand::SetStatistics(double dfMin, double dfMax, double dfMean,
7913 : double dfStdDev)
7914 :
7915 : {
7916 532 : char szValue[128] = {0};
7917 :
7918 532 : CPLsnprintf(szValue, sizeof(szValue), "%.14g", dfMin);
7919 529 : SetMetadataItem("STATISTICS_MINIMUM", szValue);
7920 :
7921 532 : CPLsnprintf(szValue, sizeof(szValue), "%.14g", dfMax);
7922 531 : SetMetadataItem("STATISTICS_MAXIMUM", szValue);
7923 :
7924 532 : CPLsnprintf(szValue, sizeof(szValue), "%.14g", dfMean);
7925 532 : SetMetadataItem("STATISTICS_MEAN", szValue);
7926 :
7927 532 : CPLsnprintf(szValue, sizeof(szValue), "%.14g", dfStdDev);
7928 532 : SetMetadataItem("STATISTICS_STDDEV", szValue);
7929 :
7930 532 : return CE_None;
7931 : }
7932 :
7933 : /************************************************************************/
7934 : /* GDALSetRasterStatistics() */
7935 : /************************************************************************/
7936 :
7937 : /**
7938 : * \brief Set statistics on band.
7939 : *
7940 : * @see GDALRasterBand::SetStatistics()
7941 : */
7942 :
7943 2 : CPLErr CPL_STDCALL GDALSetRasterStatistics(GDALRasterBandH hBand, double dfMin,
7944 : double dfMax, double dfMean,
7945 : double dfStdDev)
7946 :
7947 : {
7948 2 : VALIDATE_POINTER1(hBand, "GDALSetRasterStatistics", CE_Failure);
7949 :
7950 2 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
7951 2 : return poBand->SetStatistics(dfMin, dfMax, dfMean, dfStdDev);
7952 : }
7953 :
7954 : /************************************************************************/
7955 : /* ComputeRasterMinMax() */
7956 : /************************************************************************/
7957 :
7958 : template <class T, bool HAS_NODATA>
7959 120995 : static void ComputeMinMax(const T *buffer, size_t nElts, T nodataValue, T *pMin,
7960 : T *pMax)
7961 : {
7962 120995 : T min0 = *pMin;
7963 120995 : T max0 = *pMax;
7964 120995 : T min1 = *pMin;
7965 120995 : T max1 = *pMax;
7966 : size_t i;
7967 215473 : for (i = 0; i + 1 < nElts; i += 2)
7968 : {
7969 81892 : if (!HAS_NODATA || buffer[i] != nodataValue)
7970 : {
7971 94478 : min0 = std::min(min0, buffer[i]);
7972 94478 : max0 = std::max(max0, buffer[i]);
7973 : }
7974 81892 : if (!HAS_NODATA || buffer[i + 1] != nodataValue)
7975 : {
7976 94478 : min1 = std::min(min1, buffer[i + 1]);
7977 94478 : max1 = std::max(max1, buffer[i + 1]);
7978 : }
7979 : }
7980 120995 : T min = std::min(min0, min1);
7981 120995 : T max = std::max(max0, max1);
7982 120995 : if (i < nElts)
7983 : {
7984 119260 : if (!HAS_NODATA || buffer[i] != nodataValue)
7985 : {
7986 119280 : min = std::min(min, buffer[i]);
7987 119280 : max = std::max(max, buffer[i]);
7988 : }
7989 : }
7990 120995 : *pMin = min;
7991 120995 : *pMax = max;
7992 120995 : }
7993 :
7994 : template <GDALDataType eDataType, bool bSignedByte>
7995 : static void
7996 12305 : ComputeMinMaxGeneric(const void *pData, int nXCheck, int nYCheck,
7997 : int nBlockXSize, const GDALNoDataValues &sNoDataValues,
7998 : const GByte *pabyMaskData, double &dfMin, double &dfMax)
7999 : {
8000 12305 : double dfLocalMin = dfMin;
8001 12305 : double dfLocalMax = dfMax;
8002 :
8003 44959 : for (int iY = 0; iY < nYCheck; iY++)
8004 : {
8005 19143749 : for (int iX = 0; iX < nXCheck; iX++)
8006 : {
8007 19111163 : const GPtrDiff_t iOffset =
8008 19111163 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
8009 19111163 : if (pabyMaskData && pabyMaskData[iOffset] == 0)
8010 3448532 : continue;
8011 19028200 : bool bValid = true;
8012 19028200 : double dfValue = GetPixelValue(eDataType, bSignedByte, pData,
8013 : iOffset, sNoDataValues, bValid);
8014 19028200 : if (!bValid)
8015 3365580 : continue;
8016 :
8017 15662589 : dfLocalMin = std::min(dfLocalMin, dfValue);
8018 15662589 : dfLocalMax = std::max(dfLocalMax, dfValue);
8019 : }
8020 : }
8021 :
8022 12305 : dfMin = dfLocalMin;
8023 12305 : dfMax = dfLocalMax;
8024 12305 : }
8025 :
8026 12305 : static void ComputeMinMaxGeneric(const void *pData, GDALDataType eDataType,
8027 : bool bSignedByte, int nXCheck, int nYCheck,
8028 : int nBlockXSize,
8029 : const GDALNoDataValues &sNoDataValues,
8030 : const GByte *pabyMaskData, double &dfMin,
8031 : double &dfMax)
8032 : {
8033 12305 : switch (eDataType)
8034 : {
8035 0 : case GDT_Unknown:
8036 0 : CPLAssert(false);
8037 : break;
8038 659 : case GDT_Byte:
8039 659 : if (bSignedByte)
8040 : {
8041 3 : ComputeMinMaxGeneric<GDT_Byte, true>(
8042 : pData, nXCheck, nYCheck, nBlockXSize, sNoDataValues,
8043 : pabyMaskData, dfMin, dfMax);
8044 : }
8045 : else
8046 : {
8047 656 : ComputeMinMaxGeneric<GDT_Byte, false>(
8048 : pData, nXCheck, nYCheck, nBlockXSize, sNoDataValues,
8049 : pabyMaskData, dfMin, dfMax);
8050 : }
8051 659 : break;
8052 106 : case GDT_Int8:
8053 106 : ComputeMinMaxGeneric<GDT_Int8, false>(pData, nXCheck, nYCheck,
8054 : nBlockXSize, sNoDataValues,
8055 : pabyMaskData, dfMin, dfMax);
8056 106 : break;
8057 968 : case GDT_UInt16:
8058 968 : ComputeMinMaxGeneric<GDT_UInt16, false>(pData, nXCheck, nYCheck,
8059 : nBlockXSize, sNoDataValues,
8060 : pabyMaskData, dfMin, dfMax);
8061 968 : break;
8062 1 : case GDT_Int16:
8063 1 : ComputeMinMaxGeneric<GDT_Int16, false>(pData, nXCheck, nYCheck,
8064 : nBlockXSize, sNoDataValues,
8065 : pabyMaskData, dfMin, dfMax);
8066 1 : break;
8067 201 : case GDT_UInt32:
8068 201 : ComputeMinMaxGeneric<GDT_UInt32, false>(pData, nXCheck, nYCheck,
8069 : nBlockXSize, sNoDataValues,
8070 : pabyMaskData, dfMin, dfMax);
8071 201 : break;
8072 1089 : case GDT_Int32:
8073 1089 : ComputeMinMaxGeneric<GDT_Int32, false>(pData, nXCheck, nYCheck,
8074 : nBlockXSize, sNoDataValues,
8075 : pabyMaskData, dfMin, dfMax);
8076 1089 : break;
8077 17 : case GDT_UInt64:
8078 17 : ComputeMinMaxGeneric<GDT_UInt64, false>(pData, nXCheck, nYCheck,
8079 : nBlockXSize, sNoDataValues,
8080 : pabyMaskData, dfMin, dfMax);
8081 17 : break;
8082 29 : case GDT_Int64:
8083 29 : ComputeMinMaxGeneric<GDT_Int64, false>(pData, nXCheck, nYCheck,
8084 : nBlockXSize, sNoDataValues,
8085 : pabyMaskData, dfMin, dfMax);
8086 29 : break;
8087 0 : case GDT_Float16:
8088 0 : ComputeMinMaxGeneric<GDT_Float16, false>(
8089 : pData, nXCheck, nYCheck, nBlockXSize, sNoDataValues,
8090 : pabyMaskData, dfMin, dfMax);
8091 0 : break;
8092 5638 : case GDT_Float32:
8093 5638 : ComputeMinMaxGeneric<GDT_Float32, false>(
8094 : pData, nXCheck, nYCheck, nBlockXSize, sNoDataValues,
8095 : pabyMaskData, dfMin, dfMax);
8096 5638 : break;
8097 3487 : case GDT_Float64:
8098 3487 : ComputeMinMaxGeneric<GDT_Float64, false>(
8099 : pData, nXCheck, nYCheck, nBlockXSize, sNoDataValues,
8100 : pabyMaskData, dfMin, dfMax);
8101 3487 : break;
8102 9 : case GDT_CInt16:
8103 9 : ComputeMinMaxGeneric<GDT_CInt16, false>(pData, nXCheck, nYCheck,
8104 : nBlockXSize, sNoDataValues,
8105 : pabyMaskData, dfMin, dfMax);
8106 9 : break;
8107 9 : case GDT_CInt32:
8108 9 : ComputeMinMaxGeneric<GDT_CInt32, false>(pData, nXCheck, nYCheck,
8109 : nBlockXSize, sNoDataValues,
8110 : pabyMaskData, dfMin, dfMax);
8111 9 : break;
8112 0 : case GDT_CFloat16:
8113 0 : ComputeMinMaxGeneric<GDT_CFloat16, false>(
8114 : pData, nXCheck, nYCheck, nBlockXSize, sNoDataValues,
8115 : pabyMaskData, dfMin, dfMax);
8116 0 : break;
8117 75 : case GDT_CFloat32:
8118 75 : ComputeMinMaxGeneric<GDT_CFloat32, false>(
8119 : pData, nXCheck, nYCheck, nBlockXSize, sNoDataValues,
8120 : pabyMaskData, dfMin, dfMax);
8121 75 : break;
8122 17 : case GDT_CFloat64:
8123 17 : ComputeMinMaxGeneric<GDT_CFloat64, false>(
8124 : pData, nXCheck, nYCheck, nBlockXSize, sNoDataValues,
8125 : pabyMaskData, dfMin, dfMax);
8126 17 : break;
8127 0 : case GDT_TypeCount:
8128 0 : CPLAssert(false);
8129 : break;
8130 : }
8131 12305 : }
8132 :
8133 787 : static bool ComputeMinMaxGenericIterBlocks(
8134 : GDALRasterBand *poBand, GDALDataType eDataType, bool bSignedByte,
8135 : GIntBig nTotalBlocks, int nSampleRate, int nBlocksPerRow,
8136 : const GDALNoDataValues &sNoDataValues, GDALRasterBand *poMaskBand,
8137 : double &dfMin, double &dfMax)
8138 :
8139 : {
8140 787 : GByte *pabyMaskData = nullptr;
8141 : int nBlockXSize, nBlockYSize;
8142 787 : poBand->GetBlockSize(&nBlockXSize, &nBlockYSize);
8143 :
8144 787 : if (poMaskBand)
8145 : {
8146 : pabyMaskData =
8147 112 : static_cast<GByte *>(VSI_MALLOC2_VERBOSE(nBlockXSize, nBlockYSize));
8148 112 : if (!pabyMaskData)
8149 : {
8150 0 : return false;
8151 : }
8152 : }
8153 :
8154 13092 : for (GIntBig iSampleBlock = 0; iSampleBlock < nTotalBlocks;
8155 12305 : iSampleBlock += nSampleRate)
8156 : {
8157 12305 : const int iYBlock = static_cast<int>(iSampleBlock / nBlocksPerRow);
8158 12305 : const int iXBlock = static_cast<int>(iSampleBlock % nBlocksPerRow);
8159 :
8160 12305 : int nXCheck = 0, nYCheck = 0;
8161 12305 : poBand->GetActualBlockSize(iXBlock, iYBlock, &nXCheck, &nYCheck);
8162 :
8163 18872 : if (poMaskBand &&
8164 6567 : poMaskBand->RasterIO(GF_Read, iXBlock * nBlockXSize,
8165 : iYBlock * nBlockYSize, nXCheck, nYCheck,
8166 : pabyMaskData, nXCheck, nYCheck, GDT_Byte, 0,
8167 : nBlockXSize, nullptr) != CE_None)
8168 : {
8169 0 : CPLFree(pabyMaskData);
8170 0 : return false;
8171 : }
8172 :
8173 12305 : GDALRasterBlock *poBlock = poBand->GetLockedBlockRef(iXBlock, iYBlock);
8174 12305 : if (poBlock == nullptr)
8175 : {
8176 0 : CPLFree(pabyMaskData);
8177 0 : return false;
8178 : }
8179 :
8180 12305 : void *const pData = poBlock->GetDataRef();
8181 :
8182 12305 : ComputeMinMaxGeneric(pData, eDataType, bSignedByte, nXCheck, nYCheck,
8183 : nBlockXSize, sNoDataValues, pabyMaskData, dfMin,
8184 : dfMax);
8185 :
8186 12305 : poBlock->DropLock();
8187 : }
8188 :
8189 787 : CPLFree(pabyMaskData);
8190 787 : return true;
8191 : }
8192 :
8193 : /**
8194 : * \brief Compute the min/max values for a band.
8195 : *
8196 : * If approximate is OK, then the band's GetMinimum()/GetMaximum() will
8197 : * be trusted. If it doesn't work, a subsample of blocks will be read to
8198 : * get an approximate min/max. If the band has a nodata value it will
8199 : * be excluded from the minimum and maximum.
8200 : *
8201 : * If bApprox is FALSE, then all pixels will be read and used to compute
8202 : * an exact range.
8203 : *
8204 : * This method is the same as the C function GDALComputeRasterMinMax().
8205 : *
8206 : * @param bApproxOK TRUE if an approximate (faster) answer is OK, otherwise
8207 : * FALSE.
8208 : * @param adfMinMax the array in which the minimum (adfMinMax[0]) and the
8209 : * maximum (adfMinMax[1]) are returned.
8210 : *
8211 : * @return CE_None on success or CE_Failure on failure.
8212 : */
8213 :
8214 1780 : CPLErr GDALRasterBand::ComputeRasterMinMax(int bApproxOK, double *adfMinMax)
8215 : {
8216 : /* -------------------------------------------------------------------- */
8217 : /* Does the driver already know the min/max? */
8218 : /* -------------------------------------------------------------------- */
8219 1780 : if (bApproxOK)
8220 : {
8221 23 : int bSuccessMin = FALSE;
8222 23 : int bSuccessMax = FALSE;
8223 :
8224 23 : double dfMin = GetMinimum(&bSuccessMin);
8225 23 : double dfMax = GetMaximum(&bSuccessMax);
8226 :
8227 23 : if (bSuccessMin && bSuccessMax)
8228 : {
8229 1 : adfMinMax[0] = dfMin;
8230 1 : adfMinMax[1] = dfMax;
8231 1 : return CE_None;
8232 : }
8233 : }
8234 :
8235 : /* -------------------------------------------------------------------- */
8236 : /* If we have overview bands, use them for min/max. */
8237 : /* -------------------------------------------------------------------- */
8238 : // cppcheck-suppress knownConditionTrueFalse
8239 1779 : if (bApproxOK && GetOverviewCount() > 0 && !HasArbitraryOverviews())
8240 : {
8241 : GDALRasterBand *poBand =
8242 0 : GetRasterSampleOverview(GDALSTAT_APPROX_NUMSAMPLES);
8243 :
8244 0 : if (poBand != this)
8245 0 : return poBand->ComputeRasterMinMax(FALSE, adfMinMax);
8246 : }
8247 :
8248 : /* -------------------------------------------------------------------- */
8249 : /* Read actual data and compute minimum and maximum. */
8250 : /* -------------------------------------------------------------------- */
8251 1779 : GDALNoDataValues sNoDataValues(this, eDataType);
8252 1779 : GDALRasterBand *poMaskBand = nullptr;
8253 1779 : if (!sNoDataValues.bGotNoDataValue)
8254 : {
8255 1526 : const int l_nMaskFlags = GetMaskFlags();
8256 1638 : if (l_nMaskFlags != GMF_ALL_VALID &&
8257 112 : GetColorInterpretation() != GCI_AlphaBand)
8258 : {
8259 112 : poMaskBand = GetMaskBand();
8260 : }
8261 : }
8262 :
8263 1779 : bool bSignedByte = false;
8264 1779 : if (eDataType == GDT_Byte)
8265 : {
8266 778 : EnablePixelTypeSignedByteWarning(false);
8267 : const char *pszPixelType =
8268 778 : GetMetadataItem("PIXELTYPE", "IMAGE_STRUCTURE");
8269 778 : EnablePixelTypeSignedByteWarning(true);
8270 778 : bSignedByte =
8271 778 : pszPixelType != nullptr && EQUAL(pszPixelType, "SIGNEDBYTE");
8272 : }
8273 :
8274 : GDALRasterIOExtraArg sExtraArg;
8275 1779 : INIT_RASTERIO_EXTRA_ARG(sExtraArg);
8276 :
8277 3558 : GUInt32 nMin = (eDataType == GDT_Byte)
8278 1779 : ? 255
8279 : : 65535; // used for GByte & GUInt16 cases
8280 1779 : GUInt32 nMax = 0; // used for GByte & GUInt16 cases
8281 1779 : GInt16 nMinInt16 =
8282 : std::numeric_limits<GInt16>::max(); // used for GInt16 case
8283 1779 : GInt16 nMaxInt16 =
8284 : std::numeric_limits<GInt16>::lowest(); // used for GInt16 case
8285 1779 : double dfMin =
8286 : std::numeric_limits<double>::infinity(); // used for generic code path
8287 1779 : double dfMax =
8288 : -std::numeric_limits<double>::infinity(); // used for generic code path
8289 1779 : const bool bUseOptimizedPath =
8290 2698 : !poMaskBand && ((eDataType == GDT_Byte && !bSignedByte) ||
8291 919 : eDataType == GDT_Int16 || eDataType == GDT_UInt16);
8292 :
8293 : const auto ComputeMinMaxForBlock =
8294 20943 : [this, bSignedByte, &sNoDataValues, &nMin, &nMax, &nMinInt16,
8295 : &nMaxInt16](const void *pData, int nXCheck, int nBufferWidth,
8296 243461 : int nYCheck)
8297 : {
8298 20943 : if (eDataType == GDT_Byte && !bSignedByte)
8299 : {
8300 : const bool bHasNoData =
8301 11561 : sNoDataValues.bGotNoDataValue &&
8302 29664 : GDALIsValueInRange<GByte>(sNoDataValues.dfNoDataValue) &&
8303 11561 : static_cast<GByte>(sNoDataValues.dfNoDataValue) ==
8304 11561 : sNoDataValues.dfNoDataValue;
8305 18103 : const GUInt32 nNoDataValue =
8306 18103 : bHasNoData ? static_cast<GByte>(sNoDataValues.dfNoDataValue)
8307 : : 0;
8308 : GUIntBig nSum, nSumSquare, nSampleCount, nValidCount; // unused
8309 : ComputeStatisticsInternal<GByte,
8310 : /* COMPUTE_OTHER_STATS = */ false>::
8311 18103 : f(nXCheck, nBufferWidth, nYCheck,
8312 : static_cast<const GByte *>(pData), bHasNoData, nNoDataValue,
8313 18103 : nMin, nMax, nSum, nSumSquare, nSampleCount, nValidCount);
8314 : }
8315 2840 : else if (eDataType == GDT_UInt16)
8316 : {
8317 : const bool bHasNoData =
8318 83 : sNoDataValues.bGotNoDataValue &&
8319 1494 : GDALIsValueInRange<GUInt16>(sNoDataValues.dfNoDataValue) &&
8320 83 : static_cast<GUInt16>(sNoDataValues.dfNoDataValue) ==
8321 83 : sNoDataValues.dfNoDataValue;
8322 1411 : const GUInt32 nNoDataValue =
8323 1411 : bHasNoData ? static_cast<GUInt16>(sNoDataValues.dfNoDataValue)
8324 : : 0;
8325 : GUIntBig nSum, nSumSquare, nSampleCount, nValidCount; // unused
8326 : ComputeStatisticsInternal<GUInt16,
8327 : /* COMPUTE_OTHER_STATS = */ false>::
8328 1411 : f(nXCheck, nBufferWidth, nYCheck,
8329 : static_cast<const GUInt16 *>(pData), bHasNoData, nNoDataValue,
8330 : nMin, nMax, nSum, nSumSquare, nSampleCount, nValidCount);
8331 : }
8332 1429 : else if (eDataType == GDT_Int16)
8333 : {
8334 : const bool bHasNoData =
8335 1254 : sNoDataValues.bGotNoDataValue &&
8336 2683 : GDALIsValueInRange<int16_t>(sNoDataValues.dfNoDataValue) &&
8337 1254 : static_cast<int16_t>(sNoDataValues.dfNoDataValue) ==
8338 1254 : sNoDataValues.dfNoDataValue;
8339 1429 : if (bHasNoData)
8340 : {
8341 1254 : const int16_t nNoDataValue =
8342 1254 : static_cast<int16_t>(sNoDataValues.dfNoDataValue);
8343 120957 : for (int iY = 0; iY < nYCheck; iY++)
8344 : {
8345 119703 : ComputeMinMax<int16_t, true>(
8346 119703 : static_cast<const int16_t *>(pData) +
8347 119703 : static_cast<size_t>(iY) * nBufferWidth,
8348 : nXCheck, nNoDataValue, &nMinInt16, &nMaxInt16);
8349 : }
8350 : }
8351 : else
8352 : {
8353 1467 : for (int iY = 0; iY < nYCheck; iY++)
8354 : {
8355 1292 : ComputeMinMax<int16_t, false>(
8356 1292 : static_cast<const int16_t *>(pData) +
8357 1292 : static_cast<size_t>(iY) * nBufferWidth,
8358 : nXCheck, 0, &nMinInt16, &nMaxInt16);
8359 : }
8360 : }
8361 : }
8362 20943 : };
8363 :
8364 1779 : if (bApproxOK && HasArbitraryOverviews())
8365 : {
8366 : /* --------------------------------------------------------------------
8367 : */
8368 : /* Figure out how much the image should be reduced to get an */
8369 : /* approximate value. */
8370 : /* --------------------------------------------------------------------
8371 : */
8372 0 : double dfReduction = sqrt(static_cast<double>(nRasterXSize) *
8373 0 : nRasterYSize / GDALSTAT_APPROX_NUMSAMPLES);
8374 :
8375 0 : int nXReduced = nRasterXSize;
8376 0 : int nYReduced = nRasterYSize;
8377 0 : if (dfReduction > 1.0)
8378 : {
8379 0 : nXReduced = static_cast<int>(nRasterXSize / dfReduction);
8380 0 : nYReduced = static_cast<int>(nRasterYSize / dfReduction);
8381 :
8382 : // Catch the case of huge resizing ratios here
8383 0 : if (nXReduced == 0)
8384 0 : nXReduced = 1;
8385 0 : if (nYReduced == 0)
8386 0 : nYReduced = 1;
8387 : }
8388 :
8389 0 : void *const pData = CPLMalloc(cpl::fits_on<int>(
8390 0 : GDALGetDataTypeSizeBytes(eDataType) * nXReduced * nYReduced));
8391 :
8392 : const CPLErr eErr =
8393 0 : IRasterIO(GF_Read, 0, 0, nRasterXSize, nRasterYSize, pData,
8394 0 : nXReduced, nYReduced, eDataType, 0, 0, &sExtraArg);
8395 0 : if (eErr != CE_None)
8396 : {
8397 0 : CPLFree(pData);
8398 0 : return eErr;
8399 : }
8400 :
8401 0 : GByte *pabyMaskData = nullptr;
8402 0 : if (poMaskBand)
8403 : {
8404 : pabyMaskData =
8405 0 : static_cast<GByte *>(VSI_MALLOC2_VERBOSE(nXReduced, nYReduced));
8406 0 : if (!pabyMaskData)
8407 : {
8408 0 : CPLFree(pData);
8409 0 : return CE_Failure;
8410 : }
8411 :
8412 0 : if (poMaskBand->RasterIO(GF_Read, 0, 0, nRasterXSize, nRasterYSize,
8413 : pabyMaskData, nXReduced, nYReduced,
8414 0 : GDT_Byte, 0, 0, nullptr) != CE_None)
8415 : {
8416 0 : CPLFree(pData);
8417 0 : CPLFree(pabyMaskData);
8418 0 : return CE_Failure;
8419 : }
8420 : }
8421 :
8422 0 : if (bUseOptimizedPath)
8423 : {
8424 0 : ComputeMinMaxForBlock(pData, nXReduced, nXReduced, nYReduced);
8425 : }
8426 : else
8427 : {
8428 0 : ComputeMinMaxGeneric(pData, eDataType, bSignedByte, nXReduced,
8429 : nYReduced, nXReduced, sNoDataValues,
8430 : pabyMaskData, dfMin, dfMax);
8431 : }
8432 :
8433 0 : CPLFree(pData);
8434 0 : CPLFree(pabyMaskData);
8435 : }
8436 :
8437 : else // No arbitrary overviews
8438 : {
8439 1779 : if (!InitBlockInfo())
8440 0 : return CE_Failure;
8441 :
8442 : /* --------------------------------------------------------------------
8443 : */
8444 : /* Figure out the ratio of blocks we will read to get an */
8445 : /* approximate value. */
8446 : /* --------------------------------------------------------------------
8447 : */
8448 1779 : int nSampleRate = 1;
8449 :
8450 1779 : if (bApproxOK)
8451 : {
8452 22 : nSampleRate = static_cast<int>(std::max(
8453 44 : 1.0,
8454 22 : sqrt(static_cast<double>(nBlocksPerRow) * nBlocksPerColumn)));
8455 : // We want to avoid probing only the first column of blocks for
8456 : // a square shaped raster, because it is not unlikely that it may
8457 : // be padding only (#6378).
8458 22 : if (nSampleRate == nBlocksPerRow && nBlocksPerRow > 1)
8459 0 : nSampleRate += 1;
8460 : }
8461 :
8462 1779 : if (bUseOptimizedPath)
8463 : {
8464 992 : for (GIntBig iSampleBlock = 0;
8465 21861 : iSampleBlock <
8466 21861 : static_cast<GIntBig>(nBlocksPerRow) * nBlocksPerColumn;
8467 20869 : iSampleBlock += nSampleRate)
8468 : {
8469 20945 : const int iYBlock =
8470 20945 : static_cast<int>(iSampleBlock / nBlocksPerRow);
8471 20945 : const int iXBlock =
8472 20945 : static_cast<int>(iSampleBlock % nBlocksPerRow);
8473 :
8474 20945 : GDALRasterBlock *poBlock = GetLockedBlockRef(iXBlock, iYBlock);
8475 20945 : if (poBlock == nullptr)
8476 2 : return CE_Failure;
8477 :
8478 20943 : void *const pData = poBlock->GetDataRef();
8479 :
8480 20943 : int nXCheck = 0, nYCheck = 0;
8481 20943 : GetActualBlockSize(iXBlock, iYBlock, &nXCheck, &nYCheck);
8482 :
8483 20943 : ComputeMinMaxForBlock(pData, nXCheck, nBlockXSize, nYCheck);
8484 :
8485 20943 : poBlock->DropLock();
8486 :
8487 20943 : if (eDataType == GDT_Byte && !bSignedByte && nMin == 0 &&
8488 4110 : nMax == 255)
8489 74 : break;
8490 : }
8491 : }
8492 : else
8493 : {
8494 787 : const GIntBig nTotalBlocks =
8495 787 : static_cast<GIntBig>(nBlocksPerRow) * nBlocksPerColumn;
8496 787 : if (!ComputeMinMaxGenericIterBlocks(
8497 : this, eDataType, bSignedByte, nTotalBlocks, nSampleRate,
8498 : nBlocksPerRow, sNoDataValues, poMaskBand, dfMin, dfMax))
8499 : {
8500 0 : return CE_Failure;
8501 : }
8502 : }
8503 : }
8504 :
8505 1777 : if (bUseOptimizedPath)
8506 : {
8507 990 : if ((eDataType == GDT_Byte && !bSignedByte) || eDataType == GDT_UInt16)
8508 : {
8509 885 : dfMin = nMin;
8510 885 : dfMax = nMax;
8511 : }
8512 105 : else if (eDataType == GDT_Int16)
8513 : {
8514 105 : dfMin = nMinInt16;
8515 105 : dfMax = nMaxInt16;
8516 : }
8517 : }
8518 :
8519 1777 : if (dfMin > dfMax)
8520 : {
8521 9 : adfMinMax[0] = 0;
8522 9 : adfMinMax[1] = 0;
8523 9 : ReportError(
8524 : CE_Failure, CPLE_AppDefined,
8525 : "Failed to compute min/max, no valid pixels found in sampling.");
8526 9 : return CE_Failure;
8527 : }
8528 :
8529 1768 : adfMinMax[0] = dfMin;
8530 1768 : adfMinMax[1] = dfMax;
8531 :
8532 1768 : return CE_None;
8533 : }
8534 :
8535 : /************************************************************************/
8536 : /* GDALComputeRasterMinMax() */
8537 : /************************************************************************/
8538 :
8539 : /**
8540 : * \brief Compute the min/max values for a band.
8541 : *
8542 : * @see GDALRasterBand::ComputeRasterMinMax()
8543 : *
8544 : * @note Prior to GDAL 3.6, this function returned void
8545 : */
8546 :
8547 1629 : CPLErr CPL_STDCALL GDALComputeRasterMinMax(GDALRasterBandH hBand, int bApproxOK,
8548 : double adfMinMax[2])
8549 :
8550 : {
8551 1629 : VALIDATE_POINTER1(hBand, "GDALComputeRasterMinMax", CE_Failure);
8552 :
8553 1629 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
8554 1629 : return poBand->ComputeRasterMinMax(bApproxOK, adfMinMax);
8555 : }
8556 :
8557 : /************************************************************************/
8558 : /* ComputeRasterMinMaxLocation() */
8559 : /************************************************************************/
8560 :
8561 : /**
8562 : * \brief Compute the min/max values for a band, and their location.
8563 : *
8564 : * Pixels whose value matches the nodata value or are masked by the mask
8565 : * band are ignored.
8566 : *
8567 : * If the minimum or maximum value is hit in several locations, it is not
8568 : * specified which one will be returned.
8569 : *
8570 : * @param[out] pdfMin Pointer to the minimum value.
8571 : * @param[out] pdfMax Pointer to the maximum value.
8572 : * @param[out] pnMinX Pointer to the column where the minimum value is hit.
8573 : * @param[out] pnMinY Pointer to the line where the minimum value is hit.
8574 : * @param[out] pnMaxX Pointer to the column where the maximum value is hit.
8575 : * @param[out] pnMaxY Pointer to the line where the maximum value is hit.
8576 : *
8577 : * @return CE_None in case of success, CE_Warning if there are no valid values,
8578 : * CE_Failure in case of error.
8579 : *
8580 : * @since GDAL 3.11
8581 : */
8582 :
8583 8 : CPLErr GDALRasterBand::ComputeRasterMinMaxLocation(double *pdfMin,
8584 : double *pdfMax, int *pnMinX,
8585 : int *pnMinY, int *pnMaxX,
8586 : int *pnMaxY)
8587 : {
8588 8 : int nMinX = -1;
8589 8 : int nMinY = -1;
8590 8 : int nMaxX = -1;
8591 8 : int nMaxY = -1;
8592 8 : double dfMin = std::numeric_limits<double>::infinity();
8593 8 : double dfMax = -std::numeric_limits<double>::infinity();
8594 8 : if (pdfMin)
8595 5 : *pdfMin = dfMin;
8596 8 : if (pdfMax)
8597 5 : *pdfMax = dfMax;
8598 8 : if (pnMinX)
8599 6 : *pnMinX = nMinX;
8600 8 : if (pnMinY)
8601 6 : *pnMinY = nMinY;
8602 8 : if (pnMaxX)
8603 6 : *pnMaxX = nMaxX;
8604 8 : if (pnMaxY)
8605 6 : *pnMaxY = nMaxY;
8606 :
8607 8 : if (GDALDataTypeIsComplex(eDataType))
8608 : {
8609 0 : CPLError(CE_Failure, CPLE_NotSupported,
8610 : "Complex data type not supported");
8611 0 : return CE_Failure;
8612 : }
8613 :
8614 8 : if (!InitBlockInfo())
8615 0 : return CE_Failure;
8616 :
8617 8 : GDALNoDataValues sNoDataValues(this, eDataType);
8618 8 : GDALRasterBand *poMaskBand = nullptr;
8619 8 : if (!sNoDataValues.bGotNoDataValue)
8620 : {
8621 8 : const int l_nMaskFlags = GetMaskFlags();
8622 9 : if (l_nMaskFlags != GMF_ALL_VALID &&
8623 1 : GetColorInterpretation() != GCI_AlphaBand)
8624 : {
8625 1 : poMaskBand = GetMaskBand();
8626 : }
8627 : }
8628 :
8629 8 : bool bSignedByte = false;
8630 8 : if (eDataType == GDT_Byte)
8631 : {
8632 7 : EnablePixelTypeSignedByteWarning(false);
8633 : const char *pszPixelType =
8634 7 : GetMetadataItem("PIXELTYPE", "IMAGE_STRUCTURE");
8635 7 : EnablePixelTypeSignedByteWarning(true);
8636 7 : bSignedByte =
8637 7 : pszPixelType != nullptr && EQUAL(pszPixelType, "SIGNEDBYTE");
8638 : }
8639 :
8640 8 : GByte *pabyMaskData = nullptr;
8641 8 : if (poMaskBand)
8642 : {
8643 : pabyMaskData =
8644 1 : static_cast<GByte *>(VSI_MALLOC2_VERBOSE(nBlockXSize, nBlockYSize));
8645 1 : if (!pabyMaskData)
8646 : {
8647 0 : return CE_Failure;
8648 : }
8649 : }
8650 :
8651 8 : const GIntBig nTotalBlocks =
8652 8 : static_cast<GIntBig>(nBlocksPerRow) * nBlocksPerColumn;
8653 8 : bool bNeedsMin = pdfMin || pnMinX || pnMinY;
8654 8 : bool bNeedsMax = pdfMax || pnMaxX || pnMaxY;
8655 16 : for (GIntBig iBlock = 0; iBlock < nTotalBlocks; ++iBlock)
8656 : {
8657 11 : const int iYBlock = static_cast<int>(iBlock / nBlocksPerRow);
8658 11 : const int iXBlock = static_cast<int>(iBlock % nBlocksPerRow);
8659 :
8660 11 : int nXCheck = 0, nYCheck = 0;
8661 11 : GetActualBlockSize(iXBlock, iYBlock, &nXCheck, &nYCheck);
8662 :
8663 13 : if (poMaskBand &&
8664 2 : poMaskBand->RasterIO(GF_Read, iXBlock * nBlockXSize,
8665 2 : iYBlock * nBlockYSize, nXCheck, nYCheck,
8666 : pabyMaskData, nXCheck, nYCheck, GDT_Byte, 0,
8667 2 : nBlockXSize, nullptr) != CE_None)
8668 : {
8669 0 : CPLFree(pabyMaskData);
8670 0 : return CE_Failure;
8671 : }
8672 :
8673 11 : GDALRasterBlock *poBlock = GetLockedBlockRef(iXBlock, iYBlock);
8674 11 : if (poBlock == nullptr)
8675 : {
8676 0 : CPLFree(pabyMaskData);
8677 0 : return CE_Failure;
8678 : }
8679 :
8680 11 : void *const pData = poBlock->GetDataRef();
8681 :
8682 11 : if (poMaskBand || nYCheck < nBlockYSize || nXCheck < nBlockXSize)
8683 : {
8684 4 : for (int iY = 0; iY < nYCheck; ++iY)
8685 : {
8686 6 : for (int iX = 0; iX < nXCheck; ++iX)
8687 : {
8688 4 : const GPtrDiff_t iOffset =
8689 4 : iX + static_cast<GPtrDiff_t>(iY) * nBlockXSize;
8690 4 : if (pabyMaskData && pabyMaskData[iOffset] == 0)
8691 2 : continue;
8692 2 : bool bValid = true;
8693 : double dfValue =
8694 2 : GetPixelValue(eDataType, bSignedByte, pData, iOffset,
8695 : sNoDataValues, bValid);
8696 2 : if (!bValid)
8697 0 : continue;
8698 2 : if (dfValue < dfMin)
8699 : {
8700 2 : dfMin = dfValue;
8701 2 : nMinX = iXBlock * nBlockXSize + iX;
8702 2 : nMinY = iYBlock * nBlockYSize + iY;
8703 : }
8704 2 : if (dfValue > dfMax)
8705 : {
8706 1 : dfMax = dfValue;
8707 1 : nMaxX = iXBlock * nBlockXSize + iX;
8708 1 : nMaxY = iYBlock * nBlockYSize + iY;
8709 : }
8710 : }
8711 2 : }
8712 : }
8713 : else
8714 : {
8715 9 : size_t pos_min = 0;
8716 9 : size_t pos_max = 0;
8717 9 : const auto eEffectiveDT = bSignedByte ? GDT_Int8 : eDataType;
8718 9 : if (bNeedsMin && bNeedsMax)
8719 : {
8720 10 : std::tie(pos_min, pos_max) = gdal::minmax_element(
8721 5 : pData, static_cast<size_t>(nBlockXSize) * nBlockYSize,
8722 5 : eEffectiveDT, sNoDataValues.bGotNoDataValue,
8723 10 : sNoDataValues.dfNoDataValue);
8724 : }
8725 4 : else if (bNeedsMin)
8726 : {
8727 1 : pos_min = gdal::min_element(
8728 1 : pData, static_cast<size_t>(nBlockXSize) * nBlockYSize,
8729 1 : eEffectiveDT, sNoDataValues.bGotNoDataValue,
8730 : sNoDataValues.dfNoDataValue);
8731 : }
8732 3 : else if (bNeedsMax)
8733 : {
8734 2 : pos_max = gdal::max_element(
8735 2 : pData, static_cast<size_t>(nBlockXSize) * nBlockYSize,
8736 2 : eEffectiveDT, sNoDataValues.bGotNoDataValue,
8737 : sNoDataValues.dfNoDataValue);
8738 : }
8739 :
8740 9 : if (bNeedsMin)
8741 : {
8742 6 : const int nMinXBlock = static_cast<int>(pos_min % nBlockXSize);
8743 6 : const int nMinYBlock = static_cast<int>(pos_min / nBlockXSize);
8744 6 : bool bValid = true;
8745 : const double dfMinValueBlock =
8746 6 : GetPixelValue(eDataType, bSignedByte, pData, pos_min,
8747 : sNoDataValues, bValid);
8748 6 : if (bValid && dfMinValueBlock < dfMin)
8749 : {
8750 5 : dfMin = dfMinValueBlock;
8751 5 : nMinX = iXBlock * nBlockXSize + nMinXBlock;
8752 5 : nMinY = iYBlock * nBlockYSize + nMinYBlock;
8753 : }
8754 : }
8755 :
8756 9 : if (bNeedsMax)
8757 : {
8758 7 : const int nMaxXBlock = static_cast<int>(pos_max % nBlockXSize);
8759 7 : const int nMaxYBlock = static_cast<int>(pos_max / nBlockXSize);
8760 7 : bool bValid = true;
8761 : const double dfMaxValueBlock =
8762 7 : GetPixelValue(eDataType, bSignedByte, pData, pos_max,
8763 : sNoDataValues, bValid);
8764 7 : if (bValid && dfMaxValueBlock > dfMax)
8765 : {
8766 5 : dfMax = dfMaxValueBlock;
8767 5 : nMaxX = iXBlock * nBlockXSize + nMaxXBlock;
8768 5 : nMaxY = iYBlock * nBlockYSize + nMaxYBlock;
8769 : }
8770 : }
8771 : }
8772 :
8773 11 : poBlock->DropLock();
8774 :
8775 11 : if (eDataType == GDT_Byte)
8776 : {
8777 10 : if (bNeedsMin && dfMin == 0)
8778 : {
8779 1 : bNeedsMin = false;
8780 : }
8781 10 : if (bNeedsMax && dfMax == 255)
8782 : {
8783 4 : bNeedsMax = false;
8784 : }
8785 10 : if (!bNeedsMin && !bNeedsMax)
8786 : {
8787 3 : break;
8788 : }
8789 : }
8790 : }
8791 :
8792 8 : CPLFree(pabyMaskData);
8793 :
8794 8 : if (pdfMin)
8795 5 : *pdfMin = dfMin;
8796 8 : if (pdfMax)
8797 5 : *pdfMax = dfMax;
8798 8 : if (pnMinX)
8799 6 : *pnMinX = nMinX;
8800 8 : if (pnMinY)
8801 6 : *pnMinY = nMinY;
8802 8 : if (pnMaxX)
8803 6 : *pnMaxX = nMaxX;
8804 8 : if (pnMaxY)
8805 6 : *pnMaxY = nMaxY;
8806 8 : return ((bNeedsMin && nMinX < 0) || (bNeedsMax && nMaxX < 0)) ? CE_Warning
8807 8 : : CE_None;
8808 : }
8809 :
8810 : /************************************************************************/
8811 : /* GDALComputeRasterMinMaxLocation() */
8812 : /************************************************************************/
8813 :
8814 : /**
8815 : * \brief Compute the min/max values for a band, and their location.
8816 : *
8817 : * @see GDALRasterBand::ComputeRasterMinMax()
8818 : * @since GDAL 3.11
8819 : */
8820 :
8821 6 : CPLErr GDALComputeRasterMinMaxLocation(GDALRasterBandH hBand, double *pdfMin,
8822 : double *pdfMax, int *pnMinX, int *pnMinY,
8823 : int *pnMaxX, int *pnMaxY)
8824 :
8825 : {
8826 6 : VALIDATE_POINTER1(hBand, "GDALComputeRasterMinMaxLocation", CE_Failure);
8827 :
8828 6 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
8829 6 : return poBand->ComputeRasterMinMaxLocation(pdfMin, pdfMax, pnMinX, pnMinY,
8830 6 : pnMaxX, pnMaxY);
8831 : }
8832 :
8833 : /************************************************************************/
8834 : /* SetDefaultHistogram() */
8835 : /************************************************************************/
8836 :
8837 : /* FIXME : add proper documentation */
8838 : /**
8839 : * \brief Set default histogram.
8840 : *
8841 : * This method is the same as the C function GDALSetDefaultHistogram() and
8842 : * GDALSetDefaultHistogramEx()
8843 : */
8844 0 : CPLErr GDALRasterBand::SetDefaultHistogram(double /* dfMin */,
8845 : double /* dfMax */,
8846 : int /* nBuckets */,
8847 : GUIntBig * /* panHistogram */)
8848 :
8849 : {
8850 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
8851 0 : ReportError(CE_Failure, CPLE_NotSupported,
8852 : "SetDefaultHistogram() not implemented for this format.");
8853 :
8854 0 : return CE_Failure;
8855 : }
8856 :
8857 : /************************************************************************/
8858 : /* GDALSetDefaultHistogram() */
8859 : /************************************************************************/
8860 :
8861 : /**
8862 : * \brief Set default histogram.
8863 : *
8864 : * Use GDALSetRasterHistogramEx() instead to be able to set counts exceeding
8865 : * 2 billion.
8866 : *
8867 : * @see GDALRasterBand::SetDefaultHistogram()
8868 : * @see GDALSetRasterHistogramEx()
8869 : */
8870 :
8871 0 : CPLErr CPL_STDCALL GDALSetDefaultHistogram(GDALRasterBandH hBand, double dfMin,
8872 : double dfMax, int nBuckets,
8873 : int *panHistogram)
8874 :
8875 : {
8876 0 : VALIDATE_POINTER1(hBand, "GDALSetDefaultHistogram", CE_Failure);
8877 :
8878 0 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
8879 :
8880 : GUIntBig *panHistogramTemp =
8881 0 : static_cast<GUIntBig *>(VSIMalloc2(sizeof(GUIntBig), nBuckets));
8882 0 : if (panHistogramTemp == nullptr)
8883 : {
8884 0 : poBand->ReportError(CE_Failure, CPLE_OutOfMemory,
8885 : "Out of memory in GDALSetDefaultHistogram().");
8886 0 : return CE_Failure;
8887 : }
8888 :
8889 0 : for (int i = 0; i < nBuckets; ++i)
8890 : {
8891 0 : panHistogramTemp[i] = static_cast<GUIntBig>(panHistogram[i]);
8892 : }
8893 :
8894 : const CPLErr eErr =
8895 0 : poBand->SetDefaultHistogram(dfMin, dfMax, nBuckets, panHistogramTemp);
8896 :
8897 0 : CPLFree(panHistogramTemp);
8898 :
8899 0 : return eErr;
8900 : }
8901 :
8902 : /************************************************************************/
8903 : /* GDALSetDefaultHistogramEx() */
8904 : /************************************************************************/
8905 :
8906 : /**
8907 : * \brief Set default histogram.
8908 : *
8909 : * @see GDALRasterBand::SetDefaultHistogram()
8910 : *
8911 : */
8912 :
8913 5 : CPLErr CPL_STDCALL GDALSetDefaultHistogramEx(GDALRasterBandH hBand,
8914 : double dfMin, double dfMax,
8915 : int nBuckets,
8916 : GUIntBig *panHistogram)
8917 :
8918 : {
8919 5 : VALIDATE_POINTER1(hBand, "GDALSetDefaultHistogramEx", CE_Failure);
8920 :
8921 5 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
8922 5 : return poBand->SetDefaultHistogram(dfMin, dfMax, nBuckets, panHistogram);
8923 : }
8924 :
8925 : /************************************************************************/
8926 : /* GetDefaultRAT() */
8927 : /************************************************************************/
8928 :
8929 : /**
8930 : * \brief Fetch default Raster Attribute Table.
8931 : *
8932 : * A RAT will be returned if there is a default one associated with the
8933 : * band, otherwise NULL is returned. The returned RAT is owned by the
8934 : * band and should not be deleted by the application.
8935 : *
8936 : * This method is the same as the C function GDALGetDefaultRAT().
8937 : *
8938 : * @return NULL, or a pointer to an internal RAT owned by the band.
8939 : */
8940 :
8941 180 : GDALRasterAttributeTable *GDALRasterBand::GetDefaultRAT()
8942 :
8943 : {
8944 180 : return nullptr;
8945 : }
8946 :
8947 : /************************************************************************/
8948 : /* GDALGetDefaultRAT() */
8949 : /************************************************************************/
8950 :
8951 : /**
8952 : * \brief Fetch default Raster Attribute Table.
8953 : *
8954 : * @see GDALRasterBand::GetDefaultRAT()
8955 : */
8956 :
8957 1150 : GDALRasterAttributeTableH CPL_STDCALL GDALGetDefaultRAT(GDALRasterBandH hBand)
8958 :
8959 : {
8960 1150 : VALIDATE_POINTER1(hBand, "GDALGetDefaultRAT", nullptr);
8961 :
8962 1150 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
8963 1150 : return GDALRasterAttributeTable::ToHandle(poBand->GetDefaultRAT());
8964 : }
8965 :
8966 : /************************************************************************/
8967 : /* SetDefaultRAT() */
8968 : /************************************************************************/
8969 :
8970 : /**
8971 : * \fn GDALRasterBand::SetDefaultRAT(const GDALRasterAttributeTable*)
8972 : * \brief Set default Raster Attribute Table.
8973 : *
8974 : * Associates a default RAT with the band. If not implemented for the
8975 : * format a CPLE_NotSupported error will be issued. If successful a copy
8976 : * of the RAT is made, the original remains owned by the caller.
8977 : *
8978 : * This method is the same as the C function GDALSetDefaultRAT().
8979 : *
8980 : * @param poRAT the RAT to assign to the band.
8981 : *
8982 : * @return CE_None on success or CE_Failure if unsupported or otherwise
8983 : * failing.
8984 : */
8985 :
8986 : /**/
8987 : /**/
8988 :
8989 : CPLErr
8990 0 : GDALRasterBand::SetDefaultRAT(const GDALRasterAttributeTable * /* poRAT */)
8991 : {
8992 0 : if (!(GetMOFlags() & GMO_IGNORE_UNIMPLEMENTED))
8993 : {
8994 0 : CPLPushErrorHandler(CPLQuietErrorHandler);
8995 0 : ReportError(CE_Failure, CPLE_NotSupported,
8996 : "SetDefaultRAT() not implemented for this format.");
8997 0 : CPLPopErrorHandler();
8998 : }
8999 0 : return CE_Failure;
9000 : }
9001 :
9002 : /************************************************************************/
9003 : /* GDALSetDefaultRAT() */
9004 : /************************************************************************/
9005 :
9006 : /**
9007 : * \brief Set default Raster Attribute Table.
9008 : *
9009 : * @see GDALRasterBand::GDALSetDefaultRAT()
9010 : */
9011 :
9012 25 : CPLErr CPL_STDCALL GDALSetDefaultRAT(GDALRasterBandH hBand,
9013 : GDALRasterAttributeTableH hRAT)
9014 :
9015 : {
9016 25 : VALIDATE_POINTER1(hBand, "GDALSetDefaultRAT", CE_Failure);
9017 :
9018 25 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
9019 :
9020 25 : return poBand->SetDefaultRAT(GDALRasterAttributeTable::FromHandle(hRAT));
9021 : }
9022 :
9023 : /************************************************************************/
9024 : /* GetMaskBand() */
9025 : /************************************************************************/
9026 :
9027 : /**
9028 : * \brief Return the mask band associated with the band.
9029 : *
9030 : * The GDALRasterBand class includes a default implementation of GetMaskBand()
9031 : * that returns one of four default implementations :
9032 : * <ul>
9033 : * <li>If a corresponding .msk file exists it will be used for the mask band.
9034 : * </li>
9035 : * <li>If the dataset has a NODATA_VALUES metadata item, an instance of the new
9036 : * GDALNoDataValuesMaskBand class will be returned. GetMaskFlags() will return
9037 : * GMF_NODATA | GMF_PER_DATASET.
9038 : * </li>
9039 : * <li>If the band has a nodata value set, an instance of the new
9040 : * GDALNodataMaskRasterBand class will be returned. GetMaskFlags() will return
9041 : * GMF_NODATA.
9042 : * </li>
9043 : * <li>If there is no nodata value, but the dataset has an alpha band that seems
9044 : * to apply to this band (specific rules yet to be determined) and that is of
9045 : * type GDT_Byte then that alpha band will be returned, and the flags
9046 : * GMF_PER_DATASET and GMF_ALPHA will be returned in the flags.
9047 : * </li>
9048 : * <li>If neither of the above apply, an instance of the new
9049 : * GDALAllValidRasterBand class will be returned that has 255 values for all
9050 : * pixels. The null flags will return GMF_ALL_VALID.
9051 : * </li>
9052 : * </ul>
9053 : *
9054 : * Note that the GetMaskBand() should always return a GDALRasterBand mask, even
9055 : * if it is only an all 255 mask with the flags indicating GMF_ALL_VALID.
9056 : *
9057 : * For an external .msk file to be recognized by GDAL, it must be a valid GDAL
9058 : * dataset, with the same name as the main dataset and suffixed with .msk,
9059 : * with either one band (in the GMF_PER_DATASET case), or as many bands as the
9060 : * main dataset.
9061 : * It must have INTERNAL_MASK_FLAGS_xx metadata items set at the dataset
9062 : * level, where xx matches the band number of a band of the main dataset. The
9063 : * value of those items is a combination of the flags GMF_ALL_VALID,
9064 : * GMF_PER_DATASET, GMF_ALPHA and GMF_NODATA. If a metadata item is missing for
9065 : * a band, then the other rules explained above will be used to generate a
9066 : * on-the-fly mask band.
9067 : * \see CreateMaskBand() for the characteristics of .msk files created by GDAL.
9068 : *
9069 : * This method is the same as the C function GDALGetMaskBand().
9070 : *
9071 : * @return a valid mask band.
9072 : *
9073 : *
9074 : * @see https://gdal.org/development/rfc/rfc15_nodatabitmask.html
9075 : *
9076 : */
9077 809390 : GDALRasterBand *GDALRasterBand::GetMaskBand()
9078 :
9079 : {
9080 392863 : const auto HasNoData = [this]()
9081 : {
9082 130633 : int bHaveNoDataRaw = FALSE;
9083 130633 : bool bHaveNoData = false;
9084 130633 : if (eDataType == GDT_Int64)
9085 : {
9086 203 : CPL_IGNORE_RET_VAL(GetNoDataValueAsInt64(&bHaveNoDataRaw));
9087 203 : bHaveNoData = CPL_TO_BOOL(bHaveNoDataRaw);
9088 : }
9089 130430 : else if (eDataType == GDT_UInt64)
9090 : {
9091 151 : CPL_IGNORE_RET_VAL(GetNoDataValueAsUInt64(&bHaveNoDataRaw));
9092 151 : bHaveNoData = CPL_TO_BOOL(bHaveNoDataRaw);
9093 : }
9094 : else
9095 : {
9096 130279 : const double dfNoDataValue = GetNoDataValue(&bHaveNoDataRaw);
9097 129511 : if (bHaveNoDataRaw &&
9098 129511 : GDALNoDataMaskBand::IsNoDataInRange(dfNoDataValue, eDataType))
9099 : {
9100 1122 : bHaveNoData = true;
9101 : }
9102 : }
9103 129057 : return bHaveNoData;
9104 809390 : };
9105 :
9106 809390 : if (poMask != nullptr)
9107 : {
9108 705188 : if (poMask.IsOwned())
9109 : {
9110 332718 : if (dynamic_cast<GDALAllValidMaskBand *>(poMask.get()) != nullptr)
9111 : {
9112 32364 : if (HasNoData())
9113 : {
9114 9 : InvalidateMaskBand();
9115 : }
9116 : }
9117 300502 : else if (auto poNoDataMaskBand =
9118 300499 : dynamic_cast<GDALNoDataMaskBand *>(poMask.get()))
9119 : {
9120 394 : int bHaveNoDataRaw = FALSE;
9121 394 : bool bIsSame = false;
9122 394 : if (eDataType == GDT_Int64)
9123 17 : bIsSame = poNoDataMaskBand->m_nNoDataValueInt64 ==
9124 27 : GetNoDataValueAsInt64(&bHaveNoDataRaw) &&
9125 10 : bHaveNoDataRaw;
9126 377 : else if (eDataType == GDT_UInt64)
9127 17 : bIsSame = poNoDataMaskBand->m_nNoDataValueUInt64 ==
9128 27 : GetNoDataValueAsUInt64(&bHaveNoDataRaw) &&
9129 10 : bHaveNoDataRaw;
9130 : else
9131 : {
9132 : const double dfNoDataValue =
9133 360 : GetNoDataValue(&bHaveNoDataRaw);
9134 360 : if (bHaveNoDataRaw)
9135 : {
9136 357 : bIsSame =
9137 357 : std::isnan(dfNoDataValue)
9138 357 : ? std::isnan(poNoDataMaskBand->m_dfNoDataValue)
9139 322 : : poNoDataMaskBand->m_dfNoDataValue ==
9140 : dfNoDataValue;
9141 : }
9142 : }
9143 394 : if (!bIsSame)
9144 23 : InvalidateMaskBand();
9145 : }
9146 : }
9147 :
9148 705170 : if (poMask)
9149 708003 : return poMask.get();
9150 : }
9151 :
9152 : /* -------------------------------------------------------------------- */
9153 : /* Check for a mask in a .msk file. */
9154 : /* -------------------------------------------------------------------- */
9155 98388 : if (poDS != nullptr && poDS->oOvManager.HaveMaskFile())
9156 : {
9157 47 : poMask.resetNotOwned(poDS->oOvManager.GetMaskBand(nBand));
9158 47 : if (poMask != nullptr)
9159 : {
9160 45 : nMaskFlags = poDS->oOvManager.GetMaskFlags(nBand);
9161 45 : return poMask.get();
9162 : }
9163 : }
9164 :
9165 : /* -------------------------------------------------------------------- */
9166 : /* Check for NODATA_VALUES metadata. */
9167 : /* -------------------------------------------------------------------- */
9168 98343 : if (poDS != nullptr)
9169 : {
9170 : const char *pszGDALNoDataValues =
9171 98327 : poDS->GetMetadataItem("NODATA_VALUES");
9172 98329 : if (pszGDALNoDataValues != nullptr)
9173 : {
9174 68 : char **papszGDALNoDataValues = CSLTokenizeStringComplex(
9175 : pszGDALNoDataValues, " ", FALSE, FALSE);
9176 :
9177 : // Make sure we have as many values as bands.
9178 136 : if (CSLCount(papszGDALNoDataValues) == poDS->GetRasterCount() &&
9179 68 : poDS->GetRasterCount() != 0)
9180 : {
9181 : // Make sure that all bands have the same data type
9182 : // This is clearly not a fundamental condition, just a
9183 : // condition to make implementation easier.
9184 68 : GDALDataType eDT = GDT_Unknown;
9185 68 : int i = 0; // Used after for.
9186 270 : for (; i < poDS->GetRasterCount(); ++i)
9187 : {
9188 202 : if (i == 0)
9189 68 : eDT = poDS->GetRasterBand(1)->GetRasterDataType();
9190 134 : else if (eDT !=
9191 134 : poDS->GetRasterBand(i + 1)->GetRasterDataType())
9192 : {
9193 0 : break;
9194 : }
9195 : }
9196 68 : if (i == poDS->GetRasterCount())
9197 : {
9198 68 : nMaskFlags = GMF_NODATA | GMF_PER_DATASET;
9199 : try
9200 : {
9201 68 : poMask.reset(
9202 136 : std::make_unique<GDALNoDataValuesMaskBand>(poDS));
9203 : }
9204 0 : catch (const std::bad_alloc &)
9205 : {
9206 0 : CPLError(CE_Failure, CPLE_OutOfMemory, "Out of memory");
9207 0 : poMask.reset();
9208 : }
9209 68 : CSLDestroy(papszGDALNoDataValues);
9210 68 : return poMask.get();
9211 : }
9212 : else
9213 : {
9214 0 : ReportError(CE_Warning, CPLE_AppDefined,
9215 : "All bands should have the same type in "
9216 : "order the NODATA_VALUES metadata item "
9217 : "to be used as a mask.");
9218 : }
9219 : }
9220 : else
9221 : {
9222 0 : ReportError(
9223 : CE_Warning, CPLE_AppDefined,
9224 : "NODATA_VALUES metadata item doesn't have the same number "
9225 : "of values as the number of bands. "
9226 : "Ignoring it for mask.");
9227 : }
9228 :
9229 0 : CSLDestroy(papszGDALNoDataValues);
9230 : }
9231 : }
9232 :
9233 : /* -------------------------------------------------------------------- */
9234 : /* Check for nodata case. */
9235 : /* -------------------------------------------------------------------- */
9236 98277 : if (HasNoData())
9237 : {
9238 1148 : nMaskFlags = GMF_NODATA;
9239 : try
9240 : {
9241 1148 : poMask.reset(std::make_unique<GDALNoDataMaskBand>(this));
9242 : }
9243 0 : catch (const std::bad_alloc &)
9244 : {
9245 0 : CPLError(CE_Failure, CPLE_OutOfMemory, "Out of memory");
9246 0 : poMask.reset();
9247 : }
9248 1148 : return poMask.get();
9249 : }
9250 :
9251 : /* -------------------------------------------------------------------- */
9252 : /* Check for alpha case. */
9253 : /* -------------------------------------------------------------------- */
9254 97114 : if (poDS != nullptr && poDS->GetRasterCount() == 2 &&
9255 194840 : this == poDS->GetRasterBand(1) &&
9256 599 : poDS->GetRasterBand(2)->GetColorInterpretation() == GCI_AlphaBand)
9257 : {
9258 231 : if (poDS->GetRasterBand(2)->GetRasterDataType() == GDT_Byte)
9259 : {
9260 187 : nMaskFlags = GMF_ALPHA | GMF_PER_DATASET;
9261 187 : poMask.resetNotOwned(poDS->GetRasterBand(2));
9262 187 : return poMask.get();
9263 : }
9264 44 : else if (poDS->GetRasterBand(2)->GetRasterDataType() == GDT_UInt16)
9265 : {
9266 23 : nMaskFlags = GMF_ALPHA | GMF_PER_DATASET;
9267 : try
9268 : {
9269 23 : poMask.reset(std::make_unique<GDALRescaledAlphaBand>(
9270 46 : poDS->GetRasterBand(2)));
9271 : }
9272 0 : catch (const std::bad_alloc &)
9273 : {
9274 0 : CPLError(CE_Failure, CPLE_OutOfMemory, "Out of memory");
9275 0 : poMask.reset();
9276 : }
9277 23 : return poMask.get();
9278 : }
9279 : }
9280 :
9281 96903 : if (poDS != nullptr && poDS->GetRasterCount() == 4 &&
9282 3098 : (this == poDS->GetRasterBand(1) || this == poDS->GetRasterBand(2) ||
9283 194548 : this == poDS->GetRasterBand(3)) &&
9284 2421 : poDS->GetRasterBand(4)->GetColorInterpretation() == GCI_AlphaBand)
9285 : {
9286 1545 : if (poDS->GetRasterBand(4)->GetRasterDataType() == GDT_Byte)
9287 : {
9288 1488 : nMaskFlags = GMF_ALPHA | GMF_PER_DATASET;
9289 1488 : poMask.resetNotOwned(poDS->GetRasterBand(4));
9290 1488 : return poMask.get();
9291 : }
9292 58 : else if (poDS->GetRasterBand(4)->GetRasterDataType() == GDT_UInt16)
9293 : {
9294 42 : nMaskFlags = GMF_ALPHA | GMF_PER_DATASET;
9295 : try
9296 : {
9297 42 : poMask.reset(std::make_unique<GDALRescaledAlphaBand>(
9298 84 : poDS->GetRasterBand(4)));
9299 : }
9300 0 : catch (const std::bad_alloc &)
9301 : {
9302 0 : CPLError(CE_Failure, CPLE_OutOfMemory, "Out of memory");
9303 0 : poMask.reset();
9304 : }
9305 42 : return poMask.get();
9306 : }
9307 : }
9308 :
9309 : /* -------------------------------------------------------------------- */
9310 : /* Fallback to all valid case. */
9311 : /* -------------------------------------------------------------------- */
9312 95387 : nMaskFlags = GMF_ALL_VALID;
9313 : try
9314 : {
9315 95387 : poMask.reset(std::make_unique<GDALAllValidMaskBand>(this));
9316 : }
9317 0 : catch (const std::bad_alloc &)
9318 : {
9319 0 : CPLError(CE_Failure, CPLE_OutOfMemory, "Out of memory");
9320 0 : poMask.reset();
9321 : }
9322 :
9323 95387 : return poMask.get();
9324 : }
9325 :
9326 : /************************************************************************/
9327 : /* GDALGetMaskBand() */
9328 : /************************************************************************/
9329 :
9330 : /**
9331 : * \brief Return the mask band associated with the band.
9332 : *
9333 : * @see GDALRasterBand::GetMaskBand()
9334 : */
9335 :
9336 11042 : GDALRasterBandH CPL_STDCALL GDALGetMaskBand(GDALRasterBandH hBand)
9337 :
9338 : {
9339 11042 : VALIDATE_POINTER1(hBand, "GDALGetMaskBand", nullptr);
9340 :
9341 11042 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
9342 11042 : return poBand->GetMaskBand();
9343 : }
9344 :
9345 : /************************************************************************/
9346 : /* GetMaskFlags() */
9347 : /************************************************************************/
9348 :
9349 : /**
9350 : * \brief Return the status flags of the mask band associated with the band.
9351 : *
9352 : * The GetMaskFlags() method returns an bitwise OR-ed set of status flags with
9353 : * the following available definitions that may be extended in the future:
9354 : * <ul>
9355 : * <li>GMF_ALL_VALID(0x01): There are no invalid pixels, all mask values will be
9356 : * 255. When used this will normally be the only flag set.
9357 : * </li>
9358 : * <li>GMF_PER_DATASET(0x02): The mask band is shared between all bands on the
9359 : * dataset.
9360 : * </li>
9361 : * <li>GMF_ALPHA(0x04): The mask band is actually an alpha band
9362 : * and may have values other than 0 and 255.
9363 : * </li>
9364 : * <li>GMF_NODATA(0x08): Indicates the mask is actually being generated from
9365 : * nodata values. (mutually exclusive of GMF_ALPHA)
9366 : * </li>
9367 : * </ul>
9368 : *
9369 : * The GDALRasterBand class includes a default implementation of GetMaskBand()
9370 : * that returns one of four default implementations:
9371 : * <ul>
9372 : * <li>If a corresponding .msk file exists it will be used for the mask band.
9373 : * </li>
9374 : * <li>If the dataset has a NODATA_VALUES metadata item, an instance of the new
9375 : * GDALNoDataValuesMaskBand class will be returned. GetMaskFlags() will return
9376 : * GMF_NODATA | GMF_PER_DATASET.
9377 : * </li>
9378 : * <li>If the band has a nodata value set, an instance of the new
9379 : * GDALNodataMaskRasterBand class will be returned. GetMaskFlags() will return
9380 : * GMF_NODATA.
9381 : * </li>
9382 : * <li>If there is no nodata value, but the dataset has an alpha band that
9383 : * seems to apply to this band (specific rules yet to be determined) and that is
9384 : * of type GDT_Byte then that alpha band will be returned, and the flags
9385 : * GMF_PER_DATASET and GMF_ALPHA will be returned in the flags.
9386 : * </li>
9387 : * <li>If neither of the above apply, an instance of the new
9388 : * GDALAllValidRasterBand class will be returned that has 255 values for all
9389 : * pixels. The null flags will return GMF_ALL_VALID.
9390 : * </li>
9391 : * </ul>
9392 : *
9393 : * For an external .msk file to be recognized by GDAL, it must be a valid GDAL
9394 : * dataset, with the same name as the main dataset and suffixed with .msk,
9395 : * with either one band (in the GMF_PER_DATASET case), or as many bands as the
9396 : * main dataset.
9397 : * It must have INTERNAL_MASK_FLAGS_xx metadata items set at the dataset
9398 : * level, where xx matches the band number of a band of the main dataset. The
9399 : * value of those items is a combination of the flags GMF_ALL_VALID,
9400 : * GMF_PER_DATASET, GMF_ALPHA and GMF_NODATA. If a metadata item is missing for
9401 : * a band, then the other rules explained above will be used to generate a
9402 : * on-the-fly mask band.
9403 : * \see CreateMaskBand() for the characteristics of .msk files created by GDAL.
9404 : *
9405 : * This method is the same as the C function GDALGetMaskFlags().
9406 : *
9407 : *
9408 : * @return a valid mask band.
9409 : *
9410 : * @see https://gdal.org/development/rfc/rfc15_nodatabitmask.html
9411 : *
9412 : */
9413 156776 : int GDALRasterBand::GetMaskFlags()
9414 :
9415 : {
9416 : // If we don't have a band yet, force this now so that the masks value
9417 : // will be initialized.
9418 :
9419 156776 : if (poMask == nullptr)
9420 96671 : GetMaskBand();
9421 :
9422 156769 : return nMaskFlags;
9423 : }
9424 :
9425 : /************************************************************************/
9426 : /* GDALGetMaskFlags() */
9427 : /************************************************************************/
9428 :
9429 : /**
9430 : * \brief Return the status flags of the mask band associated with the band.
9431 : *
9432 : * @see GDALRasterBand::GetMaskFlags()
9433 : */
9434 :
9435 8742 : int CPL_STDCALL GDALGetMaskFlags(GDALRasterBandH hBand)
9436 :
9437 : {
9438 8742 : VALIDATE_POINTER1(hBand, "GDALGetMaskFlags", GMF_ALL_VALID);
9439 :
9440 8742 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
9441 8742 : return poBand->GetMaskFlags();
9442 : }
9443 :
9444 : /************************************************************************/
9445 : /* InvalidateMaskBand() */
9446 : /************************************************************************/
9447 :
9448 : //! @cond Doxygen_Suppress
9449 1848900 : void GDALRasterBand::InvalidateMaskBand()
9450 : {
9451 1848900 : poMask.reset();
9452 1848900 : nMaskFlags = 0;
9453 1848900 : }
9454 :
9455 : //! @endcond
9456 :
9457 : /************************************************************************/
9458 : /* CreateMaskBand() */
9459 : /************************************************************************/
9460 :
9461 : /**
9462 : * \brief Adds a mask band to the current band
9463 : *
9464 : * The default implementation of the CreateMaskBand() method is implemented
9465 : * based on similar rules to the .ovr handling implemented using the
9466 : * GDALDefaultOverviews object. A TIFF file with the extension .msk will
9467 : * be created with the same basename as the original file, and it will have
9468 : * as many bands as the original image (or just one for GMF_PER_DATASET).
9469 : * The mask images will be deflate compressed tiled images with the same
9470 : * block size as the original image if possible.
9471 : * It will have INTERNAL_MASK_FLAGS_xx metadata items set at the dataset
9472 : * level, where xx matches the band number of a band of the main dataset. The
9473 : * value of those items will be the one of the nFlagsIn parameter.
9474 : *
9475 : * Note that if you got a mask band with a previous call to GetMaskBand(),
9476 : * it might be invalidated by CreateMaskBand(). So you have to call
9477 : * GetMaskBand() again.
9478 : *
9479 : * This method is the same as the C function GDALCreateMaskBand().
9480 : *
9481 : *
9482 : * @param nFlagsIn 0 or combination of GMF_PER_DATASET / GMF_ALPHA.
9483 : *
9484 : * @return CE_None on success or CE_Failure on an error.
9485 : *
9486 : * @see https://gdal.org/development/rfc/rfc15_nodatabitmask.html
9487 : * @see GDALDataset::CreateMaskBand()
9488 : *
9489 : */
9490 :
9491 10 : CPLErr GDALRasterBand::CreateMaskBand(int nFlagsIn)
9492 :
9493 : {
9494 10 : if (poDS != nullptr && poDS->oOvManager.IsInitialized())
9495 : {
9496 10 : const CPLErr eErr = poDS->oOvManager.CreateMaskBand(nFlagsIn, nBand);
9497 10 : if (eErr != CE_None)
9498 1 : return eErr;
9499 :
9500 9 : InvalidateMaskBand();
9501 :
9502 9 : return CE_None;
9503 : }
9504 :
9505 0 : ReportError(CE_Failure, CPLE_NotSupported,
9506 : "CreateMaskBand() not supported for this band.");
9507 :
9508 0 : return CE_Failure;
9509 : }
9510 :
9511 : /************************************************************************/
9512 : /* GDALCreateMaskBand() */
9513 : /************************************************************************/
9514 :
9515 : /**
9516 : * \brief Adds a mask band to the current band
9517 : *
9518 : * @see GDALRasterBand::CreateMaskBand()
9519 : */
9520 :
9521 34 : CPLErr CPL_STDCALL GDALCreateMaskBand(GDALRasterBandH hBand, int nFlags)
9522 :
9523 : {
9524 34 : VALIDATE_POINTER1(hBand, "GDALCreateMaskBand", CE_Failure);
9525 :
9526 34 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
9527 34 : return poBand->CreateMaskBand(nFlags);
9528 : }
9529 :
9530 : /************************************************************************/
9531 : /* IsMaskBand() */
9532 : /************************************************************************/
9533 :
9534 : /**
9535 : * \brief Returns whether a band is a mask band.
9536 : *
9537 : * Mask band must be understood in the broad term: it can be a per-dataset
9538 : * mask band, an alpha band, or an implicit mask band.
9539 : * Typically the return of GetMaskBand()->IsMaskBand() should be true.
9540 : *
9541 : * This method is the same as the C function GDALIsMaskBand().
9542 : *
9543 : * @return true if the band is a mask band.
9544 : *
9545 : * @see GDALDataset::CreateMaskBand()
9546 : *
9547 : * @since GDAL 3.5.0
9548 : *
9549 : */
9550 :
9551 444 : bool GDALRasterBand::IsMaskBand() const
9552 : {
9553 : // The GeoTIFF driver, among others, override this method to
9554 : // also handle external .msk bands.
9555 444 : return const_cast<GDALRasterBand *>(this)->GetColorInterpretation() ==
9556 444 : GCI_AlphaBand;
9557 : }
9558 :
9559 : /************************************************************************/
9560 : /* GDALIsMaskBand() */
9561 : /************************************************************************/
9562 :
9563 : /**
9564 : * \brief Returns whether a band is a mask band.
9565 : *
9566 : * Mask band must be understood in the broad term: it can be a per-dataset
9567 : * mask band, an alpha band, or an implicit mask band.
9568 : * Typically the return of GetMaskBand()->IsMaskBand() should be true.
9569 : *
9570 : * This function is the same as the C++ method GDALRasterBand::IsMaskBand()
9571 : *
9572 : * @return true if the band is a mask band.
9573 : *
9574 : * @see GDALRasterBand::IsMaskBand()
9575 : *
9576 : * @since GDAL 3.5.0
9577 : *
9578 : */
9579 :
9580 37 : bool GDALIsMaskBand(GDALRasterBandH hBand)
9581 :
9582 : {
9583 37 : VALIDATE_POINTER1(hBand, "GDALIsMaskBand", false);
9584 :
9585 37 : const GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
9586 37 : return poBand->IsMaskBand();
9587 : }
9588 :
9589 : /************************************************************************/
9590 : /* GetMaskValueRange() */
9591 : /************************************************************************/
9592 :
9593 : /**
9594 : * \brief Returns the range of values that a mask band can take.
9595 : *
9596 : * @return the range of values that a mask band can take.
9597 : *
9598 : * @since GDAL 3.5.0
9599 : *
9600 : */
9601 :
9602 0 : GDALMaskValueRange GDALRasterBand::GetMaskValueRange() const
9603 : {
9604 0 : return GMVR_UNKNOWN;
9605 : }
9606 :
9607 : /************************************************************************/
9608 : /* GetIndexColorTranslationTo() */
9609 : /************************************************************************/
9610 :
9611 : /**
9612 : * \brief Compute translation table for color tables.
9613 : *
9614 : * When the raster band has a palette index, it may be useful to compute
9615 : * the "translation" of this palette to the palette of another band.
9616 : * The translation tries to do exact matching first, and then approximate
9617 : * matching if no exact matching is possible.
9618 : * This method returns a table such that table[i] = j where i is an index
9619 : * of the 'this' rasterband and j the corresponding index for the reference
9620 : * rasterband.
9621 : *
9622 : * This method is thought as internal to GDAL and is used for drivers
9623 : * like RPFTOC.
9624 : *
9625 : * The implementation only supports 1-byte palette rasterbands.
9626 : *
9627 : * @param poReferenceBand the raster band
9628 : * @param pTranslationTable an already allocated translation table (at least 256
9629 : * bytes), or NULL to let the method allocate it
9630 : * @param pApproximateMatching a pointer to a flag that is set if the matching
9631 : * is approximate. May be NULL.
9632 : *
9633 : * @return a translation table if the two bands are palette index and that they
9634 : * do not match or NULL in other cases. The table must be freed with CPLFree if
9635 : * NULL was passed for pTranslationTable.
9636 : */
9637 :
9638 : unsigned char *
9639 4 : GDALRasterBand::GetIndexColorTranslationTo(GDALRasterBand *poReferenceBand,
9640 : unsigned char *pTranslationTable,
9641 : int *pApproximateMatching)
9642 : {
9643 4 : if (poReferenceBand == nullptr)
9644 0 : return nullptr;
9645 :
9646 : // cppcheck-suppress knownConditionTrueFalse
9647 4 : if (poReferenceBand->GetColorInterpretation() == GCI_PaletteIndex &&
9648 : // cppcheck-suppress knownConditionTrueFalse
9649 4 : GetColorInterpretation() == GCI_PaletteIndex &&
9650 12 : poReferenceBand->GetRasterDataType() == GDT_Byte &&
9651 4 : GetRasterDataType() == GDT_Byte)
9652 : {
9653 4 : const GDALColorTable *srcColorTable = GetColorTable();
9654 4 : GDALColorTable *destColorTable = poReferenceBand->GetColorTable();
9655 4 : if (srcColorTable != nullptr && destColorTable != nullptr)
9656 : {
9657 4 : const int nEntries = srcColorTable->GetColorEntryCount();
9658 4 : const int nRefEntries = destColorTable->GetColorEntryCount();
9659 :
9660 4 : int bHasNoDataValueSrc = FALSE;
9661 4 : double dfNoDataValueSrc = GetNoDataValue(&bHasNoDataValueSrc);
9662 4 : if (!(bHasNoDataValueSrc && dfNoDataValueSrc >= 0 &&
9663 4 : dfNoDataValueSrc <= 255 &&
9664 4 : dfNoDataValueSrc == static_cast<int>(dfNoDataValueSrc)))
9665 0 : bHasNoDataValueSrc = FALSE;
9666 4 : const int noDataValueSrc =
9667 4 : bHasNoDataValueSrc ? static_cast<int>(dfNoDataValueSrc) : 0;
9668 :
9669 4 : int bHasNoDataValueRef = FALSE;
9670 : const double dfNoDataValueRef =
9671 4 : poReferenceBand->GetNoDataValue(&bHasNoDataValueRef);
9672 4 : if (!(bHasNoDataValueRef && dfNoDataValueRef >= 0 &&
9673 3 : dfNoDataValueRef <= 255 &&
9674 3 : dfNoDataValueRef == static_cast<int>(dfNoDataValueRef)))
9675 1 : bHasNoDataValueRef = FALSE;
9676 4 : const int noDataValueRef =
9677 4 : bHasNoDataValueRef ? static_cast<int>(dfNoDataValueRef) : 0;
9678 :
9679 4 : bool samePalette = false;
9680 :
9681 4 : if (pApproximateMatching)
9682 3 : *pApproximateMatching = FALSE;
9683 :
9684 4 : if (nEntries == nRefEntries &&
9685 3 : bHasNoDataValueSrc == bHasNoDataValueRef &&
9686 3 : (bHasNoDataValueSrc == FALSE ||
9687 : noDataValueSrc == noDataValueRef))
9688 : {
9689 3 : samePalette = true;
9690 654 : for (int i = 0; i < nEntries; ++i)
9691 : {
9692 651 : if (noDataValueSrc == i)
9693 3 : continue;
9694 : const GDALColorEntry *entry =
9695 648 : srcColorTable->GetColorEntry(i);
9696 : const GDALColorEntry *entryRef =
9697 648 : destColorTable->GetColorEntry(i);
9698 648 : if (entry->c1 != entryRef->c1 ||
9699 648 : entry->c2 != entryRef->c2 || entry->c3 != entryRef->c3)
9700 : {
9701 0 : samePalette = false;
9702 : }
9703 : }
9704 : }
9705 :
9706 4 : if (!samePalette)
9707 : {
9708 1 : if (pTranslationTable == nullptr)
9709 : {
9710 : pTranslationTable = static_cast<unsigned char *>(
9711 1 : VSI_CALLOC_VERBOSE(1, std::max(256, nEntries)));
9712 1 : if (pTranslationTable == nullptr)
9713 1 : return nullptr;
9714 : }
9715 :
9716 : // Trying to remap the product palette on the subdataset
9717 : // palette.
9718 5 : for (int i = 0; i < nEntries; ++i)
9719 : {
9720 4 : if (bHasNoDataValueSrc && bHasNoDataValueRef &&
9721 : noDataValueSrc == i)
9722 0 : continue;
9723 : const GDALColorEntry *entry =
9724 4 : srcColorTable->GetColorEntry(i);
9725 4 : bool bMatchFound = false;
9726 13 : for (int j = 0; j < nRefEntries; ++j)
9727 : {
9728 10 : if (bHasNoDataValueRef && noDataValueRef == j)
9729 0 : continue;
9730 : const GDALColorEntry *entryRef =
9731 10 : destColorTable->GetColorEntry(j);
9732 10 : if (entry->c1 == entryRef->c1 &&
9733 2 : entry->c2 == entryRef->c2 &&
9734 2 : entry->c3 == entryRef->c3)
9735 : {
9736 1 : pTranslationTable[i] =
9737 : static_cast<unsigned char>(j);
9738 1 : bMatchFound = true;
9739 1 : break;
9740 : }
9741 : }
9742 4 : if (!bMatchFound)
9743 : {
9744 : // No exact match. Looking for closest color now.
9745 3 : int best_j = 0;
9746 3 : int best_distance = 0;
9747 3 : if (pApproximateMatching)
9748 0 : *pApproximateMatching = TRUE;
9749 12 : for (int j = 0; j < nRefEntries; ++j)
9750 : {
9751 : const GDALColorEntry *entryRef =
9752 9 : destColorTable->GetColorEntry(j);
9753 9 : int distance = (entry->c1 - entryRef->c1) *
9754 9 : (entry->c1 - entryRef->c1) +
9755 9 : (entry->c2 - entryRef->c2) *
9756 9 : (entry->c2 - entryRef->c2) +
9757 9 : (entry->c3 - entryRef->c3) *
9758 9 : (entry->c3 - entryRef->c3);
9759 9 : if (j == 0 || distance < best_distance)
9760 : {
9761 7 : best_j = j;
9762 7 : best_distance = distance;
9763 : }
9764 : }
9765 3 : pTranslationTable[i] =
9766 : static_cast<unsigned char>(best_j);
9767 : }
9768 : }
9769 1 : if (bHasNoDataValueRef && bHasNoDataValueSrc)
9770 0 : pTranslationTable[noDataValueSrc] =
9771 : static_cast<unsigned char>(noDataValueRef);
9772 :
9773 1 : return pTranslationTable;
9774 : }
9775 : }
9776 : }
9777 3 : return nullptr;
9778 : }
9779 :
9780 : /************************************************************************/
9781 : /* SetFlushBlockErr() */
9782 : /************************************************************************/
9783 :
9784 : /**
9785 : * \brief Store that an error occurred while writing a dirty block.
9786 : *
9787 : * This function stores the fact that an error occurred while writing a dirty
9788 : * block from GDALRasterBlock::FlushCacheBlock(). Indeed when dirty blocks are
9789 : * flushed when the block cache get full, it is not convenient/possible to
9790 : * report that a dirty block could not be written correctly. This function
9791 : * remembers the error and re-issue it from GDALRasterBand::FlushCache(),
9792 : * GDALRasterBand::WriteBlock() and GDALRasterBand::RasterIO(), which are
9793 : * places where the user can easily match the error with the relevant dataset.
9794 : */
9795 :
9796 0 : void GDALRasterBand::SetFlushBlockErr(CPLErr eErr)
9797 : {
9798 0 : eFlushBlockErr = eErr;
9799 0 : }
9800 :
9801 : /************************************************************************/
9802 : /* IncDirtyBlocks() */
9803 : /************************************************************************/
9804 :
9805 : /**
9806 : * \brief Increment/decrement the number of dirty blocks
9807 : */
9808 :
9809 796527 : void GDALRasterBand::IncDirtyBlocks(int nInc)
9810 : {
9811 796527 : if (poBandBlockCache)
9812 796526 : poBandBlockCache->IncDirtyBlocks(nInc);
9813 796523 : }
9814 :
9815 : /************************************************************************/
9816 : /* ReportError() */
9817 : /************************************************************************/
9818 :
9819 : #ifndef DOXYGEN_XML
9820 : /**
9821 : * \brief Emits an error related to a raster band.
9822 : *
9823 : * This function is a wrapper for regular CPLError(). The only difference
9824 : * with CPLError() is that it prepends the error message with the dataset
9825 : * name and the band number.
9826 : *
9827 : * @param eErrClass one of CE_Warning, CE_Failure or CE_Fatal.
9828 : * @param err_no the error number (CPLE_*) from cpl_error.h.
9829 : * @param fmt a printf() style format string. Any additional arguments
9830 : * will be treated as arguments to fill in this format in a manner
9831 : * similar to printf().
9832 : *
9833 : */
9834 :
9835 2476 : void GDALRasterBand::ReportError(CPLErr eErrClass, CPLErrorNum err_no,
9836 : const char *fmt, ...) const
9837 : {
9838 : va_list args;
9839 :
9840 2476 : va_start(args, fmt);
9841 :
9842 2476 : const char *pszDSName = poDS ? poDS->GetDescription() : "";
9843 2476 : pszDSName = CPLGetFilename(pszDSName);
9844 2476 : if (pszDSName[0] != '\0')
9845 : {
9846 2403 : CPLError(eErrClass, err_no, "%s",
9847 4806 : CPLString()
9848 2403 : .Printf("%s, band %d: ", pszDSName, GetBand())
9849 4806 : .append(CPLString().vPrintf(fmt, args))
9850 : .c_str());
9851 : }
9852 : else
9853 : {
9854 73 : CPLErrorV(eErrClass, err_no, fmt, args);
9855 : }
9856 :
9857 2476 : va_end(args);
9858 2476 : }
9859 : #endif
9860 :
9861 : /************************************************************************/
9862 : /* GetVirtualMemAuto() */
9863 : /************************************************************************/
9864 :
9865 : /** \brief Create a CPLVirtualMem object from a GDAL raster band object.
9866 : *
9867 : * Only supported on Linux and Unix systems with mmap() for now.
9868 : *
9869 : * This method allows creating a virtual memory object for a GDALRasterBand,
9870 : * that exposes the whole image data as a virtual array.
9871 : *
9872 : * The default implementation relies on GDALRasterBandGetVirtualMem(), but
9873 : * specialized implementation, such as for raw files, may also directly use
9874 : * mechanisms of the operating system to create a view of the underlying file
9875 : * into virtual memory ( CPLVirtualMemFileMapNew() )
9876 : *
9877 : * At the time of writing, the GeoTIFF driver and "raw" drivers (EHdr, ...)
9878 : * offer a specialized implementation with direct file mapping, provided that
9879 : * some requirements are met :
9880 : * - for all drivers, the dataset must be backed by a "real" file in the file
9881 : * system, and the byte ordering of multi-byte datatypes (Int16, etc.)
9882 : * must match the native ordering of the CPU.
9883 : * - in addition, for the GeoTIFF driver, the GeoTIFF file must be
9884 : * uncompressed, scanline oriented (i.e. not tiled). Strips must be organized in
9885 : * the file in sequential order, and be equally spaced (which is generally the
9886 : * case). Only power-of-two bit depths are supported (8 for GDT_Bye, 16 for
9887 : * GDT_Int16/GDT_UInt16/GDT_Float16, 32 for GDT_Float32 and 64 for GDT_Float64)
9888 : *
9889 : * The pointer returned remains valid until CPLVirtualMemFree() is called.
9890 : * CPLVirtualMemFree() must be called before the raster band object is
9891 : * destroyed.
9892 : *
9893 : * If p is such a pointer and base_type the type matching
9894 : * GDALGetRasterDataType(), the element of image coordinates (x, y) can be
9895 : * accessed with
9896 : * *(base_type*) ((GByte*)p + x * *pnPixelSpace + y * *pnLineSpace)
9897 : *
9898 : * This method is the same as the C GDALGetVirtualMemAuto() function.
9899 : *
9900 : * @param eRWFlag Either GF_Read to read the band, or GF_Write to
9901 : * read/write the band.
9902 : *
9903 : * @param pnPixelSpace Output parameter giving the byte offset from the start of
9904 : * one pixel value in the buffer to the start of the next pixel value within a
9905 : * scanline.
9906 : *
9907 : * @param pnLineSpace Output parameter giving the byte offset from the start of
9908 : * one scanline in the buffer to the start of the next.
9909 : *
9910 : * @param papszOptions NULL terminated list of options.
9911 : * If a specialized implementation exists, defining
9912 : * USE_DEFAULT_IMPLEMENTATION=YES will cause the default implementation to be
9913 : * used. On the contrary, defining
9914 : * USE_DEFAULT_IMPLEMENTATION=NO will prevent the default implementation from
9915 : * being used (thus only allowing efficient implementations to be used). When
9916 : * requiring or falling back to the default implementation, the following
9917 : * options are available : CACHE_SIZE (in bytes, defaults to
9918 : * 40 MB), PAGE_SIZE_HINT (in bytes), SINGLE_THREAD ("FALSE" / "TRUE", defaults
9919 : * to FALSE)
9920 : *
9921 : * @return a virtual memory object that must be unreferenced by
9922 : * CPLVirtualMemFree(), or NULL in case of failure.
9923 : *
9924 : */
9925 :
9926 9 : CPLVirtualMem *GDALRasterBand::GetVirtualMemAuto(GDALRWFlag eRWFlag,
9927 : int *pnPixelSpace,
9928 : GIntBig *pnLineSpace,
9929 : char **papszOptions)
9930 : {
9931 9 : const char *pszImpl = CSLFetchNameValueDef(
9932 : papszOptions, "USE_DEFAULT_IMPLEMENTATION", "AUTO");
9933 9 : if (EQUAL(pszImpl, "NO") || EQUAL(pszImpl, "OFF") || EQUAL(pszImpl, "0") ||
9934 8 : EQUAL(pszImpl, "FALSE"))
9935 : {
9936 1 : return nullptr;
9937 : }
9938 :
9939 8 : const int nPixelSpace = GDALGetDataTypeSizeBytes(eDataType);
9940 8 : const GIntBig nLineSpace = static_cast<GIntBig>(nRasterXSize) * nPixelSpace;
9941 8 : if (pnPixelSpace)
9942 8 : *pnPixelSpace = nPixelSpace;
9943 8 : if (pnLineSpace)
9944 8 : *pnLineSpace = nLineSpace;
9945 : const size_t nCacheSize =
9946 8 : atoi(CSLFetchNameValueDef(papszOptions, "CACHE_SIZE", "40000000"));
9947 : const size_t nPageSizeHint =
9948 8 : atoi(CSLFetchNameValueDef(papszOptions, "PAGE_SIZE_HINT", "0"));
9949 8 : const bool bSingleThreadUsage = CPLTestBool(
9950 : CSLFetchNameValueDef(papszOptions, "SINGLE_THREAD", "FALSE"));
9951 8 : return GDALRasterBandGetVirtualMem(
9952 : GDALRasterBand::ToHandle(this), eRWFlag, 0, 0, nRasterXSize,
9953 : nRasterYSize, nRasterXSize, nRasterYSize, eDataType, nPixelSpace,
9954 : nLineSpace, nCacheSize, nPageSizeHint, bSingleThreadUsage,
9955 8 : papszOptions);
9956 : }
9957 :
9958 : /************************************************************************/
9959 : /* GDALGetVirtualMemAuto() */
9960 : /************************************************************************/
9961 :
9962 : /**
9963 : * \brief Create a CPLVirtualMem object from a GDAL raster band object.
9964 : *
9965 : * @see GDALRasterBand::GetVirtualMemAuto()
9966 : */
9967 :
9968 31 : CPLVirtualMem *GDALGetVirtualMemAuto(GDALRasterBandH hBand, GDALRWFlag eRWFlag,
9969 : int *pnPixelSpace, GIntBig *pnLineSpace,
9970 : CSLConstList papszOptions)
9971 : {
9972 31 : VALIDATE_POINTER1(hBand, "GDALGetVirtualMemAuto", nullptr);
9973 :
9974 31 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
9975 :
9976 31 : return poBand->GetVirtualMemAuto(eRWFlag, pnPixelSpace, pnLineSpace,
9977 31 : const_cast<char **>(papszOptions));
9978 : }
9979 :
9980 : /************************************************************************/
9981 : /* GDALGetDataCoverageStatus() */
9982 : /************************************************************************/
9983 :
9984 : /**
9985 : * \brief Get the coverage status of a sub-window of the raster.
9986 : *
9987 : * Returns whether a sub-window of the raster contains only data, only empty
9988 : * blocks or a mix of both. This function can be used to determine quickly
9989 : * if it is worth issuing RasterIO / ReadBlock requests in datasets that may
9990 : * be sparse.
9991 : *
9992 : * Empty blocks are blocks that are generally not physically present in the
9993 : * file, and when read through GDAL, contain only pixels whose value is the
9994 : * nodata value when it is set, or whose value is 0 when the nodata value is
9995 : * not set.
9996 : *
9997 : * The query is done in an efficient way without reading the actual pixel
9998 : * values. If not possible, or not implemented at all by the driver,
9999 : * GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED | GDAL_DATA_COVERAGE_STATUS_DATA will
10000 : * be returned.
10001 : *
10002 : * The values that can be returned by the function are the following,
10003 : * potentially combined with the binary or operator :
10004 : * <ul>
10005 : * <li>GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED : the driver does not implement
10006 : * GetDataCoverageStatus(). This flag should be returned together with
10007 : * GDAL_DATA_COVERAGE_STATUS_DATA.</li>
10008 : * <li>GDAL_DATA_COVERAGE_STATUS_DATA: There is (potentially) data in the
10009 : * queried window.</li> <li>GDAL_DATA_COVERAGE_STATUS_EMPTY: There is nodata in
10010 : * the queried window. This is typically identified by the concept of missing
10011 : * block in formats that supports it.
10012 : * </li>
10013 : * </ul>
10014 : *
10015 : * Note that GDAL_DATA_COVERAGE_STATUS_DATA might have false positives and
10016 : * should be interpreted more as hint of potential presence of data. For example
10017 : * if a GeoTIFF file is created with blocks filled with zeroes (or set to the
10018 : * nodata value), instead of using the missing block mechanism,
10019 : * GDAL_DATA_COVERAGE_STATUS_DATA will be returned. On the contrary,
10020 : * GDAL_DATA_COVERAGE_STATUS_EMPTY should have no false positives.
10021 : *
10022 : * The nMaskFlagStop should be generally set to 0. It can be set to a
10023 : * binary-or'ed mask of the above mentioned values to enable a quick exiting of
10024 : * the function as soon as the computed mask matches the nMaskFlagStop. For
10025 : * example, you can issue a request on the whole raster with nMaskFlagStop =
10026 : * GDAL_DATA_COVERAGE_STATUS_EMPTY. As soon as one missing block is encountered,
10027 : * the function will exit, so that you can potentially refine the requested area
10028 : * to find which particular region(s) have missing blocks.
10029 : *
10030 : * @see GDALRasterBand::GetDataCoverageStatus()
10031 : *
10032 : * @param hBand raster band
10033 : *
10034 : * @param nXOff The pixel offset to the top left corner of the region
10035 : * of the band to be queried. This would be zero to start from the left side.
10036 : *
10037 : * @param nYOff The line offset to the top left corner of the region
10038 : * of the band to be queried. This would be zero to start from the top.
10039 : *
10040 : * @param nXSize The width of the region of the band to be queried in pixels.
10041 : *
10042 : * @param nYSize The height of the region of the band to be queried in lines.
10043 : *
10044 : * @param nMaskFlagStop 0, or a binary-or'ed mask of possible values
10045 : * GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED,
10046 : * GDAL_DATA_COVERAGE_STATUS_DATA and GDAL_DATA_COVERAGE_STATUS_EMPTY. As soon
10047 : * as the computation of the coverage matches the mask, the computation will be
10048 : * stopped. *pdfDataPct will not be valid in that case.
10049 : *
10050 : * @param pdfDataPct Optional output parameter whose pointed value will be set
10051 : * to the (approximate) percentage in [0,100] of pixels in the queried
10052 : * sub-window that have valid values. The implementation might not always be
10053 : * able to compute it, in which case it will be set to a negative value.
10054 : *
10055 : * @return a binary-or'ed combination of possible values
10056 : * GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED,
10057 : * GDAL_DATA_COVERAGE_STATUS_DATA and GDAL_DATA_COVERAGE_STATUS_EMPTY
10058 : */
10059 :
10060 29 : int CPL_STDCALL GDALGetDataCoverageStatus(GDALRasterBandH hBand, int nXOff,
10061 : int nYOff, int nXSize, int nYSize,
10062 : int nMaskFlagStop, double *pdfDataPct)
10063 : {
10064 29 : VALIDATE_POINTER1(hBand, "GDALGetDataCoverageStatus",
10065 : GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED);
10066 :
10067 29 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
10068 :
10069 29 : return poBand->GetDataCoverageStatus(nXOff, nYOff, nXSize, nYSize,
10070 29 : nMaskFlagStop, pdfDataPct);
10071 : }
10072 :
10073 : /************************************************************************/
10074 : /* GetDataCoverageStatus() */
10075 : /************************************************************************/
10076 :
10077 : /**
10078 : * \fn GDALRasterBand::IGetDataCoverageStatus( int nXOff,
10079 : * int nYOff,
10080 : * int nXSize,
10081 : * int nYSize,
10082 : * int nMaskFlagStop,
10083 : * double* pdfDataPct)
10084 : * \brief Get the coverage status of a sub-window of the raster.
10085 : *
10086 : * Returns whether a sub-window of the raster contains only data, only empty
10087 : * blocks or a mix of both. This function can be used to determine quickly
10088 : * if it is worth issuing RasterIO / ReadBlock requests in datasets that may
10089 : * be sparse.
10090 : *
10091 : * Empty blocks are blocks that contain only pixels whose value is the nodata
10092 : * value when it is set, or whose value is 0 when the nodata value is not set.
10093 : *
10094 : * The query is done in an efficient way without reading the actual pixel
10095 : * values. If not possible, or not implemented at all by the driver,
10096 : * GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED | GDAL_DATA_COVERAGE_STATUS_DATA will
10097 : * be returned.
10098 : *
10099 : * The values that can be returned by the function are the following,
10100 : * potentially combined with the binary or operator :
10101 : * <ul>
10102 : * <li>GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED : the driver does not implement
10103 : * GetDataCoverageStatus(). This flag should be returned together with
10104 : * GDAL_DATA_COVERAGE_STATUS_DATA.</li>
10105 : * <li>GDAL_DATA_COVERAGE_STATUS_DATA: There is (potentially) data in the
10106 : * queried window.</li> <li>GDAL_DATA_COVERAGE_STATUS_EMPTY: There is nodata in
10107 : * the queried window. This is typically identified by the concept of missing
10108 : * block in formats that supports it.
10109 : * </li>
10110 : * </ul>
10111 : *
10112 : * Note that GDAL_DATA_COVERAGE_STATUS_DATA might have false positives and
10113 : * should be interpreted more as hint of potential presence of data. For example
10114 : * if a GeoTIFF file is created with blocks filled with zeroes (or set to the
10115 : * nodata value), instead of using the missing block mechanism,
10116 : * GDAL_DATA_COVERAGE_STATUS_DATA will be returned. On the contrary,
10117 : * GDAL_DATA_COVERAGE_STATUS_EMPTY should have no false positives.
10118 : *
10119 : * The nMaskFlagStop should be generally set to 0. It can be set to a
10120 : * binary-or'ed mask of the above mentioned values to enable a quick exiting of
10121 : * the function as soon as the computed mask matches the nMaskFlagStop. For
10122 : * example, you can issue a request on the whole raster with nMaskFlagStop =
10123 : * GDAL_DATA_COVERAGE_STATUS_EMPTY. As soon as one missing block is encountered,
10124 : * the function will exit, so that you can potentially refine the requested area
10125 : * to find which particular region(s) have missing blocks.
10126 : *
10127 : * @see GDALGetDataCoverageStatus()
10128 : *
10129 : * @param nXOff The pixel offset to the top left corner of the region
10130 : * of the band to be queried. This would be zero to start from the left side.
10131 : *
10132 : * @param nYOff The line offset to the top left corner of the region
10133 : * of the band to be queried. This would be zero to start from the top.
10134 : *
10135 : * @param nXSize The width of the region of the band to be queried in pixels.
10136 : *
10137 : * @param nYSize The height of the region of the band to be queried in lines.
10138 : *
10139 : * @param nMaskFlagStop 0, or a binary-or'ed mask of possible values
10140 : * GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED,
10141 : * GDAL_DATA_COVERAGE_STATUS_DATA and GDAL_DATA_COVERAGE_STATUS_EMPTY. As soon
10142 : * as the computation of the coverage matches the mask, the computation will be
10143 : * stopped. *pdfDataPct will not be valid in that case.
10144 : *
10145 : * @param pdfDataPct Optional output parameter whose pointed value will be set
10146 : * to the (approximate) percentage in [0,100] of pixels in the queried
10147 : * sub-window that have valid values. The implementation might not always be
10148 : * able to compute it, in which case it will be set to a negative value.
10149 : *
10150 : * @return a binary-or'ed combination of possible values
10151 : * GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED,
10152 : * GDAL_DATA_COVERAGE_STATUS_DATA and GDAL_DATA_COVERAGE_STATUS_EMPTY
10153 : */
10154 :
10155 : /**
10156 : * \brief Get the coverage status of a sub-window of the raster.
10157 : *
10158 : * Returns whether a sub-window of the raster contains only data, only empty
10159 : * blocks or a mix of both. This function can be used to determine quickly
10160 : * if it is worth issuing RasterIO / ReadBlock requests in datasets that may
10161 : * be sparse.
10162 : *
10163 : * Empty blocks are blocks that contain only pixels whose value is the nodata
10164 : * value when it is set, or whose value is 0 when the nodata value is not set.
10165 : *
10166 : * The query is done in an efficient way without reading the actual pixel
10167 : * values. If not possible, or not implemented at all by the driver,
10168 : * GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED | GDAL_DATA_COVERAGE_STATUS_DATA will
10169 : * be returned.
10170 : *
10171 : * The values that can be returned by the function are the following,
10172 : * potentially combined with the binary or operator :
10173 : * <ul>
10174 : * <li>GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED : the driver does not implement
10175 : * GetDataCoverageStatus(). This flag should be returned together with
10176 : * GDAL_DATA_COVERAGE_STATUS_DATA.</li>
10177 : * <li>GDAL_DATA_COVERAGE_STATUS_DATA: There is (potentially) data in the
10178 : * queried window.</li> <li>GDAL_DATA_COVERAGE_STATUS_EMPTY: There is nodata in
10179 : * the queried window. This is typically identified by the concept of missing
10180 : * block in formats that supports it.
10181 : * </li>
10182 : * </ul>
10183 : *
10184 : * Note that GDAL_DATA_COVERAGE_STATUS_DATA might have false positives and
10185 : * should be interpreted more as hint of potential presence of data. For example
10186 : * if a GeoTIFF file is created with blocks filled with zeroes (or set to the
10187 : * nodata value), instead of using the missing block mechanism,
10188 : * GDAL_DATA_COVERAGE_STATUS_DATA will be returned. On the contrary,
10189 : * GDAL_DATA_COVERAGE_STATUS_EMPTY should have no false positives.
10190 : *
10191 : * The nMaskFlagStop should be generally set to 0. It can be set to a
10192 : * binary-or'ed mask of the above mentioned values to enable a quick exiting of
10193 : * the function as soon as the computed mask matches the nMaskFlagStop. For
10194 : * example, you can issue a request on the whole raster with nMaskFlagStop =
10195 : * GDAL_DATA_COVERAGE_STATUS_EMPTY. As soon as one missing block is encountered,
10196 : * the function will exit, so that you can potentially refine the requested area
10197 : * to find which particular region(s) have missing blocks.
10198 : *
10199 : * @see GDALGetDataCoverageStatus()
10200 : *
10201 : * @param nXOff The pixel offset to the top left corner of the region
10202 : * of the band to be queried. This would be zero to start from the left side.
10203 : *
10204 : * @param nYOff The line offset to the top left corner of the region
10205 : * of the band to be queried. This would be zero to start from the top.
10206 : *
10207 : * @param nXSize The width of the region of the band to be queried in pixels.
10208 : *
10209 : * @param nYSize The height of the region of the band to be queried in lines.
10210 : *
10211 : * @param nMaskFlagStop 0, or a binary-or'ed mask of possible values
10212 : * GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED,
10213 : * GDAL_DATA_COVERAGE_STATUS_DATA and GDAL_DATA_COVERAGE_STATUS_EMPTY. As soon
10214 : * as the computation of the coverage matches the mask, the computation will be
10215 : * stopped. *pdfDataPct will not be valid in that case.
10216 : *
10217 : * @param pdfDataPct Optional output parameter whose pointed value will be set
10218 : * to the (approximate) percentage in [0,100] of pixels in the queried
10219 : * sub-window that have valid values. The implementation might not always be
10220 : * able to compute it, in which case it will be set to a negative value.
10221 : *
10222 : * @return a binary-or'ed combination of possible values
10223 : * GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED,
10224 : * GDAL_DATA_COVERAGE_STATUS_DATA and GDAL_DATA_COVERAGE_STATUS_EMPTY
10225 : */
10226 :
10227 4702 : int GDALRasterBand::GetDataCoverageStatus(int nXOff, int nYOff, int nXSize,
10228 : int nYSize, int nMaskFlagStop,
10229 : double *pdfDataPct)
10230 : {
10231 4702 : if (nXOff < 0 || nYOff < 0 || nXSize > INT_MAX - nXOff ||
10232 4702 : nYSize > INT_MAX - nYOff || nXOff + nXSize > nRasterXSize ||
10233 4702 : nYOff + nYSize > nRasterYSize)
10234 : {
10235 0 : CPLError(CE_Failure, CPLE_AppDefined, "Bad window");
10236 0 : if (pdfDataPct)
10237 0 : *pdfDataPct = 0.0;
10238 : return GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED |
10239 0 : GDAL_DATA_COVERAGE_STATUS_EMPTY;
10240 : }
10241 4702 : return IGetDataCoverageStatus(nXOff, nYOff, nXSize, nYSize, nMaskFlagStop,
10242 4702 : pdfDataPct);
10243 : }
10244 :
10245 : /************************************************************************/
10246 : /* IGetDataCoverageStatus() */
10247 : /************************************************************************/
10248 :
10249 685 : int GDALRasterBand::IGetDataCoverageStatus(int /*nXOff*/, int /*nYOff*/,
10250 : int /*nXSize*/, int /*nYSize*/,
10251 : int /*nMaskFlagStop*/,
10252 : double *pdfDataPct)
10253 : {
10254 685 : if (pdfDataPct != nullptr)
10255 0 : *pdfDataPct = 100.0;
10256 : return GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED |
10257 685 : GDAL_DATA_COVERAGE_STATUS_DATA;
10258 : }
10259 :
10260 : //! @cond Doxygen_Suppress
10261 : /************************************************************************/
10262 : /* EnterReadWrite() */
10263 : /************************************************************************/
10264 :
10265 7793690 : int GDALRasterBand::EnterReadWrite(GDALRWFlag eRWFlag)
10266 : {
10267 7793690 : if (poDS != nullptr)
10268 7027940 : return poDS->EnterReadWrite(eRWFlag);
10269 765758 : return FALSE;
10270 : }
10271 :
10272 : /************************************************************************/
10273 : /* LeaveReadWrite() */
10274 : /************************************************************************/
10275 :
10276 1128230 : void GDALRasterBand::LeaveReadWrite()
10277 : {
10278 1128230 : if (poDS != nullptr)
10279 1128000 : poDS->LeaveReadWrite();
10280 1128290 : }
10281 :
10282 : /************************************************************************/
10283 : /* InitRWLock() */
10284 : /************************************************************************/
10285 :
10286 3978210 : void GDALRasterBand::InitRWLock()
10287 : {
10288 3978210 : if (poDS != nullptr)
10289 3977800 : poDS->InitRWLock();
10290 3978210 : }
10291 :
10292 : //! @endcond
10293 :
10294 : // clang-format off
10295 :
10296 : /**
10297 : * \fn GDALRasterBand::SetMetadata( char ** papszMetadata, const char * pszDomain)
10298 : * \brief Set metadata.
10299 : *
10300 : * CAUTION: depending on the format, older values of the updated information
10301 : * might still be found in the file in a "ghost" state, even if no longer
10302 : * accessible through the GDAL API. This is for example the case of the GTiff
10303 : * format (this is not a exhaustive list)
10304 : *
10305 : * The C function GDALSetMetadata() does the same thing as this method.
10306 : *
10307 : * @param papszMetadata the metadata in name=value string list format to
10308 : * apply.
10309 : * @param pszDomain the domain of interest. Use "" or NULL for the default
10310 : * domain.
10311 : * @return CE_None on success, CE_Failure on failure and CE_Warning if the
10312 : * metadata has been accepted, but is likely not maintained persistently
10313 : * by the underlying object between sessions.
10314 : */
10315 :
10316 : /**
10317 : * \fn GDALRasterBand::SetMetadataItem( const char * pszName, const char * pszValue, const char * pszDomain)
10318 : * \brief Set single metadata item.
10319 : *
10320 : * CAUTION: depending on the format, older values of the updated information
10321 : * might still be found in the file in a "ghost" state, even if no longer
10322 : * accessible through the GDAL API. This is for example the case of the GTiff
10323 : * format (this is not a exhaustive list)
10324 : *
10325 : * The C function GDALSetMetadataItem() does the same thing as this method.
10326 : *
10327 : * @param pszName the key for the metadata item to fetch.
10328 : * @param pszValue the value to assign to the key.
10329 : * @param pszDomain the domain to set within, use NULL for the default domain.
10330 : *
10331 : * @return CE_None on success, or an error code on failure.
10332 : */
10333 :
10334 : // clang-format on
10335 :
10336 : //! @cond Doxygen_Suppress
10337 : /************************************************************************/
10338 : /* EnablePixelTypeSignedByteWarning() */
10339 : /************************************************************************/
10340 :
10341 157078 : void GDALRasterBand::EnablePixelTypeSignedByteWarning(bool b)
10342 : {
10343 157078 : m_bEnablePixelTypeSignedByteWarning = b;
10344 157078 : }
10345 :
10346 4902 : void GDALEnablePixelTypeSignedByteWarning(GDALRasterBandH hBand, bool b)
10347 : {
10348 4902 : GDALRasterBand::FromHandle(hBand)->EnablePixelTypeSignedByteWarning(b);
10349 4902 : }
10350 :
10351 : //! @endcond
10352 :
10353 : /************************************************************************/
10354 : /* GetMetadataItem() */
10355 : /************************************************************************/
10356 :
10357 621103 : const char *GDALRasterBand::GetMetadataItem(const char *pszName,
10358 : const char *pszDomain)
10359 : {
10360 : // TODO (GDAL 4.0?): remove this when GDAL 3.7 has been widely adopted.
10361 621103 : if (m_bEnablePixelTypeSignedByteWarning && eDataType == GDT_Byte &&
10362 462496 : pszDomain != nullptr && EQUAL(pszDomain, "IMAGE_STRUCTURE") &&
10363 321873 : EQUAL(pszName, "PIXELTYPE"))
10364 : {
10365 2 : CPLError(CE_Warning, CPLE_AppDefined,
10366 : "Starting with GDAL 3.7, PIXELTYPE=SIGNEDBYTE is no longer "
10367 : "used to signal signed 8-bit raster. Change your code to "
10368 : "test for the new GDT_Int8 data type instead.");
10369 : }
10370 621103 : return GDALMajorObject::GetMetadataItem(pszName, pszDomain);
10371 : }
10372 :
10373 : /************************************************************************/
10374 : /* WindowIterator */
10375 : /************************************************************************/
10376 :
10377 : //! @cond Doxygen_Suppress
10378 :
10379 560 : GDALRasterBand::WindowIterator::WindowIterator(int nRasterXSize,
10380 : int nRasterYSize,
10381 : int nBlockXSize, int nBlockYSize,
10382 560 : int nRow, int nCol)
10383 : : m_nRasterXSize(nRasterXSize), m_nRasterYSize(nRasterYSize),
10384 : m_nBlockXSize(nBlockXSize), m_nBlockYSize(nBlockYSize), m_row(nRow),
10385 560 : m_col(nCol)
10386 : {
10387 560 : }
10388 :
10389 768 : bool GDALRasterBand::WindowIterator::operator==(
10390 : const WindowIterator &other) const
10391 : {
10392 251 : return m_row == other.m_row && m_col == other.m_col &&
10393 251 : m_nRasterXSize == other.m_nRasterXSize &&
10394 251 : m_nRasterYSize == other.m_nRasterYSize &&
10395 1270 : m_nBlockXSize == other.m_nBlockXSize &&
10396 1019 : m_nBlockYSize == other.m_nBlockYSize;
10397 : }
10398 :
10399 742 : bool GDALRasterBand::WindowIterator::operator!=(
10400 : const WindowIterator &other) const
10401 : {
10402 742 : return !(*this == other);
10403 : }
10404 :
10405 : GDALRasterBand::WindowIterator::value_type
10406 516 : GDALRasterBand::WindowIterator::operator*() const
10407 : {
10408 : GDALRasterWindow ret;
10409 516 : ret.nXOff = m_col * m_nBlockXSize;
10410 516 : ret.nYOff = m_row * m_nBlockYSize;
10411 516 : ret.nXSize = std::min(m_nBlockXSize, m_nRasterXSize - ret.nXOff);
10412 516 : ret.nYSize = std::min(m_nBlockYSize, m_nRasterYSize - ret.nYOff);
10413 :
10414 516 : return ret;
10415 : }
10416 :
10417 514 : GDALRasterBand::WindowIterator &GDALRasterBand::WindowIterator::operator++()
10418 : {
10419 514 : m_col++;
10420 514 : if (m_col >= DIV_ROUND_UP(m_nRasterXSize, m_nBlockXSize))
10421 : {
10422 430 : m_col = 0;
10423 430 : m_row++;
10424 : }
10425 514 : return *this;
10426 : }
10427 :
10428 297 : GDALRasterBand::WindowIteratorWrapper::WindowIteratorWrapper(
10429 297 : const GDALRasterBand &band, size_t maxSize)
10430 297 : : m_nRasterXSize(band.GetXSize()), m_nRasterYSize(band.GetYSize()),
10431 297 : m_nBlockXSize(-1), m_nBlockYSize(-1)
10432 : {
10433 : #ifdef CSA_BUILD
10434 : assert(this);
10435 : #endif
10436 : int nXSize, nYSize;
10437 :
10438 297 : CPLErrorStateBackuper state(CPLQuietErrorHandler);
10439 297 : band.GetBlockSize(&nXSize, &nYSize);
10440 297 : if (nXSize < 1 || nYSize < 0)
10441 : {
10442 : // If invalid block size is reported, assume scanlines
10443 4 : nXSize = m_nRasterXSize;
10444 4 : nYSize = 1;
10445 : }
10446 :
10447 297 : if (maxSize == 0)
10448 : {
10449 234 : m_nBlockXSize = nXSize;
10450 234 : m_nBlockYSize = nYSize;
10451 234 : return;
10452 : }
10453 :
10454 63 : const double dfBlocksPerRow = static_cast<double>(m_nRasterXSize) / nXSize;
10455 63 : const double dfBlocksPerChunk =
10456 63 : static_cast<double>(maxSize) /
10457 63 : (static_cast<double>(nXSize) * static_cast<double>(nYSize));
10458 :
10459 63 : if (dfBlocksPerChunk < dfBlocksPerRow)
10460 : {
10461 14 : m_nBlockXSize = static_cast<int>(std::min<double>(
10462 14 : m_nRasterXSize,
10463 14 : nXSize * std::max(std::floor(dfBlocksPerChunk), 1.0)));
10464 14 : m_nBlockYSize = nYSize;
10465 : }
10466 : else
10467 : {
10468 49 : m_nBlockXSize = m_nRasterXSize;
10469 49 : m_nBlockYSize = static_cast<int>(std::min<double>(
10470 49 : m_nRasterYSize,
10471 49 : nYSize * std::floor(dfBlocksPerChunk / dfBlocksPerRow)));
10472 : }
10473 : if constexpr (sizeof(size_t) < sizeof(uint64_t))
10474 : {
10475 : if (m_nBlockXSize > std::numeric_limits<int>::max() / m_nBlockYSize)
10476 : {
10477 : nXSize = m_nRasterXSize;
10478 : nYSize = 1;
10479 : }
10480 : }
10481 : }
10482 :
10483 : GDALRasterBand::WindowIterator
10484 266 : GDALRasterBand::WindowIteratorWrapper::begin() const
10485 : {
10486 266 : return WindowIterator(m_nRasterXSize, m_nRasterYSize, m_nBlockXSize,
10487 266 : m_nBlockYSize, 0, 0);
10488 : }
10489 :
10490 : GDALRasterBand::WindowIterator
10491 266 : GDALRasterBand::WindowIteratorWrapper::end() const
10492 : {
10493 266 : return WindowIterator(m_nRasterXSize, m_nRasterYSize, m_nBlockXSize,
10494 266 : m_nBlockYSize,
10495 266 : DIV_ROUND_UP(m_nRasterYSize, m_nBlockYSize), 0);
10496 : }
10497 :
10498 55 : uint64_t GDALRasterBand::WindowIteratorWrapper::count() const
10499 : {
10500 55 : return static_cast<uint64_t>(
10501 55 : cpl::div_round_up(m_nRasterXSize, m_nBlockXSize)) *
10502 55 : static_cast<uint64_t>(
10503 55 : cpl::div_round_up(m_nRasterYSize, m_nBlockYSize));
10504 : }
10505 :
10506 : //! @endcond
10507 :
10508 : /** Return an object whose begin() and end() methods can be used to iterate
10509 : * over GDALRasterWindow objects that are aligned with blocks in this raster
10510 : * band. The iteration order is from left to right, then from top to bottom.
10511 : *
10512 : \code{.cpp}
10513 : std::vector<double> pixelValues;
10514 : for (const auto& window : poBand->IterateWindows()) {
10515 : CPLErr eErr = poBand->ReadRaster(pixelValues, window.nXOff, window.nYOff,
10516 : window.nXSize, window.nYSize);
10517 : // check eErr
10518 : }
10519 : \endcode
10520 : *
10521 : *
10522 : * @param maxSize The maximum number of pixels in each window. If set to
10523 : * zero (the default), or a number smaller than the block size,
10524 : * the window size will be the same as the block size.
10525 : * @since GDAL 3.12
10526 : */
10527 : GDALRasterBand::WindowIteratorWrapper
10528 297 : GDALRasterBand::IterateWindows(size_t maxSize) const
10529 : {
10530 297 : return WindowIteratorWrapper(*this, maxSize);
10531 : }
10532 :
10533 : /************************************************************************/
10534 : /* GDALMDArrayFromRasterBand */
10535 : /************************************************************************/
10536 :
10537 : class GDALMDArrayFromRasterBand final : public GDALMDArray
10538 : {
10539 : CPL_DISALLOW_COPY_ASSIGN(GDALMDArrayFromRasterBand)
10540 :
10541 : GDALDataset *m_poDS;
10542 : GDALRasterBand *m_poBand;
10543 : GDALExtendedDataType m_dt;
10544 : std::vector<std::shared_ptr<GDALDimension>> m_dims{};
10545 : std::string m_osUnit;
10546 : std::vector<GByte> m_pabyNoData{};
10547 : std::shared_ptr<GDALMDArray> m_varX{};
10548 : std::shared_ptr<GDALMDArray> m_varY{};
10549 : std::string m_osFilename{};
10550 :
10551 : bool ReadWrite(GDALRWFlag eRWFlag, const GUInt64 *arrayStartIdx,
10552 : const size_t *count, const GInt64 *arrayStep,
10553 : const GPtrDiff_t *bufferStride,
10554 : const GDALExtendedDataType &bufferDataType,
10555 : void *pBuffer) const;
10556 :
10557 : protected:
10558 34 : GDALMDArrayFromRasterBand(GDALDataset *poDS, GDALRasterBand *poBand)
10559 68 : : GDALAbstractMDArray(std::string(),
10560 68 : std::string(poDS->GetDescription()) +
10561 : CPLSPrintf(" band %d", poBand->GetBand())),
10562 68 : GDALMDArray(std::string(),
10563 68 : std::string(poDS->GetDescription()) +
10564 : CPLSPrintf(" band %d", poBand->GetBand())),
10565 : m_poDS(poDS), m_poBand(poBand),
10566 : m_dt(GDALExtendedDataType::Create(poBand->GetRasterDataType())),
10567 170 : m_osUnit(poBand->GetUnitType()), m_osFilename(poDS->GetDescription())
10568 : {
10569 34 : m_poDS->Reference();
10570 :
10571 34 : int bHasNoData = false;
10572 34 : if (m_poBand->GetRasterDataType() == GDT_Int64)
10573 : {
10574 0 : const auto nNoData = m_poBand->GetNoDataValueAsInt64(&bHasNoData);
10575 0 : if (bHasNoData)
10576 : {
10577 0 : m_pabyNoData.resize(m_dt.GetSize());
10578 0 : GDALCopyWords64(&nNoData, GDT_Int64, 0, &m_pabyNoData[0],
10579 : m_dt.GetNumericDataType(), 0, 1);
10580 : }
10581 : }
10582 34 : else if (m_poBand->GetRasterDataType() == GDT_UInt64)
10583 : {
10584 0 : const auto nNoData = m_poBand->GetNoDataValueAsUInt64(&bHasNoData);
10585 0 : if (bHasNoData)
10586 : {
10587 0 : m_pabyNoData.resize(m_dt.GetSize());
10588 0 : GDALCopyWords64(&nNoData, GDT_UInt64, 0, &m_pabyNoData[0],
10589 : m_dt.GetNumericDataType(), 0, 1);
10590 : }
10591 : }
10592 : else
10593 : {
10594 34 : const auto dfNoData = m_poBand->GetNoDataValue(&bHasNoData);
10595 34 : if (bHasNoData)
10596 : {
10597 1 : m_pabyNoData.resize(m_dt.GetSize());
10598 1 : GDALCopyWords64(&dfNoData, GDT_Float64, 0, &m_pabyNoData[0],
10599 : m_dt.GetNumericDataType(), 0, 1);
10600 : }
10601 : }
10602 :
10603 34 : const int nXSize = poBand->GetXSize();
10604 34 : const int nYSize = poBand->GetYSize();
10605 :
10606 34 : auto poSRS = m_poDS->GetSpatialRef();
10607 68 : std::string osTypeY;
10608 68 : std::string osTypeX;
10609 68 : std::string osDirectionY;
10610 68 : std::string osDirectionX;
10611 34 : if (poSRS && poSRS->GetAxesCount() == 2)
10612 : {
10613 24 : const auto &mapping = poSRS->GetDataAxisToSRSAxisMapping();
10614 24 : OGRAxisOrientation eOrientation1 = OAO_Other;
10615 24 : poSRS->GetAxis(nullptr, 0, &eOrientation1);
10616 24 : OGRAxisOrientation eOrientation2 = OAO_Other;
10617 24 : poSRS->GetAxis(nullptr, 1, &eOrientation2);
10618 24 : if (eOrientation1 == OAO_East && eOrientation2 == OAO_North)
10619 : {
10620 8 : if (mapping == std::vector<int>{1, 2})
10621 : {
10622 8 : osTypeY = GDAL_DIM_TYPE_HORIZONTAL_Y;
10623 8 : osDirectionY = "NORTH";
10624 8 : osTypeX = GDAL_DIM_TYPE_HORIZONTAL_X;
10625 8 : osDirectionX = "EAST";
10626 : }
10627 : }
10628 16 : else if (eOrientation1 == OAO_North && eOrientation2 == OAO_East)
10629 : {
10630 16 : if (mapping == std::vector<int>{2, 1})
10631 : {
10632 16 : osTypeY = GDAL_DIM_TYPE_HORIZONTAL_Y;
10633 16 : osDirectionY = "NORTH";
10634 16 : osTypeX = GDAL_DIM_TYPE_HORIZONTAL_X;
10635 16 : osDirectionX = "EAST";
10636 : }
10637 : }
10638 : }
10639 :
10640 170 : m_dims = {std::make_shared<GDALDimensionWeakIndexingVar>(
10641 : "/", "Y", osTypeY, osDirectionY, nYSize),
10642 68 : std::make_shared<GDALDimensionWeakIndexingVar>(
10643 102 : "/", "X", osTypeX, osDirectionX, nXSize)};
10644 :
10645 34 : GDALGeoTransform gt;
10646 34 : if (m_poDS->GetGeoTransform(gt) == CE_None && gt[2] == 0 && gt[4] == 0)
10647 : {
10648 50 : m_varX = GDALMDArrayRegularlySpaced::Create("/", "X", m_dims[1],
10649 50 : gt[0], gt[1], 0.5);
10650 25 : m_dims[1]->SetIndexingVariable(m_varX);
10651 :
10652 50 : m_varY = GDALMDArrayRegularlySpaced::Create("/", "Y", m_dims[0],
10653 50 : gt[3], gt[5], 0.5);
10654 25 : m_dims[0]->SetIndexingVariable(m_varY);
10655 : }
10656 34 : }
10657 :
10658 : bool IRead(const GUInt64 *arrayStartIdx, const size_t *count,
10659 : const GInt64 *arrayStep, const GPtrDiff_t *bufferStride,
10660 : const GDALExtendedDataType &bufferDataType,
10661 : void *pDstBuffer) const override;
10662 :
10663 1 : bool IWrite(const GUInt64 *arrayStartIdx, const size_t *count,
10664 : const GInt64 *arrayStep, const GPtrDiff_t *bufferStride,
10665 : const GDALExtendedDataType &bufferDataType,
10666 : const void *pSrcBuffer) override
10667 : {
10668 1 : return ReadWrite(GF_Write, arrayStartIdx, count, arrayStep,
10669 : bufferStride, bufferDataType,
10670 1 : const_cast<void *>(pSrcBuffer));
10671 : }
10672 :
10673 : public:
10674 68 : ~GDALMDArrayFromRasterBand() override
10675 34 : {
10676 34 : m_poDS->ReleaseRef();
10677 68 : }
10678 :
10679 34 : static std::shared_ptr<GDALMDArray> Create(GDALDataset *poDS,
10680 : GDALRasterBand *poBand)
10681 : {
10682 : auto array(std::shared_ptr<GDALMDArrayFromRasterBand>(
10683 68 : new GDALMDArrayFromRasterBand(poDS, poBand)));
10684 34 : array->SetSelf(array);
10685 68 : return array;
10686 : }
10687 :
10688 5 : bool IsWritable() const override
10689 : {
10690 5 : return m_poDS->GetAccess() == GA_Update;
10691 : }
10692 :
10693 122 : const std::string &GetFilename() const override
10694 : {
10695 122 : return m_osFilename;
10696 : }
10697 :
10698 : const std::vector<std::shared_ptr<GDALDimension>> &
10699 343 : GetDimensions() const override
10700 : {
10701 343 : return m_dims;
10702 : }
10703 :
10704 158 : const GDALExtendedDataType &GetDataType() const override
10705 : {
10706 158 : return m_dt;
10707 : }
10708 :
10709 5 : const std::string &GetUnit() const override
10710 : {
10711 5 : return m_osUnit;
10712 : }
10713 :
10714 32 : const void *GetRawNoDataValue() const override
10715 : {
10716 32 : return m_pabyNoData.empty() ? nullptr : m_pabyNoData.data();
10717 : }
10718 :
10719 4 : double GetOffset(bool *pbHasOffset,
10720 : GDALDataType *peStorageType) const override
10721 : {
10722 4 : int bHasOffset = false;
10723 4 : double dfRes = m_poBand->GetOffset(&bHasOffset);
10724 4 : if (pbHasOffset)
10725 4 : *pbHasOffset = CPL_TO_BOOL(bHasOffset);
10726 4 : if (peStorageType)
10727 1 : *peStorageType = GDT_Unknown;
10728 4 : return dfRes;
10729 : }
10730 :
10731 4 : double GetScale(bool *pbHasScale,
10732 : GDALDataType *peStorageType) const override
10733 : {
10734 4 : int bHasScale = false;
10735 4 : double dfRes = m_poBand->GetScale(&bHasScale);
10736 4 : if (pbHasScale)
10737 4 : *pbHasScale = CPL_TO_BOOL(bHasScale);
10738 4 : if (peStorageType)
10739 1 : *peStorageType = GDT_Unknown;
10740 4 : return dfRes;
10741 : }
10742 :
10743 88 : std::shared_ptr<OGRSpatialReference> GetSpatialRef() const override
10744 : {
10745 88 : auto poSrcSRS = m_poDS->GetSpatialRef();
10746 88 : if (!poSrcSRS)
10747 2 : return nullptr;
10748 172 : auto poSRS = std::shared_ptr<OGRSpatialReference>(poSrcSRS->Clone());
10749 :
10750 172 : auto axisMapping = poSRS->GetDataAxisToSRSAxisMapping();
10751 86 : constexpr int iYDim = 0;
10752 86 : constexpr int iXDim = 1;
10753 258 : for (auto &m : axisMapping)
10754 : {
10755 172 : if (m == 1)
10756 86 : m = iXDim + 1;
10757 86 : else if (m == 2)
10758 86 : m = iYDim + 1;
10759 : else
10760 0 : m = 0;
10761 : }
10762 86 : poSRS->SetDataAxisToSRSAxisMapping(axisMapping);
10763 86 : return poSRS;
10764 : }
10765 :
10766 32 : std::vector<GUInt64> GetBlockSize() const override
10767 : {
10768 32 : int nBlockXSize = 0;
10769 32 : int nBlockYSize = 0;
10770 32 : m_poBand->GetBlockSize(&nBlockXSize, &nBlockYSize);
10771 32 : return std::vector<GUInt64>{static_cast<GUInt64>(nBlockYSize),
10772 32 : static_cast<GUInt64>(nBlockXSize)};
10773 : }
10774 :
10775 : std::vector<std::shared_ptr<GDALAttribute>>
10776 23 : GetAttributes(CSLConstList) const override
10777 : {
10778 23 : std::vector<std::shared_ptr<GDALAttribute>> res;
10779 23 : auto papszMD = m_poBand->GetMetadata();
10780 25 : for (auto iter = papszMD; iter && iter[0]; ++iter)
10781 : {
10782 2 : char *pszKey = nullptr;
10783 2 : const char *pszValue = CPLParseNameValue(*iter, &pszKey);
10784 2 : if (pszKey && pszValue)
10785 : {
10786 : res.emplace_back(
10787 2 : std::make_shared<GDALMDIAsAttribute>(pszKey, pszValue));
10788 : }
10789 2 : CPLFree(pszKey);
10790 : }
10791 23 : return res;
10792 : }
10793 : };
10794 :
10795 39 : bool GDALMDArrayFromRasterBand::IRead(
10796 : const GUInt64 *arrayStartIdx, const size_t *count, const GInt64 *arrayStep,
10797 : const GPtrDiff_t *bufferStride, const GDALExtendedDataType &bufferDataType,
10798 : void *pDstBuffer) const
10799 : {
10800 39 : return ReadWrite(GF_Read, arrayStartIdx, count, arrayStep, bufferStride,
10801 39 : bufferDataType, pDstBuffer);
10802 : }
10803 :
10804 : /************************************************************************/
10805 : /* ReadWrite() */
10806 : /************************************************************************/
10807 :
10808 40 : bool GDALMDArrayFromRasterBand::ReadWrite(
10809 : GDALRWFlag eRWFlag, const GUInt64 *arrayStartIdx, const size_t *count,
10810 : const GInt64 *arrayStep, const GPtrDiff_t *bufferStride,
10811 : const GDALExtendedDataType &bufferDataType, void *pBuffer) const
10812 : {
10813 40 : constexpr size_t iDimX = 1;
10814 40 : constexpr size_t iDimY = 0;
10815 40 : return GDALMDRasterIOFromBand(m_poBand, eRWFlag, iDimX, iDimY,
10816 : arrayStartIdx, count, arrayStep, bufferStride,
10817 40 : bufferDataType, pBuffer);
10818 : }
10819 :
10820 : /************************************************************************/
10821 : /* GDALMDRasterIOFromBand() */
10822 : /************************************************************************/
10823 :
10824 73 : bool GDALMDRasterIOFromBand(GDALRasterBand *poBand, GDALRWFlag eRWFlag,
10825 : size_t iDimX, size_t iDimY,
10826 : const GUInt64 *arrayStartIdx, const size_t *count,
10827 : const GInt64 *arrayStep,
10828 : const GPtrDiff_t *bufferStride,
10829 : const GDALExtendedDataType &bufferDataType,
10830 : void *pBuffer)
10831 : {
10832 73 : const auto eDT(bufferDataType.GetNumericDataType());
10833 73 : const auto nDTSize(GDALGetDataTypeSizeBytes(eDT));
10834 73 : const int nX =
10835 73 : arrayStep[iDimX] > 0
10836 73 : ? static_cast<int>(arrayStartIdx[iDimX])
10837 2 : : static_cast<int>(arrayStartIdx[iDimX] -
10838 2 : (count[iDimX] - 1) * -arrayStep[iDimX]);
10839 73 : const int nY =
10840 73 : arrayStep[iDimY] > 0
10841 73 : ? static_cast<int>(arrayStartIdx[iDimY])
10842 6 : : static_cast<int>(arrayStartIdx[iDimY] -
10843 6 : (count[iDimY] - 1) * -arrayStep[iDimY]);
10844 73 : const int nSizeX = static_cast<int>(count[iDimX] * ABS(arrayStep[iDimX]));
10845 73 : const int nSizeY = static_cast<int>(count[iDimY] * ABS(arrayStep[iDimY]));
10846 73 : GByte *pabyBuffer = static_cast<GByte *>(pBuffer);
10847 73 : int nStrideXSign = 1;
10848 73 : if (arrayStep[iDimX] < 0)
10849 : {
10850 2 : pabyBuffer += (count[iDimX] - 1) * bufferStride[iDimX] * nDTSize;
10851 2 : nStrideXSign = -1;
10852 : }
10853 73 : int nStrideYSign = 1;
10854 73 : if (arrayStep[iDimY] < 0)
10855 : {
10856 6 : pabyBuffer += (count[iDimY] - 1) * bufferStride[iDimY] * nDTSize;
10857 6 : nStrideYSign = -1;
10858 : }
10859 :
10860 146 : return poBand->RasterIO(eRWFlag, nX, nY, nSizeX, nSizeY, pabyBuffer,
10861 73 : static_cast<int>(count[iDimX]),
10862 73 : static_cast<int>(count[iDimY]), eDT,
10863 : static_cast<GSpacing>(
10864 73 : nStrideXSign * bufferStride[iDimX] * nDTSize),
10865 : static_cast<GSpacing>(
10866 73 : nStrideYSign * bufferStride[iDimY] * nDTSize),
10867 73 : nullptr) == CE_None;
10868 : }
10869 :
10870 : /************************************************************************/
10871 : /* AsMDArray() */
10872 : /************************************************************************/
10873 :
10874 : /** Return a view of this raster band as a 2D multidimensional GDALMDArray.
10875 : *
10876 : * The band must be linked to a GDALDataset. If this dataset is not already
10877 : * marked as shared, it will be, so that the returned array holds a reference
10878 : * to it.
10879 : *
10880 : * If the dataset has a geotransform attached, the X and Y dimensions of the
10881 : * returned array will have an associated indexing variable.
10882 : *
10883 : * This is the same as the C function GDALRasterBandAsMDArray().
10884 : *
10885 : * The "reverse" method is GDALMDArray::AsClassicDataset().
10886 : *
10887 : * @return a new array, or nullptr.
10888 : *
10889 : * @since GDAL 3.1
10890 : */
10891 34 : std::shared_ptr<GDALMDArray> GDALRasterBand::AsMDArray() const
10892 : {
10893 34 : if (!poDS)
10894 : {
10895 0 : CPLError(CE_Failure, CPLE_AppDefined, "Band not attached to a dataset");
10896 0 : return nullptr;
10897 : }
10898 34 : if (!poDS->GetShared())
10899 : {
10900 33 : poDS->MarkAsShared();
10901 : }
10902 : return GDALMDArrayFromRasterBand::Create(
10903 34 : poDS, const_cast<GDALRasterBand *>(this));
10904 : }
10905 :
10906 : /************************************************************************/
10907 : /* InterpolateAtPoint() */
10908 : /************************************************************************/
10909 :
10910 : /**
10911 : * \brief Interpolates the value between pixels using a resampling algorithm,
10912 : * taking pixel/line coordinates as input.
10913 : *
10914 : * @param dfPixel pixel coordinate as a double, where interpolation should be done.
10915 : * @param dfLine line coordinate as a double, where interpolation should be done.
10916 : * @param eInterpolation interpolation type. Only near, bilinear, cubic and cubicspline are allowed.
10917 : * @param pdfRealValue pointer to real part of interpolated value
10918 : * @param pdfImagValue pointer to imaginary part of interpolated value (may be null if not needed)
10919 : *
10920 : * @return CE_None on success, or an error code on failure.
10921 : * @since GDAL 3.10
10922 : */
10923 :
10924 167 : CPLErr GDALRasterBand::InterpolateAtPoint(double dfPixel, double dfLine,
10925 : GDALRIOResampleAlg eInterpolation,
10926 : double *pdfRealValue,
10927 : double *pdfImagValue) const
10928 : {
10929 167 : if (eInterpolation != GRIORA_NearestNeighbour &&
10930 33 : eInterpolation != GRIORA_Bilinear && eInterpolation != GRIORA_Cubic &&
10931 : eInterpolation != GRIORA_CubicSpline)
10932 : {
10933 2 : CPLError(CE_Failure, CPLE_AppDefined,
10934 : "Only nearest, bilinear, cubic and cubicspline interpolation "
10935 : "methods "
10936 : "allowed");
10937 :
10938 2 : return CE_Failure;
10939 : }
10940 :
10941 165 : GDALRasterBand *pBand = const_cast<GDALRasterBand *>(this);
10942 165 : if (!m_poPointsCache)
10943 85 : m_poPointsCache = new GDALDoublePointsCache();
10944 :
10945 : const bool res =
10946 165 : GDALInterpolateAtPoint(pBand, eInterpolation, m_poPointsCache->cache,
10947 : dfPixel, dfLine, pdfRealValue, pdfImagValue);
10948 :
10949 165 : return res ? CE_None : CE_Failure;
10950 : }
10951 :
10952 : /************************************************************************/
10953 : /* GDALRasterInterpolateAtPoint() */
10954 : /************************************************************************/
10955 :
10956 : /**
10957 : * \brief Interpolates the value between pixels using
10958 : * a resampling algorithm
10959 : *
10960 : * @see GDALRasterBand::InterpolateAtPoint()
10961 : * @since GDAL 3.10
10962 : */
10963 :
10964 144 : CPLErr GDALRasterInterpolateAtPoint(GDALRasterBandH hBand, double dfPixel,
10965 : double dfLine,
10966 : GDALRIOResampleAlg eInterpolation,
10967 : double *pdfRealValue, double *pdfImagValue)
10968 : {
10969 144 : VALIDATE_POINTER1(hBand, "GDALRasterInterpolateAtPoint", CE_Failure);
10970 :
10971 144 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
10972 144 : return poBand->InterpolateAtPoint(dfPixel, dfLine, eInterpolation,
10973 144 : pdfRealValue, pdfImagValue);
10974 : }
10975 :
10976 : /************************************************************************/
10977 : /* InterpolateAtGeolocation() */
10978 : /************************************************************************/
10979 :
10980 : /**
10981 : * \brief Interpolates the value between pixels using a resampling algorithm,
10982 : * taking georeferenced coordinates as input.
10983 : *
10984 : * When poSRS is null, those georeferenced coordinates (dfGeolocX, dfGeolocY)
10985 : * must be in the "natural" SRS of the dataset, that is the one returned by
10986 : * GetSpatialRef() if there is a geotransform, GetGCPSpatialRef() if there are
10987 : * GCPs, WGS 84 if there are RPC coefficients, or the SRS of the geolocation
10988 : * array (generally WGS 84) if there is a geolocation array.
10989 : * If that natural SRS is a geographic one, dfGeolocX must be a longitude, and
10990 : * dfGeolocY a latitude. If that natural SRS is a projected one, dfGeolocX must
10991 : * be a easting, and dfGeolocY a northing.
10992 : *
10993 : * When poSRS is set to a non-null value, (dfGeolocX, dfGeolocY) must be
10994 : * expressed in that CRS, and that tuple must be conformant with the
10995 : * data-axis-to-crs-axis setting of poSRS, that is the one returned by
10996 : * the OGRSpatialReference::GetDataAxisToSRSAxisMapping(). If you want to be sure
10997 : * of the axis order, then make sure to call poSRS->SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER)
10998 : * before calling this method, and in that case, dfGeolocX must be a longitude
10999 : * or an easting value, and dfGeolocX a latitude or a northing value.
11000 : *
11001 : * The GDALDataset::GeolocationToPixelLine() will be used to transform from
11002 : * (dfGeolocX,dfGeolocY) georeferenced coordinates to (pixel, line). Refer to
11003 : * it for details on how that transformation is done.
11004 : *
11005 : * @param dfGeolocX X coordinate of the position (longitude or easting if poSRS
11006 : * is null, otherwise consistent with poSRS data-axis-to-crs-axis mapping),
11007 : * where interpolation should be done.
11008 : * @param dfGeolocY Y coordinate of the position (latitude or northing if poSRS
11009 : * is null, otherwise consistent with poSRS data-axis-to-crs-axis mapping),
11010 : * where interpolation should be done.
11011 : * @param poSRS If set, override the natural CRS in which dfGeolocX, dfGeolocY are expressed
11012 : * @param eInterpolation interpolation type. Only near, bilinear, cubic and cubicspline are allowed.
11013 : * @param pdfRealValue pointer to real part of interpolated value
11014 : * @param pdfImagValue pointer to imaginary part of interpolated value (may be null if not needed)
11015 : * @param papszTransformerOptions Options accepted by GDALDataset::GeolocationToPixelLine() (GDALCreateGenImgProjTransformer2()), or nullptr.
11016 : *
11017 : * @return CE_None on success, or an error code on failure.
11018 : * @since GDAL 3.11
11019 : */
11020 :
11021 15 : CPLErr GDALRasterBand::InterpolateAtGeolocation(
11022 : double dfGeolocX, double dfGeolocY, const OGRSpatialReference *poSRS,
11023 : GDALRIOResampleAlg eInterpolation, double *pdfRealValue,
11024 : double *pdfImagValue, CSLConstList papszTransformerOptions) const
11025 : {
11026 : double dfPixel;
11027 : double dfLine;
11028 15 : if (poDS->GeolocationToPixelLine(dfGeolocX, dfGeolocY, poSRS, &dfPixel,
11029 : &dfLine,
11030 15 : papszTransformerOptions) != CE_None)
11031 : {
11032 1 : return CE_Failure;
11033 : }
11034 14 : return InterpolateAtPoint(dfPixel, dfLine, eInterpolation, pdfRealValue,
11035 14 : pdfImagValue);
11036 : }
11037 :
11038 : /************************************************************************/
11039 : /* GDALRasterInterpolateAtGeolocation() */
11040 : /************************************************************************/
11041 :
11042 : /**
11043 : * \brief Interpolates the value between pixels using a resampling algorithm,
11044 : * taking georeferenced coordinates as input.
11045 : *
11046 : * @see GDALRasterBand::InterpolateAtGeolocation()
11047 : * @since GDAL 3.11
11048 : */
11049 :
11050 15 : CPLErr GDALRasterInterpolateAtGeolocation(GDALRasterBandH hBand,
11051 : double dfGeolocX, double dfGeolocY,
11052 : OGRSpatialReferenceH hSRS,
11053 : GDALRIOResampleAlg eInterpolation,
11054 : double *pdfRealValue,
11055 : double *pdfImagValue,
11056 : CSLConstList papszTransformerOptions)
11057 : {
11058 15 : VALIDATE_POINTER1(hBand, "GDALRasterInterpolateAtGeolocation", CE_Failure);
11059 :
11060 15 : GDALRasterBand *poBand = GDALRasterBand::FromHandle(hBand);
11061 15 : return poBand->InterpolateAtGeolocation(
11062 15 : dfGeolocX, dfGeolocY, OGRSpatialReference::FromHandle(hSRS),
11063 15 : eInterpolation, pdfRealValue, pdfImagValue, papszTransformerOptions);
11064 : }
11065 :
11066 : /************************************************************************/
11067 : /* GDALRasterBand::SplitRasterIO() */
11068 : /************************************************************************/
11069 :
11070 : //! @cond Doxygen_Suppress
11071 :
11072 : /** Implements IRasterIO() by dividing the request in 2.
11073 : *
11074 : * Should only be called when nBufXSize == nXSize && nBufYSize == nYSize
11075 : *
11076 : * Return CE_Warning if the split could not be done, CE_None in case of
11077 : * success and CE_Failure in case of error.
11078 : *
11079 : * @since 3.12
11080 : */
11081 999 : CPLErr GDALRasterBand::SplitRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
11082 : [[maybe_unused]] int nXSize,
11083 : [[maybe_unused]] int nYSize, void *pData,
11084 : int nBufXSize, int nBufYSize,
11085 : GDALDataType eBufType,
11086 : GSpacing nPixelSpace, GSpacing nLineSpace,
11087 : GDALRasterIOExtraArg *psExtraArg)
11088 : {
11089 999 : CPLAssert(nBufXSize == nXSize && nBufYSize == nYSize);
11090 :
11091 999 : GByte *pabyData = static_cast<GByte *>(pData);
11092 999 : if ((nBufXSize == nRasterXSize || nBufYSize >= nBufXSize) && nBufYSize >= 2)
11093 : {
11094 : GDALRasterIOExtraArg sArg;
11095 499 : INIT_RASTERIO_EXTRA_ARG(sArg);
11096 499 : const int nHalfHeight = nBufYSize / 2;
11097 :
11098 499 : sArg.pfnProgress = GDALScaledProgress;
11099 499 : sArg.pProgressData = GDALCreateScaledProgress(
11100 : 0, 0.5, psExtraArg->pfnProgress, psExtraArg->pProgressData);
11101 499 : if (sArg.pProgressData == nullptr)
11102 499 : sArg.pfnProgress = nullptr;
11103 998 : CPLErr eErr = IRasterIO(eRWFlag, nXOff, nYOff, nBufXSize, nHalfHeight,
11104 : pabyData, nBufXSize, nHalfHeight, eBufType,
11105 499 : nPixelSpace, nLineSpace, &sArg);
11106 499 : GDALDestroyScaledProgress(sArg.pProgressData);
11107 :
11108 499 : if (eErr == CE_None)
11109 : {
11110 499 : sArg.pfnProgress = GDALScaledProgress;
11111 499 : sArg.pProgressData = GDALCreateScaledProgress(
11112 : 0.5, 1, psExtraArg->pfnProgress, psExtraArg->pProgressData);
11113 499 : if (sArg.pProgressData == nullptr)
11114 499 : sArg.pfnProgress = nullptr;
11115 998 : eErr = IRasterIO(eRWFlag, nXOff, nYOff + nHalfHeight, nBufXSize,
11116 : nBufYSize - nHalfHeight,
11117 499 : pabyData + nHalfHeight * nLineSpace, nBufXSize,
11118 : nBufYSize - nHalfHeight, eBufType, nPixelSpace,
11119 499 : nLineSpace, &sArg);
11120 499 : GDALDestroyScaledProgress(sArg.pProgressData);
11121 : }
11122 499 : return eErr;
11123 : }
11124 500 : else if (nBufXSize >= 2)
11125 : {
11126 : GDALRasterIOExtraArg sArg;
11127 500 : INIT_RASTERIO_EXTRA_ARG(sArg);
11128 500 : const int nHalfWidth = nBufXSize / 2;
11129 :
11130 500 : sArg.pfnProgress = GDALScaledProgress;
11131 500 : sArg.pProgressData = GDALCreateScaledProgress(
11132 : 0, 0.5, psExtraArg->pfnProgress, psExtraArg->pProgressData);
11133 500 : if (sArg.pProgressData == nullptr)
11134 500 : sArg.pfnProgress = nullptr;
11135 1000 : CPLErr eErr = IRasterIO(eRWFlag, nXOff, nYOff, nHalfWidth, nBufYSize,
11136 : pabyData, nHalfWidth, nBufYSize, eBufType,
11137 500 : nPixelSpace, nLineSpace, &sArg);
11138 500 : GDALDestroyScaledProgress(sArg.pProgressData);
11139 :
11140 500 : if (eErr == CE_None)
11141 : {
11142 500 : sArg.pfnProgress = GDALScaledProgress;
11143 500 : sArg.pProgressData = GDALCreateScaledProgress(
11144 : 0.5, 1, psExtraArg->pfnProgress, psExtraArg->pProgressData);
11145 500 : if (sArg.pProgressData == nullptr)
11146 500 : sArg.pfnProgress = nullptr;
11147 1000 : eErr = IRasterIO(eRWFlag, nXOff + nHalfWidth, nYOff,
11148 : nBufXSize - nHalfWidth, nBufYSize,
11149 500 : pabyData + nHalfWidth * nPixelSpace,
11150 : nBufXSize - nHalfWidth, nBufYSize, eBufType,
11151 500 : nPixelSpace, nLineSpace, &sArg);
11152 500 : GDALDestroyScaledProgress(sArg.pProgressData);
11153 : }
11154 500 : return eErr;
11155 : }
11156 :
11157 0 : return CE_Warning;
11158 : }
11159 :
11160 : //! @endcond
11161 :
11162 : /************************************************************************/
11163 : /* ThrowIfNotSameDimensions() */
11164 : /************************************************************************/
11165 :
11166 : //! @cond Doxygen_Suppress
11167 : /* static */
11168 169 : void GDALRasterBand::ThrowIfNotSameDimensions(const GDALRasterBand &first,
11169 : const GDALRasterBand &second)
11170 : {
11171 320 : if (first.GetXSize() != second.GetXSize() ||
11172 151 : first.GetYSize() != second.GetYSize())
11173 : {
11174 36 : throw std::runtime_error("Bands do not have the same dimensions");
11175 : }
11176 133 : }
11177 :
11178 : //! @endcond
11179 :
11180 : /************************************************************************/
11181 : /* GDALRasterBandUnaryOp() */
11182 : /************************************************************************/
11183 :
11184 : /** Apply a unary operation on this band.
11185 : *
11186 : * The resulting band is lazy evaluated. A reference is taken on the input
11187 : * dataset.
11188 : *
11189 : * @since 3.12
11190 : * @return a handle to free with GDALComputedRasterBandRelease(), or nullptr if error.
11191 : */
11192 : GDALComputedRasterBandH
11193 6 : GDALRasterBandUnaryOp(GDALRasterBandH hBand,
11194 : GDALRasterAlgebraUnaryOperation eOp)
11195 : {
11196 6 : VALIDATE_POINTER1(hBand, __func__, nullptr);
11197 6 : GDALComputedRasterBand::Operation cppOp{};
11198 6 : switch (eOp)
11199 : {
11200 2 : case GRAUO_LOGICAL_NOT:
11201 : return new GDALComputedRasterBand(
11202 : GDALComputedRasterBand::Operation::OP_NE,
11203 2 : *(GDALRasterBand::FromHandle(hBand)), true);
11204 1 : case GRAUO_ABS:
11205 1 : cppOp = GDALComputedRasterBand::Operation::OP_ABS;
11206 1 : break;
11207 1 : case GRAUO_SQRT:
11208 1 : cppOp = GDALComputedRasterBand::Operation::OP_SQRT;
11209 1 : break;
11210 1 : case GRAUO_LOG:
11211 : #ifndef HAVE_MUPARSER
11212 : CPLError(
11213 : CE_Failure, CPLE_NotSupported,
11214 : "log(band) not available on a GDAL build without muparser");
11215 : return nullptr;
11216 : #else
11217 1 : cppOp = GDALComputedRasterBand::Operation::OP_LOG;
11218 1 : break;
11219 : #endif
11220 1 : case GRAUO_LOG10:
11221 1 : cppOp = GDALComputedRasterBand::Operation::OP_LOG10;
11222 1 : break;
11223 : }
11224 : return new GDALComputedRasterBand(cppOp,
11225 4 : *(GDALRasterBand::FromHandle(hBand)));
11226 : }
11227 :
11228 : /************************************************************************/
11229 : /* ConvertGDALRasterAlgebraBinaryOperationToCpp() */
11230 : /************************************************************************/
11231 :
11232 : static GDALComputedRasterBand::Operation
11233 120 : ConvertGDALRasterAlgebraBinaryOperationToCpp(
11234 : GDALRasterAlgebraBinaryOperation eOp)
11235 : {
11236 120 : switch (eOp)
11237 : {
11238 26 : case GRABO_ADD:
11239 26 : return GDALComputedRasterBand::Operation::OP_ADD;
11240 2 : case GRABO_SUB:
11241 2 : return GDALComputedRasterBand::Operation::OP_SUBTRACT;
11242 24 : case GRABO_MUL:
11243 24 : return GDALComputedRasterBand::Operation::OP_MULTIPLY;
11244 3 : case GRABO_DIV:
11245 3 : return GDALComputedRasterBand::Operation::OP_DIVIDE;
11246 6 : case GRABO_GT:
11247 6 : return GDALComputedRasterBand::Operation::OP_GT;
11248 8 : case GRABO_GE:
11249 8 : return GDALComputedRasterBand::Operation::OP_GE;
11250 6 : case GRABO_LT:
11251 6 : return GDALComputedRasterBand::Operation::OP_LT;
11252 6 : case GRABO_LE:
11253 6 : return GDALComputedRasterBand::Operation::OP_LE;
11254 6 : case GRABO_EQ:
11255 6 : return GDALComputedRasterBand::Operation::OP_EQ;
11256 6 : case GRABO_NE:
11257 6 : break;
11258 12 : case GRABO_LOGICAL_AND:
11259 12 : return GDALComputedRasterBand::Operation::OP_LOGICAL_AND;
11260 12 : case GRABO_LOGICAL_OR:
11261 12 : return GDALComputedRasterBand::Operation::OP_LOGICAL_OR;
11262 3 : case GRABO_POW:
11263 3 : return GDALComputedRasterBand::Operation::OP_POW;
11264 : }
11265 6 : return GDALComputedRasterBand::Operation::OP_NE;
11266 : }
11267 :
11268 : /************************************************************************/
11269 : /* GDALRasterBandBinaryOpBand() */
11270 : /************************************************************************/
11271 :
11272 : /** Apply a binary operation on this band with another one.
11273 : *
11274 : * e.g. GDALRasterBandBinaryOpBand(hBand1, GRABO_SUB, hBand2) performs
11275 : * "hBand1 - hBand2".
11276 : *
11277 : * The resulting band is lazy evaluated. A reference is taken on both input
11278 : * datasets.
11279 : *
11280 : * @since 3.12
11281 : * @return a handle to free with GDALComputedRasterBandRelease(), or nullptr if error.
11282 : */
11283 : GDALComputedRasterBandH
11284 57 : GDALRasterBandBinaryOpBand(GDALRasterBandH hBand,
11285 : GDALRasterAlgebraBinaryOperation eOp,
11286 : GDALRasterBandH hOtherBand)
11287 : {
11288 57 : VALIDATE_POINTER1(hBand, __func__, nullptr);
11289 57 : VALIDATE_POINTER1(hOtherBand, __func__, nullptr);
11290 : #ifndef HAVE_MUPARSER
11291 : if (eOp >= GRABO_GT && eOp <= GRABO_NE)
11292 : {
11293 : CPLError(
11294 : CE_Failure, CPLE_NotSupported,
11295 : "Band comparison operators not available on a GDAL build without "
11296 : "muparser");
11297 : return nullptr;
11298 : }
11299 : else if (eOp == GRABO_POW)
11300 : {
11301 : CPLError(
11302 : CE_Failure, CPLE_NotSupported,
11303 : "pow(band, band) not available on a GDAL build without muparser");
11304 : return nullptr;
11305 : }
11306 : #endif
11307 57 : auto &firstBand = *(GDALRasterBand::FromHandle(hBand));
11308 57 : auto &secondBand = *(GDALRasterBand::FromHandle(hOtherBand));
11309 : try
11310 : {
11311 57 : GDALRasterBand::ThrowIfNotSameDimensions(firstBand, secondBand);
11312 : }
11313 13 : catch (const std::exception &e)
11314 : {
11315 13 : CPLError(CE_Failure, CPLE_AppDefined, "%s", e.what());
11316 13 : return nullptr;
11317 : }
11318 : return new GDALComputedRasterBand(
11319 44 : ConvertGDALRasterAlgebraBinaryOperationToCpp(eOp), firstBand,
11320 44 : secondBand);
11321 : }
11322 :
11323 : /************************************************************************/
11324 : /* GDALRasterBandBinaryOpDouble() */
11325 : /************************************************************************/
11326 :
11327 : /** Apply a binary operation on this band with a constant
11328 : *
11329 : * e.g. GDALRasterBandBinaryOpDouble(hBand, GRABO_SUB, constant) performs
11330 : * "hBand - constant".
11331 : *
11332 : * The resulting band is lazy evaluated. A reference is taken on the input
11333 : * dataset.
11334 : *
11335 : * @since 3.12
11336 : * @return a handle to free with GDALComputedRasterBandRelease(), or nullptr if error.
11337 : */
11338 : GDALComputedRasterBandH
11339 59 : GDALRasterBandBinaryOpDouble(GDALRasterBandH hBand,
11340 : GDALRasterAlgebraBinaryOperation eOp,
11341 : double constant)
11342 : {
11343 59 : VALIDATE_POINTER1(hBand, __func__, nullptr);
11344 : #ifndef HAVE_MUPARSER
11345 : if (eOp >= GRABO_GT && eOp <= GRABO_NE)
11346 : {
11347 : CPLError(
11348 : CE_Failure, CPLE_NotSupported,
11349 : "Band comparison operators not available on a GDAL build without "
11350 : "muparser");
11351 : return nullptr;
11352 : }
11353 : #endif
11354 : return new GDALComputedRasterBand(
11355 59 : ConvertGDALRasterAlgebraBinaryOperationToCpp(eOp),
11356 59 : *(GDALRasterBand::FromHandle(hBand)), constant);
11357 : }
11358 :
11359 : /************************************************************************/
11360 : /* GDALRasterBandBinaryOpDoubleToBand() */
11361 : /************************************************************************/
11362 :
11363 : /** Apply a binary operation on the constant with this band
11364 : *
11365 : * e.g. GDALRasterBandBinaryOpDoubleToBand(constant, GRABO_SUB, hBand) performs
11366 : * "constant - hBand".
11367 : *
11368 : * The resulting band is lazy evaluated. A reference is taken on the input
11369 : * dataset.
11370 : *
11371 : * @since 3.12
11372 : * @return a handle to free with GDALComputedRasterBandRelease(), or nullptr if error.
11373 : */
11374 : GDALComputedRasterBandH
11375 18 : GDALRasterBandBinaryOpDoubleToBand(double constant,
11376 : GDALRasterAlgebraBinaryOperation eOp,
11377 : GDALRasterBandH hBand)
11378 : {
11379 18 : VALIDATE_POINTER1(hBand, __func__, nullptr);
11380 : #ifndef HAVE_MUPARSER
11381 : if (eOp >= GRABO_GT && eOp <= GRABO_NE)
11382 : {
11383 : CPLError(
11384 : CE_Failure, CPLE_NotSupported,
11385 : "Band comparison operators not available on a GDAL build without "
11386 : "muparser");
11387 : return nullptr;
11388 : }
11389 : #endif
11390 18 : switch (eOp)
11391 : {
11392 15 : case GRABO_ADD:
11393 : case GRABO_MUL:
11394 : {
11395 : return new GDALComputedRasterBand(
11396 15 : ConvertGDALRasterAlgebraBinaryOperationToCpp(eOp),
11397 15 : *(GDALRasterBand::FromHandle(hBand)), constant);
11398 : }
11399 :
11400 2 : case GRABO_DIV:
11401 : case GRABO_GT:
11402 : case GRABO_GE:
11403 : case GRABO_LT:
11404 : case GRABO_LE:
11405 : case GRABO_EQ:
11406 : case GRABO_NE:
11407 : case GRABO_LOGICAL_AND:
11408 : case GRABO_LOGICAL_OR:
11409 : case GRABO_POW:
11410 : {
11411 : return new GDALComputedRasterBand(
11412 2 : ConvertGDALRasterAlgebraBinaryOperationToCpp(eOp), constant,
11413 2 : *(GDALRasterBand::FromHandle(hBand)));
11414 : }
11415 :
11416 1 : case GRABO_SUB:
11417 : {
11418 1 : break;
11419 : }
11420 : }
11421 :
11422 : return new GDALComputedRasterBand(
11423 : GDALComputedRasterBand::Operation::OP_ADD,
11424 2 : GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_MULTIPLY,
11425 1 : *(GDALRasterBand::FromHandle(hBand)), -1.0),
11426 1 : constant);
11427 : }
11428 :
11429 : /************************************************************************/
11430 : /* operator+() */
11431 : /************************************************************************/
11432 :
11433 : /** Add this band with another one.
11434 : *
11435 : * The resulting band is lazy evaluated. A reference is taken on both input
11436 : * datasets.
11437 : *
11438 : * @since 3.12
11439 : * @throw std::runtime_error if both bands do not have the same dimensions.
11440 : */
11441 : GDALComputedRasterBand
11442 8 : GDALRasterBand::operator+(const GDALRasterBand &other) const
11443 : {
11444 8 : ThrowIfNotSameDimensions(*this, other);
11445 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_ADD,
11446 7 : *this, other);
11447 : }
11448 :
11449 : /************************************************************************/
11450 : /* operator+() */
11451 : /************************************************************************/
11452 :
11453 : /** Add this band with a constant.
11454 : *
11455 : * The resulting band is lazy evaluated. A reference is taken on the input
11456 : * dataset.
11457 : *
11458 : * @since 3.12
11459 : */
11460 13 : GDALComputedRasterBand GDALRasterBand::operator+(double constant) const
11461 : {
11462 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_ADD,
11463 13 : *this, constant);
11464 : }
11465 :
11466 : /************************************************************************/
11467 : /* operator+() */
11468 : /************************************************************************/
11469 :
11470 : /** Add a band with a constant.
11471 : *
11472 : * The resulting band is lazy evaluated. A reference is taken on the input
11473 : * dataset.
11474 : *
11475 : * @since 3.12
11476 : */
11477 1 : GDALComputedRasterBand operator+(double constant, const GDALRasterBand &other)
11478 : {
11479 1 : return other + constant;
11480 : }
11481 :
11482 : /************************************************************************/
11483 : /* operator-() */
11484 : /************************************************************************/
11485 :
11486 : /** Return a band whose value is the opposite value of the band for each
11487 : * pixel.
11488 : *
11489 : * The resulting band is lazy evaluated. A reference is taken on the input
11490 : * dataset.
11491 : *
11492 : * @since 3.12
11493 : */
11494 2 : GDALComputedRasterBand GDALRasterBand::operator-() const
11495 : {
11496 2 : return 0 - *this;
11497 : }
11498 :
11499 : /************************************************************************/
11500 : /* operator-() */
11501 : /************************************************************************/
11502 :
11503 : /** Subtract this band with another one.
11504 : *
11505 : * The resulting band is lazy evaluated. A reference is taken on both input
11506 : * datasets.
11507 : *
11508 : * @since 3.12
11509 : * @throw std::runtime_error if both bands do not have the same dimensions.
11510 : */
11511 : GDALComputedRasterBand
11512 2 : GDALRasterBand::operator-(const GDALRasterBand &other) const
11513 : {
11514 2 : ThrowIfNotSameDimensions(*this, other);
11515 : return GDALComputedRasterBand(
11516 2 : GDALComputedRasterBand::Operation::OP_SUBTRACT, *this, other);
11517 : }
11518 :
11519 : /************************************************************************/
11520 : /* operator-() */
11521 : /************************************************************************/
11522 :
11523 : /** Subtract this band with a constant.
11524 : *
11525 : * The resulting band is lazy evaluated. A reference is taken on the input
11526 : * dataset.
11527 : *
11528 : * @since 3.12
11529 : */
11530 1 : GDALComputedRasterBand GDALRasterBand::operator-(double constant) const
11531 : {
11532 : return GDALComputedRasterBand(
11533 1 : GDALComputedRasterBand::Operation::OP_SUBTRACT, *this, constant);
11534 : }
11535 :
11536 : /************************************************************************/
11537 : /* operator-() */
11538 : /************************************************************************/
11539 :
11540 : /** Subtract a constant with a band.
11541 : *
11542 : * The resulting band is lazy evaluated. A reference is taken on the input
11543 : * dataset.
11544 : *
11545 : * @since 3.12
11546 : */
11547 3 : GDALComputedRasterBand operator-(double constant, const GDALRasterBand &other)
11548 : {
11549 6 : return other * (-1.0) + constant;
11550 : }
11551 :
11552 : /************************************************************************/
11553 : /* operator*() */
11554 : /************************************************************************/
11555 :
11556 : /** Multiply this band with another one.
11557 : *
11558 : * The resulting band is lazy evaluated. A reference is taken on both input
11559 : * datasets.
11560 : *
11561 : * @since 3.12
11562 : * @throw std::runtime_error if both bands do not have the same dimensions.
11563 : */
11564 : GDALComputedRasterBand
11565 2 : GDALRasterBand::operator*(const GDALRasterBand &other) const
11566 : {
11567 2 : ThrowIfNotSameDimensions(*this, other);
11568 : return GDALComputedRasterBand(
11569 2 : GDALComputedRasterBand::Operation::OP_MULTIPLY, *this, other);
11570 : }
11571 :
11572 : /************************************************************************/
11573 : /* operator*() */
11574 : /************************************************************************/
11575 :
11576 : /** Multiply this band by a constant.
11577 : *
11578 : * The resulting band is lazy evaluated. A reference is taken on the input
11579 : * dataset.
11580 : *
11581 : * @since 3.12
11582 : */
11583 14 : GDALComputedRasterBand GDALRasterBand::operator*(double constant) const
11584 : {
11585 : return GDALComputedRasterBand(
11586 14 : GDALComputedRasterBand::Operation::OP_MULTIPLY, *this, constant);
11587 : }
11588 :
11589 : /************************************************************************/
11590 : /* operator*() */
11591 : /************************************************************************/
11592 :
11593 : /** Multiply a band with a constant.
11594 : *
11595 : * The resulting band is lazy evaluated. A reference is taken on the input
11596 : * dataset.
11597 : *
11598 : * @since 3.12
11599 : */
11600 2 : GDALComputedRasterBand operator*(double constant, const GDALRasterBand &other)
11601 : {
11602 2 : return other * constant;
11603 : }
11604 :
11605 : /************************************************************************/
11606 : /* operator/() */
11607 : /************************************************************************/
11608 :
11609 : /** Divide this band with another one.
11610 : *
11611 : * The resulting band is lazy evaluated. A reference is taken on both input
11612 : * datasets.
11613 : *
11614 : * @since 3.12
11615 : * @throw std::runtime_error if both bands do not have the same dimensions.
11616 : */
11617 : GDALComputedRasterBand
11618 2 : GDALRasterBand::operator/(const GDALRasterBand &other) const
11619 : {
11620 2 : ThrowIfNotSameDimensions(*this, other);
11621 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_DIVIDE,
11622 2 : *this, other);
11623 : }
11624 :
11625 : /************************************************************************/
11626 : /* operator/() */
11627 : /************************************************************************/
11628 :
11629 : /** Divide this band by a constant.
11630 : *
11631 : * The resulting band is lazy evaluated. A reference is taken on the input
11632 : * dataset.
11633 : *
11634 : * @since 3.12
11635 : */
11636 0 : GDALComputedRasterBand GDALRasterBand::operator/(double constant) const
11637 : {
11638 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_DIVIDE,
11639 0 : *this, constant);
11640 : }
11641 :
11642 : /************************************************************************/
11643 : /* operator/() */
11644 : /************************************************************************/
11645 :
11646 : /** Divide a constant by a band.
11647 : *
11648 : * The resulting band is lazy evaluated. A reference is taken on the input
11649 : * dataset.
11650 : *
11651 : * @since 3.12
11652 : */
11653 1 : GDALComputedRasterBand operator/(double constant, const GDALRasterBand &other)
11654 : {
11655 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_DIVIDE,
11656 1 : constant, other);
11657 : }
11658 :
11659 : /************************************************************************/
11660 : /* ThrowIfNotMuparser() */
11661 : /************************************************************************/
11662 :
11663 : #ifndef HAVE_MUPARSER
11664 : static GDALComputedRasterBand ThrowIfNotMuparser()
11665 : {
11666 : throw std::runtime_error("Operator not available on a "
11667 : "GDAL build without muparser");
11668 : }
11669 : #endif
11670 :
11671 : /************************************************************************/
11672 : /* operator>() */
11673 : /************************************************************************/
11674 :
11675 : /** Return a band whose value is 1 if the pixel value of the left operand
11676 : * is greater than the pixel value of the right operand.
11677 : *
11678 : * The resulting band is lazy evaluated. A reference is taken on the input
11679 : * dataset.
11680 : *
11681 : * @since 3.12
11682 : */
11683 : GDALComputedRasterBand
11684 3 : GDALRasterBand::operator>(const GDALRasterBand &other) const
11685 : {
11686 : #ifndef HAVE_MUPARSER
11687 : (void)other;
11688 : return ThrowIfNotMuparser();
11689 : #else
11690 3 : ThrowIfNotSameDimensions(*this, other);
11691 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_GT,
11692 2 : *this, other);
11693 : #endif
11694 : }
11695 :
11696 : /************************************************************************/
11697 : /* operator>() */
11698 : /************************************************************************/
11699 :
11700 : /** Return a band whose value is 1 if the pixel value of the left operand
11701 : * is greater than the constant.
11702 : *
11703 : * The resulting band is lazy evaluated. A reference is taken on the input
11704 : * dataset.
11705 : *
11706 : * @since 3.12
11707 : */
11708 3 : GDALComputedRasterBand GDALRasterBand::operator>(double constant) const
11709 : {
11710 : #ifndef HAVE_MUPARSER
11711 : (void)constant;
11712 : return ThrowIfNotMuparser();
11713 : #else
11714 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_GT,
11715 3 : *this, constant);
11716 : #endif
11717 : }
11718 :
11719 : /************************************************************************/
11720 : /* operator>() */
11721 : /************************************************************************/
11722 :
11723 : /** Return a band whose value is 1 if the constant is greater than the pixel
11724 : * value of the right operand.
11725 : *
11726 : * The resulting band is lazy evaluated. A reference is taken on the input
11727 : * dataset.
11728 : *
11729 : * @since 3.12
11730 : */
11731 2 : GDALComputedRasterBand operator>(double constant, const GDALRasterBand &other)
11732 : {
11733 : #ifndef HAVE_MUPARSER
11734 : (void)constant;
11735 : (void)other;
11736 : return ThrowIfNotMuparser();
11737 : #else
11738 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_GT,
11739 2 : constant, other);
11740 : #endif
11741 : }
11742 :
11743 : /************************************************************************/
11744 : /* operator>=() */
11745 : /************************************************************************/
11746 :
11747 : /** Return a band whose value is 1 if the pixel value of the left operand
11748 : * is greater or equal to the pixel value of the right operand.
11749 : *
11750 : * The resulting band is lazy evaluated. A reference is taken on the input
11751 : * dataset.
11752 : *
11753 : * @since 3.12
11754 : */
11755 : GDALComputedRasterBand
11756 4 : GDALRasterBand::operator>=(const GDALRasterBand &other) const
11757 : {
11758 : #ifndef HAVE_MUPARSER
11759 : (void)other;
11760 : return ThrowIfNotMuparser();
11761 : #else
11762 4 : ThrowIfNotSameDimensions(*this, other);
11763 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_GE,
11764 3 : *this, other);
11765 : #endif
11766 : }
11767 :
11768 : /************************************************************************/
11769 : /* operator>=() */
11770 : /************************************************************************/
11771 :
11772 : /** Return a band whose value is 1 if the pixel value of the left operand
11773 : * is greater or equal to the constant.
11774 : *
11775 : * The resulting band is lazy evaluated. A reference is taken on the input
11776 : * dataset.
11777 : *
11778 : * @since 3.12
11779 : */
11780 3 : GDALComputedRasterBand GDALRasterBand::operator>=(double constant) const
11781 : {
11782 : #ifndef HAVE_MUPARSER
11783 : (void)constant;
11784 : return ThrowIfNotMuparser();
11785 : #else
11786 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_GE,
11787 3 : *this, constant);
11788 : #endif
11789 : }
11790 :
11791 : /************************************************************************/
11792 : /* operator>=() */
11793 : /************************************************************************/
11794 :
11795 : /** Return a band whose value is 1 if the constant is greater or equal to
11796 : * the pixel value of the right operand.
11797 : *
11798 : * The resulting band is lazy evaluated. A reference is taken on the input
11799 : * dataset.
11800 : *
11801 : * @since 3.12
11802 : */
11803 2 : GDALComputedRasterBand operator>=(double constant, const GDALRasterBand &other)
11804 : {
11805 : #ifndef HAVE_MUPARSER
11806 : (void)constant;
11807 : (void)other;
11808 : return ThrowIfNotMuparser();
11809 : #else
11810 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_GE,
11811 2 : constant, other);
11812 : #endif
11813 : }
11814 :
11815 : /************************************************************************/
11816 : /* operator<() */
11817 : /************************************************************************/
11818 :
11819 : /** Return a band whose value is 1 if the pixel value of the left operand
11820 : * is lesser than the pixel value of the right operand.
11821 : *
11822 : * The resulting band is lazy evaluated. A reference is taken on the input
11823 : * dataset.
11824 : *
11825 : * @since 3.12
11826 : */
11827 : GDALComputedRasterBand
11828 3 : GDALRasterBand::operator<(const GDALRasterBand &other) const
11829 : {
11830 : #ifndef HAVE_MUPARSER
11831 : (void)other;
11832 : return ThrowIfNotMuparser();
11833 : #else
11834 3 : ThrowIfNotSameDimensions(*this, other);
11835 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_LT,
11836 2 : *this, other);
11837 : #endif
11838 : }
11839 :
11840 : /************************************************************************/
11841 : /* operator<() */
11842 : /************************************************************************/
11843 :
11844 : /** Return a band whose value is 1 if the pixel value of the left operand
11845 : * is lesser than the constant.
11846 : *
11847 : * The resulting band is lazy evaluated. A reference is taken on the input
11848 : * dataset.
11849 : *
11850 : * @since 3.12
11851 : */
11852 3 : GDALComputedRasterBand GDALRasterBand::operator<(double constant) const
11853 : {
11854 : #ifndef HAVE_MUPARSER
11855 : (void)constant;
11856 : return ThrowIfNotMuparser();
11857 : #else
11858 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_LT,
11859 3 : *this, constant);
11860 : #endif
11861 : }
11862 :
11863 : /************************************************************************/
11864 : /* operator<() */
11865 : /************************************************************************/
11866 :
11867 : /** Return a band whose value is 1 if the constant is lesser than the pixel
11868 : * value of the right operand.
11869 : *
11870 : * The resulting band is lazy evaluated. A reference is taken on the input
11871 : * dataset.
11872 : *
11873 : * @since 3.12
11874 : */
11875 2 : GDALComputedRasterBand operator<(double constant, const GDALRasterBand &other)
11876 : {
11877 : #ifndef HAVE_MUPARSER
11878 : (void)constant;
11879 : (void)other;
11880 : return ThrowIfNotMuparser();
11881 : #else
11882 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_LT,
11883 2 : constant, other);
11884 : #endif
11885 : }
11886 :
11887 : /************************************************************************/
11888 : /* operator<=() */
11889 : /************************************************************************/
11890 :
11891 : /** Return a band whose value is 1 if the pixel value of the left operand
11892 : * is lesser or equal to the pixel value of the right operand.
11893 : *
11894 : * The resulting band is lazy evaluated. A reference is taken on the input
11895 : * dataset.
11896 : *
11897 : * @since 3.12
11898 : */
11899 : GDALComputedRasterBand
11900 4 : GDALRasterBand::operator<=(const GDALRasterBand &other) const
11901 : {
11902 : #ifndef HAVE_MUPARSER
11903 : (void)other;
11904 : return ThrowIfNotMuparser();
11905 : #else
11906 4 : ThrowIfNotSameDimensions(*this, other);
11907 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_LE,
11908 3 : *this, other);
11909 : #endif
11910 : }
11911 :
11912 : /************************************************************************/
11913 : /* operator<=() */
11914 : /************************************************************************/
11915 :
11916 : /** Return a band whose value is 1 if the pixel value of the left operand
11917 : * is lesser or equal to the constant.
11918 : *
11919 : * The resulting band is lazy evaluated. A reference is taken on the input
11920 : * dataset.
11921 : *
11922 : * @since 3.12
11923 : */
11924 3 : GDALComputedRasterBand GDALRasterBand::operator<=(double constant) const
11925 : {
11926 : #ifndef HAVE_MUPARSER
11927 : (void)constant;
11928 : return ThrowIfNotMuparser();
11929 : #else
11930 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_LE,
11931 3 : *this, constant);
11932 : #endif
11933 : }
11934 :
11935 : /************************************************************************/
11936 : /* operator<=() */
11937 : /************************************************************************/
11938 :
11939 : /** Return a band whose value is 1 if the constant is lesser or equal to
11940 : * the pixel value of the right operand.
11941 : *
11942 : * The resulting band is lazy evaluated. A reference is taken on the input
11943 : * dataset.
11944 : *
11945 : * @since 3.12
11946 : */
11947 2 : GDALComputedRasterBand operator<=(double constant, const GDALRasterBand &other)
11948 : {
11949 : #ifndef HAVE_MUPARSER
11950 : (void)constant;
11951 : (void)other;
11952 : return ThrowIfNotMuparser();
11953 : #else
11954 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_LE,
11955 2 : constant, other);
11956 : #endif
11957 : }
11958 :
11959 : /************************************************************************/
11960 : /* operator==() */
11961 : /************************************************************************/
11962 :
11963 : /** Return a band whose value is 1 if the pixel value of the left operand
11964 : * is equal to the pixel value of the right operand.
11965 : *
11966 : * The resulting band is lazy evaluated. A reference is taken on the input
11967 : * dataset.
11968 : *
11969 : * @since 3.12
11970 : */
11971 : GDALComputedRasterBand
11972 3 : GDALRasterBand::operator==(const GDALRasterBand &other) const
11973 : {
11974 : #ifndef HAVE_MUPARSER
11975 : (void)other;
11976 : return ThrowIfNotMuparser();
11977 : #else
11978 3 : ThrowIfNotSameDimensions(*this, other);
11979 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_EQ,
11980 2 : *this, other);
11981 : #endif
11982 : }
11983 :
11984 : /************************************************************************/
11985 : /* operator==() */
11986 : /************************************************************************/
11987 :
11988 : /** Return a band whose value is 1 if the pixel value of the left operand
11989 : * is equal to the constant.
11990 : *
11991 : * The resulting band is lazy evaluated. A reference is taken on the input
11992 : * dataset.
11993 : *
11994 : * @since 3.12
11995 : */
11996 8 : GDALComputedRasterBand GDALRasterBand::operator==(double constant) const
11997 : {
11998 : #ifndef HAVE_MUPARSER
11999 : (void)constant;
12000 : return ThrowIfNotMuparser();
12001 : #else
12002 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_EQ,
12003 8 : *this, constant);
12004 : #endif
12005 : }
12006 :
12007 : /************************************************************************/
12008 : /* operator==() */
12009 : /************************************************************************/
12010 :
12011 : /** Return a band whose value is 1 if the constant is equal to
12012 : * the pixel value of the right operand.
12013 : *
12014 : * The resulting band is lazy evaluated. A reference is taken on the input
12015 : * dataset.
12016 : *
12017 : * @since 3.12
12018 : */
12019 2 : GDALComputedRasterBand operator==(double constant, const GDALRasterBand &other)
12020 : {
12021 : #ifndef HAVE_MUPARSER
12022 : (void)constant;
12023 : (void)other;
12024 : return ThrowIfNotMuparser();
12025 : #else
12026 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_EQ,
12027 2 : constant, other);
12028 : #endif
12029 : }
12030 :
12031 : /************************************************************************/
12032 : /* operator!=() */
12033 : /************************************************************************/
12034 :
12035 : /** Return a band whose value is 1 if the pixel value of the left operand
12036 : * is different from the pixel value of the right operand.
12037 : *
12038 : * The resulting band is lazy evaluated. A reference is taken on the input
12039 : * dataset.
12040 : *
12041 : * @since 3.12
12042 : */
12043 : GDALComputedRasterBand
12044 3 : GDALRasterBand::operator!=(const GDALRasterBand &other) const
12045 : {
12046 : #ifndef HAVE_MUPARSER
12047 : (void)other;
12048 : return ThrowIfNotMuparser();
12049 : #else
12050 3 : ThrowIfNotSameDimensions(*this, other);
12051 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_NE,
12052 2 : *this, other);
12053 : #endif
12054 : }
12055 :
12056 : /************************************************************************/
12057 : /* operator!=() */
12058 : /************************************************************************/
12059 :
12060 : /** Return a band whose value is 1 if the pixel value of the left operand
12061 : * is different from the constant.
12062 : *
12063 : * The resulting band is lazy evaluated. A reference is taken on the input
12064 : * dataset.
12065 : *
12066 : * @since 3.12
12067 : */
12068 6 : GDALComputedRasterBand GDALRasterBand::operator!=(double constant) const
12069 : {
12070 : #ifndef HAVE_MUPARSER
12071 : (void)constant;
12072 : return ThrowIfNotMuparser();
12073 : #else
12074 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_NE,
12075 6 : *this, constant);
12076 : #endif
12077 : }
12078 :
12079 : /************************************************************************/
12080 : /* operator!=() */
12081 : /************************************************************************/
12082 :
12083 : /** Return a band whose value is 1 if the constant is different from
12084 : * the pixel value of the right operand.
12085 : *
12086 : * The resulting band is lazy evaluated. A reference is taken on the input
12087 : * dataset.
12088 : *
12089 : * @since 3.12
12090 : */
12091 2 : GDALComputedRasterBand operator!=(double constant, const GDALRasterBand &other)
12092 : {
12093 : #ifndef HAVE_MUPARSER
12094 : (void)constant;
12095 : (void)other;
12096 : return ThrowIfNotMuparser();
12097 : #else
12098 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_NE,
12099 2 : constant, other);
12100 : #endif
12101 : }
12102 :
12103 : #if defined(__GNUC__)
12104 : #pragma GCC diagnostic push
12105 : #pragma GCC diagnostic ignored "-Weffc++"
12106 : #endif
12107 :
12108 : /************************************************************************/
12109 : /* operator&&() */
12110 : /************************************************************************/
12111 :
12112 : /** Return a band whose value is 1 if the pixel value of the left and right
12113 : * operands is true.
12114 : *
12115 : * The resulting band is lazy evaluated. A reference is taken on the input
12116 : * dataset.
12117 : *
12118 : * @since 3.12
12119 : */
12120 : GDALComputedRasterBand
12121 3 : GDALRasterBand::operator&&(const GDALRasterBand &other) const
12122 : {
12123 : #ifndef HAVE_MUPARSER
12124 : (void)other;
12125 : return ThrowIfNotMuparser();
12126 : #else
12127 3 : ThrowIfNotSameDimensions(*this, other);
12128 : return GDALComputedRasterBand(
12129 2 : GDALComputedRasterBand::Operation::OP_LOGICAL_AND, *this, other);
12130 : #endif
12131 : }
12132 :
12133 : /************************************************************************/
12134 : /* operator&&() */
12135 : /************************************************************************/
12136 :
12137 : /** Return a band whose value is 1 if the pixel value of the left operand
12138 : * is true, as well as the constant
12139 : *
12140 : * The resulting band is lazy evaluated. A reference is taken on the input
12141 : * dataset.
12142 : *
12143 : * @since 3.12
12144 : */
12145 2 : GDALComputedRasterBand GDALRasterBand::operator&&(bool constant) const
12146 : {
12147 : #ifndef HAVE_MUPARSER
12148 : (void)constant;
12149 : return ThrowIfNotMuparser();
12150 : #else
12151 : return GDALComputedRasterBand(
12152 2 : GDALComputedRasterBand::Operation::OP_LOGICAL_AND, *this, constant);
12153 : #endif
12154 : }
12155 :
12156 : /************************************************************************/
12157 : /* operator&&() */
12158 : /************************************************************************/
12159 :
12160 : /** Return a band whose value is 1 if the constant is true, as well as
12161 : * the pixel value of the right operand.
12162 : *
12163 : * The resulting band is lazy evaluated. A reference is taken on the input
12164 : * dataset.
12165 : *
12166 : * @since 3.12
12167 : */
12168 2 : GDALComputedRasterBand operator&&(bool constant, const GDALRasterBand &other)
12169 : {
12170 : #ifndef HAVE_MUPARSER
12171 : (void)constant;
12172 : (void)other;
12173 : return ThrowIfNotMuparser();
12174 : #else
12175 : return GDALComputedRasterBand(
12176 2 : GDALComputedRasterBand::Operation::OP_LOGICAL_AND, constant, other);
12177 : #endif
12178 : }
12179 :
12180 : /************************************************************************/
12181 : /* operator||() */
12182 : /************************************************************************/
12183 :
12184 : /** Return a band whose value is 1 if the pixel value of the left or right
12185 : * operands is true.
12186 : *
12187 : * The resulting band is lazy evaluated. A reference is taken on the input
12188 : * dataset.
12189 : *
12190 : * @since 3.12
12191 : */
12192 : GDALComputedRasterBand
12193 4 : GDALRasterBand::operator||(const GDALRasterBand &other) const
12194 : {
12195 : #ifndef HAVE_MUPARSER
12196 : (void)other;
12197 : return ThrowIfNotMuparser();
12198 : #else
12199 4 : ThrowIfNotSameDimensions(*this, other);
12200 : return GDALComputedRasterBand(
12201 3 : GDALComputedRasterBand::Operation::OP_LOGICAL_OR, *this, other);
12202 : #endif
12203 : }
12204 :
12205 : /************************************************************************/
12206 : /* operator||() */
12207 : /************************************************************************/
12208 :
12209 : /** Return a band whose value is 1 if the pixel value of the left operand
12210 : * is true, or if the constant is true
12211 : *
12212 : * The resulting band is lazy evaluated. A reference is taken on the input
12213 : * dataset.
12214 : *
12215 : * @since 3.12
12216 : */
12217 4 : GDALComputedRasterBand GDALRasterBand::operator||(bool constant) const
12218 : {
12219 : #ifndef HAVE_MUPARSER
12220 : (void)constant;
12221 : return ThrowIfNotMuparser();
12222 : #else
12223 : return GDALComputedRasterBand(
12224 4 : GDALComputedRasterBand::Operation::OP_LOGICAL_OR, *this, constant);
12225 : #endif
12226 : }
12227 :
12228 : /************************************************************************/
12229 : /* operator||() */
12230 : /************************************************************************/
12231 :
12232 : /** Return a band whose value is 1 if the constant is true, or
12233 : * the pixel value of the right operand is true
12234 : *
12235 : * The resulting band is lazy evaluated. A reference is taken on the input
12236 : * dataset.
12237 : *
12238 : * @since 3.12
12239 : */
12240 4 : GDALComputedRasterBand operator||(bool constant, const GDALRasterBand &other)
12241 : {
12242 : #ifndef HAVE_MUPARSER
12243 : (void)constant;
12244 : (void)other;
12245 : return ThrowIfNotMuparser();
12246 : #else
12247 : return GDALComputedRasterBand(
12248 4 : GDALComputedRasterBand::Operation::OP_LOGICAL_OR, constant, other);
12249 : #endif
12250 : }
12251 :
12252 : #if defined(__GNUC__)
12253 : #pragma GCC diagnostic pop
12254 : #endif
12255 :
12256 : /************************************************************************/
12257 : /* operator!() */
12258 : /************************************************************************/
12259 :
12260 : /** Return a band whose value is the logical negation of the pixel value
12261 : *
12262 : * The resulting band is lazy evaluated. A reference is taken on the input
12263 : * dataset.
12264 : *
12265 : * @since 3.12
12266 : */
12267 2 : GDALComputedRasterBand GDALRasterBand::operator!() const
12268 : {
12269 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_NE,
12270 2 : *this, true);
12271 : }
12272 :
12273 : namespace gdal
12274 : {
12275 :
12276 : /************************************************************************/
12277 : /* IfThenElse() */
12278 : /************************************************************************/
12279 :
12280 : /** Return a band whose value is thenBand if the corresponding pixel in condBand
12281 : * is not zero, or the one from elseBand otherwise.
12282 : *
12283 : * Variants of this method exits where thenBand and/or elseBand can be double
12284 : * values.
12285 : *
12286 : * The resulting band is lazy evaluated. A reference is taken on the input
12287 : * datasets.
12288 : *
12289 : * This method is the same as the C function GDALRasterBandIfThenElse()
12290 : *
12291 : * @since 3.12
12292 : */
12293 5 : GDALComputedRasterBand IfThenElse(const GDALRasterBand &condBand,
12294 : const GDALRasterBand &thenBand,
12295 : const GDALRasterBand &elseBand)
12296 : {
12297 : #ifndef HAVE_MUPARSER
12298 : (void)condBand;
12299 : (void)thenBand;
12300 : (void)elseBand;
12301 : return ThrowIfNotMuparser();
12302 : #else
12303 5 : GDALRasterBand::ThrowIfNotSameDimensions(condBand, thenBand);
12304 4 : GDALRasterBand::ThrowIfNotSameDimensions(condBand, elseBand);
12305 : return GDALComputedRasterBand(
12306 : GDALComputedRasterBand::Operation::OP_TERNARY,
12307 6 : std::vector<const GDALRasterBand *>{&condBand, &thenBand, &elseBand});
12308 : #endif
12309 : }
12310 :
12311 : //! @cond Doxygen_Suppress
12312 :
12313 : /************************************************************************/
12314 : /* IfThenElse() */
12315 : /************************************************************************/
12316 :
12317 : /** Return a band whose value is thenValue if the corresponding pixel in condBand
12318 : * is not zero, or the one from elseBand otherwise.
12319 : *
12320 : * The resulting band is lazy evaluated. A reference is taken on the input
12321 : * datasets.
12322 : *
12323 : * This method is the same as the C function GDALRasterBandIfThenElse(),
12324 : * with thenBand = (condBand * 0) + thenValue
12325 : *
12326 : * @since 3.12
12327 : */
12328 1 : GDALComputedRasterBand IfThenElse(const GDALRasterBand &condBand,
12329 : double thenValue,
12330 : const GDALRasterBand &elseBand)
12331 : {
12332 : #ifndef HAVE_MUPARSER
12333 : (void)condBand;
12334 : (void)thenValue;
12335 : (void)elseBand;
12336 : return ThrowIfNotMuparser();
12337 : #else
12338 1 : GDALRasterBand::ThrowIfNotSameDimensions(condBand, elseBand);
12339 : auto thenBand =
12340 1 : (condBand * 0)
12341 2 : .AsType(GDALDataTypeUnionWithValue(GDT_Unknown, thenValue, false)) +
12342 1 : thenValue;
12343 : return GDALComputedRasterBand(
12344 : GDALComputedRasterBand::Operation::OP_TERNARY,
12345 3 : std::vector<const GDALRasterBand *>{&condBand, &thenBand, &elseBand});
12346 : #endif
12347 : }
12348 :
12349 : /************************************************************************/
12350 : /* IfThenElse() */
12351 : /************************************************************************/
12352 :
12353 : /** Return a band whose value is thenBand if the corresponding pixel in condBand
12354 : * is not zero, or the one from elseValue otherwise.
12355 : *
12356 : * The resulting band is lazy evaluated. A reference is taken on the input
12357 : * datasets.
12358 : *
12359 : * This method is the same as the C function GDALRasterBandIfThenElse(),
12360 : * with elseBand = (condBand * 0) + elseValue
12361 :
12362 : * @since 3.12
12363 : */
12364 1 : GDALComputedRasterBand IfThenElse(const GDALRasterBand &condBand,
12365 : const GDALRasterBand &thenBand,
12366 : double elseValue)
12367 : {
12368 : #ifndef HAVE_MUPARSER
12369 : (void)condBand;
12370 : (void)thenBand;
12371 : (void)elseValue;
12372 : return ThrowIfNotMuparser();
12373 : #else
12374 1 : GDALRasterBand::ThrowIfNotSameDimensions(condBand, thenBand);
12375 : auto elseBand =
12376 1 : (condBand * 0)
12377 2 : .AsType(GDALDataTypeUnionWithValue(GDT_Unknown, elseValue, false)) +
12378 1 : elseValue;
12379 : return GDALComputedRasterBand(
12380 : GDALComputedRasterBand::Operation::OP_TERNARY,
12381 3 : std::vector<const GDALRasterBand *>{&condBand, &thenBand, &elseBand});
12382 : #endif
12383 : }
12384 :
12385 : /************************************************************************/
12386 : /* IfThenElse() */
12387 : /************************************************************************/
12388 :
12389 : /** Return a band whose value is thenValue if the corresponding pixel in condBand
12390 : * is not zero, or the one from elseValue otherwise.
12391 : *
12392 : * The resulting band is lazy evaluated. A reference is taken on the input
12393 : * datasets.
12394 : *
12395 : * This method is the same as the C function GDALRasterBandIfThenElse(),
12396 : * with thenBand = (condBand * 0) + thenValue and elseBand = (condBand * 0) + elseValue
12397 : *
12398 : * @since 3.12
12399 : */
12400 3 : GDALComputedRasterBand IfThenElse(const GDALRasterBand &condBand,
12401 : double thenValue, double elseValue)
12402 : {
12403 : #ifndef HAVE_MUPARSER
12404 : (void)condBand;
12405 : (void)thenValue;
12406 : (void)elseValue;
12407 : return ThrowIfNotMuparser();
12408 : #else
12409 : auto thenBand =
12410 3 : (condBand * 0)
12411 6 : .AsType(GDALDataTypeUnionWithValue(GDT_Unknown, thenValue, false)) +
12412 6 : thenValue;
12413 : auto elseBand =
12414 3 : (condBand * 0)
12415 6 : .AsType(GDALDataTypeUnionWithValue(GDT_Unknown, elseValue, false)) +
12416 3 : elseValue;
12417 : return GDALComputedRasterBand(
12418 : GDALComputedRasterBand::Operation::OP_TERNARY,
12419 9 : std::vector<const GDALRasterBand *>{&condBand, &thenBand, &elseBand});
12420 : #endif
12421 : }
12422 :
12423 : //! @endcond
12424 :
12425 : } // namespace gdal
12426 :
12427 : /************************************************************************/
12428 : /* GDALRasterBandIfThenElse() */
12429 : /************************************************************************/
12430 :
12431 : /** Return a band whose value is hThenBand if the corresponding pixel in hCondBand
12432 : * is not zero, or the one from hElseBand otherwise.
12433 : *
12434 : * The resulting band is lazy evaluated. A reference is taken on the input
12435 : * datasets.
12436 : *
12437 : * This function is the same as the C++ method gdal::IfThenElse()
12438 : *
12439 : * @since 3.12
12440 : */
12441 12 : GDALComputedRasterBandH GDALRasterBandIfThenElse(GDALRasterBandH hCondBand,
12442 : GDALRasterBandH hThenBand,
12443 : GDALRasterBandH hElseBand)
12444 : {
12445 12 : VALIDATE_POINTER1(hCondBand, __func__, nullptr);
12446 12 : VALIDATE_POINTER1(hThenBand, __func__, nullptr);
12447 12 : VALIDATE_POINTER1(hElseBand, __func__, nullptr);
12448 : #ifndef HAVE_MUPARSER
12449 : CPLError(CE_Failure, CPLE_NotSupported,
12450 : "Band comparison operators not available on a GDAL build without "
12451 : "muparser");
12452 : return nullptr;
12453 : #else
12454 :
12455 12 : auto &condBand = *(GDALRasterBand::FromHandle(hCondBand));
12456 12 : auto &thenBand = *(GDALRasterBand::FromHandle(hThenBand));
12457 12 : auto &elseBand = *(GDALRasterBand::FromHandle(hElseBand));
12458 : try
12459 : {
12460 12 : GDALRasterBand::ThrowIfNotSameDimensions(condBand, thenBand);
12461 11 : GDALRasterBand::ThrowIfNotSameDimensions(condBand, elseBand);
12462 : }
12463 2 : catch (const std::exception &e)
12464 : {
12465 2 : CPLError(CE_Failure, CPLE_AppDefined, "%s", e.what());
12466 2 : return nullptr;
12467 : }
12468 : return new GDALComputedRasterBand(
12469 : GDALComputedRasterBand::Operation::OP_TERNARY,
12470 10 : std::vector<const GDALRasterBand *>{&condBand, &thenBand, &elseBand});
12471 : #endif
12472 : }
12473 :
12474 : /************************************************************************/
12475 : /* GDALRasterBand::AsType() */
12476 : /************************************************************************/
12477 :
12478 : /** Cast this band to another type.
12479 : *
12480 : * The resulting band is lazy evaluated. A reference is taken on the input
12481 : * dataset.
12482 : *
12483 : * This method is the same as the C function GDALRasterBandAsDataType()
12484 : *
12485 : * @since 3.12
12486 : */
12487 10 : GDALComputedRasterBand GDALRasterBand::AsType(GDALDataType dt) const
12488 : {
12489 10 : if (dt == GDT_Unknown)
12490 : {
12491 1 : throw std::runtime_error("AsType(GDT_Unknown) is not supported");
12492 : }
12493 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_CAST,
12494 9 : *this, dt);
12495 : }
12496 :
12497 : /************************************************************************/
12498 : /* GDALRasterBandAsDataType() */
12499 : /************************************************************************/
12500 :
12501 : /** Cast this band to another type.
12502 : *
12503 : * The resulting band is lazy evaluated. A reference is taken on the input
12504 : * dataset.
12505 : *
12506 : * This function is the same as the C++ method GDALRasterBand::AsType()
12507 : *
12508 : * @since 3.12
12509 : * @return a handle to free with GDALComputedRasterBandRelease(), or nullptr if error.
12510 : */
12511 16 : GDALComputedRasterBandH GDALRasterBandAsDataType(GDALRasterBandH hBand,
12512 : GDALDataType eDT)
12513 : {
12514 16 : VALIDATE_POINTER1(hBand, __func__, nullptr);
12515 16 : if (eDT == GDT_Unknown)
12516 : {
12517 1 : CPLError(CE_Failure, CPLE_NotSupported,
12518 : "GDALRasterBandAsDataType(GDT_Unknown) not supported");
12519 1 : return nullptr;
12520 : }
12521 : return new GDALComputedRasterBand(
12522 : GDALComputedRasterBand::Operation::OP_CAST,
12523 15 : *(GDALRasterBand::FromHandle(hBand)), eDT);
12524 : }
12525 :
12526 : /************************************************************************/
12527 : /* GetBandVector() */
12528 : /************************************************************************/
12529 :
12530 : static std::vector<const GDALRasterBand *>
12531 10 : GetBandVector(size_t nBandCount, GDALRasterBandH *pahBands)
12532 : {
12533 10 : std::vector<const GDALRasterBand *> bands;
12534 27 : for (size_t i = 0; i < nBandCount; ++i)
12535 : {
12536 20 : if (i > 0)
12537 : {
12538 10 : GDALRasterBand::ThrowIfNotSameDimensions(
12539 10 : *(GDALRasterBand::FromHandle(pahBands[0])),
12540 10 : *(GDALRasterBand::FromHandle(pahBands[i])));
12541 : }
12542 17 : bands.push_back(GDALRasterBand::FromHandle(pahBands[i]));
12543 : }
12544 7 : return bands;
12545 : }
12546 :
12547 : /************************************************************************/
12548 : /* GDALOperationOnNBands() */
12549 : /************************************************************************/
12550 :
12551 : static GDALComputedRasterBandH
12552 11 : GDALOperationOnNBands(GDALComputedRasterBand::Operation op, size_t nBandCount,
12553 : GDALRasterBandH *pahBands)
12554 : {
12555 11 : VALIDATE_POINTER1(pahBands, __func__, nullptr);
12556 11 : if (nBandCount == 0)
12557 : {
12558 1 : CPLError(CE_Failure, CPLE_AppDefined,
12559 : "At least one band should be passed");
12560 1 : return nullptr;
12561 : }
12562 :
12563 20 : std::vector<const GDALRasterBand *> bands;
12564 : try
12565 : {
12566 10 : bands = GetBandVector(nBandCount, pahBands);
12567 : }
12568 3 : catch (const std::exception &e)
12569 : {
12570 3 : CPLError(CE_Failure, CPLE_AppDefined, "%s", e.what());
12571 3 : return nullptr;
12572 : }
12573 7 : return GDALRasterBand::ToHandle(new GDALComputedRasterBand(op, bands));
12574 : }
12575 :
12576 : /************************************************************************/
12577 : /* GDALMaximumOfNBands() */
12578 : /************************************************************************/
12579 :
12580 : /** Return a band whose each pixel value is the maximum of the corresponding
12581 : * pixel values in the input bands.
12582 : *
12583 : * The resulting band is lazy evaluated. A reference is taken on input
12584 : * datasets.
12585 : *
12586 : * This function is the same as the C ++ method gdal::max()
12587 : *
12588 : * @since 3.12
12589 : * @return a handle to free with GDALComputedRasterBandRelease(), or nullptr if error.
12590 : */
12591 4 : GDALComputedRasterBandH GDALMaximumOfNBands(size_t nBandCount,
12592 : GDALRasterBandH *pahBands)
12593 : {
12594 4 : return GDALOperationOnNBands(GDALComputedRasterBand::Operation::OP_MAX,
12595 4 : nBandCount, pahBands);
12596 : }
12597 :
12598 : /************************************************************************/
12599 : /* gdal::max() */
12600 : /************************************************************************/
12601 :
12602 : namespace gdal
12603 : {
12604 : /** Return a band whose each pixel value is the maximum of the corresponding
12605 : * pixel values in the inputs (bands or constants)
12606 : *
12607 : * The resulting band is lazy evaluated. A reference is taken on input
12608 : * datasets.
12609 : *
12610 : * Two or more bands can be passed.
12611 : *
12612 : * This method is the same as the C function GDALMaximumOfNBands()
12613 : *
12614 : * @since 3.12
12615 : * @throw std::runtime_error if bands do not have the same dimensions.
12616 : */
12617 1 : GDALComputedRasterBand max(const GDALRasterBand &first,
12618 : const GDALRasterBand &second)
12619 : {
12620 1 : GDALRasterBand::ThrowIfNotSameDimensions(first, second);
12621 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_MAX,
12622 1 : first, second);
12623 : }
12624 : } // namespace gdal
12625 :
12626 : /************************************************************************/
12627 : /* GDALRasterBandMaxConstant() */
12628 : /************************************************************************/
12629 :
12630 : /** Return a band whose each pixel value is the maximum of the corresponding
12631 : * pixel values in the input band and the constant.
12632 : *
12633 : * The resulting band is lazy evaluated. A reference is taken on the input
12634 : * dataset.
12635 : *
12636 : * This function is the same as the C ++ method gdal::max()
12637 : *
12638 : * @since 3.12
12639 : * @return a handle to free with GDALComputedRasterBandRelease(), or nullptr if error.
12640 : */
12641 2 : GDALComputedRasterBandH GDALRasterBandMaxConstant(GDALRasterBandH hBand,
12642 : double dfConstant)
12643 : {
12644 2 : return GDALRasterBand::ToHandle(new GDALComputedRasterBand(
12645 : GDALComputedRasterBand::Operation::OP_MAX,
12646 4 : std::vector<const GDALRasterBand *>{GDALRasterBand::FromHandle(hBand)},
12647 6 : dfConstant));
12648 : }
12649 :
12650 : /************************************************************************/
12651 : /* GDALMinimumOfNBands() */
12652 : /************************************************************************/
12653 :
12654 : /** Return a band whose each pixel value is the minimum of the corresponding
12655 : * pixel values in the input bands.
12656 : *
12657 : * The resulting band is lazy evaluated. A reference is taken on input
12658 : * datasets.
12659 : *
12660 : * This function is the same as the C ++ method gdal::min()
12661 : *
12662 : * @since 3.12
12663 : * @return a handle to free with GDALComputedRasterBandRelease(), or nullptr if error.
12664 : */
12665 4 : GDALComputedRasterBandH GDALMinimumOfNBands(size_t nBandCount,
12666 : GDALRasterBandH *pahBands)
12667 : {
12668 4 : return GDALOperationOnNBands(GDALComputedRasterBand::Operation::OP_MIN,
12669 4 : nBandCount, pahBands);
12670 : }
12671 :
12672 : /************************************************************************/
12673 : /* gdal::min() */
12674 : /************************************************************************/
12675 :
12676 : namespace gdal
12677 : {
12678 : /** Return a band whose each pixel value is the minimum of the corresponding
12679 : * pixel values in the inputs (bands or constants)
12680 : *
12681 : * The resulting band is lazy evaluated. A reference is taken on input
12682 : * datasets.
12683 : *
12684 : * Two or more bands can be passed.
12685 : *
12686 : * This method is the same as the C function GDALMinimumOfNBands()
12687 : *
12688 : * @since 3.12
12689 : * @throw std::runtime_error if bands do not have the same dimensions.
12690 : */
12691 0 : GDALComputedRasterBand min(const GDALRasterBand &first,
12692 : const GDALRasterBand &second)
12693 : {
12694 0 : GDALRasterBand::ThrowIfNotSameDimensions(first, second);
12695 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_MIN,
12696 0 : first, second);
12697 : }
12698 : } // namespace gdal
12699 :
12700 : /************************************************************************/
12701 : /* GDALRasterBandMinConstant() */
12702 : /************************************************************************/
12703 :
12704 : /** Return a band whose each pixel value is the minimum of the corresponding
12705 : * pixel values in the input band and the constant.
12706 : *
12707 : * The resulting band is lazy evaluated. A reference is taken on the input
12708 : * dataset.
12709 : *
12710 : * This function is the same as the C ++ method gdal::min()
12711 : *
12712 : * @since 3.12
12713 : * @return a handle to free with GDALComputedRasterBandRelease(), or nullptr if error.
12714 : */
12715 2 : GDALComputedRasterBandH GDALRasterBandMinConstant(GDALRasterBandH hBand,
12716 : double dfConstant)
12717 : {
12718 2 : return GDALRasterBand::ToHandle(new GDALComputedRasterBand(
12719 : GDALComputedRasterBand::Operation::OP_MIN,
12720 4 : std::vector<const GDALRasterBand *>{GDALRasterBand::FromHandle(hBand)},
12721 6 : dfConstant));
12722 : }
12723 :
12724 : /************************************************************************/
12725 : /* GDALMeanOfNBands() */
12726 : /************************************************************************/
12727 :
12728 : /** Return a band whose each pixel value is the arithmetic mean of the
12729 : * corresponding pixel values in the input bands.
12730 : *
12731 : * The resulting band is lazy evaluated. A reference is taken on input
12732 : * datasets.
12733 : *
12734 : * This function is the same as the C ++ method gdal::mean()
12735 : *
12736 : * @since 3.12
12737 : * @return a handle to free with GDALComputedRasterBandRelease(), or nullptr if error.
12738 : */
12739 3 : GDALComputedRasterBandH GDALMeanOfNBands(size_t nBandCount,
12740 : GDALRasterBandH *pahBands)
12741 : {
12742 3 : return GDALOperationOnNBands(GDALComputedRasterBand::Operation::OP_MEAN,
12743 3 : nBandCount, pahBands);
12744 : }
12745 :
12746 : /************************************************************************/
12747 : /* gdal::mean() */
12748 : /************************************************************************/
12749 :
12750 : namespace gdal
12751 : {
12752 :
12753 : /** Return a band whose each pixel value is the arithmetic mean of the
12754 : * corresponding pixel values in the input bands.
12755 : *
12756 : * The resulting band is lazy evaluated. A reference is taken on input
12757 : * datasets.
12758 : *
12759 : * Two or more bands can be passed.
12760 : *
12761 : * This method is the same as the C function GDALMeanOfNBands()
12762 : *
12763 : * @since 3.12
12764 : * @throw std::runtime_error if bands do not have the same dimensions.
12765 : */
12766 0 : GDALComputedRasterBand mean(const GDALRasterBand &first,
12767 : const GDALRasterBand &second)
12768 : {
12769 0 : GDALRasterBand::ThrowIfNotSameDimensions(first, second);
12770 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_MEAN,
12771 0 : first, second);
12772 : }
12773 : } // namespace gdal
12774 :
12775 : /************************************************************************/
12776 : /* gdal::abs() */
12777 : /************************************************************************/
12778 :
12779 : namespace gdal
12780 : {
12781 :
12782 : /** Return a band whose each pixel value is the absolute value (or module
12783 : * for complex data type) of the corresponding pixel value in the input band.
12784 : *
12785 : * The resulting band is lazy evaluated. A reference is taken on input
12786 : * datasets.
12787 : *
12788 : * @since 3.12
12789 : */
12790 1 : GDALComputedRasterBand abs(const GDALRasterBand &band)
12791 : {
12792 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_ABS,
12793 1 : band);
12794 : }
12795 : } // namespace gdal
12796 :
12797 : /************************************************************************/
12798 : /* gdal::fabs() */
12799 : /************************************************************************/
12800 :
12801 : namespace gdal
12802 : {
12803 :
12804 : /** Return a band whose each pixel value is the absolute value (or module
12805 : * for complex data type) of the corresponding pixel value in the input band.
12806 : *
12807 : * The resulting band is lazy evaluated. A reference is taken on input
12808 : * datasets.
12809 : *
12810 : * @since 3.12
12811 : */
12812 1 : GDALComputedRasterBand fabs(const GDALRasterBand &band)
12813 : {
12814 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_ABS,
12815 1 : band);
12816 : }
12817 : } // namespace gdal
12818 :
12819 : /************************************************************************/
12820 : /* gdal::sqrt() */
12821 : /************************************************************************/
12822 :
12823 : namespace gdal
12824 : {
12825 :
12826 : /** Return a band whose each pixel value is the square root of the
12827 : * corresponding pixel value in the input band.
12828 : *
12829 : * The resulting band is lazy evaluated. A reference is taken on input
12830 : * datasets.
12831 : *
12832 : * @since 3.12
12833 : */
12834 1 : GDALComputedRasterBand sqrt(const GDALRasterBand &band)
12835 : {
12836 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_SQRT,
12837 1 : band);
12838 : }
12839 : } // namespace gdal
12840 :
12841 : /************************************************************************/
12842 : /* gdal::log() */
12843 : /************************************************************************/
12844 :
12845 : namespace gdal
12846 : {
12847 :
12848 : /** Return a band whose each pixel value is the natural logarithm of the
12849 : * corresponding pixel value in the input band.
12850 : *
12851 : * The resulting band is lazy evaluated. A reference is taken on input
12852 : * datasets.
12853 : *
12854 : * @since 3.12
12855 : */
12856 1 : GDALComputedRasterBand log(const GDALRasterBand &band)
12857 : {
12858 : #ifndef HAVE_MUPARSER
12859 : (void)band;
12860 : return ThrowIfNotMuparser();
12861 : #else
12862 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_LOG,
12863 1 : band);
12864 : #endif
12865 : }
12866 : } // namespace gdal
12867 :
12868 : /************************************************************************/
12869 : /* gdal::log10() */
12870 : /************************************************************************/
12871 :
12872 : namespace gdal
12873 : {
12874 :
12875 : /** Return a band whose each pixel value is the logarithm base 10 of the
12876 : * corresponding pixel value in the input band.
12877 : *
12878 : * The resulting band is lazy evaluated. A reference is taken on input
12879 : * datasets.
12880 : *
12881 : * @since 3.12
12882 : */
12883 1 : GDALComputedRasterBand log10(const GDALRasterBand &band)
12884 : {
12885 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_LOG10,
12886 1 : band);
12887 : }
12888 : } // namespace gdal
12889 :
12890 : /************************************************************************/
12891 : /* gdal::pow() */
12892 : /************************************************************************/
12893 :
12894 : namespace gdal
12895 : {
12896 :
12897 : #ifndef DOXYGEN_SKIP
12898 : /** Return a band whose each pixel value is the constant raised to the power of
12899 : * the corresponding pixel value in the input band.
12900 : *
12901 : * The resulting band is lazy evaluated. A reference is taken on input
12902 : * datasets.
12903 : *
12904 : * @since 3.12
12905 : */
12906 1 : GDALComputedRasterBand pow(double constant, const GDALRasterBand &band)
12907 : {
12908 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_POW,
12909 1 : constant, band);
12910 : }
12911 : #endif
12912 :
12913 : } // namespace gdal
12914 :
12915 : /************************************************************************/
12916 : /* gdal::pow() */
12917 : /************************************************************************/
12918 :
12919 : namespace gdal
12920 : {
12921 :
12922 : /** Return a band whose each pixel value is the the corresponding pixel value
12923 : * in the input band raised to the power of the constant.
12924 : *
12925 : * The resulting band is lazy evaluated. A reference is taken on input
12926 : * datasets.
12927 : *
12928 : * @since 3.12
12929 : */
12930 1 : GDALComputedRasterBand pow(const GDALRasterBand &band, double constant)
12931 : {
12932 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_POW,
12933 1 : band, constant);
12934 : }
12935 : } // namespace gdal
12936 :
12937 : /************************************************************************/
12938 : /* gdal::pow() */
12939 : /************************************************************************/
12940 :
12941 : namespace gdal
12942 : {
12943 :
12944 : #ifndef DOXYGEN_SKIP
12945 : /** Return a band whose each pixel value is the the corresponding pixel value
12946 : * in the input band1 raised to the power of the corresponding pixel value
12947 : * in the input band2
12948 : *
12949 : * The resulting band is lazy evaluated. A reference is taken on input
12950 : * datasets.
12951 : *
12952 : * @since 3.12
12953 : * @throw std::runtime_error if bands do not have the same dimensions.
12954 : */
12955 2 : GDALComputedRasterBand pow(const GDALRasterBand &band1,
12956 : const GDALRasterBand &band2)
12957 : {
12958 : #ifndef HAVE_MUPARSER
12959 : (void)band1;
12960 : (void)band2;
12961 : return ThrowIfNotMuparser();
12962 : #else
12963 2 : GDALRasterBand::ThrowIfNotSameDimensions(band1, band2);
12964 : return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_POW,
12965 1 : band1, band2);
12966 : #endif
12967 : }
12968 : #endif
12969 : } // namespace gdal
|
