Line data Source code
1 : /******************************************************************************
2 : *
3 : * Project: GDAL Utilities
4 : * Purpose: GDAL Image Translator Program
5 : * Author: Frank Warmerdam, warmerdam@pobox.com
6 : *
7 : ******************************************************************************
8 : * Copyright (c) 1998, 2002, Frank Warmerdam
9 : * Copyright (c) 2007-2015, Even Rouault <even dot rouault at spatialys.com>
10 : * Copyright (c) 2015, Faza Mahamood
11 : *
12 : * SPDX-License-Identifier: MIT
13 : ****************************************************************************/
14 :
15 : #include "cpl_port.h"
16 : #include "gdal_utils.h"
17 : #include "gdal_utils_priv.h"
18 : #include "gdalargumentparser.h"
19 :
20 : #include <cmath>
21 : #include <cstdlib>
22 : #include <cstring>
23 :
24 : #include <algorithm>
25 : #include <array>
26 : #include <limits>
27 : #include <set>
28 :
29 : #include "commonutils.h"
30 : #include "cpl_conv.h"
31 : #include "cpl_error.h"
32 : #include "cpl_json.h"
33 : #include "cpl_progress.h"
34 : #include "cpl_string.h"
35 : #include "cpl_vsi.h"
36 : #include "gdal.h"
37 : #include "gdal_priv.h"
38 : #include "gdal_priv_templates.hpp"
39 : #include "gdal_rat.h"
40 : #include "gdal_vrt.h"
41 : #include "ogr_core.h"
42 : #include "ogr_spatialref.h"
43 : #include "vrtdataset.h"
44 :
45 : static void AttachMetadata(GDALDatasetH, const CPLStringList &);
46 : static void AttachDomainMetadata(GDALDatasetH, const CPLStringList &);
47 :
48 : static void CopyBandInfo(GDALRasterBand *poSrcBand, GDALRasterBand *poDstBand,
49 : int bCanCopyStatsMetadata, int bCopyScale,
50 : int bCopyNoData, bool bCopyRAT,
51 : const GDALTranslateOptions *psOptions);
52 :
53 : typedef enum
54 : {
55 : MASK_DISABLED,
56 : MASK_AUTO,
57 : MASK_USER
58 : } MaskMode;
59 :
60 : /************************************************************************/
61 : /* GDALTranslateScaleParams */
62 : /************************************************************************/
63 :
64 : /** scaling parameters for use in GDALTranslateOptions.
65 : */
66 : struct GDALTranslateScaleParams
67 : {
68 : /*! scaling is done only if it is set to TRUE. This is helpful when there is
69 : a need to scale only certain bands. */
70 : bool bScale = false;
71 :
72 : /*! the range of input pixel values which need to be scaled.
73 : If not set, the input range is automatically computed from the source data. */
74 : double dfScaleSrcMin = std::numeric_limits<double>::quiet_NaN();
75 : double dfScaleSrcMax = std::numeric_limits<double>::quiet_NaN();
76 :
77 : /*! the range of output pixel values. */
78 : double dfScaleDstMin = std::numeric_limits<double>::quiet_NaN();
79 : double dfScaleDstMax = std::numeric_limits<double>::quiet_NaN();
80 : };
81 :
82 : /************************************************************************/
83 : /* GDALTranslateOptions */
84 : /************************************************************************/
85 :
86 : /** Options for use with GDALTranslate(). GDALTranslateOptions* must be
87 : * allocated and freed with GDALTranslateOptionsNew() and
88 : * GDALTranslateOptionsFree() respectively.
89 : */
90 : struct GDALTranslateOptions
91 : {
92 : /*! Raw program arguments */
93 : CPLStringList aosArgs{};
94 :
95 : /*! output format. Use the short format name. */
96 : std::string osFormat{};
97 :
98 : /*! allow or suppress progress monitor and other non-error output */
99 : bool bQuiet = false;
100 :
101 : /*! the progress function to use */
102 : GDALProgressFunc pfnProgress = GDALDummyProgress;
103 :
104 : /*! pointer to the progress data variable */
105 : void *pProgressData = nullptr;
106 :
107 : /*! for the output bands to be of the indicated data type */
108 : GDALDataType eOutputType = GDT_Unknown;
109 :
110 : /*! Used only by parser logic */
111 : bool bParsedMaskArgument = false;
112 :
113 : MaskMode eMaskMode = MASK_AUTO;
114 :
115 : /*! number of input bands to write to the output file, or to reorder bands
116 : */
117 : int nBandCount = 0;
118 :
119 : /*! list of input bands to write to the output file, or to reorder bands.
120 : The value 1 corresponds to the 1st band. */
121 : std::vector<int> anBandList{}; /* negative value of panBandList[i] means
122 : mask band of ABS(panBandList[i]) */
123 :
124 : /*! size of the output file. GDALTranslateOptions::nOXSizePixel is in pixels
125 : and GDALTranslateOptions::nOYSizePixel is in lines. If one of the two
126 : values is set to 0, its value will be determined from the other one,
127 : while maintaining the aspect ratio of the source dataset */
128 : int nOXSizePixel = 0;
129 : int nOYSizePixel = 0;
130 :
131 : /*! size of the output file. GDALTranslateOptions::dfOXSizePct and
132 : GDALTranslateOptions::dfOYSizePct are fraction of the input image size.
133 : The value 100 means 100%. If one of the two values is set to 0, its value
134 : will be determined from the other one, while maintaining the aspect ratio
135 : of the source dataset */
136 : double dfOXSizePct = 0;
137 : double dfOYSizePct = 0;
138 :
139 : /*! list of creation options to the output format driver */
140 : CPLStringList aosCreateOptions{};
141 :
142 : /*! subwindow from the source image for copying based on pixel/line location
143 : */
144 : struct PixelLineWindow
145 : {
146 : double dfXOff{0};
147 : double dfYOff{0};
148 : double dfXSize{0};
149 : double dfYSize{0};
150 : };
151 :
152 : PixelLineWindow srcWin{};
153 :
154 : /*! don't be forgiving of mismatches and lost data when translating to the
155 : * output format */
156 : bool bStrict = false;
157 :
158 : /*! apply the scale/offset metadata for the bands to convert scaled values
159 : * to unscaled values. It is also often necessary to reset the output
160 : * datatype with GDALTranslateOptions::eOutputType */
161 : bool bUnscale = false;
162 :
163 : bool bSetScale = false;
164 :
165 : double dfScale = 1;
166 :
167 : bool bSetOffset = false;
168 :
169 : double dfOffset = 0;
170 :
171 : /*! the list of scale parameters for each band. */
172 : std::vector<GDALTranslateScaleParams> asScaleParams{};
173 :
174 : /*! It is set to TRUE, when scale parameters are specific to each band */
175 : bool bHasUsedExplicitScaleBand = false;
176 :
177 : bool bNoClip = false;
178 :
179 : bool bNoWarnAboutOutsideWindow = false;
180 :
181 : /*! to apply non-linear scaling with a power function. It is the list of
182 : exponents of the power function (must be positive). This option must be
183 : used with GDALTranslateOptions::asScaleParams. If
184 : GDALTranslateOptions::adfExponent.size() is 1, it is applied to all
185 : bands of the output image. */
186 : std::vector<double> adfExponent{};
187 :
188 : bool bHasUsedExplicitExponentBand = false;
189 :
190 : /*! list of metadata key and value to set on the output dataset if possible. */
191 : CPLStringList aosMetadataOptions{};
192 :
193 : /*! list of metadata key and value in a domain to set on the output dataset if possible. */
194 : CPLStringList aosDomainMetadataOptions{};
195 :
196 : /*! override the projection for the output file. The SRS may be any of the
197 : usual GDAL/OGR forms, complete WKT, PROJ.4, EPSG:n or a file containing
198 : the WKT. */
199 : std::string osOutputSRS{};
200 :
201 : /*! Coordinate epoch of output SRS */
202 : double dfOutputCoordinateEpoch = 0;
203 :
204 : /*! does not copy source GCP into destination dataset (when TRUE) */
205 : bool bNoGCP = false;
206 :
207 : /*! list of GCPs to be added to the output dataset */
208 : std::vector<gdal::GCP> asGCPs{};
209 :
210 : /*! assign/override the georeferenced bounds of the output file. This
211 : assigns georeferenced bounds to the output file, ignoring what would have
212 : been derived from the source file. So this does not cause reprojection to
213 : the specified SRS. */
214 : std::array<double, 4> adfULLR{{0, 0, 0, 0}};
215 :
216 : /*! assign/override the geotransform of the output file. This
217 : assigns a geotransform to the output file, ignoring what would have
218 : been derived from the source file. So this does not cause reprojection to
219 : the specified SRS. */
220 : GDALGeoTransform gt{0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
221 :
222 : /*! set a nodata value specified in GDALTranslateOptions::osNoData to the
223 : * output bands */
224 : bool bSetNoData = 0;
225 :
226 : /*! avoid setting a nodata value to the output file if one exists for the
227 : * source file */
228 : bool bUnsetNoData = 0;
229 :
230 : /*! Assign a specified nodata value to output bands (
231 : GDALTranslateOptions::bSetNoData option should be set). Note that if the
232 : input dataset has a nodata value, this does not cause pixel values that
233 : are equal to that nodata value to be changed to the value specified. */
234 : std::string osNoData{};
235 :
236 : /*! to expose a dataset with 1 band with a color table as a dataset with
237 : 3 (RGB) or 4 (RGBA) bands. Useful for output drivers such as JPEG,
238 : JPEG2000, MrSID, ECW that don't support color indexed datasets.
239 : The 1 value enables to expand a dataset with a color table that only
240 : contains gray levels to a gray indexed dataset. */
241 : int nRGBExpand = 0;
242 :
243 : int nMaskBand = 0; /* negative value means mask band of ABS(nMaskBand) */
244 :
245 : /*! force recomputation of statistics */
246 : bool bStats = false;
247 :
248 : bool bApproxStats = false;
249 :
250 : /*! If this option is set, GDALTranslateOptions::adfSrcWin or
251 : (GDALTranslateOptions::dfULX, GDALTranslateOptions::dfULY,
252 : GDALTranslateOptions::dfLRX, GDALTranslateOptions::dfLRY) values that
253 : falls partially outside the source raster extent will be considered as an
254 : error. The default behavior is to accept such requests. */
255 : bool bErrorOnPartiallyOutside = false;
256 :
257 : /*! Same as bErrorOnPartiallyOutside, except that the criterion for
258 : erroring out is when the request falls completely outside the
259 : source raster extent. */
260 : bool bErrorOnCompletelyOutside = false;
261 :
262 : /*! does not copy source RAT into destination dataset (when TRUE) */
263 : bool bNoRAT = false;
264 :
265 : /*! resampling algorithm
266 : nearest (default), bilinear, cubic, cubicspline, lanczos, average, mode
267 : */
268 : std::string osResampling{};
269 :
270 : /*! target resolution. The values must be expressed in georeferenced units.
271 : Both must be positive values. This is exclusive with
272 : GDALTranslateOptions::nOXSizePixel (or
273 : GDALTranslateOptions::dfOXSizePct), GDALTranslateOptions::nOYSizePixel
274 : (or GDALTranslateOptions::dfOYSizePct), GDALTranslateOptions::adfULLR,
275 : and GDALTranslateOptions::gt.
276 : */
277 : double dfXRes = 0;
278 : double dfYRes = 0;
279 :
280 : /*! subwindow from the source image for copying (like
281 : GDALTranslateOptions::adfSrcWin) but with the corners given in
282 : georeferenced coordinates (by default expressed in the SRS of the
283 : dataset. Can be changed with osProjSRS) */
284 : double dfULX = 0;
285 : double dfULY = 0;
286 : double dfLRX = 0;
287 : double dfLRY = 0;
288 :
289 : /*! SRS in which to interpret the coordinates given with
290 : GDALTranslateOptions::dfULX, GDALTranslateOptions::dfULY,
291 : GDALTranslateOptions::dfLRX, GDALTranslateOptions::dfLRY. The SRS may be
292 : any of the usual GDAL/OGR forms, complete WKT, PROJ.4, EPSG:n or a file
293 : containing the WKT. Note that this does not cause reprojection of the
294 : dataset to the specified SRS. */
295 : std::string osProjSRS{};
296 :
297 : int nLimitOutSize = 0;
298 :
299 : // Array of color interpretations per band. Should be a GDALColorInterp
300 : // value, or -1 if no override.
301 : std::vector<int> anColorInterp{};
302 :
303 : /*! does not copy source XMP into destination dataset (when TRUE) */
304 : bool bNoXMP = false;
305 :
306 : /*! overview level of source file to be used */
307 : int nOvLevel = OVR_LEVEL_AUTO;
308 :
309 : /*! set to true to prevent overwriting existing dataset */
310 : bool bNoOverwrite = false;
311 :
312 3270 : GDALTranslateOptions() = default;
313 3243 : GDALTranslateOptions(const GDALTranslateOptions &) = default;
314 : GDALTranslateOptions &operator=(const GDALTranslateOptions &) = delete;
315 : };
316 :
317 : /************************************************************************/
318 : /* SrcToDst() */
319 : /************************************************************************/
320 :
321 154 : static void SrcToDst(double dfX, double dfY, double dfSrcXOff, double dfSrcYOff,
322 : double dfSrcXSize, double dfSrcYSize, double dfDstXOff,
323 : double dfDstYOff, double dfDstXSize, double dfDstYSize,
324 : double &dfXOut, double &dfYOut)
325 :
326 : {
327 154 : dfXOut = ((dfX - dfSrcXOff) / dfSrcXSize) * dfDstXSize + dfDstXOff;
328 154 : dfYOut = ((dfY - dfSrcYOff) / dfSrcYSize) * dfDstYSize + dfDstYOff;
329 154 : }
330 :
331 : /************************************************************************/
332 : /* GetSrcDstWindow() */
333 : /************************************************************************/
334 :
335 2030 : static bool FixSrcDstWindow(GDALTranslateOptions::PixelLineWindow &srcWin,
336 : GDALTranslateOptions::PixelLineWindow &dstWin,
337 : int nSrcRasterXSize, int nSrcRasterYSize)
338 :
339 : {
340 2030 : const double dfSrcXOff = srcWin.dfXOff;
341 2030 : const double dfSrcYOff = srcWin.dfYOff;
342 2030 : const double dfSrcXSize = srcWin.dfXSize;
343 2030 : const double dfSrcYSize = srcWin.dfYSize;
344 :
345 2030 : const double dfDstXOff = dstWin.dfXOff;
346 2030 : const double dfDstYOff = dstWin.dfYOff;
347 2030 : const double dfDstXSize = dstWin.dfXSize;
348 2030 : const double dfDstYSize = dstWin.dfYSize;
349 :
350 2030 : bool bModifiedX = false;
351 2030 : bool bModifiedY = false;
352 :
353 2030 : double dfModifiedSrcXOff = dfSrcXOff;
354 2030 : double dfModifiedSrcYOff = dfSrcYOff;
355 :
356 2030 : double dfModifiedSrcXSize = dfSrcXSize;
357 2030 : double dfModifiedSrcYSize = dfSrcYSize;
358 :
359 : /* -------------------------------------------------------------------- */
360 : /* Clamp within the bounds of the available source data. */
361 : /* -------------------------------------------------------------------- */
362 2030 : if (dfModifiedSrcXOff < 0)
363 : {
364 58 : dfModifiedSrcXSize += dfModifiedSrcXOff;
365 58 : dfModifiedSrcXOff = 0;
366 :
367 58 : bModifiedX = true;
368 : }
369 :
370 2030 : if (dfModifiedSrcYOff < 0)
371 : {
372 8 : dfModifiedSrcYSize += dfModifiedSrcYOff;
373 8 : dfModifiedSrcYOff = 0;
374 8 : bModifiedY = true;
375 : }
376 :
377 2030 : if (dfModifiedSrcXOff + dfModifiedSrcXSize > nSrcRasterXSize)
378 : {
379 24 : dfModifiedSrcXSize = nSrcRasterXSize - dfModifiedSrcXOff;
380 24 : bModifiedX = true;
381 : }
382 :
383 2030 : if (dfModifiedSrcYOff + dfModifiedSrcYSize > nSrcRasterYSize)
384 : {
385 72 : dfModifiedSrcYSize = nSrcRasterYSize - dfModifiedSrcYOff;
386 72 : bModifiedY = true;
387 : }
388 :
389 : /* -------------------------------------------------------------------- */
390 : /* Don't do anything if the requesting region is completely off */
391 : /* the source image. */
392 : /* -------------------------------------------------------------------- */
393 2030 : if (dfModifiedSrcXOff >= nSrcRasterXSize ||
394 2028 : dfModifiedSrcYOff >= nSrcRasterYSize || dfModifiedSrcXSize <= 0 ||
395 : dfModifiedSrcYSize <= 0)
396 : {
397 4 : return false;
398 : }
399 :
400 2026 : srcWin.dfXOff = dfModifiedSrcXOff;
401 2026 : srcWin.dfYOff = dfModifiedSrcYOff;
402 2026 : srcWin.dfXSize = dfModifiedSrcXSize;
403 2026 : srcWin.dfYSize = dfModifiedSrcYSize;
404 :
405 : /* -------------------------------------------------------------------- */
406 : /* If we haven't had to modify the source rectangle, then the */
407 : /* destination rectangle must be the whole region. */
408 : /* -------------------------------------------------------------------- */
409 2026 : if (!bModifiedX && !bModifiedY)
410 1949 : return true;
411 :
412 : /* -------------------------------------------------------------------- */
413 : /* Now transform this possibly reduced request back into the */
414 : /* destination buffer coordinates in case the output region is */
415 : /* less than the whole buffer. */
416 : /* -------------------------------------------------------------------- */
417 : double dfDstULX, dfDstULY, dfDstLRX, dfDstLRY;
418 :
419 77 : SrcToDst(dfModifiedSrcXOff, dfModifiedSrcYOff, dfSrcXOff, dfSrcYOff,
420 : dfSrcXSize, dfSrcYSize, dfDstXOff, dfDstYOff, dfDstXSize,
421 : dfDstYSize, dfDstULX, dfDstULY);
422 77 : SrcToDst(dfModifiedSrcXOff + dfModifiedSrcXSize,
423 : dfModifiedSrcYOff + dfModifiedSrcYSize, dfSrcXOff, dfSrcYOff,
424 : dfSrcXSize, dfSrcYSize, dfDstXOff, dfDstYOff, dfDstXSize,
425 : dfDstYSize, dfDstLRX, dfDstLRY);
426 :
427 77 : double dfModifiedDstXOff = dfDstXOff;
428 77 : double dfModifiedDstYOff = dfDstYOff;
429 77 : double dfModifiedDstXSize = dfDstXSize;
430 77 : double dfModifiedDstYSize = dfDstYSize;
431 :
432 77 : if (bModifiedX)
433 : {
434 75 : dfModifiedDstXOff = dfDstULX - dfDstXOff;
435 75 : dfModifiedDstXSize = (dfDstLRX - dfDstXOff) - dfModifiedDstXOff;
436 :
437 75 : dfModifiedDstXOff = std::max(0.0, dfModifiedDstXOff);
438 75 : if (dfModifiedDstXOff + dfModifiedDstXSize > dfDstXSize)
439 0 : dfModifiedDstXSize = dfDstXSize - dfModifiedDstXOff;
440 : }
441 :
442 77 : if (bModifiedY)
443 : {
444 73 : dfModifiedDstYOff = dfDstULY - dfDstYOff;
445 73 : dfModifiedDstYSize = (dfDstLRY - dfDstYOff) - dfModifiedDstYOff;
446 :
447 73 : dfModifiedDstYOff = std::max(0.0, dfModifiedDstYOff);
448 73 : if (dfModifiedDstYOff + dfModifiedDstYSize > dfDstYSize)
449 0 : dfModifiedDstYSize = dfDstYSize - dfModifiedDstYOff;
450 : }
451 :
452 77 : if (dfModifiedDstXSize <= 0.0 || dfModifiedDstYSize <= 0.0)
453 : {
454 0 : return false;
455 : }
456 :
457 77 : dstWin.dfXOff = dfModifiedDstXOff;
458 77 : dstWin.dfYOff = dfModifiedDstYOff;
459 77 : dstWin.dfXSize = dfModifiedDstXSize;
460 77 : dstWin.dfYSize = dfModifiedDstYSize;
461 :
462 77 : return true;
463 : }
464 :
465 : /************************************************************************/
466 : /* GDALTranslateFlush() */
467 : /************************************************************************/
468 :
469 2727 : static GDALDatasetH GDALTranslateFlush(GDALDatasetH hOutDS)
470 : {
471 2727 : if (hOutDS != nullptr)
472 : {
473 2545 : CPLErr eErrBefore = CPLGetLastErrorType();
474 2545 : GDALFlushCache(hOutDS);
475 2545 : if (eErrBefore == CE_None && CPLGetLastErrorType() != CE_None)
476 : {
477 1 : GDALClose(hOutDS);
478 1 : hOutDS = nullptr;
479 : }
480 : }
481 2727 : return hOutDS;
482 : }
483 :
484 : /************************************************************************/
485 : /* EditISIS3MetadataForBandChange() */
486 : /************************************************************************/
487 :
488 1 : static CPLJSONObject Clone(const CPLJSONObject &obj)
489 : {
490 2 : auto serialized = obj.Format(CPLJSONObject::PrettyFormat::Plain);
491 2 : CPLJSONDocument oJSONDocument;
492 1 : const GByte *pabyData = reinterpret_cast<const GByte *>(serialized.c_str());
493 1 : oJSONDocument.LoadMemory(pabyData);
494 2 : return oJSONDocument.GetRoot();
495 : }
496 :
497 4 : static void ReworkArray(CPLJSONObject &container, const CPLJSONObject &obj,
498 : int nSrcBandCount,
499 : const GDALTranslateOptions *psOptions)
500 : {
501 8 : auto oArray = obj.ToArray();
502 4 : if (oArray.Size() == nSrcBandCount)
503 : {
504 8 : CPLJSONArray oNewArray;
505 8 : for (int nBand : psOptions->anBandList)
506 : {
507 4 : const int iSrcIdx = nBand - 1;
508 4 : oNewArray.Add(oArray[iSrcIdx]);
509 : }
510 8 : const auto childName(obj.GetName());
511 4 : container.Delete(childName);
512 4 : container.Add(childName, oNewArray);
513 : }
514 4 : }
515 :
516 : static std::string
517 1 : EditISIS3MetadataForBandChange(const char *pszJSON, int nSrcBandCount,
518 : const GDALTranslateOptions *psOptions)
519 : {
520 2 : CPLJSONDocument oJSONDocument;
521 1 : if (!oJSONDocument.LoadMemory(pszJSON))
522 : {
523 0 : return std::string();
524 : }
525 :
526 2 : auto oRoot = oJSONDocument.GetRoot();
527 1 : if (!oRoot.IsValid())
528 : {
529 0 : return std::string();
530 : }
531 :
532 3 : auto oBandBin = oRoot.GetObj("IsisCube/BandBin");
533 1 : if (oBandBin.IsValid() && oBandBin.GetType() == CPLJSONObject::Type::Object)
534 : {
535 : // Backup original BandBin object
536 1 : oRoot.GetObj("IsisCube").Add("OriginalBandBin", Clone(oBandBin));
537 :
538 : // Iterate over BandBin members and reorder/resize its arrays that
539 : // have the same number of elements than the number of bands of the
540 : // source dataset.
541 7 : for (auto &child : oBandBin.GetChildren())
542 : {
543 6 : if (child.GetType() == CPLJSONObject::Type::Array)
544 : {
545 3 : ReworkArray(oBandBin, child, nSrcBandCount, psOptions);
546 : }
547 3 : else if (child.GetType() == CPLJSONObject::Type::Object)
548 : {
549 3 : auto oValue = child.GetObj("value");
550 3 : auto oUnit = child.GetObj("unit");
551 1 : if (oValue.GetType() == CPLJSONObject::Type::Array)
552 : {
553 1 : ReworkArray(child, oValue, nSrcBandCount, psOptions);
554 : }
555 : }
556 : }
557 : }
558 :
559 1 : return oRoot.Format(CPLJSONObject::PrettyFormat::Pretty);
560 : }
561 :
562 : /************************************************************************/
563 : /* EditISIS3ForMetadataChanges() */
564 : /************************************************************************/
565 :
566 : static std::string
567 2 : EditISIS3ForMetadataChanges(const char *pszJSON, bool bKeepExtent,
568 : bool bKeepResolution,
569 : const GDALTranslateOptions *psOptions)
570 : {
571 4 : CPLJSONDocument oJSONDocument;
572 2 : if (!oJSONDocument.LoadMemory(pszJSON))
573 : {
574 0 : return std::string();
575 : }
576 :
577 4 : auto oRoot = oJSONDocument.GetRoot();
578 2 : if (!oRoot.IsValid())
579 : {
580 0 : return std::string();
581 : }
582 :
583 6 : auto oGDALHistory = oRoot.GetObj("GDALHistory");
584 2 : if (!oGDALHistory.IsValid())
585 : {
586 2 : oGDALHistory = CPLJSONObject();
587 2 : oRoot.Add("GDALHistory", oGDALHistory);
588 : }
589 2 : oGDALHistory["_type"] = "object";
590 :
591 2 : char szFullFilename[2048] = {0};
592 2 : if (!CPLGetExecPath(szFullFilename, sizeof(szFullFilename) - 1))
593 0 : strcpy(szFullFilename, "unknown_program");
594 4 : const CPLString osProgram(CPLGetBasenameSafe(szFullFilename));
595 4 : const CPLString osPath(CPLGetPathSafe(szFullFilename));
596 :
597 2 : oGDALHistory["GdalVersion"] = GDALVersionInfo("RELEASE_NAME");
598 2 : oGDALHistory["Program"] = osProgram;
599 2 : if (osPath != ".")
600 2 : oGDALHistory["ProgramPath"] = osPath;
601 :
602 4 : std::vector<std::string> aosOps;
603 2 : if (!bKeepExtent)
604 : {
605 2 : aosOps.push_back("a clipping operation");
606 : }
607 2 : if (!bKeepResolution)
608 : {
609 1 : aosOps.push_back("a resolution change operation");
610 : }
611 2 : if (psOptions->bUnscale)
612 : {
613 0 : aosOps.push_back("an unscaling operation");
614 : }
615 2 : else if (!psOptions->asScaleParams.empty())
616 : {
617 1 : aosOps.push_back("a scaling operation");
618 : }
619 :
620 4 : std::string osArgs;
621 22 : for (const char *pszArg : psOptions->aosArgs)
622 : {
623 20 : if (!osArgs.empty())
624 18 : osArgs += ' ';
625 20 : osArgs += pszArg;
626 : }
627 2 : oGDALHistory["ProgramArguments"] = osArgs;
628 :
629 4 : std::string osComment = "Part of that metadata might be invalid due to ";
630 6 : for (size_t i = 0; i < aosOps.size(); ++i)
631 : {
632 4 : if (i > 0 && i + 1 == aosOps.size())
633 1 : osComment += " and ";
634 3 : else if (i > 0)
635 1 : osComment += ", ";
636 4 : osComment += aosOps[i];
637 : }
638 2 : osComment += " having been performed by GDAL tools";
639 2 : oGDALHistory.Add("Comment", osComment);
640 :
641 2 : return oRoot.Format(CPLJSONObject::PrettyFormat::Pretty);
642 : }
643 :
644 : /************************************************************************/
645 : /* GDALTranslate() */
646 : /************************************************************************/
647 :
648 : /* clang-format off */
649 : /**
650 : * Converts raster data between different formats.
651 : *
652 : * This is the equivalent of the
653 : * <a href="/programs/gdal_translate.html">gdal_translate</a> utility.
654 : *
655 : * GDALTranslateOptions* must be allocated and freed with
656 : * GDALTranslateOptionsNew() and GDALTranslateOptionsFree() respectively.
657 : *
658 : * @param pszDest the destination dataset path.
659 : * @param hSrcDataset the source dataset handle.
660 : * @param psOptionsIn the options struct returned by GDALTranslateOptionsNew()
661 : * or NULL.
662 : * @param pbUsageError pointer to a integer output variable to store if any
663 : * usage error has occurred or NULL.
664 : * @return the output dataset (new dataset that must be closed using
665 : * GDALClose()) or NULL in case of error. If the output
666 : * format is a VRT dataset, then the returned VRT dataset has a reference to
667 : * hSrcDataset. Hence hSrcDataset should be closed after the returned dataset
668 : * if using GDALClose().
669 : * A safer alternative is to use GDALReleaseDataset() instead of using
670 : * GDALClose(), in which case you can close datasets in any order.
671 : *
672 : * @since GDAL 2.1
673 : */
674 : /* clang-format on */
675 :
676 3254 : GDALDatasetH GDALTranslate(const char *pszDest, GDALDatasetH hSrcDataset,
677 : const GDALTranslateOptions *psOptionsIn,
678 : int *pbUsageError)
679 :
680 : {
681 3254 : CPLErrorReset();
682 3254 : if (hSrcDataset == nullptr)
683 : {
684 0 : CPLError(CE_Failure, CPLE_AppDefined, "No source dataset specified.");
685 :
686 0 : if (pbUsageError)
687 0 : *pbUsageError = TRUE;
688 0 : return nullptr;
689 : }
690 3254 : if (pszDest == nullptr)
691 : {
692 0 : CPLError(CE_Failure, CPLE_AppDefined, "No target dataset specified.");
693 :
694 0 : if (pbUsageError)
695 0 : *pbUsageError = TRUE;
696 0 : return nullptr;
697 : }
698 :
699 : auto psOptions = psOptionsIn
700 : ? std::make_unique<GDALTranslateOptions>(*psOptionsIn)
701 : : std::unique_ptr<GDALTranslateOptions>(
702 6508 : GDALTranslateOptionsNew(nullptr, nullptr));
703 :
704 3254 : GDALDatasetH hOutDS = nullptr;
705 3254 : bool bGotBounds = false;
706 3254 : bool bGotGeoTransform = false;
707 :
708 3254 : if (pbUsageError)
709 2391 : *pbUsageError = FALSE;
710 :
711 6493 : if (psOptions->adfULLR[0] != 0.0 || psOptions->adfULLR[1] != 0.0 ||
712 6493 : psOptions->adfULLR[2] != 0.0 || psOptions->adfULLR[3] != 0.0)
713 19 : bGotBounds = true;
714 :
715 3254 : if (psOptions->gt != GDALGeoTransform(0, 0, 0, 0, 0, 0))
716 3 : bGotGeoTransform = true;
717 :
718 3254 : GDALDataset *poSrcDS = GDALDataset::FromHandle(hSrcDataset);
719 3254 : const char *pszSource = poSrcDS->GetDescription();
720 :
721 3254 : if (strcmp(pszSource, pszDest) == 0 && pszSource[0] != '\0' &&
722 0 : poSrcDS->GetDriver() != GDALGetDriverByName("MEM"))
723 : {
724 0 : CPLError(CE_Failure, CPLE_AppDefined,
725 : "Source and destination datasets must be different.");
726 :
727 0 : if (pbUsageError)
728 0 : *pbUsageError = TRUE;
729 0 : return nullptr;
730 : }
731 :
732 6508 : CPLString osProjSRS;
733 :
734 3254 : if (!psOptions->osProjSRS.empty())
735 : {
736 8 : OGRSpatialReference oSRS;
737 8 : oSRS.SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
738 :
739 8 : if (oSRS.SetFromUserInput(psOptions->osProjSRS.c_str()) != OGRERR_NONE)
740 : {
741 0 : CPLError(CE_Failure, CPLE_AppDefined,
742 : "Failed to process SRS definition: %s",
743 0 : psOptions->osProjSRS.c_str());
744 0 : return nullptr;
745 : }
746 :
747 8 : char *pszSRS = nullptr;
748 8 : oSRS.exportToWkt(&pszSRS);
749 8 : if (pszSRS)
750 8 : osProjSRS = pszSRS;
751 8 : CPLFree(pszSRS);
752 : }
753 :
754 3367 : if (!psOptions->osOutputSRS.empty() && psOptions->osOutputSRS != "null" &&
755 113 : psOptions->osOutputSRS != "none")
756 : {
757 112 : OGRSpatialReference oOutputSRS;
758 112 : if (oOutputSRS.SetFromUserInput(psOptions->osOutputSRS.c_str()) !=
759 : OGRERR_NONE)
760 : {
761 0 : CPLError(CE_Failure, CPLE_AppDefined,
762 : "Failed to process SRS definition: %s",
763 0 : psOptions->osOutputSRS.c_str());
764 0 : return nullptr;
765 : }
766 : }
767 :
768 : /* -------------------------------------------------------------------- */
769 : /* Check that incompatible options are not used */
770 : /* -------------------------------------------------------------------- */
771 :
772 6293 : if ((psOptions->nOXSizePixel != 0 || psOptions->dfOXSizePct != 0.0 ||
773 6510 : psOptions->nOYSizePixel != 0 || psOptions->dfOYSizePct != 0.0) &&
774 247 : (psOptions->dfXRes != 0 && psOptions->dfYRes != 0))
775 : {
776 0 : CPLError(CE_Failure, CPLE_IllegalArg,
777 : "-outsize and -tr options cannot be used at the same time.");
778 0 : if (pbUsageError)
779 0 : *pbUsageError = TRUE;
780 0 : return nullptr;
781 : }
782 3276 : if ((bGotBounds | bGotGeoTransform) &&
783 22 : (psOptions->dfXRes != 0 && psOptions->dfYRes != 0))
784 : {
785 0 : CPLError(
786 : CE_Failure, CPLE_IllegalArg,
787 : "-a_ullr or -a_gt options cannot be used at the same time as -tr.");
788 0 : if (pbUsageError)
789 0 : *pbUsageError = TRUE;
790 0 : return nullptr;
791 : }
792 3254 : if (bGotBounds && bGotGeoTransform)
793 : {
794 0 : CPLError(CE_Failure, CPLE_IllegalArg,
795 : "-a_ullr and -a_gt options cannot be used at the same time.");
796 0 : if (pbUsageError)
797 0 : *pbUsageError = TRUE;
798 0 : return nullptr;
799 : }
800 :
801 : /* -------------------------------------------------------------------- */
802 : /* Collect some information from the source file. */
803 : /* -------------------------------------------------------------------- */
804 3254 : if (psOptions->srcWin.dfXSize == 0 && psOptions->srcWin.dfYSize == 0)
805 : {
806 2326 : psOptions->srcWin.dfXSize = poSrcDS->GetRasterXSize();
807 2326 : psOptions->srcWin.dfYSize = poSrcDS->GetRasterYSize();
808 : }
809 :
810 : /* -------------------------------------------------------------------- */
811 : /* Build band list to translate */
812 : /* -------------------------------------------------------------------- */
813 3254 : bool bAllBandsInOrder = true;
814 :
815 3254 : if (psOptions->anBandList.empty())
816 : {
817 :
818 2985 : psOptions->nBandCount = poSrcDS->GetRasterCount();
819 2985 : if ((psOptions->nBandCount == 0) && (psOptions->bStrict))
820 : {
821 : // if not strict then the driver can fail if it doesn't support zero
822 : // bands
823 0 : CPLError(CE_Failure, CPLE_AppDefined,
824 : "Input file has no bands, and so cannot be translated.");
825 0 : return nullptr;
826 : }
827 :
828 2985 : psOptions->anBandList.resize(psOptions->nBandCount);
829 74530 : for (int i = 0; i < psOptions->nBandCount; i++)
830 71545 : psOptions->anBandList[i] = i + 1;
831 : }
832 : else
833 : {
834 923 : for (int i = 0; i < psOptions->nBandCount; i++)
835 : {
836 654 : if (std::abs(psOptions->anBandList[i]) > poSrcDS->GetRasterCount())
837 : {
838 0 : CPLError(CE_Failure, CPLE_AppDefined,
839 : "Band %d requested, but only bands 1 to %d available.",
840 0 : std::abs(psOptions->anBandList[i]),
841 : poSrcDS->GetRasterCount());
842 0 : return nullptr;
843 : }
844 :
845 654 : if (psOptions->anBandList[i] != i + 1)
846 128 : bAllBandsInOrder = FALSE;
847 : }
848 :
849 269 : if (psOptions->nBandCount != poSrcDS->GetRasterCount())
850 212 : bAllBandsInOrder = FALSE;
851 : }
852 :
853 3254 : if (static_cast<int>(psOptions->asScaleParams.size()) >
854 3254 : psOptions->nBandCount)
855 : {
856 0 : if (!psOptions->bHasUsedExplicitScaleBand)
857 0 : CPLError(CE_Failure, CPLE_IllegalArg,
858 : "-scale has been specified more times than the number of "
859 : "output bands");
860 : else
861 0 : CPLError(CE_Failure, CPLE_IllegalArg,
862 : "-scale_XX has been specified with XX greater than the "
863 : "number of output bands");
864 0 : if (pbUsageError)
865 0 : *pbUsageError = TRUE;
866 0 : return nullptr;
867 : }
868 :
869 3254 : if (static_cast<int>(psOptions->adfExponent.size()) > psOptions->nBandCount)
870 : {
871 0 : if (!psOptions->bHasUsedExplicitExponentBand)
872 0 : CPLError(CE_Failure, CPLE_IllegalArg,
873 : "-exponent has been specified more times than the number "
874 : "of output bands");
875 : else
876 0 : CPLError(CE_Failure, CPLE_IllegalArg,
877 : "-exponent_XX has been specified with XX greater than the "
878 : "number of output bands");
879 0 : if (pbUsageError)
880 0 : *pbUsageError = TRUE;
881 0 : return nullptr;
882 : }
883 :
884 3261 : if (!psOptions->bQuiet && (psOptions->bSetScale || psOptions->bSetOffset) &&
885 7 : psOptions->bUnscale)
886 : {
887 : // Cf https://github.com/OSGeo/gdal/issues/7863
888 1 : CPLError(CE_Warning, CPLE_AppDefined,
889 : "-a_scale/-a_offset are not applied by -unscale, but are set "
890 : "after it, and -unscale uses the original source band "
891 : "scale/offset values. "
892 : "You may want to use -scale 0 1 %.16g %.16g instead. "
893 : "This warning will not appear if -q is specified.",
894 1 : psOptions->dfOffset, psOptions->dfOffset + psOptions->dfScale);
895 : }
896 :
897 : /* -------------------------------------------------------------------- */
898 : /* Compute the source window from the projected source window */
899 : /* if the projected coordinates were provided. Note that the */
900 : /* projected coordinates are in ulx, uly, lrx, lry format, */
901 : /* while the adfSrcWin is xoff, yoff, xsize, ysize with the */
902 : /* xoff,yoff being the ulx, uly in pixel/line. */
903 : /* -------------------------------------------------------------------- */
904 3254 : const char *pszProjection = nullptr;
905 :
906 6171 : if (psOptions->dfULX != 0.0 || psOptions->dfULY != 0.0 ||
907 6171 : psOptions->dfLRX != 0.0 || psOptions->dfLRY != 0.0)
908 : {
909 346 : GDALGeoTransform gt;
910 346 : poSrcDS->GetGeoTransform(gt);
911 :
912 346 : if (gt.xscale == 0.0 || gt.yscale == 0.0)
913 : {
914 0 : CPLError(CE_Failure, CPLE_AppDefined,
915 : "The -projwin option was used, but the geotransform is "
916 : "invalid.");
917 1 : return nullptr;
918 : }
919 346 : if (!gt.IsAxisAligned())
920 : {
921 1 : CPLError(CE_Failure, CPLE_AppDefined,
922 : "The -projwin option was used, but the geotransform is\n"
923 : "rotated. This configuration is not supported.");
924 1 : return nullptr;
925 : }
926 :
927 345 : if (!osProjSRS.empty())
928 : {
929 7 : pszProjection = poSrcDS->GetProjectionRef();
930 7 : if (pszProjection != nullptr && strlen(pszProjection) > 0)
931 : {
932 6 : OGRSpatialReference oSRSIn;
933 6 : OGRSpatialReference oSRSDS;
934 6 : oSRSIn.SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
935 6 : oSRSDS.SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
936 6 : oSRSIn.SetFromUserInput(osProjSRS);
937 6 : oSRSDS.SetFromUserInput(pszProjection);
938 6 : if (!oSRSIn.IsSame(&oSRSDS))
939 : {
940 : OGRCoordinateTransformation *poCT =
941 5 : OGRCreateCoordinateTransformation(&oSRSIn, &oSRSDS);
942 10 : if (!(poCT &&
943 5 : poCT->TransformBounds(
944 5 : psOptions->dfULX, psOptions->dfLRY,
945 5 : psOptions->dfLRX, psOptions->dfULY,
946 5 : &psOptions->dfULX, &psOptions->dfLRY,
947 5 : &psOptions->dfLRX, &psOptions->dfULY, 21)))
948 : {
949 0 : OGRCoordinateTransformation::DestroyCT(poCT);
950 :
951 0 : CPLError(CE_Failure, CPLE_AppDefined,
952 : "-projwin_srs ignored since coordinate "
953 : "transformation failed.");
954 0 : return nullptr;
955 : }
956 5 : delete poCT;
957 6 : }
958 : }
959 : else
960 : {
961 1 : CPLError(CE_Warning, CPLE_None,
962 : "-projwin_srs ignored since the dataset has no "
963 : "projection.");
964 : }
965 : }
966 :
967 : bool bAlignToInputPixels =
968 387 : psOptions->osResampling.empty() ||
969 42 : EQUALN(psOptions->osResampling.c_str(), "NEAR", 4);
970 :
971 345 : double dfULX = psOptions->dfULX;
972 345 : double dfULY = psOptions->dfULY;
973 :
974 345 : psOptions->srcWin.dfXOff = (dfULX - gt.xorig) / gt.xscale;
975 345 : psOptions->srcWin.dfYOff = (dfULY - gt.yorig) / gt.yscale;
976 :
977 : // In case of nearest resampling, round to integer pixels (#6610)
978 345 : if (bAlignToInputPixels)
979 : {
980 616 : psOptions->srcWin.dfXOff =
981 308 : std::floor(psOptions->srcWin.dfXOff + 0.001); // xoff
982 616 : psOptions->srcWin.dfYOff =
983 308 : std::floor(psOptions->srcWin.dfYOff + 0.001); // yoff
984 :
985 308 : dfULX = psOptions->srcWin.dfXOff * gt.xscale + gt.xorig;
986 308 : dfULY = psOptions->srcWin.dfYOff * gt.yscale + gt.yorig;
987 : }
988 :
989 : // Calculate xsize and ysize based on the (possibly snapped) ULX, ULY
990 690 : psOptions->srcWin.dfXSize =
991 345 : (psOptions->dfLRX - dfULX) / gt.xscale; // xsize
992 690 : psOptions->srcWin.dfYSize =
993 345 : (psOptions->dfLRY - dfULY) / gt.yscale; // ysize
994 :
995 345 : if (bAlignToInputPixels)
996 : {
997 616 : psOptions->srcWin.dfXSize =
998 308 : std::ceil(psOptions->srcWin.dfXSize - 0.001);
999 308 : psOptions->srcWin.dfYSize =
1000 308 : std::ceil(psOptions->srcWin.dfYSize - 0.001);
1001 : }
1002 : }
1003 :
1004 : /* -------------------------------------------------------------------- */
1005 : /* Verify source window dimensions. */
1006 : /* -------------------------------------------------------------------- */
1007 6502 : if (poSrcDS->GetRasterXSize() != 0 && poSrcDS->GetRasterYSize() != 0 &&
1008 3249 : (psOptions->srcWin.dfXSize <= 0 || psOptions->srcWin.dfYSize <= 0))
1009 : {
1010 1 : CPLError(CE_Failure, CPLE_AppDefined,
1011 : "Error: %ssource window (x,y)=(%g,%g), (width,height)=(%g,%g) "
1012 : "has negative width and/or height.",
1013 1 : (psOptions->dfULX != 0.0 || psOptions->dfULY != 0.0 ||
1014 0 : psOptions->dfLRX != 0.0 || psOptions->dfLRY != 0.0)
1015 : ? "Computed "
1016 : : "",
1017 1 : psOptions->srcWin.dfXOff, psOptions->srcWin.dfYOff,
1018 1 : psOptions->srcWin.dfXSize, psOptions->srcWin.dfYSize);
1019 1 : return nullptr;
1020 : }
1021 :
1022 : /* -------------------------------------------------------------------- */
1023 : /* Verify source window dimensions. */
1024 : /* -------------------------------------------------------------------- */
1025 6439 : else if (psOptions->srcWin.dfXOff <= -1 || psOptions->srcWin.dfYOff <= -1 ||
1026 3183 : psOptions->srcWin.dfXOff + psOptions->srcWin.dfXSize - 1 >=
1027 9603 : poSrcDS->GetRasterXSize() ||
1028 3164 : psOptions->srcWin.dfYOff + psOptions->srcWin.dfYSize - 1 >=
1029 3164 : poSrcDS->GetRasterYSize())
1030 : {
1031 : const bool bCompletelyOutside =
1032 92 : psOptions->srcWin.dfXOff + psOptions->srcWin.dfXSize <= 0 ||
1033 86 : psOptions->srcWin.dfYOff + psOptions->srcWin.dfYSize <= 0 ||
1034 261 : psOptions->srcWin.dfXOff >= poSrcDS->GetRasterXSize() ||
1035 83 : psOptions->srcWin.dfYOff >= poSrcDS->GetRasterYSize();
1036 : const bool bIsError =
1037 98 : psOptions->bErrorOnPartiallyOutside ||
1038 6 : (bCompletelyOutside && psOptions->bErrorOnCompletelyOutside);
1039 92 : if ((!psOptions->bQuiet && !psOptions->bNoWarnAboutOutsideWindow) ||
1040 : bIsError)
1041 : {
1042 19 : CPLErr eErr = bIsError ? CE_Failure : CE_Warning;
1043 :
1044 38 : CPLError(eErr, CPLE_AppDefined,
1045 : "%s-srcwin %g %g %g %g falls %s outside source raster "
1046 : "extent.%s",
1047 19 : (psOptions->dfULX != 0.0 || psOptions->dfULY != 0.0 ||
1048 9 : psOptions->dfLRX != 0.0 || psOptions->dfLRY != 0.0)
1049 : ? "Computed "
1050 : : "",
1051 19 : psOptions->srcWin.dfXOff, psOptions->srcWin.dfYOff,
1052 19 : psOptions->srcWin.dfXSize, psOptions->srcWin.dfYSize,
1053 : bCompletelyOutside ? "completely" : "partially",
1054 : bIsError
1055 : ? ""
1056 : : " Pixels outside the source raster extent will be "
1057 : "set to the NoData value (if defined), or zero.");
1058 : }
1059 92 : if (bIsError)
1060 : {
1061 9 : return nullptr;
1062 : }
1063 : }
1064 :
1065 : /* -------------------------------------------------------------------- */
1066 : /* Find the output driver. */
1067 : /* -------------------------------------------------------------------- */
1068 3243 : if (psOptions->osFormat.empty())
1069 : {
1070 1457 : psOptions->osFormat = GetOutputDriverForRaster(pszDest);
1071 1457 : if (psOptions->osFormat.empty())
1072 : {
1073 1 : CPLError(CE_Failure, CPLE_AppDefined,
1074 : "Could not identify an output driver for %s", pszDest);
1075 1 : return nullptr;
1076 : }
1077 : }
1078 :
1079 3242 : GDALDriverH hDriver = GDALGetDriverByName(psOptions->osFormat.c_str());
1080 3242 : if (hDriver == nullptr)
1081 : {
1082 1 : CPLError(CE_Failure, CPLE_IllegalArg,
1083 : "Output driver `%s' not recognised.",
1084 1 : psOptions->osFormat.c_str());
1085 1 : return nullptr;
1086 : }
1087 :
1088 : /* -------------------------------------------------------------------- */
1089 : /* Make sure we cleanup if there is an existing dataset of this */
1090 : /* name. But even if that seems to fail we will continue since */
1091 : /* it might just be a corrupt file or something. */
1092 : /* This is needed for */
1093 : /* gdal_translate foo.tif foo.tif.ovr -outsize 50% 50% */
1094 : /* -------------------------------------------------------------------- */
1095 3241 : if (psOptions->aosCreateOptions.FetchBool("APPEND_SUBDATASET", false))
1096 : {
1097 12 : if (GDALGetMetadataItem(hDriver, GDAL_DCAP_CREATE_SUBDATASETS,
1098 12 : nullptr) == nullptr)
1099 : {
1100 1 : CPLError(CE_Failure, CPLE_NotSupported,
1101 : "Subdataset creation not supported for driver %s",
1102 : GDALGetDescription(hDriver));
1103 1 : return nullptr;
1104 : }
1105 : }
1106 : else
1107 : {
1108 3229 : if (!EQUAL(psOptions->osFormat.c_str(), "VRT"))
1109 : {
1110 : // Prevent GDALDriver::CreateCopy() from doing that again.
1111 2581 : psOptions->aosCreateOptions.SetNameValue(
1112 2581 : "@QUIET_DELETE_ON_CREATE_COPY", "NO");
1113 : }
1114 :
1115 3337 : if (psOptions->bNoOverwrite && !EQUAL(pszDest, "") &&
1116 108 : !EQUAL(pszDest, "/vsistdout/"))
1117 : {
1118 : VSIStatBufL sStat;
1119 106 : if (VSIStatL(pszDest, &sStat) == 0)
1120 : {
1121 0 : CPLError(CE_Failure, CPLE_AppDefined,
1122 : "File '%s' already exists. Specify the --overwrite "
1123 : "option to overwrite it.",
1124 : pszDest);
1125 0 : return nullptr;
1126 : }
1127 : else
1128 : {
1129 : bool bExists;
1130 : {
1131 106 : CPLErrorStateBackuper oBackuper(CPLQuietErrorHandler);
1132 212 : bExists = std::unique_ptr<GDALDataset>(
1133 106 : GDALDataset::Open(pszDest)) != nullptr;
1134 : }
1135 106 : if (bExists)
1136 : {
1137 0 : CPLError(
1138 : CE_Failure, CPLE_AppDefined,
1139 : "Dataset '%s' already exists. Specify the --overwrite "
1140 : "option to overwrite it.",
1141 : pszDest);
1142 0 : return nullptr;
1143 : }
1144 : }
1145 : }
1146 :
1147 3229 : GDALDriver::FromHandle(hDriver)->QuietDeleteForCreateCopy(pszDest,
1148 : poSrcDS);
1149 :
1150 : // Make sure to load early overviews, so that on the GTiff driver
1151 : // external .ovr is looked for before it might be created as the
1152 : // output dataset !
1153 3229 : if (poSrcDS->GetRasterCount())
1154 : {
1155 3222 : auto poBand = poSrcDS->GetRasterBand(1);
1156 3222 : if (poBand)
1157 3222 : poBand->GetOverviewCount();
1158 : }
1159 : }
1160 :
1161 3240 : CSLConstList papszDriverMD = GDALGetMetadata(hDriver, nullptr);
1162 :
1163 3240 : if (!CPLTestBool(
1164 : CSLFetchNameValueDef(papszDriverMD, GDAL_DCAP_RASTER, "FALSE")))
1165 : {
1166 1 : CPLError(CE_Failure, CPLE_AppDefined,
1167 : "%s driver has no raster capabilities.",
1168 1 : psOptions->osFormat.c_str());
1169 1 : return nullptr;
1170 : }
1171 :
1172 3239 : if (!CPLTestBool(
1173 3544 : CSLFetchNameValueDef(papszDriverMD, GDAL_DCAP_CREATE, "FALSE")) &&
1174 305 : !CPLTestBool(
1175 : CSLFetchNameValueDef(papszDriverMD, GDAL_DCAP_CREATECOPY, "FALSE")))
1176 : {
1177 1 : CPLError(CE_Failure, CPLE_AppDefined,
1178 : "%s driver has no creation capabilities.",
1179 1 : psOptions->osFormat.c_str());
1180 1 : return nullptr;
1181 : }
1182 :
1183 : /* -------------------------------------------------------------------- */
1184 : /* The short form is to CreateCopy(). We use this if the input */
1185 : /* matches the whole dataset. Eventually we should rewrite */
1186 : /* this entire program to use virtual datasets to construct a */
1187 : /* virtual input source to copy from. */
1188 : /* -------------------------------------------------------------------- */
1189 :
1190 : const bool bKeepResolution =
1191 6261 : psOptions->nOXSizePixel == 0 && psOptions->dfOXSizePct == 0.0 &&
1192 9252 : psOptions->nOYSizePixel == 0 && psOptions->dfOYSizePct == 0.0 &&
1193 2991 : psOptions->dfXRes == 0.0;
1194 : const bool bKeepExtent =
1195 5523 : psOptions->srcWin.dfXOff == 0 && psOptions->srcWin.dfYOff == 0 &&
1196 7555 : psOptions->srcWin.dfXSize == poSrcDS->GetRasterXSize() &&
1197 2032 : psOptions->srcWin.dfYSize == poSrcDS->GetRasterYSize();
1198 3238 : const bool bSpatialArrangementPreserved = bKeepExtent && bKeepResolution;
1199 : const bool bValuesChanged =
1200 3238 : psOptions->bUnscale || !psOptions->asScaleParams.empty();
1201 :
1202 6116 : if (psOptions->eOutputType == GDT_Unknown &&
1203 5708 : psOptions->asScaleParams.empty() && psOptions->adfExponent.empty() &&
1204 2829 : !psOptions->bUnscale && !psOptions->bSetScale &&
1205 2824 : !psOptions->bSetOffset && psOptions->aosMetadataOptions.empty() &&
1206 2796 : psOptions->aosDomainMetadataOptions.empty() && bAllBandsInOrder &&
1207 2695 : psOptions->eMaskMode == MASK_AUTO && bSpatialArrangementPreserved &&
1208 1353 : !psOptions->bNoGCP && psOptions->asGCPs.empty() && !bGotBounds &&
1209 1327 : !bGotGeoTransform && psOptions->osOutputSRS.empty() &&
1210 1275 : psOptions->dfOutputCoordinateEpoch == 0 && !psOptions->bSetNoData &&
1211 1250 : !psOptions->bUnsetNoData && psOptions->nRGBExpand == 0 &&
1212 1220 : !psOptions->bNoRAT && psOptions->anColorInterp.empty() &&
1213 6116 : !psOptions->bNoXMP && psOptions->nOvLevel == OVR_LEVEL_AUTO)
1214 : {
1215 :
1216 : // For gdal_translate_fuzzer
1217 1204 : if (psOptions->nLimitOutSize > 0)
1218 : {
1219 : vsi_l_offset nRawOutSize =
1220 0 : static_cast<vsi_l_offset>(poSrcDS->GetRasterXSize()) *
1221 0 : poSrcDS->GetRasterYSize() * psOptions->nBandCount;
1222 0 : if (psOptions->nBandCount)
1223 : {
1224 0 : nRawOutSize *= GDALGetDataTypeSizeBytes(
1225 : poSrcDS->GetRasterBand(1)->GetRasterDataType());
1226 : }
1227 0 : if (nRawOutSize >
1228 0 : static_cast<vsi_l_offset>(psOptions->nLimitOutSize))
1229 : {
1230 0 : CPLError(CE_Failure, CPLE_IllegalArg,
1231 : "Attempt to create %dx%d dataset is above authorized "
1232 : "limit.",
1233 : poSrcDS->GetRasterXSize(), poSrcDS->GetRasterYSize());
1234 0 : return nullptr;
1235 : }
1236 : }
1237 :
1238 : /* --------------------------------------------------------------------
1239 : */
1240 : /* Compute stats if required. */
1241 : /* --------------------------------------------------------------------
1242 : */
1243 :
1244 1204 : if (psOptions->bStats && EQUAL(psOptions->osFormat.c_str(), "COG"))
1245 : {
1246 2 : psOptions->aosCreateOptions.SetNameValue("STATISTICS", "YES");
1247 : }
1248 1202 : else if (psOptions->bStats)
1249 : {
1250 4 : for (int i = 0; i < poSrcDS->GetRasterCount(); i++)
1251 : {
1252 : double dfMin, dfMax, dfMean, dfStdDev;
1253 2 : poSrcDS->GetRasterBand(i + 1)->ComputeStatistics(
1254 2 : psOptions->bApproxStats, &dfMin, &dfMax, &dfMean, &dfStdDev,
1255 2 : GDALDummyProgress, nullptr);
1256 : }
1257 : }
1258 :
1259 1204 : hOutDS = GDALCreateCopy(
1260 : hDriver, pszDest, GDALDataset::ToHandle(poSrcDS),
1261 1204 : psOptions->bStrict, psOptions->aosCreateOptions.List(),
1262 1204 : psOptions->pfnProgress, psOptions->pProgressData);
1263 1204 : hOutDS = GDALTranslateFlush(hOutDS);
1264 :
1265 1204 : return hOutDS;
1266 : }
1267 :
1268 2034 : if (psOptions->aosCreateOptions.FetchNameValue("COPY_SRC_OVERVIEWS"))
1269 : {
1270 0 : CPLError(CE_Warning, CPLE_AppDefined,
1271 : "General options of gdal_translate make the "
1272 : "COPY_SRC_OVERVIEWS creation option ineffective as they hide "
1273 : "the overviews");
1274 : }
1275 :
1276 : /* -------------------------------------------------------------------- */
1277 : /* Establish some parameters. */
1278 : /* -------------------------------------------------------------------- */
1279 2034 : int nOXSize = 0;
1280 2034 : int nOYSize = 0;
1281 :
1282 2034 : bool bHasSrcGeoTransform = false;
1283 2034 : GDALGeoTransform srcGT;
1284 2034 : if (poSrcDS->GetGeoTransform(srcGT) == CE_None)
1285 1775 : bHasSrcGeoTransform = true;
1286 :
1287 : const bool bOutsizeExplicitlySet =
1288 3823 : !(psOptions->nOXSizePixel == 0 && psOptions->dfOXSizePct == 0.0 &&
1289 1789 : psOptions->nOYSizePixel == 0 && psOptions->dfOYSizePct == 0.0);
1290 2034 : if (psOptions->dfXRes != 0.0 && psOptions->dfYRes != 0.0)
1291 : {
1292 136 : if (!(bHasSrcGeoTransform && psOptions->asGCPs.empty() &&
1293 68 : srcGT[2] == 0.0 && srcGT[4] == 0.0))
1294 : {
1295 0 : CPLError(CE_Failure, CPLE_IllegalArg,
1296 : "The -tr option was used, but there's no geotransform or "
1297 : "it is\n"
1298 : "rotated. This configuration is not supported.");
1299 0 : return nullptr;
1300 : }
1301 : const double dfOXSize =
1302 68 : psOptions->srcWin.dfXSize / psOptions->dfXRes * srcGT[1] + 0.5;
1303 : const double dfOYSize =
1304 68 : psOptions->srcWin.dfYSize / psOptions->dfYRes * fabs(srcGT[5]) +
1305 68 : 0.5;
1306 68 : if (dfOXSize < 1 || !GDALIsValueInRange<int>(dfOXSize) ||
1307 136 : dfOYSize < 1 || !GDALIsValueInRange<int>(dfOYSize))
1308 : {
1309 0 : CPLError(CE_Failure, CPLE_IllegalArg,
1310 : "Invalid output size: %g x %g", dfOXSize, dfOYSize);
1311 0 : return nullptr;
1312 : }
1313 68 : nOXSize = static_cast<int>(dfOXSize);
1314 68 : nOYSize = static_cast<int>(dfOYSize);
1315 : }
1316 1966 : else if (!bOutsizeExplicitlySet)
1317 : {
1318 1719 : double dfOXSize = ceil(psOptions->srcWin.dfXSize - 0.001);
1319 1719 : double dfOYSize = ceil(psOptions->srcWin.dfYSize - 0.001);
1320 1719 : if (dfOXSize < 1 || !GDALIsValueInRange<int>(dfOXSize) ||
1321 3438 : dfOYSize < 1 || !GDALIsValueInRange<int>(dfOYSize))
1322 : {
1323 2 : CPLError(CE_Failure, CPLE_IllegalArg,
1324 : "Invalid output size: %g x %g", dfOXSize, dfOYSize);
1325 2 : return nullptr;
1326 : }
1327 1717 : nOXSize = static_cast<int>(dfOXSize);
1328 1717 : nOYSize = static_cast<int>(dfOYSize);
1329 : }
1330 : else
1331 : {
1332 247 : if (!(psOptions->nOXSizePixel == 0 && psOptions->dfOXSizePct == 0.0))
1333 : {
1334 245 : if (psOptions->nOXSizePixel != 0)
1335 215 : nOXSize = psOptions->nOXSizePixel;
1336 : else
1337 : {
1338 : const double dfOXSize =
1339 30 : psOptions->dfOXSizePct / 100 * psOptions->srcWin.dfXSize;
1340 30 : if (dfOXSize < 1 || !GDALIsValueInRange<int>(dfOXSize))
1341 : {
1342 1 : CPLError(CE_Failure, CPLE_IllegalArg,
1343 : "Invalid output width: %g", dfOXSize);
1344 1 : return nullptr;
1345 : }
1346 29 : nOXSize = static_cast<int>(dfOXSize);
1347 : }
1348 : }
1349 :
1350 246 : if (!(psOptions->nOYSizePixel == 0 && psOptions->dfOYSizePct == 0.0))
1351 : {
1352 173 : if (psOptions->nOYSizePixel != 0)
1353 145 : nOYSize = psOptions->nOYSizePixel;
1354 : else
1355 : {
1356 : const double dfOYSize =
1357 28 : psOptions->dfOYSizePct / 100 * psOptions->srcWin.dfYSize;
1358 28 : if (dfOYSize < 1 || !GDALIsValueInRange<int>(dfOYSize))
1359 : {
1360 1 : CPLError(CE_Failure, CPLE_IllegalArg,
1361 : "Invalid output height: %g", dfOYSize);
1362 1 : return nullptr;
1363 : }
1364 27 : nOYSize = static_cast<int>(dfOYSize);
1365 : }
1366 : }
1367 :
1368 245 : if (psOptions->nOXSizePixel == 0 && psOptions->dfOXSizePct == 0.0)
1369 : {
1370 4 : const double dfOXSize = static_cast<double>(nOYSize) *
1371 2 : psOptions->srcWin.dfXSize /
1372 2 : psOptions->srcWin.dfYSize +
1373 2 : 0.5;
1374 2 : if (dfOXSize < 1 || !GDALIsValueInRange<int>(dfOXSize))
1375 : {
1376 0 : CPLError(CE_Failure, CPLE_IllegalArg,
1377 : "Invalid output width: %g", dfOXSize);
1378 0 : return nullptr;
1379 : }
1380 2 : nOXSize = static_cast<int>(dfOXSize);
1381 : }
1382 243 : else if (psOptions->nOYSizePixel == 0 && psOptions->dfOYSizePct == 0.0)
1383 : {
1384 146 : const double dfOYSize = static_cast<double>(nOXSize) *
1385 73 : psOptions->srcWin.dfYSize /
1386 73 : psOptions->srcWin.dfXSize +
1387 73 : 0.5;
1388 73 : if (dfOYSize < 1 || !GDALIsValueInRange<int>(dfOYSize))
1389 : {
1390 0 : CPLError(CE_Failure, CPLE_IllegalArg,
1391 : "Invalid output height: %g", dfOYSize);
1392 0 : return nullptr;
1393 : }
1394 73 : nOYSize = static_cast<int>(dfOYSize);
1395 : }
1396 : }
1397 :
1398 2030 : if (nOXSize <= 0 || nOYSize <= 0)
1399 : {
1400 0 : CPLError(CE_Failure, CPLE_IllegalArg,
1401 : "Attempt to create %dx%d dataset is illegal.", nOXSize,
1402 : nOYSize);
1403 0 : return nullptr;
1404 : }
1405 :
1406 : // Build overview dataset if -ovr is specified
1407 2030 : GDALDataset *poSrcOvrDS = nullptr;
1408 2030 : GDALDataset *poSrcDSOri = poSrcDS;
1409 2030 : const auto poFirstBand = poSrcDS->GetRasterBand(1);
1410 2030 : const int nOvCount = poFirstBand ? poFirstBand->GetOverviewCount() : 0;
1411 2030 : if (psOptions->nOvLevel < OVR_LEVEL_AUTO && poFirstBand && nOvCount > 0)
1412 : {
1413 4 : int iOvr = 0;
1414 7 : for (; iOvr < nOvCount - 1; iOvr++)
1415 : {
1416 4 : if (poFirstBand->GetOverview(iOvr)->GetXSize() <= nOXSize)
1417 : {
1418 1 : break;
1419 : }
1420 : }
1421 4 : iOvr += (psOptions->nOvLevel - OVR_LEVEL_AUTO);
1422 4 : if (iOvr >= 0)
1423 : {
1424 3 : CPLDebug("GDAL", "Selecting overview level %d", iOvr);
1425 3 : poSrcOvrDS = GDALCreateOverviewDataset(poSrcDS, iOvr,
1426 : /* bThisLevelOnly = */ true);
1427 : }
1428 : }
1429 2026 : else if (psOptions->nOvLevel >= OVR_LEVEL_NONE)
1430 : {
1431 11 : poSrcOvrDS = GDALCreateOverviewDataset(poSrcDS, psOptions->nOvLevel,
1432 : /* bThisLevelOnly = */ true);
1433 11 : if (poSrcOvrDS == nullptr)
1434 : {
1435 3 : if (!psOptions->bQuiet)
1436 : {
1437 3 : if (nOvCount > 0)
1438 : {
1439 2 : CPLError(CE_Warning, CPLE_AppDefined,
1440 : "Cannot get overview level %d. "
1441 : "Defaulting to level %d.",
1442 2 : psOptions->nOvLevel, nOvCount - 1);
1443 : }
1444 : else
1445 : {
1446 1 : CPLError(CE_Warning, CPLE_AppDefined,
1447 : "Cannot get overview level %d. "
1448 : "Defaulting to full resolution.",
1449 1 : psOptions->nOvLevel);
1450 : }
1451 : }
1452 3 : if (nOvCount > 0)
1453 : poSrcOvrDS =
1454 2 : GDALCreateOverviewDataset(poSrcDS, nOvCount - 1,
1455 : /* bThisLevelOnly = */ true);
1456 : }
1457 11 : if (poSrcOvrDS && psOptions->dfXRes == 0.0 && !bOutsizeExplicitlySet)
1458 : {
1459 : const double dfRatioX =
1460 8 : static_cast<double>(poSrcDSOri->GetRasterXSize()) /
1461 8 : poSrcOvrDS->GetRasterXSize();
1462 : const double dfRatioY =
1463 8 : static_cast<double>(poSrcDSOri->GetRasterYSize()) /
1464 8 : poSrcOvrDS->GetRasterYSize();
1465 8 : nOXSize =
1466 8 : std::max(1, static_cast<int>(ceil(nOXSize / dfRatioX - 0.001)));
1467 8 : nOYSize =
1468 8 : std::max(1, static_cast<int>(ceil(nOYSize / dfRatioY - 0.001)));
1469 : }
1470 : }
1471 :
1472 2030 : if (poSrcOvrDS)
1473 13 : poSrcDS = poSrcOvrDS;
1474 : else
1475 2017 : poSrcDS->Reference();
1476 :
1477 : // For gdal_translate_fuzzer
1478 2030 : if (psOptions->nLimitOutSize > 0)
1479 : {
1480 0 : vsi_l_offset nRawOutSize = static_cast<vsi_l_offset>(nOXSize) * nOYSize;
1481 0 : if (psOptions->nBandCount)
1482 : {
1483 0 : if (nRawOutSize > std::numeric_limits<vsi_l_offset>::max() /
1484 0 : psOptions->nBandCount)
1485 : {
1486 0 : poSrcDS->Release();
1487 0 : return nullptr;
1488 : }
1489 0 : nRawOutSize *= psOptions->nBandCount;
1490 0 : const int nDTSize = GDALGetDataTypeSizeBytes(
1491 : poSrcDS->GetRasterBand(1)->GetRasterDataType());
1492 0 : if (nDTSize > 0 &&
1493 : nRawOutSize >
1494 0 : std::numeric_limits<vsi_l_offset>::max() / nDTSize)
1495 : {
1496 0 : poSrcDS->Release();
1497 0 : return nullptr;
1498 : }
1499 0 : nRawOutSize *= nDTSize;
1500 : }
1501 0 : if (nRawOutSize > static_cast<vsi_l_offset>(psOptions->nLimitOutSize))
1502 : {
1503 0 : CPLError(
1504 : CE_Failure, CPLE_IllegalArg,
1505 : "Attempt to create %dx%d dataset is above authorized limit.",
1506 : nOXSize, nOYSize);
1507 0 : poSrcDS->Release();
1508 0 : return nullptr;
1509 : }
1510 : }
1511 :
1512 : /* ==================================================================== */
1513 : /* Create a virtual dataset. */
1514 : /* ==================================================================== */
1515 :
1516 : /* -------------------------------------------------------------------- */
1517 : /* Make a virtual clone. */
1518 : /* -------------------------------------------------------------------- */
1519 2030 : VRTDataset *poVDS = static_cast<VRTDataset *>(VRTCreate(nOXSize, nOYSize));
1520 :
1521 2030 : if (psOptions->asGCPs.empty())
1522 : {
1523 4042 : if (psOptions->osOutputSRS == "null" ||
1524 2021 : psOptions->osOutputSRS == "none")
1525 : {
1526 1 : poVDS->SetSpatialRef(nullptr);
1527 : }
1528 : else
1529 : {
1530 4040 : OGRSpatialReference oSRS;
1531 2020 : if (!psOptions->osOutputSRS.empty())
1532 : {
1533 107 : oSRS.SetFromUserInput(psOptions->osOutputSRS.c_str());
1534 107 : oSRS.SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
1535 : }
1536 : else
1537 : {
1538 1913 : const OGRSpatialReference *poSrcSRS = poSrcDS->GetSpatialRef();
1539 1913 : if (poSrcSRS)
1540 1487 : oSRS = *poSrcSRS;
1541 : }
1542 2020 : if (!oSRS.IsEmpty())
1543 : {
1544 1594 : if (psOptions->dfOutputCoordinateEpoch > 0)
1545 4 : oSRS.SetCoordinateEpoch(psOptions->dfOutputCoordinateEpoch);
1546 1594 : poVDS->SetSpatialRef(&oSRS);
1547 : }
1548 : }
1549 : }
1550 :
1551 2030 : bool bHasDstGeoTransform = false;
1552 2030 : GDALGeoTransform dstGT;
1553 :
1554 2030 : if (bGotBounds)
1555 : {
1556 19 : bHasDstGeoTransform = true;
1557 19 : dstGT[0] = psOptions->adfULLR[0];
1558 19 : dstGT[1] = (psOptions->adfULLR[2] - psOptions->adfULLR[0]) / nOXSize;
1559 19 : dstGT[2] = 0.0;
1560 19 : dstGT[3] = psOptions->adfULLR[1];
1561 19 : dstGT[4] = 0.0;
1562 19 : dstGT[5] = (psOptions->adfULLR[3] - psOptions->adfULLR[1]) / nOYSize;
1563 :
1564 19 : poVDS->SetGeoTransform(dstGT);
1565 : }
1566 :
1567 2011 : else if (bGotGeoTransform)
1568 : {
1569 3 : bHasDstGeoTransform = true;
1570 3 : poVDS->SetGeoTransform(psOptions->gt);
1571 : }
1572 :
1573 2008 : else if (bHasSrcGeoTransform && psOptions->asGCPs.empty())
1574 : {
1575 1747 : bHasDstGeoTransform = true;
1576 1747 : dstGT = srcGT;
1577 1747 : dstGT[0] += psOptions->srcWin.dfXOff * dstGT[1] +
1578 1747 : psOptions->srcWin.dfYOff * dstGT[2];
1579 1747 : dstGT[3] += psOptions->srcWin.dfXOff * dstGT[4] +
1580 1747 : psOptions->srcWin.dfYOff * dstGT[5];
1581 :
1582 1747 : const double dfXRatio = psOptions->srcWin.dfXSize / nOXSize;
1583 1747 : const double dfYRatio = psOptions->srcWin.dfYSize / nOYSize;
1584 1747 : dstGT.Rescale(dfXRatio, dfYRatio);
1585 :
1586 1747 : if (psOptions->dfXRes != 0.0)
1587 : {
1588 68 : dstGT[1] = psOptions->dfXRes;
1589 68 : dstGT[5] = (dstGT[5] > 0) ? psOptions->dfYRes : -psOptions->dfYRes;
1590 : }
1591 :
1592 1747 : poVDS->SetGeoTransform(dstGT);
1593 : }
1594 :
1595 2030 : if (!psOptions->asGCPs.empty())
1596 : {
1597 18 : OGRSpatialReference oSRS;
1598 18 : if (psOptions->osOutputSRS == "null" ||
1599 9 : psOptions->osOutputSRS == "none")
1600 : {
1601 : // nothing to do
1602 : }
1603 9 : else if (!psOptions->osOutputSRS.empty())
1604 : {
1605 5 : oSRS.SetFromUserInput(psOptions->osOutputSRS.c_str());
1606 5 : oSRS.SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
1607 : }
1608 : else
1609 : {
1610 4 : const OGRSpatialReference *poSrcSRS = poSrcDS->GetGCPSpatialRef();
1611 4 : if (poSrcSRS)
1612 0 : oSRS = *poSrcSRS;
1613 : }
1614 18 : poVDS->SetGCPs(static_cast<int>(psOptions->asGCPs.size()),
1615 9 : gdal::GCP::c_ptr(psOptions->asGCPs),
1616 9 : !oSRS.IsEmpty() ? &oSRS : nullptr);
1617 : }
1618 :
1619 2021 : else if (!psOptions->bNoGCP && poSrcDSOri->GetGCPCount() > 0)
1620 : {
1621 1 : const int nGCPs = poSrcDSOri->GetGCPCount();
1622 :
1623 1 : GDAL_GCP *pasGCPs = GDALDuplicateGCPs(nGCPs, poSrcDSOri->GetGCPs());
1624 :
1625 5 : for (int i = 0; i < nGCPs; i++)
1626 : {
1627 4 : pasGCPs[i].dfGCPPixel -= psOptions->srcWin.dfXOff;
1628 4 : pasGCPs[i].dfGCPLine -= psOptions->srcWin.dfYOff;
1629 4 : pasGCPs[i].dfGCPPixel *=
1630 4 : nOXSize / static_cast<double>(psOptions->srcWin.dfXSize);
1631 4 : pasGCPs[i].dfGCPLine *=
1632 4 : nOYSize / static_cast<double>(psOptions->srcWin.dfYSize);
1633 : }
1634 :
1635 1 : poVDS->SetGCPs(nGCPs, pasGCPs, poSrcDSOri->GetGCPSpatialRef());
1636 :
1637 1 : GDALDeinitGCPs(nGCPs, pasGCPs);
1638 1 : CPLFree(pasGCPs);
1639 : }
1640 :
1641 : /* -------------------------------------------------------------------- */
1642 : /* To make the VRT to look less awkward (but this is optional */
1643 : /* in fact), avoid negative values. */
1644 : /* -------------------------------------------------------------------- */
1645 2030 : GDALTranslateOptions::PixelLineWindow dstWin{
1646 2030 : 0.0, 0.0, static_cast<double>(nOXSize), static_cast<double>(nOYSize)};
1647 :
1648 : // When specifying -tr with non-nearest resampling, make sure that the
1649 : // size of target window precisely matches the requested resolution, to
1650 : // avoid any shift.
1651 1771 : if (bHasSrcGeoTransform && bHasDstGeoTransform &&
1652 3809 : psOptions->dfXRes != 0.0 && !psOptions->osResampling.empty() &&
1653 8 : !EQUALN(psOptions->osResampling.c_str(), "NEAR", 4))
1654 : {
1655 8 : dstWin.dfXSize = psOptions->srcWin.dfXSize * srcGT[1] / dstGT[1];
1656 8 : dstWin.dfYSize = psOptions->srcWin.dfYSize * fabs(srcGT[5] / dstGT[5]);
1657 : }
1658 :
1659 2030 : GDALTranslateOptions::PixelLineWindow srcWinOri(psOptions->srcWin);
1660 : const double dfRatioX =
1661 2030 : poSrcDS->GetRasterXSize() == 0
1662 2030 : ? 1.0
1663 2030 : : static_cast<double>(poSrcDSOri->GetRasterXSize()) /
1664 2030 : poSrcDS->GetRasterXSize();
1665 : const double dfRatioY =
1666 2030 : poSrcDS->GetRasterYSize() == 0
1667 2030 : ? 1.0
1668 2030 : : static_cast<double>(poSrcDSOri->GetRasterYSize()) /
1669 2030 : poSrcDS->GetRasterYSize();
1670 2030 : psOptions->srcWin.dfXOff /= dfRatioX;
1671 2030 : psOptions->srcWin.dfYOff /= dfRatioY;
1672 2030 : psOptions->srcWin.dfXSize /= dfRatioX;
1673 2030 : psOptions->srcWin.dfYSize /= dfRatioY;
1674 2030 : FixSrcDstWindow(psOptions->srcWin, dstWin, poSrcDS->GetRasterXSize(),
1675 : poSrcDS->GetRasterYSize());
1676 :
1677 : /* -------------------------------------------------------------------- */
1678 : /* Transfer generally applicable metadata. */
1679 : /* -------------------------------------------------------------------- */
1680 2030 : char **papszMetadata = CSLDuplicate(poSrcDS->GetMetadata());
1681 3972 : if (!psOptions->asScaleParams.empty() || psOptions->bUnscale ||
1682 1942 : psOptions->eOutputType != GDT_Unknown)
1683 : {
1684 : /* Remove TIFFTAG_MINSAMPLEVALUE and TIFFTAG_MAXSAMPLEVALUE */
1685 : /* if the data range may change because of options */
1686 410 : char **papszIter = papszMetadata;
1687 796 : while (papszIter && *papszIter)
1688 : {
1689 386 : if (STARTS_WITH_CI(*papszIter, "TIFFTAG_MINSAMPLEVALUE=") ||
1690 386 : STARTS_WITH_CI(*papszIter, "TIFFTAG_MAXSAMPLEVALUE="))
1691 : {
1692 0 : CPLFree(*papszIter);
1693 0 : memmove(papszIter, papszIter + 1,
1694 0 : sizeof(char *) * (CSLCount(papszIter + 1) + 1));
1695 : }
1696 : else
1697 386 : papszIter++;
1698 : }
1699 : }
1700 :
1701 : // Remove NITF_BLOCKA_ stuff if georeferencing is changed
1702 2974 : if (!(psOptions->srcWin.dfXOff == 0 && psOptions->srcWin.dfYOff == 0 &&
1703 944 : psOptions->srcWin.dfXSize == poSrcDS->GetRasterXSize() &&
1704 847 : psOptions->srcWin.dfYSize == poSrcDS->GetRasterYSize() &&
1705 842 : psOptions->asGCPs.empty() && !bGotBounds && !bGotGeoTransform))
1706 : {
1707 1219 : char **papszIter = papszMetadata;
1708 3453 : while (papszIter && *papszIter)
1709 : {
1710 2234 : if (STARTS_WITH_CI(*papszIter, "NITF_BLOCKA_"))
1711 : {
1712 10 : CPLFree(*papszIter);
1713 10 : memmove(papszIter, papszIter + 1,
1714 10 : sizeof(char *) * (CSLCount(papszIter + 1) + 1));
1715 : }
1716 : else
1717 2224 : papszIter++;
1718 : }
1719 : }
1720 :
1721 : {
1722 2030 : char **papszIter = papszMetadata;
1723 5220 : while (papszIter && *papszIter)
1724 : {
1725 : // Do not preserve the CACHE_PATH from the WMS driver
1726 3190 : if (STARTS_WITH_CI(*papszIter, "CACHE_PATH="))
1727 : {
1728 0 : CPLFree(*papszIter);
1729 0 : memmove(papszIter, papszIter + 1,
1730 0 : sizeof(char *) * (CSLCount(papszIter + 1) + 1));
1731 : }
1732 : else
1733 3190 : papszIter++;
1734 : }
1735 : }
1736 :
1737 2035 : if (CSLFetchNameValue(papszMetadata, "NODATA_VALUES") &&
1738 5 : !(bAllBandsInOrder &&
1739 1 : psOptions->nBandCount == poSrcDS->GetRasterCount()))
1740 : {
1741 : papszMetadata =
1742 4 : CSLSetNameValue(papszMetadata, "NODATA_VALUES", nullptr);
1743 : }
1744 :
1745 2030 : poVDS->SetMetadata(papszMetadata);
1746 2030 : CSLDestroy(papszMetadata);
1747 2030 : AttachMetadata(GDALDataset::ToHandle(poVDS), psOptions->aosMetadataOptions);
1748 :
1749 2030 : AttachDomainMetadata(GDALDataset::ToHandle(poVDS),
1750 2030 : psOptions->aosDomainMetadataOptions);
1751 :
1752 : const char *pszInterleave =
1753 2030 : poSrcDS->GetMetadataItem("INTERLEAVE", "IMAGE_STRUCTURE");
1754 2030 : if (pszInterleave)
1755 1827 : poVDS->SetMetadataItem("INTERLEAVE", pszInterleave, "IMAGE_STRUCTURE");
1756 :
1757 : {
1758 : const char *pszCompression =
1759 2030 : poSrcDS->GetMetadataItem("COMPRESSION", "IMAGE_STRUCTURE");
1760 2030 : if (pszCompression)
1761 : {
1762 57 : poVDS->SetMetadataItem("COMPRESSION", pszCompression,
1763 57 : "IMAGE_STRUCTURE");
1764 : }
1765 : }
1766 :
1767 : /* ISIS3 metadata preservation */
1768 2030 : CSLConstList papszMD_ISIS3 = poSrcDS->GetMetadata("json:ISIS3");
1769 2030 : if (papszMD_ISIS3 != nullptr && papszMD_ISIS3[0])
1770 : {
1771 8 : std::string osJSON = papszMD_ISIS3[0];
1772 4 : if (!bAllBandsInOrder)
1773 : {
1774 2 : osJSON = EditISIS3MetadataForBandChange(
1775 2 : osJSON.c_str(), poSrcDS->GetRasterCount(), psOptions.get());
1776 : }
1777 4 : if (!bSpatialArrangementPreserved || bValuesChanged)
1778 : {
1779 4 : osJSON = EditISIS3ForMetadataChanges(
1780 4 : osJSON.c_str(), bKeepExtent, bKeepResolution, psOptions.get());
1781 : }
1782 4 : if (!osJSON.empty())
1783 : {
1784 4 : char *apszMD[] = {osJSON.data(), nullptr};
1785 4 : poVDS->SetMetadata(apszMD, "json:ISIS3");
1786 : }
1787 : }
1788 :
1789 : // PDS4 -> PDS4 special case
1790 2030 : if (EQUAL(psOptions->osFormat.c_str(), "PDS4"))
1791 : {
1792 3 : CSLConstList papszMD_PDS4 = poSrcDS->GetMetadata("xml:PDS4");
1793 3 : if (papszMD_PDS4 != nullptr)
1794 2 : poVDS->SetMetadata(papszMD_PDS4, "xml:PDS4");
1795 : }
1796 :
1797 : // VICAR -> VICAR special case
1798 2030 : if (EQUAL(psOptions->osFormat.c_str(), "VICAR"))
1799 : {
1800 0 : CSLConstList papszMD_VICAR = poSrcDS->GetMetadata("json:VICAR");
1801 0 : if (papszMD_VICAR != nullptr)
1802 0 : poVDS->SetMetadata(papszMD_VICAR, "json:VICAR");
1803 : }
1804 :
1805 : // Copy XMP metadata
1806 2030 : if (!psOptions->bNoXMP)
1807 : {
1808 2028 : CSLConstList papszXMP = poSrcDS->GetMetadata("xml:XMP");
1809 2028 : if (papszXMP != nullptr && *papszXMP != nullptr)
1810 : {
1811 1 : poVDS->SetMetadata(papszXMP, "xml:XMP");
1812 : }
1813 : }
1814 :
1815 : /* -------------------------------------------------------------------- */
1816 : /* Transfer metadata that remains valid if the spatial */
1817 : /* arrangement of the data is unaltered. */
1818 : /* -------------------------------------------------------------------- */
1819 2030 : if (bSpatialArrangementPreserved)
1820 : {
1821 606 : CSLConstList papszMD = poSrcDS->GetMetadata("RPC");
1822 606 : if (papszMD != nullptr)
1823 2 : poVDS->SetMetadata(papszMD, "RPC");
1824 :
1825 606 : papszMD = poSrcDS->GetMetadata("GEOLOCATION");
1826 606 : if (papszMD != nullptr)
1827 1 : poVDS->SetMetadata(papszMD, "GEOLOCATION");
1828 : }
1829 : else
1830 : {
1831 2848 : CPLStringList aosMD(poSrcDSOri->GetMetadata("RPC"));
1832 1424 : if (!aosMD.empty())
1833 : {
1834 : double dfSAMP_OFF =
1835 2 : CPLAtof(aosMD.FetchNameValueDef("SAMP_OFF", "0"));
1836 : double dfLINE_OFF =
1837 2 : CPLAtof(aosMD.FetchNameValueDef("LINE_OFF", "0"));
1838 : double dfSAMP_SCALE =
1839 2 : CPLAtof(aosMD.FetchNameValueDef("SAMP_SCALE", "1"));
1840 : double dfLINE_SCALE =
1841 2 : CPLAtof(aosMD.FetchNameValueDef("LINE_SCALE", "1"));
1842 :
1843 2 : dfSAMP_OFF -= srcWinOri.dfXOff;
1844 2 : dfLINE_OFF -= srcWinOri.dfYOff;
1845 :
1846 2 : const double df2 = srcWinOri.dfXSize;
1847 2 : const double df3 = srcWinOri.dfYSize;
1848 2 : const double dfXRatio = nOXSize / df2;
1849 2 : const double dfYRatio = nOYSize / df3;
1850 :
1851 : // For line offset and pixel offset, we need to convert from RPC
1852 : // pixel center registration convention to GDAL pixel top-left corner
1853 : // registration convention by adding an initial 0.5 shift, and un-apply
1854 : // it after scaling.
1855 :
1856 2 : dfSAMP_OFF += 0.5;
1857 2 : dfSAMP_OFF *= dfXRatio;
1858 2 : dfSAMP_OFF -= 0.5;
1859 :
1860 2 : dfLINE_OFF += 0.5;
1861 2 : dfLINE_OFF *= dfYRatio;
1862 2 : dfLINE_OFF -= 0.5;
1863 :
1864 2 : dfSAMP_SCALE *= dfXRatio;
1865 2 : dfLINE_SCALE *= dfYRatio;
1866 :
1867 4 : CPLString osField;
1868 2 : osField.Printf("%.15g", dfLINE_OFF);
1869 2 : aosMD.SetNameValue("LINE_OFF", osField);
1870 :
1871 2 : osField.Printf("%.15g", dfSAMP_OFF);
1872 2 : aosMD.SetNameValue("SAMP_OFF", osField);
1873 :
1874 2 : osField.Printf("%.15g", dfLINE_SCALE);
1875 2 : aosMD.SetNameValue("LINE_SCALE", osField);
1876 :
1877 2 : osField.Printf("%.15g", dfSAMP_SCALE);
1878 2 : aosMD.SetNameValue("SAMP_SCALE", osField);
1879 :
1880 2 : poVDS->SetMetadata(aosMD.List(), "RPC");
1881 : }
1882 : }
1883 :
1884 2030 : const int nSrcBandCount = psOptions->nBandCount;
1885 :
1886 2030 : if (psOptions->nRGBExpand != 0)
1887 : {
1888 : GDALRasterBand *poSrcBand =
1889 29 : poSrcDS->GetRasterBand(std::abs(psOptions->anBandList[0]));
1890 29 : if (psOptions->anBandList[0] < 0)
1891 0 : poSrcBand = poSrcBand->GetMaskBand();
1892 29 : GDALColorTable *poColorTable = poSrcBand->GetColorTable();
1893 29 : if (poColorTable == nullptr)
1894 : {
1895 0 : CPLError(CE_Failure, CPLE_AppDefined,
1896 : "Error : band %d has no color table",
1897 0 : std::abs(psOptions->anBandList[0]));
1898 0 : GDALClose(poVDS);
1899 0 : return nullptr;
1900 : }
1901 :
1902 : /* Check that the color table only contains gray levels */
1903 : /* when using -expand gray */
1904 29 : if (psOptions->nRGBExpand == 1)
1905 : {
1906 1 : int nColorCount = poColorTable->GetColorEntryCount();
1907 3 : for (int nColor = 0; nColor < nColorCount; nColor++)
1908 : {
1909 : const GDALColorEntry *poEntry =
1910 2 : poColorTable->GetColorEntry(nColor);
1911 2 : if (poEntry->c1 != poEntry->c2 || poEntry->c1 != poEntry->c3)
1912 : {
1913 0 : CPLError(CE_Warning, CPLE_AppDefined,
1914 : "Warning : color table contains non gray levels "
1915 : "colors");
1916 0 : break;
1917 : }
1918 : }
1919 : }
1920 :
1921 29 : if (psOptions->nBandCount == 1)
1922 : {
1923 28 : psOptions->nBandCount = psOptions->nRGBExpand;
1924 : }
1925 2 : else if (psOptions->nBandCount == 2 &&
1926 1 : (psOptions->nRGBExpand == 3 || psOptions->nRGBExpand == 4))
1927 : {
1928 1 : psOptions->nBandCount = psOptions->nRGBExpand;
1929 : }
1930 : else
1931 : {
1932 0 : CPLError(CE_Failure, CPLE_IllegalArg,
1933 : "Error : invalid use of -expand option.");
1934 0 : GDALClose(poVDS);
1935 0 : return nullptr;
1936 : }
1937 : }
1938 :
1939 : // Can be set to TRUE in the band loop too
1940 1942 : bool bFilterOutStatsMetadata = bValuesChanged ||
1941 2564 : !bSpatialArrangementPreserved ||
1942 534 : psOptions->nRGBExpand != 0;
1943 :
1944 2030 : if (static_cast<int>(psOptions->anColorInterp.size()) >
1945 2030 : psOptions->nBandCount)
1946 : {
1947 1 : CPLError(CE_Warning, CPLE_AppDefined,
1948 : "More bands defined in -colorinterp than output bands");
1949 : }
1950 :
1951 : /* ==================================================================== */
1952 : /* Process all bands. */
1953 : /* ==================================================================== */
1954 2030 : GDALDataType eOutputType = psOptions->eOutputType;
1955 :
1956 6818 : for (int i = 0; i < psOptions->nBandCount; i++)
1957 : {
1958 4789 : int nComponent = 0;
1959 4789 : int nSrcBand = 0;
1960 :
1961 4789 : if (psOptions->nRGBExpand != 0)
1962 : {
1963 97 : if (nSrcBandCount == 2 && psOptions->nRGBExpand == 4 && i == 3)
1964 1 : nSrcBand = psOptions->anBandList[1];
1965 : else
1966 : {
1967 96 : nSrcBand = psOptions->anBandList[0];
1968 96 : nComponent = i + 1;
1969 : }
1970 : }
1971 : else
1972 : {
1973 4692 : nSrcBand = psOptions->anBandList[i];
1974 : }
1975 :
1976 4789 : GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand(std::abs(nSrcBand));
1977 :
1978 : /* --------------------------------------------------------------------
1979 : */
1980 : /* Select output data type to match source. */
1981 : /* --------------------------------------------------------------------
1982 : */
1983 : GDALRasterBand *poRealSrcBand =
1984 4789 : (nSrcBand < 0) ? poSrcBand->GetMaskBand() : poSrcBand;
1985 : GDALDataType eBandType;
1986 4789 : if (eOutputType == GDT_Unknown)
1987 : {
1988 4128 : eBandType = poRealSrcBand->GetRasterDataType();
1989 4128 : if (eBandType != GDT_UInt8 && psOptions->nRGBExpand != 0)
1990 : {
1991 : // Use case of https://github.com/OSGeo/gdal/issues/9402
1992 5 : if (const auto poColorTable = poRealSrcBand->GetColorTable())
1993 : {
1994 5 : bool bIn0To255Range = true;
1995 5 : const int nColorCount = poColorTable->GetColorEntryCount();
1996 6 : for (int nColor = 0; nColor < nColorCount; nColor++)
1997 : {
1998 : const GDALColorEntry *poEntry =
1999 5 : poColorTable->GetColorEntry(nColor);
2000 5 : if (poEntry->c1 > 255 || poEntry->c2 > 255 ||
2001 3 : poEntry->c3 > 255 || poEntry->c4 > 255)
2002 : {
2003 4 : bIn0To255Range = false;
2004 4 : break;
2005 : }
2006 : }
2007 5 : if (bIn0To255Range)
2008 : {
2009 1 : if (!psOptions->bQuiet)
2010 : {
2011 1 : CPLError(CE_Warning, CPLE_AppDefined,
2012 : "Using Byte output data type due to range "
2013 : "of values in color table");
2014 : }
2015 1 : eBandType = GDT_UInt8;
2016 : }
2017 : }
2018 5 : eOutputType = eBandType;
2019 : }
2020 : }
2021 : else
2022 : {
2023 661 : eBandType = eOutputType;
2024 :
2025 : // Check that we can copy existing statistics
2026 661 : GDALDataType eSrcBandType = poRealSrcBand->GetRasterDataType();
2027 : const char *pszMin =
2028 661 : poRealSrcBand->GetMetadataItem("STATISTICS_MINIMUM");
2029 : const char *pszMax =
2030 661 : poRealSrcBand->GetMetadataItem("STATISTICS_MAXIMUM");
2031 661 : if (!bFilterOutStatsMetadata && eBandType != eSrcBandType &&
2032 4 : pszMin != nullptr && pszMax != nullptr)
2033 : {
2034 : const bool bSrcIsInteger =
2035 8 : CPL_TO_BOOL(GDALDataTypeIsInteger(eSrcBandType) &&
2036 4 : !GDALDataTypeIsComplex(eSrcBandType));
2037 : const bool bDstIsInteger =
2038 7 : CPL_TO_BOOL(GDALDataTypeIsInteger(eBandType) &&
2039 3 : !GDALDataTypeIsComplex(eBandType));
2040 4 : if (bSrcIsInteger && bDstIsInteger)
2041 : {
2042 3 : std::int64_t nDstMin = 0;
2043 3 : std::uint64_t nDstMax = 0;
2044 3 : switch (eBandType)
2045 : {
2046 1 : case GDT_UInt8:
2047 1 : nDstMin = std::numeric_limits<std::uint8_t>::min();
2048 1 : nDstMax = std::numeric_limits<std::uint8_t>::max();
2049 1 : break;
2050 0 : case GDT_Int8:
2051 0 : nDstMin = std::numeric_limits<std::int8_t>::min();
2052 0 : nDstMax = std::numeric_limits<std::int8_t>::max();
2053 0 : break;
2054 2 : case GDT_UInt16:
2055 2 : nDstMin = std::numeric_limits<std::uint16_t>::min();
2056 2 : nDstMax = std::numeric_limits<std::uint16_t>::max();
2057 2 : break;
2058 0 : case GDT_Int16:
2059 0 : nDstMin = std::numeric_limits<std::int16_t>::min();
2060 0 : nDstMax = std::numeric_limits<std::int16_t>::max();
2061 0 : break;
2062 0 : case GDT_UInt32:
2063 0 : nDstMin = std::numeric_limits<std::uint32_t>::min();
2064 0 : nDstMax = std::numeric_limits<std::uint32_t>::max();
2065 0 : break;
2066 0 : case GDT_Int32:
2067 0 : nDstMin = std::numeric_limits<std::int32_t>::min();
2068 0 : nDstMax = std::numeric_limits<std::int32_t>::max();
2069 0 : break;
2070 0 : case GDT_UInt64:
2071 0 : nDstMin = std::numeric_limits<std::uint64_t>::min();
2072 0 : nDstMax = std::numeric_limits<std::uint64_t>::max();
2073 0 : break;
2074 0 : case GDT_Int64:
2075 0 : nDstMin = std::numeric_limits<std::int64_t>::min();
2076 0 : nDstMax = std::numeric_limits<std::int64_t>::max();
2077 0 : break;
2078 0 : default:
2079 0 : CPLAssert(false);
2080 : break;
2081 : }
2082 :
2083 : try
2084 : {
2085 3 : const auto nMin = std::stoll(pszMin);
2086 3 : const auto nMax = std::stoull(pszMax);
2087 3 : if (nMin < nDstMin || nMax > nDstMax)
2088 1 : bFilterOutStatsMetadata = true;
2089 : }
2090 0 : catch (const std::exception &)
2091 : {
2092 3 : }
2093 : }
2094 : // Float64 is large enough to hold all integer <= 32 bit or
2095 : // float32 values there might be other OK cases, but ere on safe
2096 : // side for now
2097 1 : else if (!((bSrcIsInteger || eSrcBandType == GDT_Float32) &&
2098 : eBandType == GDT_Float64))
2099 : {
2100 0 : bFilterOutStatsMetadata = true;
2101 : }
2102 : }
2103 : }
2104 :
2105 : /* --------------------------------------------------------------------
2106 : */
2107 : /* Create this band. */
2108 : /* --------------------------------------------------------------------
2109 : */
2110 4789 : CPLStringList aosAddBandOptions;
2111 : int nSrcBlockXSize, nSrcBlockYSize;
2112 4789 : poSrcBand->GetBlockSize(&nSrcBlockXSize, &nSrcBlockYSize);
2113 4287 : if (bKeepResolution &&
2114 9076 : (fmod(psOptions->srcWin.dfXOff, nSrcBlockXSize)) == 0 &&
2115 1798 : (fmod(psOptions->srcWin.dfYOff, nSrcBlockYSize)) == 0)
2116 : {
2117 : aosAddBandOptions.SetNameValue("BLOCKXSIZE",
2118 1390 : CPLSPrintf("%d", nSrcBlockXSize));
2119 : aosAddBandOptions.SetNameValue("BLOCKYSIZE",
2120 1390 : CPLSPrintf("%d", nSrcBlockYSize));
2121 : }
2122 : const char *pszBlockXSize =
2123 4789 : psOptions->aosCreateOptions.FetchNameValue("BLOCKXSIZE");
2124 4789 : if (pszBlockXSize)
2125 58 : aosAddBandOptions.SetNameValue("BLOCKXSIZE", pszBlockXSize);
2126 : const char *pszBlockYSize =
2127 4789 : psOptions->aosCreateOptions.FetchNameValue("BLOCKYSIZE");
2128 4789 : if (pszBlockYSize)
2129 76 : aosAddBandOptions.SetNameValue("BLOCKYSIZE", pszBlockYSize);
2130 4789 : poVDS->AddBand(eBandType, aosAddBandOptions.List());
2131 : VRTSourcedRasterBand *poVRTBand =
2132 4789 : static_cast<VRTSourcedRasterBand *>(poVDS->GetRasterBand(i + 1));
2133 :
2134 4789 : if (nSrcBand < 0)
2135 : {
2136 16 : poVRTBand->AddMaskBandSource(
2137 16 : poSrcBand, psOptions->srcWin.dfXOff, psOptions->srcWin.dfYOff,
2138 16 : psOptions->srcWin.dfXSize, psOptions->srcWin.dfYSize,
2139 : dstWin.dfXOff, dstWin.dfYOff, dstWin.dfXSize, dstWin.dfYSize);
2140 :
2141 16 : poVRTBand->SetColorInterpretation(GCI_AlphaBand);
2142 :
2143 : // Color interpretation override
2144 16 : if (!psOptions->anColorInterp.empty())
2145 : {
2146 18 : if (i < static_cast<int>(psOptions->anColorInterp.size()) &&
2147 9 : psOptions->anColorInterp[i] >= 0)
2148 : {
2149 9 : poVRTBand->SetColorInterpretation(
2150 : static_cast<GDALColorInterp>(
2151 9 : psOptions->anColorInterp[i]));
2152 : }
2153 : }
2154 :
2155 16 : continue;
2156 : }
2157 :
2158 : // Preserve NBITS if no option change values
2159 : const char *pszNBits =
2160 4773 : poSrcBand->GetMetadataItem("NBITS", "IMAGE_STRUCTURE");
2161 27 : if (pszNBits && psOptions->nRGBExpand == 0 &&
2162 26 : psOptions->asScaleParams.empty() && !psOptions->bUnscale &&
2163 4800 : psOptions->eOutputType == GDT_Unknown &&
2164 13 : psOptions->osResampling.empty())
2165 : {
2166 1 : poVRTBand->SetMetadataItem("NBITS", pszNBits, "IMAGE_STRUCTURE");
2167 : }
2168 :
2169 : // Preserve PIXELTYPE if no option change values
2170 4773 : if (poSrcBand->GetRasterDataType() == GDT_UInt8 &&
2171 4518 : psOptions->nRGBExpand == 0 && psOptions->asScaleParams.empty() &&
2172 13142 : !psOptions->bUnscale && psOptions->eOutputType == GDT_Unknown &&
2173 3851 : psOptions->osResampling.empty())
2174 : {
2175 3682 : poSrcBand->EnablePixelTypeSignedByteWarning(false);
2176 : const char *pszPixelType =
2177 3682 : poSrcBand->GetMetadataItem("PIXELTYPE", "IMAGE_STRUCTURE");
2178 3682 : poSrcBand->EnablePixelTypeSignedByteWarning(true);
2179 3682 : if (pszPixelType)
2180 : {
2181 1 : poVRTBand->SetMetadataItem("PIXELTYPE", pszPixelType,
2182 1 : "IMAGE_STRUCTURE");
2183 : }
2184 : }
2185 :
2186 : const char *pszCompression =
2187 4773 : poSrcBand->GetMetadataItem("COMPRESSION", "IMAGE_STRUCTURE");
2188 4773 : if (pszCompression)
2189 : {
2190 9 : poVRTBand->SetMetadataItem("COMPRESSION", pszCompression,
2191 9 : "IMAGE_STRUCTURE");
2192 : }
2193 :
2194 : /* --------------------------------------------------------------------
2195 : */
2196 : /* Do we need to collect scaling information? */
2197 : /* --------------------------------------------------------------------
2198 : */
2199 4773 : double dfScale = 1.0;
2200 4773 : double dfOffset = 0.0;
2201 4773 : bool bScale = false;
2202 4773 : double dfScaleSrcMin = std::numeric_limits<double>::quiet_NaN();
2203 4773 : double dfScaleSrcMax = std::numeric_limits<double>::quiet_NaN();
2204 4773 : double dfScaleDstMin = std::numeric_limits<double>::quiet_NaN();
2205 4773 : double dfScaleDstMax = std::numeric_limits<double>::quiet_NaN();
2206 4773 : bool bExponentScaling = false;
2207 4773 : double dfExponent = 0.0;
2208 :
2209 4855 : if (i < static_cast<int>(psOptions->asScaleParams.size()) &&
2210 82 : psOptions->asScaleParams[i].bScale)
2211 : {
2212 71 : bScale = psOptions->asScaleParams[i].bScale;
2213 71 : dfScaleSrcMin = psOptions->asScaleParams[i].dfScaleSrcMin;
2214 71 : dfScaleSrcMax = psOptions->asScaleParams[i].dfScaleSrcMax;
2215 71 : dfScaleDstMin = psOptions->asScaleParams[i].dfScaleDstMin;
2216 71 : dfScaleDstMax = psOptions->asScaleParams[i].dfScaleDstMax;
2217 : }
2218 4741 : else if (psOptions->asScaleParams.size() == 1 &&
2219 39 : !psOptions->bHasUsedExplicitScaleBand)
2220 : {
2221 38 : bScale = psOptions->asScaleParams[0].bScale;
2222 38 : dfScaleSrcMin = psOptions->asScaleParams[0].dfScaleSrcMin;
2223 38 : dfScaleSrcMax = psOptions->asScaleParams[0].dfScaleSrcMax;
2224 38 : dfScaleDstMin = psOptions->asScaleParams[0].dfScaleDstMin;
2225 38 : dfScaleDstMax = psOptions->asScaleParams[0].dfScaleDstMax;
2226 : }
2227 :
2228 4800 : if (i < static_cast<int>(psOptions->adfExponent.size()) &&
2229 27 : psOptions->adfExponent[i] != 0.0)
2230 : {
2231 24 : bExponentScaling = TRUE;
2232 24 : dfExponent = psOptions->adfExponent[i];
2233 : }
2234 4753 : else if (psOptions->adfExponent.size() == 1 &&
2235 4 : !psOptions->bHasUsedExplicitExponentBand)
2236 : {
2237 3 : bExponentScaling = TRUE;
2238 3 : dfExponent = psOptions->adfExponent[0];
2239 : }
2240 :
2241 4773 : if (bExponentScaling && !bScale)
2242 : {
2243 1 : CPLError(CE_Failure, CPLE_IllegalArg,
2244 : "For band %d, -scale should be specified when -exponent "
2245 : "is specified.",
2246 : i + 1);
2247 1 : if (pbUsageError)
2248 0 : *pbUsageError = TRUE;
2249 1 : delete poVDS;
2250 1 : poSrcDS->Release();
2251 1 : return nullptr;
2252 : }
2253 :
2254 4772 : if (bScale && std::isnan(dfScaleSrcMin))
2255 : {
2256 13 : double adfCMinMax[2] = {};
2257 13 : GDALComputeRasterMinMax(poSrcBand, TRUE, adfCMinMax);
2258 13 : dfScaleSrcMin = adfCMinMax[0];
2259 13 : dfScaleSrcMax = adfCMinMax[1];
2260 : }
2261 :
2262 4772 : if (bScale)
2263 : {
2264 : /* To avoid a divide by zero */
2265 109 : if (dfScaleSrcMax == dfScaleSrcMin)
2266 0 : dfScaleSrcMax += 0.1;
2267 :
2268 : // Can still occur for very big values
2269 109 : if (dfScaleSrcMax == dfScaleSrcMin)
2270 : {
2271 0 : CPLError(CE_Failure, CPLE_AppDefined,
2272 : "-scale cannot be applied due to source "
2273 : "minimum and maximum being equal");
2274 0 : delete poVDS;
2275 0 : poSrcDS->Release();
2276 0 : return nullptr;
2277 : }
2278 :
2279 109 : if (std::isnan(dfScaleDstMin))
2280 : {
2281 16 : switch (poVRTBand->GetRasterDataType())
2282 : {
2283 5 : case GDT_UInt8:
2284 5 : dfScaleDstMin = std::numeric_limits<uint8_t>::lowest();
2285 5 : dfScaleDstMax = std::numeric_limits<uint8_t>::max();
2286 5 : break;
2287 1 : case GDT_Int8:
2288 1 : dfScaleDstMin = std::numeric_limits<int8_t>::lowest();
2289 1 : dfScaleDstMax = std::numeric_limits<int8_t>::max();
2290 1 : break;
2291 1 : case GDT_UInt16:
2292 1 : dfScaleDstMin = std::numeric_limits<uint16_t>::lowest();
2293 1 : dfScaleDstMax = std::numeric_limits<uint16_t>::max();
2294 1 : break;
2295 1 : case GDT_Int16:
2296 : case GDT_CInt16:
2297 1 : dfScaleDstMin = std::numeric_limits<int16_t>::lowest();
2298 1 : dfScaleDstMax = std::numeric_limits<int16_t>::max();
2299 1 : break;
2300 1 : case GDT_UInt32:
2301 1 : dfScaleDstMin = std::numeric_limits<uint32_t>::lowest();
2302 1 : dfScaleDstMax = std::numeric_limits<uint32_t>::max();
2303 1 : break;
2304 1 : case GDT_Int32:
2305 : case GDT_CInt32:
2306 1 : dfScaleDstMin = std::numeric_limits<int32_t>::lowest();
2307 1 : dfScaleDstMax = std::numeric_limits<int32_t>::max();
2308 1 : break;
2309 1 : case GDT_UInt64:
2310 1 : dfScaleDstMin = static_cast<double>(
2311 1 : std::numeric_limits<uint64_t>::lowest());
2312 1 : dfScaleDstMax = static_cast<double>(
2313 1 : std::numeric_limits<uint64_t>::max() - 2048);
2314 1 : break;
2315 1 : case GDT_Int64:
2316 1 : dfScaleDstMin = static_cast<double>(
2317 1 : std::numeric_limits<int64_t>::lowest() + 1024);
2318 1 : dfScaleDstMax = static_cast<double>(
2319 1 : std::numeric_limits<int64_t>::max() - 2048);
2320 1 : break;
2321 4 : case GDT_Float16:
2322 : case GDT_Float32:
2323 : case GDT_Float64:
2324 : case GDT_CFloat16:
2325 : case GDT_CFloat32:
2326 : case GDT_CFloat64:
2327 : case GDT_Unknown:
2328 : case GDT_TypeCount:
2329 4 : dfScaleDstMin = 0;
2330 4 : dfScaleDstMax = 1;
2331 4 : break;
2332 : }
2333 : }
2334 :
2335 109 : if (!bExponentScaling)
2336 : {
2337 83 : dfScale = (dfScaleDstMax - dfScaleDstMin) /
2338 83 : (dfScaleSrcMax - dfScaleSrcMin);
2339 83 : dfOffset = -1 * dfScaleSrcMin * dfScale + dfScaleDstMin;
2340 : }
2341 : }
2342 :
2343 4772 : if (psOptions->bUnscale)
2344 : {
2345 25 : dfScale = poSrcBand->GetScale();
2346 25 : dfOffset = poSrcBand->GetOffset();
2347 : }
2348 :
2349 : /* --------------------------------------------------------------------
2350 : */
2351 : /* Create a simple or complex data source depending on the */
2352 : /* translation type required. */
2353 : /* --------------------------------------------------------------------
2354 : */
2355 4772 : std::unique_ptr<VRTSimpleSource> poSimpleSource;
2356 9410 : if (psOptions->bUnscale || bScale ||
2357 4638 : (psOptions->nRGBExpand != 0 && i < psOptions->nRGBExpand))
2358 : {
2359 462 : auto poComplexSource = std::make_unique<VRTComplexSource>();
2360 :
2361 : /* --------------------------------------------------------------------
2362 : */
2363 : /* Set complex parameters. */
2364 : /* --------------------------------------------------------------------
2365 : */
2366 :
2367 231 : if (dfOffset != 0.0 || dfScale != 1.0)
2368 : {
2369 99 : poComplexSource->SetLinearScaling(dfOffset, dfScale);
2370 : }
2371 132 : else if (bExponentScaling)
2372 : {
2373 26 : poComplexSource->SetPowerScaling(
2374 : dfExponent, dfScaleSrcMin, dfScaleSrcMax, dfScaleDstMin,
2375 26 : dfScaleDstMax, !psOptions->bNoClip);
2376 : }
2377 :
2378 231 : poComplexSource->SetColorTableComponent(nComponent);
2379 :
2380 : int bSuccess;
2381 231 : double dfNoData = poSrcBand->GetNoDataValue(&bSuccess);
2382 231 : if (bSuccess)
2383 : {
2384 20 : poComplexSource->SetNoDataValue(dfNoData);
2385 : }
2386 :
2387 231 : poSimpleSource = std::move(poComplexSource);
2388 : }
2389 : else
2390 : {
2391 4541 : poSimpleSource = std::make_unique<VRTSimpleSource>();
2392 : }
2393 :
2394 4958 : poSimpleSource->SetResampling(psOptions->osResampling.empty()
2395 : ? nullptr
2396 186 : : psOptions->osResampling.c_str());
2397 4772 : poVRTBand->ConfigureSource(
2398 4772 : poSimpleSource.get(), poSrcBand, FALSE, psOptions->srcWin.dfXOff,
2399 4772 : psOptions->srcWin.dfYOff, psOptions->srcWin.dfXSize,
2400 4772 : psOptions->srcWin.dfYSize, dstWin.dfXOff, dstWin.dfYOff,
2401 : dstWin.dfXSize, dstWin.dfYSize);
2402 :
2403 4772 : poVRTBand->AddSource(std::move(poSimpleSource));
2404 :
2405 : /* --------------------------------------------------------------------
2406 : */
2407 : /* In case of color table translate, we only set the color */
2408 : /* interpretation other info copied by CopyBandInfo are */
2409 : /* not relevant in RGB expansion. */
2410 : /* --------------------------------------------------------------------
2411 : */
2412 4772 : if (psOptions->nRGBExpand == 1)
2413 : {
2414 1 : poVRTBand->SetColorInterpretation(GCI_GrayIndex);
2415 : }
2416 4771 : else if (psOptions->nRGBExpand != 0 && i < psOptions->nRGBExpand)
2417 : {
2418 96 : poVRTBand->SetColorInterpretation(
2419 96 : static_cast<GDALColorInterp>(GCI_RedBand + i));
2420 : }
2421 :
2422 : /* --------------------------------------------------------------------
2423 : */
2424 : /* copy over some other information of interest. */
2425 : /* --------------------------------------------------------------------
2426 : */
2427 : else
2428 : {
2429 4675 : CopyBandInfo(poSrcBand, poVRTBand,
2430 4675 : !psOptions->bStats && !bFilterOutStatsMetadata,
2431 9322 : !psOptions->bUnscale && !psOptions->bSetScale &&
2432 4647 : !psOptions->bSetOffset,
2433 4675 : !psOptions->bSetNoData && !psOptions->bUnsetNoData,
2434 4675 : !psOptions->bNoRAT, psOptions.get());
2435 9227 : if (psOptions->asScaleParams.empty() &&
2436 9227 : psOptions->adfExponent.empty() &&
2437 4552 : EQUAL(psOptions->osFormat.c_str(), "GRIB"))
2438 : {
2439 0 : CSLConstList papszMD_GRIB = poSrcBand->GetMetadata("GRIB");
2440 0 : if (papszMD_GRIB != nullptr)
2441 0 : poVRTBand->SetMetadata(papszMD_GRIB, "GRIB");
2442 : }
2443 : }
2444 :
2445 : // Color interpretation override
2446 4772 : if (!psOptions->anColorInterp.empty())
2447 : {
2448 126 : if (i < static_cast<int>(psOptions->anColorInterp.size()) &&
2449 62 : psOptions->anColorInterp[i] >= 0)
2450 : {
2451 37 : poVRTBand->SetColorInterpretation(
2452 37 : static_cast<GDALColorInterp>(psOptions->anColorInterp[i]));
2453 : }
2454 : }
2455 :
2456 : /* --------------------------------------------------------------------
2457 : */
2458 : /* Set a forcible nodata value? */
2459 : /* --------------------------------------------------------------------
2460 : */
2461 4772 : if (psOptions->bSetNoData)
2462 : {
2463 : const char *pszPixelType =
2464 83 : psOptions->aosCreateOptions.FetchNameValue("PIXELTYPE");
2465 165 : if (pszPixelType == nullptr &&
2466 82 : poVRTBand->GetRasterDataType() == GDT_UInt8)
2467 : {
2468 32 : poVRTBand->EnablePixelTypeSignedByteWarning(false);
2469 : pszPixelType =
2470 32 : poVRTBand->GetMetadataItem("PIXELTYPE", "IMAGE_STRUCTURE");
2471 32 : poVRTBand->EnablePixelTypeSignedByteWarning(true);
2472 : }
2473 :
2474 83 : bool bCannotBeExactlyRepresented = false;
2475 :
2476 83 : if (pszPixelType != nullptr && EQUAL(pszPixelType, "SIGNEDBYTE"))
2477 : {
2478 2 : char *endptr = nullptr;
2479 : const double dfVal =
2480 2 : CPLStrtod(psOptions->osNoData.c_str(), &endptr);
2481 2 : if (endptr == psOptions->osNoData.c_str() +
2482 4 : psOptions->osNoData.size() &&
2483 6 : dfVal >= -128.0 && dfVal <= 127.0 &&
2484 2 : static_cast<int8_t>(dfVal) == dfVal)
2485 : {
2486 2 : poVRTBand->SetNoDataValue(dfVal);
2487 : }
2488 : else
2489 : {
2490 0 : bCannotBeExactlyRepresented = true;
2491 2 : }
2492 : }
2493 : else
2494 : {
2495 81 : poVRTBand->SetNoDataValueAsString(psOptions->osNoData.c_str(),
2496 : &bCannotBeExactlyRepresented);
2497 : }
2498 83 : if (bCannotBeExactlyRepresented)
2499 : {
2500 4 : CPLError(CE_Warning, CPLE_AppDefined,
2501 : "Nodata value was not set to output band, "
2502 : "as it cannot be represented on its data type.");
2503 : }
2504 : }
2505 :
2506 4772 : if (psOptions->bSetScale)
2507 4 : poVRTBand->SetScale(psOptions->dfScale);
2508 :
2509 4772 : if (psOptions->bSetOffset)
2510 5 : poVRTBand->SetOffset(psOptions->dfOffset);
2511 :
2512 4772 : if (psOptions->eMaskMode == MASK_AUTO &&
2513 4666 : (poSrcDS->GetRasterBand(1)->GetMaskFlags() & GMF_PER_DATASET) ==
2514 9438 : 0 &&
2515 4260 : (poSrcBand->GetMaskFlags() & (GMF_ALL_VALID | GMF_NODATA)) == 0)
2516 : {
2517 7 : if (poVRTBand->CreateMaskBand(poSrcBand->GetMaskFlags()) == CE_None)
2518 : {
2519 : VRTSourcedRasterBand *hMaskVRTBand =
2520 7 : cpl::down_cast<VRTSourcedRasterBand *>(
2521 7 : poVRTBand->GetMaskBand());
2522 7 : hMaskVRTBand->AddMaskBandSource(
2523 7 : poSrcBand, psOptions->srcWin.dfXOff,
2524 7 : psOptions->srcWin.dfYOff, psOptions->srcWin.dfXSize,
2525 7 : psOptions->srcWin.dfYSize, dstWin.dfXOff, dstWin.dfYOff,
2526 : dstWin.dfXSize, dstWin.dfYSize);
2527 : }
2528 : }
2529 : }
2530 :
2531 2029 : if (psOptions->eMaskMode == MASK_USER)
2532 : {
2533 : GDALRasterBand *poSrcBand =
2534 25 : poSrcDS->GetRasterBand(std::abs(psOptions->nMaskBand));
2535 25 : if (poSrcBand && poVDS->CreateMaskBand(GMF_PER_DATASET) == CE_None)
2536 : {
2537 : VRTSourcedRasterBand *hMaskVRTBand =
2538 25 : static_cast<VRTSourcedRasterBand *>(GDALGetMaskBand(
2539 : GDALGetRasterBand(static_cast<GDALDataset *>(poVDS), 1)));
2540 25 : if (psOptions->nMaskBand > 0)
2541 23 : hMaskVRTBand->AddSimpleSource(
2542 23 : poSrcBand, psOptions->srcWin.dfXOff,
2543 23 : psOptions->srcWin.dfYOff, psOptions->srcWin.dfXSize,
2544 23 : psOptions->srcWin.dfYSize, dstWin.dfXOff, dstWin.dfYOff,
2545 : dstWin.dfXSize, dstWin.dfYSize);
2546 : else
2547 2 : hMaskVRTBand->AddMaskBandSource(
2548 2 : poSrcBand, psOptions->srcWin.dfXOff,
2549 2 : psOptions->srcWin.dfYOff, psOptions->srcWin.dfXSize,
2550 2 : psOptions->srcWin.dfYSize, dstWin.dfXOff, dstWin.dfYOff,
2551 : dstWin.dfXSize, dstWin.dfYSize);
2552 : }
2553 : }
2554 3990 : else if (psOptions->eMaskMode == MASK_AUTO && nSrcBandCount > 0 &&
2555 1986 : poSrcDS->GetRasterBand(1)->GetMaskFlags() == GMF_PER_DATASET)
2556 : {
2557 4 : if (poVDS->CreateMaskBand(GMF_PER_DATASET) == CE_None)
2558 : {
2559 : VRTSourcedRasterBand *hMaskVRTBand =
2560 4 : static_cast<VRTSourcedRasterBand *>(GDALGetMaskBand(
2561 : GDALGetRasterBand(static_cast<GDALDataset *>(poVDS), 1)));
2562 4 : hMaskVRTBand->AddMaskBandSource(
2563 4 : poSrcDS->GetRasterBand(1), psOptions->srcWin.dfXOff,
2564 4 : psOptions->srcWin.dfYOff, psOptions->srcWin.dfXSize,
2565 4 : psOptions->srcWin.dfYSize, dstWin.dfXOff, dstWin.dfYOff,
2566 : dstWin.dfXSize, dstWin.dfYSize);
2567 : }
2568 : }
2569 :
2570 : /* -------------------------------------------------------------------- */
2571 : /* Compute stats if required. */
2572 : /* -------------------------------------------------------------------- */
2573 2029 : if (psOptions->bStats && EQUAL(psOptions->osFormat.c_str(), "COG"))
2574 : {
2575 0 : psOptions->aosCreateOptions.SetNameValue("STATISTICS", "YES");
2576 : }
2577 2029 : else if (psOptions->bStats)
2578 : {
2579 2 : for (int i = 0; i < poVDS->GetRasterCount(); i++)
2580 : {
2581 : double dfMin, dfMax, dfMean, dfStdDev;
2582 1 : poVDS->GetRasterBand(i + 1)->ComputeStatistics(
2583 1 : psOptions->bApproxStats, &dfMin, &dfMax, &dfMean, &dfStdDev,
2584 1 : GDALDummyProgress, nullptr);
2585 : }
2586 : }
2587 :
2588 : /* -------------------------------------------------------------------- */
2589 : /* Write to the output file using CopyCreate(). */
2590 : /* -------------------------------------------------------------------- */
2591 2564 : if (EQUAL(psOptions->osFormat.c_str(), "VRT") &&
2592 535 : (psOptions->aosCreateOptions.empty() ||
2593 17 : (psOptions->aosCreateOptions.size() == 1 &&
2594 5 : psOptions->aosCreateOptions.FetchNameValue("BLOCKXSIZE")) ||
2595 17 : (psOptions->aosCreateOptions.size() == 1 &&
2596 5 : psOptions->aosCreateOptions.FetchNameValue("BLOCKYSIZE")) ||
2597 12 : (psOptions->aosCreateOptions.size() == 2 &&
2598 12 : psOptions->aosCreateOptions.FetchNameValue("BLOCKXSIZE") &&
2599 12 : psOptions->aosCreateOptions.FetchNameValue("BLOCKYSIZE"))))
2600 : {
2601 535 : poVDS->SetDescription(pszDest);
2602 535 : hOutDS = GDALDataset::ToHandle(poVDS);
2603 535 : if (!EQUAL(pszDest, ""))
2604 : {
2605 29 : hOutDS = GDALTranslateFlush(hOutDS);
2606 : }
2607 : }
2608 : else
2609 : {
2610 1494 : hOutDS = GDALCreateCopy(
2611 1494 : hDriver, pszDest, GDALDataset::ToHandle(poVDS), psOptions->bStrict,
2612 1494 : psOptions->aosCreateOptions.List(), psOptions->pfnProgress,
2613 1494 : psOptions->pProgressData);
2614 1494 : hOutDS = GDALTranslateFlush(hOutDS);
2615 :
2616 1494 : GDALClose(poVDS);
2617 : }
2618 :
2619 2029 : poSrcDS->Release();
2620 :
2621 2029 : return hOutDS;
2622 : }
2623 :
2624 : /************************************************************************/
2625 : /* AttachMetadata() */
2626 : /************************************************************************/
2627 :
2628 2030 : static void AttachMetadata(GDALDatasetH hDS,
2629 : const CPLStringList &aosMetadataOptions)
2630 :
2631 : {
2632 60 : for (const auto &[pszKey, pszValue] :
2633 2090 : cpl::IterateNameValue(aosMetadataOptions))
2634 : {
2635 30 : GDALSetMetadataItem(hDS, pszKey, pszValue, nullptr);
2636 : }
2637 2030 : }
2638 :
2639 : /************************************************************************/
2640 : /* AttachDomainMetadata() */
2641 : /************************************************************************/
2642 :
2643 2030 : static void AttachDomainMetadata(GDALDatasetH hDS,
2644 : const CPLStringList &aosDomainMetadataOptions)
2645 :
2646 : {
2647 2039 : for (const char *pszStr : aosDomainMetadataOptions)
2648 : {
2649 :
2650 9 : char *pszKey = nullptr;
2651 9 : char *pszDomain = nullptr;
2652 :
2653 : // parse the DOMAIN:KEY=value, Remainder is KEY=value
2654 : const char *pszRemainder =
2655 9 : CPLParseNameValueSep(pszStr, &pszDomain, ':');
2656 :
2657 9 : if (pszDomain && pszRemainder)
2658 : {
2659 :
2660 : const char *pszValue =
2661 8 : CPLParseNameValueSep(pszRemainder, &pszKey, '=');
2662 8 : if (pszKey && pszValue)
2663 : {
2664 7 : GDALSetMetadataItem(hDS, pszKey, pszValue, pszDomain);
2665 : }
2666 : }
2667 9 : CPLFree(pszKey);
2668 :
2669 9 : CPLFree(pszDomain);
2670 : }
2671 2030 : }
2672 :
2673 : /************************************************************************/
2674 : /* CopyBandInfo() */
2675 : /************************************************************************/
2676 :
2677 : /* A bit of a clone of VRTRasterBand::CopyCommonInfoFrom(), but we need */
2678 : /* more and more custom behavior in the context of gdal_translate ... */
2679 :
2680 4675 : static void CopyBandInfo(GDALRasterBand *poSrcBand, GDALRasterBand *poDstBand,
2681 : int bCanCopyStatsMetadata, int bCopyScale,
2682 : int bCopyNoData, bool bCopyRAT,
2683 : const GDALTranslateOptions * /*psOptions*/)
2684 :
2685 : {
2686 :
2687 4675 : if (bCanCopyStatsMetadata)
2688 : {
2689 892 : poDstBand->SetMetadata(poSrcBand->GetMetadata());
2690 892 : if (bCopyRAT)
2691 : {
2692 891 : poDstBand->SetDefaultRAT(poSrcBand->GetDefaultRAT());
2693 : }
2694 : }
2695 : else
2696 : {
2697 3783 : CSLConstList papszMetadata = poSrcBand->GetMetadata();
2698 3783 : char **papszMetadataNew = nullptr;
2699 3872 : for (int i = 0; papszMetadata != nullptr && papszMetadata[i] != nullptr;
2700 : i++)
2701 : {
2702 89 : if (!STARTS_WITH(papszMetadata[i], "STATISTICS_"))
2703 : papszMetadataNew =
2704 71 : CSLAddString(papszMetadataNew, papszMetadata[i]);
2705 : }
2706 3783 : poDstBand->SetMetadata(papszMetadataNew);
2707 3783 : CSLDestroy(papszMetadataNew);
2708 :
2709 : // we need to strip histogram data from the source RAT
2710 3783 : if (poSrcBand->GetDefaultRAT() && bCopyRAT)
2711 : {
2712 : GDALRasterAttributeTable *poNewRAT =
2713 2 : poSrcBand->GetDefaultRAT()->Clone();
2714 :
2715 : // strip histogram data (as defined by the source RAT)
2716 2 : poNewRAT->RemoveStatistics();
2717 2 : if (poNewRAT->GetColumnCount())
2718 : {
2719 1 : poDstBand->SetDefaultRAT(poNewRAT);
2720 : }
2721 : // since SetDefaultRAT copies the RAT data we need to delete our
2722 : // original
2723 2 : delete poNewRAT;
2724 : }
2725 : }
2726 :
2727 4675 : poDstBand->SetColorTable(poSrcBand->GetColorTable());
2728 4675 : poDstBand->SetColorInterpretation(poSrcBand->GetColorInterpretation());
2729 4675 : if (strlen(poSrcBand->GetDescription()) > 0)
2730 7 : poDstBand->SetDescription(poSrcBand->GetDescription());
2731 :
2732 4675 : if (bCopyNoData)
2733 : {
2734 4586 : int bSuccess = FALSE;
2735 4586 : CPL_IGNORE_RET_VAL(poSrcBand->GetNoDataValue(&bSuccess));
2736 4586 : if (bSuccess)
2737 : {
2738 117 : bool bCannotBeExactlyRepresented = false;
2739 117 : if (!GDALCopyNoDataValue(poDstBand, poSrcBand,
2740 117 : &bCannotBeExactlyRepresented) &&
2741 : bCannotBeExactlyRepresented)
2742 : {
2743 0 : CPLError(CE_Warning, CPLE_AppDefined,
2744 : "Source nodata value was not copied to output band, "
2745 : "as it cannot be represented on its data type.");
2746 : }
2747 : }
2748 : }
2749 :
2750 4675 : if (bCopyScale)
2751 : {
2752 4644 : poDstBand->SetOffset(poSrcBand->GetOffset());
2753 4644 : poDstBand->SetScale(poSrcBand->GetScale());
2754 : }
2755 :
2756 4675 : poDstBand->SetCategoryNames(poSrcBand->GetCategoryNames());
2757 :
2758 : // Copy unit only if the range of pixel values is not modified
2759 5561 : if (bCanCopyStatsMetadata && bCopyScale &&
2760 886 : !EQUAL(poSrcBand->GetUnitType(), ""))
2761 24 : poDstBand->SetUnitType(poSrcBand->GetUnitType());
2762 4675 : }
2763 :
2764 : /************************************************************************/
2765 : /* GetColorInterp() */
2766 : /************************************************************************/
2767 :
2768 47 : static int GetColorInterp(const char *pszStr)
2769 : {
2770 47 : if (EQUAL(pszStr, "undefined"))
2771 5 : return GCI_Undefined;
2772 42 : const int eInterp = GDALGetColorInterpretationByName(pszStr);
2773 42 : if (eInterp != GCI_Undefined)
2774 41 : return eInterp;
2775 1 : CPLError(CE_Warning, CPLE_NotSupported,
2776 : "Unsupported color interpretation: %s", pszStr);
2777 1 : return -1;
2778 : }
2779 :
2780 : /************************************************************************/
2781 : /* GDALTranslateOptionsGetParser() */
2782 : /************************************************************************/
2783 :
2784 : static std::unique_ptr<GDALArgumentParser>
2785 3268 : GDALTranslateOptionsGetParser(GDALTranslateOptions *psOptions,
2786 : GDALTranslateOptionsForBinary *psOptionsForBinary)
2787 : {
2788 : auto argParser = std::make_unique<GDALArgumentParser>(
2789 3268 : "gdal_translate", /* bForBinary=*/psOptionsForBinary != nullptr);
2790 :
2791 3268 : argParser->add_description(
2792 : _("Convert raster data between different formats, with potential "
2793 3268 : "subsetting, resampling, and rescaling pixels in the process."));
2794 :
2795 3268 : argParser->add_epilog(_("For more details, consult "
2796 3268 : "https://gdal.org/programs/gdal_translate.html"));
2797 :
2798 3268 : argParser->add_output_type_argument(psOptions->eOutputType);
2799 :
2800 3268 : argParser->add_argument("-if")
2801 3268 : .append()
2802 6536 : .metavar("<format>")
2803 : .action(
2804 6 : [psOptionsForBinary](const std::string &s)
2805 : {
2806 3 : if (psOptionsForBinary)
2807 : {
2808 3 : if (GDALGetDriverByName(s.c_str()) == nullptr)
2809 : {
2810 1 : CPLError(CE_Warning, CPLE_AppDefined,
2811 : "%s is not a recognized driver", s.c_str());
2812 : }
2813 : psOptionsForBinary->aosAllowedInputDrivers.AddString(
2814 3 : s.c_str());
2815 : }
2816 3268 : })
2817 3268 : .help(_("Format/driver name(s) to try when opening the input file."));
2818 :
2819 3268 : argParser->add_output_format_argument(psOptions->osFormat);
2820 :
2821 3268 : argParser->add_quiet_argument(&(psOptions->bQuiet));
2822 :
2823 3268 : argParser->add_argument("-b")
2824 3268 : .append()
2825 6536 : .metavar("<band>")
2826 : .action(
2827 1340 : [psOptions](const std::string &s)
2828 : {
2829 654 : const char *pszBand = s.c_str();
2830 654 : bool bMask = false;
2831 654 : if (EQUAL(pszBand, "mask"))
2832 16 : pszBand = "mask,1";
2833 654 : if (STARTS_WITH_CI(pszBand, "mask,"))
2834 : {
2835 16 : bMask = true;
2836 16 : pszBand += 5;
2837 : /* If we use the source mask band as a regular band */
2838 : /* don't create a target mask band by default */
2839 16 : if (!psOptions->bParsedMaskArgument)
2840 16 : psOptions->eMaskMode = MASK_DISABLED;
2841 : }
2842 654 : const int nBand = atoi(pszBand);
2843 654 : if (nBand < 1)
2844 : {
2845 : throw std::invalid_argument(CPLSPrintf(
2846 0 : "Unrecognizable band number (%s).", s.c_str()));
2847 : }
2848 :
2849 654 : psOptions->nBandCount++;
2850 654 : psOptions->anBandList.emplace_back(nBand * (bMask ? -1 : 1));
2851 3922 : })
2852 3268 : .help(_("Select input band(s)"));
2853 :
2854 3268 : argParser->add_argument("-mask")
2855 6536 : .metavar("<mask>")
2856 : .action(
2857 54 : [psOptions](const std::string &s)
2858 : {
2859 26 : psOptions->bParsedMaskArgument = true;
2860 26 : const char *pszBand = s.c_str();
2861 26 : if (EQUAL(pszBand, "none"))
2862 : {
2863 1 : psOptions->eMaskMode = MASK_DISABLED;
2864 : }
2865 25 : else if (EQUAL(pszBand, "auto"))
2866 : {
2867 0 : psOptions->eMaskMode = MASK_AUTO;
2868 : }
2869 : else
2870 : {
2871 25 : bool bMask = false;
2872 :
2873 25 : if (EQUAL(pszBand, "mask"))
2874 1 : pszBand = "mask,1";
2875 25 : if (STARTS_WITH_CI(pszBand, "mask,"))
2876 : {
2877 2 : bMask = true;
2878 2 : pszBand += 5;
2879 : }
2880 25 : const int nBand = atoi(pszBand);
2881 25 : if (nBand < 1)
2882 : {
2883 : throw std::invalid_argument(CPLSPrintf(
2884 0 : "Unrecognizable band number (%s).", s.c_str()));
2885 : }
2886 :
2887 25 : psOptions->eMaskMode = MASK_USER;
2888 25 : psOptions->nMaskBand = nBand;
2889 25 : if (bMask)
2890 2 : psOptions->nMaskBand *= -1;
2891 : }
2892 3294 : })
2893 3268 : .help(_("Select an input band to create output dataset mask band"));
2894 :
2895 3268 : argParser->add_argument("-expand")
2896 6536 : .metavar("gray|rgb|rgba")
2897 : .action(
2898 58 : [psOptions](const std::string &s)
2899 : {
2900 29 : if (EQUAL(s.c_str(), "gray"))
2901 1 : psOptions->nRGBExpand = 1;
2902 28 : else if (EQUAL(s.c_str(), "rgb"))
2903 16 : psOptions->nRGBExpand = 3;
2904 12 : else if (EQUAL(s.c_str(), "rgba"))
2905 12 : psOptions->nRGBExpand = 4;
2906 : else
2907 : {
2908 : throw std::invalid_argument(CPLSPrintf(
2909 : "Value %s unsupported. Only gray, rgb or rgba are "
2910 : "supported.",
2911 0 : s.c_str()));
2912 : }
2913 3297 : })
2914 : .help(_("To expose a dataset with 1 band with a color table as a "
2915 3268 : "dataset with 3 (RGB) or 4 (RGBA) bands."));
2916 :
2917 : {
2918 3268 : auto &group = argParser->add_mutually_exclusive_group();
2919 3268 : group.add_argument("-strict")
2920 3268 : .store_into(psOptions->bStrict)
2921 3268 : .help(_("Enable strict mode"));
2922 :
2923 3268 : group.add_argument("-not_strict")
2924 3268 : .flag()
2925 0 : .action([psOptions](const std::string &)
2926 3268 : { psOptions->bStrict = false; })
2927 3268 : .help(_("Disable strict mode"));
2928 : }
2929 :
2930 3268 : argParser->add_argument("-outsize")
2931 6536 : .metavar("<xsize[%]|0> <ysize[%]|0>")
2932 3268 : .nargs(2)
2933 3268 : .help(_("Set the size of the output file."));
2934 :
2935 3268 : argParser->add_argument("-tr")
2936 6536 : .metavar("<xres> <yres>")
2937 3268 : .nargs(2)
2938 3268 : .scan<'g', double>()
2939 3268 : .help(_("Set target resolution."));
2940 :
2941 3268 : argParser->add_argument("-ovr")
2942 6536 : .metavar("<level>|AUTO|AUTO-<n>|NONE")
2943 : .action(
2944 31 : [psOptions](const std::string &s)
2945 : {
2946 16 : const char *pszOvLevel = s.c_str();
2947 16 : if (EQUAL(pszOvLevel, "AUTO"))
2948 0 : psOptions->nOvLevel = OVR_LEVEL_AUTO;
2949 16 : else if (STARTS_WITH_CI(pszOvLevel, "AUTO-"))
2950 4 : psOptions->nOvLevel =
2951 4 : OVR_LEVEL_AUTO - atoi(pszOvLevel + strlen("AUTO-"));
2952 12 : else if (EQUAL(pszOvLevel, "NONE"))
2953 1 : psOptions->nOvLevel = OVR_LEVEL_NONE;
2954 11 : else if (CPLGetValueType(pszOvLevel) == CPL_VALUE_INTEGER)
2955 10 : psOptions->nOvLevel = atoi(pszOvLevel);
2956 : else
2957 : {
2958 : throw std::invalid_argument(CPLSPrintf(
2959 1 : "Invalid value '%s' for -ovr option", pszOvLevel));
2960 : }
2961 3283 : })
2962 3268 : .help(_("Specify which overview level of source file must be used"));
2963 :
2964 3268 : if (psOptionsForBinary)
2965 : {
2966 151 : argParser->add_argument("-sds")
2967 151 : .store_into(psOptionsForBinary->bCopySubDatasets)
2968 151 : .help(_("Copy subdatasets"));
2969 : }
2970 :
2971 3268 : argParser->add_argument("-r")
2972 6536 : .metavar("nearest,bilinear,cubic,cubicspline,lanczos,average,mode")
2973 3268 : .store_into(psOptions->osResampling)
2974 3268 : .help(_("Resampling algorithm."));
2975 :
2976 : {
2977 3268 : auto &group = argParser->add_mutually_exclusive_group();
2978 3268 : group.add_argument("-scale")
2979 6536 : .metavar("[<src_min> <src_max> [<dst_min> <dst_max>]]")
2980 : //.nargs(0, 4)
2981 3268 : .append()
2982 3268 : .scan<'g', double>()
2983 : .help(_("Rescale the input pixels values from the range src_min to "
2984 3268 : "src_max to the range dst_min to dst_max."));
2985 :
2986 3268 : group.add_argument("-scale_X")
2987 6536 : .metavar("[<src_min> <src_max> [<dst_min> <dst_max>]]")
2988 : //.nargs(0, 4)
2989 3268 : .append()
2990 3268 : .scan<'g', double>()
2991 3268 : .help(_("Rescale the input pixels values for band X."));
2992 :
2993 3268 : group.add_argument("-unscale")
2994 3268 : .store_into(psOptions->bUnscale)
2995 : .help(_("Apply the scale/offset metadata for the bands to convert "
2996 3268 : "scaled values to unscaled values."));
2997 : }
2998 :
2999 : {
3000 3268 : auto &group = argParser->add_mutually_exclusive_group();
3001 3268 : group.add_argument("-exponent")
3002 6536 : .metavar("<value>")
3003 3268 : .scan<'g', double>()
3004 : .help(_(
3005 3268 : "Exponent to apply non-linear scaling with a power function"));
3006 :
3007 3268 : group.add_argument("-exponent_X")
3008 3268 : .append()
3009 6536 : .metavar("<value>")
3010 3268 : .scan<'g', double>()
3011 : .help(
3012 : _("Exponent to apply non-linear scaling with a power function, "
3013 3268 : "for band X"));
3014 : }
3015 :
3016 3268 : argParser->add_argument("-srcwin")
3017 6536 : .metavar("<xoff> <yoff> <xsize> <ysize>")
3018 3268 : .nargs(4)
3019 3268 : .scan<'g', double>()
3020 : .help(_("Selects a subwindow from the source image based on pixel/line "
3021 3268 : "location."));
3022 :
3023 3268 : argParser->add_argument("-projwin")
3024 6536 : .metavar("<ulx> <uly> <lrx> <lry>")
3025 3268 : .nargs(4)
3026 3268 : .scan<'g', double>()
3027 : .help(_("Selects a subwindow from the source image based on "
3028 3268 : "georeferenced coordinates."));
3029 :
3030 3268 : argParser->add_argument("-projwin_srs")
3031 6536 : .metavar("<srs_def>")
3032 3268 : .store_into(psOptions->osProjSRS)
3033 : .help(_("Specifies the SRS in which to interpret the coordinates given "
3034 3268 : "with -projwin."));
3035 :
3036 3268 : argParser->add_argument("-epo")
3037 3268 : .flag()
3038 : .action(
3039 17 : [psOptions](const std::string &)
3040 : {
3041 17 : psOptions->bErrorOnPartiallyOutside = true;
3042 17 : psOptions->bErrorOnCompletelyOutside = true;
3043 3268 : })
3044 3268 : .help(_("Error when Partially Outside."));
3045 :
3046 3268 : argParser->add_argument("-eco")
3047 3268 : .store_into(psOptions->bErrorOnCompletelyOutside)
3048 3268 : .help(_("Error when Completely Outside."));
3049 :
3050 3268 : argParser->add_argument("-a_srs")
3051 6536 : .metavar("<srs_def>")
3052 3268 : .store_into(psOptions->osOutputSRS)
3053 3268 : .help(_("Override the projection for the output file."));
3054 :
3055 3268 : argParser->add_argument("-a_coord_epoch")
3056 6536 : .metavar("<epoch>")
3057 3268 : .store_into(psOptions->dfOutputCoordinateEpoch)
3058 3268 : .help(_("Assign a coordinate epoch."));
3059 :
3060 3268 : argParser->add_argument("-a_ullr")
3061 6536 : .metavar("<ulx> <uly> <lrx> <lry>")
3062 3268 : .nargs(4)
3063 3268 : .scan<'g', double>()
3064 : .help(
3065 3268 : _("Assign/override the georeferenced bounds of the output file."));
3066 :
3067 3268 : argParser->add_argument("-a_nodata")
3068 6536 : .metavar("<value>|none")
3069 3268 : .help(_("Assign a specified nodata value to output bands."));
3070 :
3071 3268 : argParser->add_argument("-a_gt")
3072 6536 : .metavar("<gt(0)> <gt(1)> <gt(2)> <gt(3)> <gt(4)> <gt(5)>")
3073 3268 : .nargs(6)
3074 3268 : .scan<'g', double>()
3075 3268 : .help(_("Assign/override the geotransform of the output file."));
3076 :
3077 3268 : argParser->add_argument("-a_scale")
3078 6536 : .metavar("<value>")
3079 3268 : .store_into(psOptions->dfScale)
3080 3268 : .help(_("Set band scaling value."));
3081 :
3082 3268 : argParser->add_argument("-a_offset")
3083 6536 : .metavar("<value>")
3084 3268 : .store_into(psOptions->dfOffset)
3085 3268 : .help(_("Set band offset value."));
3086 :
3087 3268 : argParser->add_argument("-nogcp")
3088 3268 : .store_into(psOptions->bNoGCP)
3089 : .help(_("Do not copy the GCPs in the source dataset to the output "
3090 3268 : "dataset."));
3091 :
3092 3268 : argParser->add_argument("-gcp")
3093 6536 : .metavar("<pixel> <line> <easting> <northing> [<elevation>]")
3094 3268 : .nargs(4, 5)
3095 3268 : .append()
3096 3268 : .scan<'g', double>()
3097 : .help(
3098 3268 : _("Add the indicated ground control point to the output dataset."));
3099 :
3100 3268 : argParser->add_argument("-colorinterp")
3101 : .metavar("{red|green|blue|alpha|gray|undefined|pan|coastal|rededge|nir|"
3102 6536 : "swir|mwir|lwir|...},...")
3103 : .action(
3104 56 : [psOptions](const std::string &s)
3105 : {
3106 22 : CPLStringList aosList(CSLTokenizeString2(s.c_str(), ",", 0));
3107 11 : psOptions->anColorInterp.resize(aosList.size());
3108 45 : for (int j = 0; j < aosList.size(); j++)
3109 : {
3110 34 : psOptions->anColorInterp[j] = GetColorInterp(aosList[j]);
3111 : }
3112 3279 : })
3113 3268 : .help(_("Override the color interpretation of all specified bands."));
3114 :
3115 3268 : argParser->add_argument("-colorinterp_X")
3116 3268 : .append()
3117 : .metavar("{red|green|blue|alpha|gray|undefined|pan|coastal|rededge|nir|"
3118 6536 : "swir|mwir|lwir|...}")
3119 3268 : .help(_("Override the color interpretation of band X."));
3120 :
3121 : {
3122 3268 : auto &group = argParser->add_mutually_exclusive_group();
3123 3268 : group.add_argument("-stats")
3124 3268 : .flag()
3125 : .action(
3126 5 : [psOptions](const std::string &)
3127 : {
3128 5 : psOptions->bStats = true;
3129 5 : psOptions->bApproxStats = false;
3130 3268 : })
3131 3268 : .help(_("Force (re)computation of statistics."));
3132 :
3133 3268 : group.add_argument("-approx_stats")
3134 3268 : .flag()
3135 : .action(
3136 0 : [psOptions](const std::string &)
3137 : {
3138 0 : psOptions->bStats = true;
3139 0 : psOptions->bApproxStats = true;
3140 3268 : })
3141 3268 : .help(_("Force (re)computation of approximate statistics."));
3142 : }
3143 :
3144 3268 : argParser->add_argument("-norat")
3145 3268 : .store_into(psOptions->bNoRAT)
3146 3268 : .help(_("Do not copy source RAT into destination dataset."));
3147 :
3148 3268 : argParser->add_argument("-noxmp")
3149 3268 : .store_into(psOptions->bNoXMP)
3150 3268 : .help(_("Do not copy the XMP metadata into destination dataset."));
3151 :
3152 3268 : argParser->add_creation_options_argument(psOptions->aosCreateOptions);
3153 :
3154 : argParser->add_metadata_item_options_argument(
3155 3268 : psOptions->aosMetadataOptions);
3156 :
3157 3268 : argParser->add_argument("-dmo")
3158 6536 : .metavar("<DOMAIN>:<KEY>=<VALUE>")
3159 3268 : .append()
3160 9 : .action([psOptions](const std::string &s)
3161 3277 : { psOptions->aosDomainMetadataOptions.AddString(s.c_str()); })
3162 : .help(_("Passes a metadata key and value in specified domain to set on "
3163 3268 : "the output dataset if possible."));
3164 :
3165 : argParser->add_open_options_argument(
3166 3268 : psOptionsForBinary ? &(psOptionsForBinary->aosOpenOptions) : nullptr);
3167 :
3168 : // Undocumented option used by gdal_translate_fuzzer
3169 3268 : argParser->add_argument("-limit_outsize")
3170 3268 : .hidden()
3171 3268 : .store_into(psOptions->nLimitOutSize);
3172 :
3173 : // Undocumented option used by gdal raster convert
3174 3268 : argParser->add_argument("--no-overwrite")
3175 3268 : .store_into(psOptions->bNoOverwrite)
3176 3268 : .hidden();
3177 :
3178 : // Undocumented option used by gdal raster scale
3179 3268 : argParser->add_argument("--no-clip")
3180 3268 : .store_into(psOptions->bNoClip)
3181 3268 : .hidden();
3182 :
3183 : // Undocumented option used by gdal raster clip
3184 3268 : argParser->add_argument("--no-warn-about-outside-window")
3185 3268 : .store_into(psOptions->bNoWarnAboutOutsideWindow)
3186 3268 : .hidden();
3187 :
3188 3268 : if (psOptionsForBinary)
3189 : {
3190 151 : argParser->add_argument("input_file")
3191 302 : .metavar("<input_file>")
3192 151 : .store_into(psOptionsForBinary->osSource)
3193 151 : .help(_("Input file."));
3194 :
3195 151 : argParser->add_argument("output_file")
3196 302 : .metavar("<output_file>")
3197 151 : .store_into(psOptionsForBinary->osDest)
3198 151 : .help(_("Output file."));
3199 : }
3200 :
3201 3268 : return argParser;
3202 : }
3203 :
3204 : /************************************************************************/
3205 : /* GDALTranslateGetParserUsage() */
3206 : /************************************************************************/
3207 :
3208 4 : std::string GDALTranslateGetParserUsage()
3209 : {
3210 : try
3211 : {
3212 8 : GDALTranslateOptions sOptions;
3213 8 : GDALTranslateOptionsForBinary sOptionsForBinary;
3214 : auto argParser =
3215 8 : GDALTranslateOptionsGetParser(&sOptions, &sOptionsForBinary);
3216 4 : return argParser->usage();
3217 : }
3218 0 : catch (const std::exception &err)
3219 : {
3220 0 : CPLError(CE_Failure, CPLE_AppDefined, "Unexpected exception: %s",
3221 0 : err.what());
3222 0 : return std::string();
3223 : }
3224 : }
3225 :
3226 : /************************************************************************/
3227 : /* GDALTranslateOptionsNew() */
3228 : /************************************************************************/
3229 :
3230 : /**
3231 : * Allocates a GDALTranslateOptions struct.
3232 : *
3233 : * @param papszArgv NULL terminated list of options (potentially including
3234 : * filename and open options too), or NULL. The accepted options are the ones of
3235 : * the <a href="/programs/gdal_translate.html">gdal_translate</a> utility.
3236 : * @param psOptionsForBinary (output) may be NULL (and should generally be
3237 : * NULL), otherwise (gdal_translate_bin.cpp use case) must be allocated with
3238 : * GDALTranslateOptionsForBinaryNew() prior to this
3239 : * function. Will be filled with potentially present filename, open options,...
3240 : * @return pointer to the allocated GDALTranslateOptions struct. Must be freed
3241 : * with GDALTranslateOptionsFree().
3242 : *
3243 : * @since GDAL 2.1
3244 : */
3245 :
3246 : GDALTranslateOptions *
3247 3266 : GDALTranslateOptionsNew(char **papszArgv,
3248 : GDALTranslateOptionsForBinary *psOptionsForBinary)
3249 : {
3250 6532 : auto psOptions = std::make_unique<GDALTranslateOptions>();
3251 :
3252 3266 : psOptions->aosArgs.Assign(CSLDuplicate(papszArgv), true);
3253 :
3254 : /* -------------------------------------------------------------------- */
3255 : /* Pre-processing for custom syntax that ArgumentParser does not */
3256 : /* support. */
3257 : /* -------------------------------------------------------------------- */
3258 :
3259 6532 : CPLStringList aosArgv;
3260 3266 : const int argc = CSLCount(papszArgv);
3261 20670 : for (int i = 0; i < argc && papszArgv != nullptr && papszArgv[i] != nullptr;
3262 : i++)
3263 : {
3264 17406 : if (i + 4 < argc && EQUAL(papszArgv[i], "-gcp"))
3265 : {
3266 : /* -gcp pixel line easting northing [elev] */
3267 29 : psOptions->asGCPs.resize(psOptions->asGCPs.size() + 1);
3268 29 : psOptions->asGCPs.back().Pixel() = CPLAtofM(papszArgv[++i]);
3269 29 : psOptions->asGCPs.back().Line() = CPLAtofM(papszArgv[++i]);
3270 29 : psOptions->asGCPs.back().X() = CPLAtofM(papszArgv[++i]);
3271 29 : psOptions->asGCPs.back().Y() = CPLAtofM(papszArgv[++i]);
3272 :
3273 29 : char *endptr = nullptr;
3274 56 : if (papszArgv[i + 1] != nullptr &&
3275 27 : (CPLStrtod(papszArgv[i + 1], &endptr) != 0.0 ||
3276 27 : papszArgv[i + 1][0] == '0'))
3277 : {
3278 : /* Check that last argument is really a number and not a
3279 : * filename */
3280 : /* looking like a number (see ticket #863) */
3281 13 : if (endptr && *endptr == 0)
3282 13 : psOptions->asGCPs.back().Z() = CPLAtofM(papszArgv[++i]);
3283 29 : }
3284 :
3285 : /* should set id and info? */
3286 : }
3287 :
3288 17377 : else if (EQUAL(papszArgv[i], "-scale") ||
3289 17317 : STARTS_WITH_CI(papszArgv[i], "-scale_"))
3290 : {
3291 73 : int nIndex = 0;
3292 73 : if (STARTS_WITH_CI(papszArgv[i], "-scale_"))
3293 : {
3294 26 : if (!psOptions->bHasUsedExplicitScaleBand &&
3295 13 : !psOptions->asScaleParams.empty())
3296 : {
3297 0 : CPLError(CE_Failure, CPLE_NotSupported,
3298 : "Cannot mix -scale and -scale_XX syntax");
3299 0 : return nullptr;
3300 : }
3301 13 : psOptions->bHasUsedExplicitScaleBand = true;
3302 13 : nIndex = atoi(papszArgv[i] + 7);
3303 13 : if (nIndex <= 0 || nIndex > 65535)
3304 : {
3305 0 : CPLError(CE_Failure, CPLE_NotSupported,
3306 0 : "Invalid parameter name: %s", papszArgv[i]);
3307 0 : return nullptr;
3308 : }
3309 13 : nIndex--;
3310 : }
3311 : else
3312 : {
3313 60 : if (psOptions->bHasUsedExplicitScaleBand)
3314 : {
3315 0 : CPLError(CE_Failure, CPLE_NotSupported,
3316 : "Cannot mix -scale and -scale_XX syntax");
3317 0 : return nullptr;
3318 : }
3319 60 : nIndex = static_cast<int>(psOptions->asScaleParams.size());
3320 : }
3321 :
3322 73 : if (nIndex >= static_cast<int>(psOptions->asScaleParams.size()))
3323 : {
3324 73 : psOptions->asScaleParams.resize(nIndex + 1);
3325 : }
3326 73 : psOptions->asScaleParams[nIndex].bScale = true;
3327 73 : bool bScanForDst = false;
3328 73 : if (i < argc - 2 && EQUAL(papszArgv[i + 1], "NaN") &&
3329 1 : EQUAL(papszArgv[i + 2], "NaN"))
3330 : {
3331 1 : bScanForDst = true;
3332 1 : i += 2;
3333 : }
3334 72 : else if (i < argc - 2 && ArgIsNumeric(papszArgv[i + 1]))
3335 : {
3336 60 : if (!ArgIsNumeric(papszArgv[i + 2]))
3337 : {
3338 0 : CPLError(CE_Failure, CPLE_IllegalArg,
3339 : "Value of -scale must be numeric");
3340 0 : return nullptr;
3341 : }
3342 60 : psOptions->asScaleParams[nIndex].dfScaleSrcMin =
3343 60 : CPLAtofM(papszArgv[i + 1]);
3344 60 : psOptions->asScaleParams[nIndex].dfScaleSrcMax =
3345 60 : CPLAtofM(papszArgv[i + 2]);
3346 60 : bScanForDst = true;
3347 60 : i += 2;
3348 : }
3349 73 : if (i < argc - 2 && bScanForDst && ArgIsNumeric(papszArgv[i + 1]))
3350 : {
3351 57 : if (!ArgIsNumeric(papszArgv[i + 2]))
3352 : {
3353 1 : CPLError(CE_Failure, CPLE_IllegalArg,
3354 : "Value of -scale must be numeric");
3355 1 : return nullptr;
3356 : }
3357 56 : psOptions->asScaleParams[nIndex].dfScaleDstMin =
3358 56 : CPLAtofM(papszArgv[i + 1]);
3359 56 : psOptions->asScaleParams[nIndex].dfScaleDstMax =
3360 56 : CPLAtofM(papszArgv[i + 2]);
3361 56 : i += 2;
3362 72 : }
3363 : }
3364 :
3365 17304 : else if ((EQUAL(papszArgv[i], "-exponent") ||
3366 17284 : STARTS_WITH_CI(papszArgv[i], "-exponent_")) &&
3367 24 : papszArgv[i + 1])
3368 : {
3369 24 : int nIndex = 0;
3370 24 : if (STARTS_WITH_CI(papszArgv[i], "-exponent_"))
3371 : {
3372 8 : if (!psOptions->bHasUsedExplicitExponentBand &&
3373 4 : !psOptions->adfExponent.empty())
3374 : {
3375 0 : CPLError(CE_Failure, CPLE_NotSupported,
3376 : "Cannot mix -exponent and -exponent_XX syntax");
3377 0 : return nullptr;
3378 : }
3379 4 : psOptions->bHasUsedExplicitExponentBand = true;
3380 4 : nIndex = atoi(papszArgv[i] + 10);
3381 4 : if (nIndex <= 0 || nIndex > 65535)
3382 : {
3383 0 : CPLError(CE_Failure, CPLE_NotSupported,
3384 0 : "Invalid parameter name: %s", papszArgv[i]);
3385 0 : return nullptr;
3386 : }
3387 4 : nIndex--;
3388 : }
3389 : else
3390 : {
3391 20 : if (psOptions->bHasUsedExplicitExponentBand)
3392 : {
3393 0 : CPLError(CE_Failure, CPLE_NotSupported,
3394 : "Cannot mix -exponent and -exponent_XX syntax");
3395 0 : return nullptr;
3396 : }
3397 20 : nIndex = static_cast<int>(psOptions->adfExponent.size());
3398 : }
3399 :
3400 24 : if (nIndex >= static_cast<int>(psOptions->adfExponent.size()))
3401 : {
3402 24 : psOptions->adfExponent.resize(nIndex + 1);
3403 : }
3404 24 : double dfExponent = CPLAtofM(papszArgv[++i]);
3405 24 : psOptions->adfExponent[nIndex] = dfExponent;
3406 : }
3407 :
3408 17280 : else if (STARTS_WITH_CI(papszArgv[i], "-colorinterp_") &&
3409 14 : papszArgv[i + 1])
3410 : {
3411 14 : int nIndex = atoi(papszArgv[i] + strlen("-colorinterp_"));
3412 14 : if (nIndex <= 0 || nIndex > 65535)
3413 : {
3414 1 : CPLError(CE_Failure, CPLE_NotSupported,
3415 1 : "Invalid parameter name: %s", papszArgv[i]);
3416 1 : return nullptr;
3417 : }
3418 13 : nIndex--;
3419 :
3420 13 : if (nIndex >= static_cast<int>(psOptions->anColorInterp.size()))
3421 : {
3422 13 : psOptions->anColorInterp.resize(nIndex + 1, -1);
3423 : }
3424 13 : ++i;
3425 13 : psOptions->anColorInterp[nIndex] = GetColorInterp(papszArgv[i]);
3426 : }
3427 :
3428 : // argparser will be confused if the value of a string argument
3429 : // starts with a negative sign.
3430 17266 : else if (EQUAL(papszArgv[i], "-a_nodata") && papszArgv[i + 1])
3431 : {
3432 75 : ++i;
3433 75 : const char *s = papszArgv[i];
3434 75 : if (EQUAL(s, "none") || EQUAL(s, "null"))
3435 : {
3436 4 : psOptions->bUnsetNoData = true;
3437 : }
3438 : else
3439 : {
3440 71 : psOptions->bSetNoData = true;
3441 71 : psOptions->osNoData = s;
3442 75 : }
3443 : }
3444 :
3445 : else
3446 : {
3447 17191 : aosArgv.AddString(papszArgv[i]);
3448 : }
3449 : }
3450 :
3451 : try
3452 : {
3453 :
3454 : auto argParser =
3455 6528 : GDALTranslateOptionsGetParser(psOptions.get(), psOptionsForBinary);
3456 :
3457 3264 : argParser->parse_args_without_binary_name(aosArgv.List());
3458 :
3459 3260 : psOptions->bSetScale = argParser->is_used("-a_scale");
3460 3260 : psOptions->bSetOffset = argParser->is_used("-a_offset");
3461 :
3462 3279 : if (auto adfULLR = argParser->present<std::vector<double>>("-a_ullr"))
3463 : {
3464 19 : CPLAssert(psOptions->adfULLR.size() == adfULLR->size());
3465 95 : for (size_t i = 0; i < adfULLR->size(); ++i)
3466 76 : psOptions->adfULLR[i] = (*adfULLR)[i];
3467 : }
3468 :
3469 3263 : if (auto adfGT = argParser->present<std::vector<double>>("-a_gt"))
3470 : {
3471 3 : CPLAssert(adfGT->size() == 6);
3472 21 : for (size_t i = 0; i < adfGT->size(); ++i)
3473 18 : psOptions->gt[i] = (*adfGT)[i];
3474 : }
3475 :
3476 3260 : bool bOutsizeExplicitlySet = false;
3477 3260 : if (auto aosOutSize =
3478 6520 : argParser->present<std::vector<std::string>>("-outsize"))
3479 : {
3480 248 : if ((*aosOutSize)[0].back() == '%')
3481 30 : psOptions->dfOXSizePct = CPLAtofM((*aosOutSize)[0].c_str());
3482 : else
3483 218 : psOptions->nOXSizePixel = atoi((*aosOutSize)[0].c_str());
3484 :
3485 248 : if ((*aosOutSize)[1].back() == '%')
3486 29 : psOptions->dfOYSizePct = CPLAtofM((*aosOutSize)[1].c_str());
3487 : else
3488 219 : psOptions->nOYSizePixel = atoi((*aosOutSize)[1].c_str());
3489 248 : bOutsizeExplicitlySet = true;
3490 : }
3491 :
3492 3260 : if (auto adfTargetRes = argParser->present<std::vector<double>>("-tr"))
3493 : {
3494 68 : psOptions->dfXRes = (*adfTargetRes)[0];
3495 68 : psOptions->dfYRes = fabs((*adfTargetRes)[1]);
3496 68 : if (psOptions->dfXRes == 0 || psOptions->dfYRes == 0)
3497 : {
3498 0 : CPLError(CE_Failure, CPLE_IllegalArg,
3499 : "Wrong value for -tr parameters.");
3500 0 : return nullptr;
3501 : }
3502 : }
3503 :
3504 4188 : if (auto adfSrcWin = argParser->present<std::vector<double>>("-srcwin"))
3505 : {
3506 928 : psOptions->srcWin.dfXOff = (*adfSrcWin)[0];
3507 928 : psOptions->srcWin.dfYOff = (*adfSrcWin)[1];
3508 928 : psOptions->srcWin.dfXSize = (*adfSrcWin)[2];
3509 928 : psOptions->srcWin.dfYSize = (*adfSrcWin)[3];
3510 : }
3511 :
3512 3260 : if (auto adfProjWin =
3513 6520 : argParser->present<std::vector<double>>("-projwin"))
3514 : {
3515 346 : psOptions->dfULX = (*adfProjWin)[0];
3516 346 : psOptions->dfULY = (*adfProjWin)[1];
3517 346 : psOptions->dfLRX = (*adfProjWin)[2];
3518 346 : psOptions->dfLRY = (*adfProjWin)[3];
3519 : }
3520 :
3521 3260 : if (!psOptions->asGCPs.empty() && psOptions->bNoGCP)
3522 : {
3523 0 : CPLError(CE_Failure, CPLE_IllegalArg,
3524 : "-nogcp and -gcp cannot be used as the same time");
3525 0 : return nullptr;
3526 : }
3527 :
3528 248 : if (bOutsizeExplicitlySet && psOptions->nOXSizePixel == 0 &&
3529 3509 : psOptions->dfOXSizePct == 0.0 && psOptions->nOYSizePixel == 0 &&
3530 1 : psOptions->dfOYSizePct == 0.0)
3531 : {
3532 1 : CPLError(CE_Failure, CPLE_NotSupported, "-outsize %d %d invalid.",
3533 1 : psOptions->nOXSizePixel, psOptions->nOYSizePixel);
3534 1 : return nullptr;
3535 : }
3536 :
3537 3259 : if (!psOptions->asScaleParams.empty() && psOptions->bUnscale)
3538 : {
3539 1 : CPLError(CE_Failure, CPLE_IllegalArg,
3540 : "-scale and -unscale cannot be used as the same time");
3541 1 : return nullptr;
3542 : }
3543 :
3544 3258 : if (psOptionsForBinary)
3545 : {
3546 144 : psOptionsForBinary->bQuiet = psOptions->bQuiet;
3547 144 : psOptionsForBinary->aosCreateOptions = psOptions->aosCreateOptions;
3548 144 : if (!psOptions->osFormat.empty())
3549 89 : psOptionsForBinary->osFormat = psOptions->osFormat;
3550 : }
3551 :
3552 3258 : return psOptions.release();
3553 : }
3554 4 : catch (const std::exception &err)
3555 : {
3556 4 : CPLError(CE_Failure, CPLE_AppDefined, "%s", err.what());
3557 4 : return nullptr;
3558 : }
3559 : }
3560 :
3561 : /************************************************************************/
3562 : /* GDALTranslateOptionsFree() */
3563 : /************************************************************************/
3564 :
3565 : /**
3566 : * Frees the GDALTranslateOptions struct.
3567 : *
3568 : * @param psOptions the options struct for GDALTranslate().
3569 : *
3570 : * @since GDAL 2.1
3571 : */
3572 :
3573 3243 : void GDALTranslateOptionsFree(GDALTranslateOptions *psOptions)
3574 : {
3575 3243 : delete psOptions;
3576 3243 : }
3577 :
3578 : /************************************************************************/
3579 : /* GDALTranslateOptionsSetProgress() */
3580 : /************************************************************************/
3581 :
3582 : /**
3583 : * Set a progress function.
3584 : *
3585 : * @param psOptions the options struct for GDALTranslate().
3586 : * @param pfnProgress the progress callback.
3587 : * @param pProgressData the user data for the progress callback.
3588 : *
3589 : * @since GDAL 2.1
3590 : */
3591 :
3592 458 : void GDALTranslateOptionsSetProgress(GDALTranslateOptions *psOptions,
3593 : GDALProgressFunc pfnProgress,
3594 : void *pProgressData)
3595 : {
3596 458 : psOptions->pfnProgress = pfnProgress;
3597 458 : psOptions->pProgressData = pProgressData;
3598 458 : if (pfnProgress == GDALTermProgress)
3599 135 : psOptions->bQuiet = false;
3600 458 : }
|
