# gdal.h: Raster C API

Public (C callable) GDAL entry points.

Defines

`INIT_RASTERIO_EXTRA_ARG`(s)

  Macro to initialize an instance of GDALRasterIOExtraArg structure.

  Since

    GDAL 2.0

`GDALMD_AREA_OR_POINT`

  Metadata item for dataset that indicates the spatial interpretation of a pixel.

`GDALMD_AOP_AREA`

  Value for GDALMD_AREA_OR_POINT that indicates that a pixel represents an area.

`GDALMD_AOP_POINT`

  Value for GDALMD_AREA_OR_POINT that indicates that a pixel represents a point.

`GDAL_DMD_LONGNAME`

  Long name of the driver.

`GDAL_DMD_HELPTOPIC`

  URL (relative to http://gdal.org/) to the help page of the driver.

`GDAL_DMD_MIMETYPE`

  MIME type handled by the driver.

`GDAL_DMD_EXTENSION`

  Extension handled by the driver.

`GDAL_DMD_CONNECTION_PREFIX`

  Connection prefix to provide as the file name of the open function.

  Typically set for non-file based drivers. Generally used with open options.

  Since

    GDAL 2.0

`GDAL_DMD_EXTENSIONS`

  List of (space separated) extensions handled by the driver.

  Since

    GDAL 2.0

`GDAL_DMD_CREATIONOPTIONLIST`

  XML snippet with creation options.

`GDAL_DMD_MULTIDIM_DATASET_CREATIONOPTIONLIST`

  XML snippet with multidimensional dataset creation options.

  Since

    GDAL 3.1

`GDAL_DMD_MULTIDIM_GROUP_CREATIONOPTIONLIST`

  XML snippet with multidimensional group creation options.

  Since

    GDAL 3.1

`GDAL_DMD_MULTIDIM_DIMENSION_CREATIONOPTIONLIST`

  XML snippet with multidimensional dimension creation options.

  Since

    GDAL 3.1

`GDAL_DMD_MULTIDIM_ARRAY_CREATIONOPTIONLIST`

  XML snippet with multidimensional array creation options.

  Since

    GDAL 3.1

`GDAL_DMD_MULTIDIM_ATTRIBUTE_CREATIONOPTIONLIST`

  XML snippet with multidimensional attribute creation options.

  Since

    GDAL 3.1

`GDAL_DMD_OPENOPTIONLIST`

  XML snippet with open options.

  Since

    GDAL 2.0

`GDAL_DMD_CREATIONDATATYPES`

  List of (space separated) raster data types support by the Create()/CreateCopy() API.

`GDAL_DMD_CREATIONFIELDDATATYPES`

  List of (space separated) vector field types support by the CreateField() API.

  Since

    GDAL 2.0

`GDAL_DMD_CREATIONFIELDDATASUBTYPES`

  List of (space separated) vector field sub-types support by the CreateField() API.

  Since

    GDAL 2.3

`GDAL_DMD_SUBDATASETS`

  Capability set by a driver that exposes Subdatasets.

`GDAL_DCAP_OPEN`

  Capability set by a driver that implements the Open() API.

`GDAL_DCAP_CREATE`

  Capability set by a driver that implements the Create() API.

  If GDAL_DCAP_CREATE is set, but GDAL_DCAP_CREATECOPY not, a generic CreateCopy() implementation is available and will use the Create() API of the driver. So to test if some CreateCopy() implementation is available, generic or specialize, test for both GDAL_DCAP_CREATE and GDAL_DCAP_CREATECOPY.

`GDAL_DCAP_CREATE_MULTIDIMENSIONAL`

  Capability set by a driver that implements the CreateMultidimensional() API.

  Since

    GDAL 3.1

`GDAL_DCAP_CREATECOPY`

  Capability set by a driver that implements the CreateCopy() API.

  If GDAL_DCAP_CREATECOPY is not defined, but GDAL_DCAP_CREATE is set, a generic CreateCopy() implementation is available and will use the Create() API of the driver. So to test if some CreateCopy() implementation is available, generic or specialize, test for both GDAL_DCAP_CREATE and GDAL_DCAP_CREATECOPY.

`GDAL_DCAP_CREATECOPY_MULTIDIMENSIONAL`

  Capability set by a driver that implements the CreateCopy() API, but with multidimensional raster as input and output.

  Since

    GDAL 3.1

`GDAL_DCAP_MULTIDIM_RASTER`

  Capability set by a driver that supports multidimensionnal data.

  Since

    GDAL 3.1

`GDAL_DCAP_SUBCREATECOPY`

  Capability set by a driver that can copy over subdatasets.

`GDAL_DCAP_VIRTUALIO`

  Capability set by a driver that can read/create datasets through the VSI*L API.

`GDAL_DCAP_RASTER`

  Capability set by a driver having raster capability.

  Since

    GDAL 2.0

`GDAL_DCAP_VECTOR`

  Capability set by a driver having vector capability.

  Since

    GDAL 2.0

`GDAL_DCAP_GNM`

  Capability set by a driver having geographical network model capability.

  Since

    GDAL 2.1

`GDAL_DCAP_NOTNULL_FIELDS`

  Capability set by a driver that can create fields with NOT NULL constraint.

  Since

    GDAL 2.0

`GDAL_DCAP_DEFAULT_FIELDS`

  Capability set by a driver that can create fields with DEFAULT values.

  Since

    GDAL 2.0

`GDAL_DCAP_NOTNULL_GEOMFIELDS`

  Capability set by a driver that can create geometry fields with NOT NULL constraint.

  Since

    GDAL 2.0

`GDAL_DCAP_NONSPATIAL`

  Capability set by a non-spatial driver having no support for geometries.

  E.g. non-spatial vector drivers (e.g. spreadsheet format drivers) do not support geometries, and accordingly will have this capability present.

  Since

    GDAL 2.3

`GDAL_DCAP_FEATURE_STYLES`

  Capability set by drivers which support feature styles.

  Since

    GDAL 2.3

`GDAL_DIM_TYPE_HORIZONTAL_X`

  Value for GDALDimension::GetType() specifying the X axis of a horizontal CRS.

  Since

    GDAL 3.1

`GDAL_DIM_TYPE_HORIZONTAL_Y`

  Value for GDALDimension::GetType() specifying the Y axis of a horizontal CRS.

  Since

    GDAL 3.1

`GDAL_DIM_TYPE_VERTICAL`

  Value for GDALDimension::GetType() specifying a vertical axis.

  Since

    GDAL 3.1

`GDAL_DIM_TYPE_TEMPORAL`

  Value for GDALDimension::GetType() specifying a temporal axis.

  Since

    GDAL 3.1

`GDAL_DIM_TYPE_PARAMETRIC`

  Value for GDALDimension::GetType() specifying a parametric axis.

  Since

    GDAL 3.1

`GDAL_OF_READONLY`

  Open in read-only mode.

  Used by GDALOpenEx().

  Since

    GDAL 2.0

`GDAL_OF_UPDATE`

  Open in update mode.

  Used by GDALOpenEx().

  Since

    GDAL 2.0

`GDAL_OF_ALL`

  Allow raster and vector drivers to be used.

  Used by GDALOpenEx().

  Since

    GDAL 2.0

`GDAL_OF_RASTER`

  Allow raster drivers to be used.

  Used by GDALOpenEx().

  Since

    GDAL 2.0

`GDAL_OF_VECTOR`

  Allow vector drivers to be used.

  Used by GDALOpenEx().

  Since

    GDAL 2.0

`GDAL_OF_GNM`

  Allow gnm drivers to be used.

  Used by GDALOpenEx().

  Since

    GDAL 2.1

`GDAL_OF_MULTIDIM_RASTER`

  Allow multidimensionnal raster drivers to be used.

  Used by GDALOpenEx().

  Since

    GDAL 3.1

`GDAL_OF_SHARED`

  Open in shared mode.

  Used by GDALOpenEx().

  Since

    GDAL 2.0

`GDAL_OF_VERBOSE_ERROR`

  Emit error message in case of failed open.

  Used by GDALOpenEx().

  Since

    GDAL 2.0

`GDAL_OF_INTERNAL`

  Open as internal dataset.

  Such dataset isn’t registered in the global list of opened dataset. Cannot be used with GDAL_OF_SHARED.

  Used by GDALOpenEx().

  Since

    GDAL 2.0

`GDAL_OF_DEFAULT_BLOCK_ACCESS`

  Let GDAL decide if a array-based or hashset-based storage strategy for cached blocks must be used.

  GDAL_OF_DEFAULT_BLOCK_ACCESS, GDAL_OF_ARRAY_BLOCK_ACCESS and GDAL_OF_HASHSET_BLOCK_ACCESS are mutually exclusive.

  Used by GDALOpenEx().

  Since

    GDAL 2.1

`GDAL_OF_ARRAY_BLOCK_ACCESS`

  Use a array-based storage strategy for cached blocks.

  GDAL_OF_DEFAULT_BLOCK_ACCESS, GDAL_OF_ARRAY_BLOCK_ACCESS and GDAL_OF_HASHSET_BLOCK_ACCESS are mutually exclusive.

  Used by GDALOpenEx().

  Since

    GDAL 2.1

`GDAL_OF_HASHSET_BLOCK_ACCESS`

  Use a hashset-based storage strategy for cached blocks.

  GDAL_OF_DEFAULT_BLOCK_ACCESS, GDAL_OF_ARRAY_BLOCK_ACCESS and GDAL_OF_HASHSET_BLOCK_ACCESS are mutually exclusive.

  Used by GDALOpenEx().

  Since

    GDAL 2.1

`GDAL_DS_LAYER_CREATIONOPTIONLIST`

  Name of driver metadata item for layer creation option list.

`SRCVAL`(papoSource, eSrcType, ii)

  SRCVAL - Macro which may be used by pixel functions to obtain a pixel from a source buffer.

`GMF_ALL_VALID`

  Flag returned by GDALGetMaskFlags() to indicate that all pixels are valid.

`GMF_PER_DATASET`

  Flag returned by GDALGetMaskFlags() to indicate that the mask band is valid for all bands.

`GMF_ALPHA`

  Flag returned by GDALGetMaskFlags() to indicate that the mask band is an alpha band.

`GMF_NODATA`

  Flag returned by GDALGetMaskFlags() to indicate that the mask band is computed from nodata values.

`GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED`

  Flag returned by GDALGetDataCoverageStatus() when the driver does not implement GetDataCoverageStatus().

  This flag should be returned together with GDAL_DATA_COVERAGE_STATUS_DATA

`GDAL_DATA_COVERAGE_STATUS_DATA`

  Flag returned by GDALGetDataCoverageStatus() when there is (potentially) data in the queried window.

  Can be combined with the binary or operator with GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED or GDAL_DATA_COVERAGE_STATUS_EMPTY

`GDAL_DATA_COVERAGE_STATUS_EMPTY`

  Flag returned by GDALGetDataCoverageStatus() when there is nodata in the queried window.

  This is typically identified by the concept of missing block in formats that supports it. Can be combined with the binary or operator with GDAL_DATA_COVERAGE_STATUS_DATA

`GDAL_CHECK_VERSION`(pszCallingComponentName)

  Helper macro for GDALCheckVersion()

  See

    GDALCheckVersion()

Typedefs

typedef void *`GDALMajorObjectH`

  Opaque type used for the C bindings of the C++ GDALMajorObject class.

typedef void *`GDALDatasetH`

  Opaque type used for the C bindings of the C++ GDALDataset class.

typedef void *`GDALRasterBandH`

  Opaque type used for the C bindings of the C++ GDALRasterBand class.

typedef void *`GDALDriverH`

  Opaque type used for the C bindings of the C++ GDALDriver class.

typedef void *`GDALColorTableH`

  Opaque type used for the C bindings of the C++ GDALColorTable class.

typedef void *`GDALRasterAttributeTableH`

  Opaque type used for the C bindings of the C++ GDALRasterAttributeTable class.

typedef void *`GDALAsyncReaderH`

  Opaque type used for the C bindings of the C++ GDALAsyncReader class.

typedef GIntBig `GSpacing`

  Type to express pixel, line or band spacing.

  Signed 64 bit integer.

typedef struct GDALExtendedDataTypeHS *`GDALExtendedDataTypeH`

  Opaque type for C++ GDALExtendedDataType.

typedef struct GDALEDTComponentHS *`GDALEDTComponentH`

  Opaque type for C++ GDALEDTComponent.

typedef struct GDALGroupHS *`GDALGroupH`

  Opaque type for C++ GDALGroup.

typedef struct GDALMDArrayHS *`GDALMDArrayH`

  Opaque type for C++ GDALMDArray.

typedef struct GDALAttributeHS *`GDALAttributeH`

  Opaque type for C++ GDALAttribute.

typedef struct GDALDimensionHS *`GDALDimensionH`

  Opaque type for C++ GDALDimension.

typedef CPLErr (*`GDALDerivedPixelFunc`)(void **papoSources, int nSources, void *pData, int nBufXSize, int nBufYSize, GDALDataType eSrcType, GDALDataType eBufType, int nPixelSpace, int nLineSpace)

  Type of functions to pass to GDALAddDerivedBandPixelFunc.

  Since

    GDAL 2.2

Enums

enum `GDALDataType`

  Pixel data types

  Values:

  `GDT_Unknown` = 0

    Unknown or unspecified type

  `GDT_Byte` = 1

    Eight bit unsigned integer

  `GDT_UInt16` = 2

    Sixteen bit unsigned integer

  `GDT_Int16` = 3

    Sixteen bit signed integer

  `GDT_UInt32` = 4

    Thirty two bit unsigned integer

  `GDT_Int32` = 5

    Thirty two bit signed integer

  `GDT_Float32` = 6

    Thirty two bit floating point

  `GDT_Float64` = 7

    Sixty four bit floating point

  `GDT_CInt16` = 8

    Complex Int16

  `GDT_CInt32` = 9

    Complex Int32

  `GDT_CFloat32` = 10

    Complex Float32

  `GDT_CFloat64` = 11

    Complex Float64

  `GDT_TypeCount` = 12

enum `GDALAsyncStatusType`

  status of the asynchronous stream

  Values:

  `GARIO_PENDING` = 0
  `GARIO_UPDATE` = 1
  `GARIO_ERROR` = 2
  `GARIO_COMPLETE` = 3
  `GARIO_TypeCount` = 4

enum `GDALAccess`

  Flag indicating read/write, or read-only access to data.

  Values:

  `GA_ReadOnly` = 0

    Read only (no update) access

  `GA_Update` = 1

    Read/write access.

enum `GDALRWFlag`

  Read/Write flag for RasterIO() method

  Values:

  `GF_Read` = 0

    Read data

  `GF_Write` = 1

    Write data

enum `GDALRIOResampleAlg`

  RasterIO() resampling method.

  Since

    GDAL 2.0

  Values:

  `GRIORA_NearestNeighbour` = 0

    Nearest neighbour

  `GRIORA_Bilinear` = 1

    Bilinear (2x2 kernel)

  `GRIORA_Cubic` = 2

    Cubic Convolution Approximation (4x4 kernel)

  `GRIORA_CubicSpline` = 3

    Cubic B-Spline Approximation (4x4 kernel)

  `GRIORA_Lanczos` = 4

    Lanczos windowed sinc interpolation (6x6 kernel)

  `GRIORA_Average` = 5

    Average

  `GRIORA_Mode` = 6

    Mode (selects the value which appears most often of all the sampled points)

  `GRIORA_Gauss` = 7

    Gauss blurring

enum `GDALColorInterp`

  Types of color interpretation for raster bands.

  Values:

  `GCI_Undefined` = 0

    Undefined

  `GCI_GrayIndex` = 1

    Greyscale

  `GCI_PaletteIndex` = 2

    Paletted (see associated color table)

  `GCI_RedBand` = 3

    Red band of RGBA image

  `GCI_GreenBand` = 4

    Green band of RGBA image

  `GCI_BlueBand` = 5

    Blue band of RGBA image

  `GCI_AlphaBand` = 6

    Alpha (0=transparent, 255=opaque)

  `GCI_HueBand` = 7

    Hue band of HLS image

  `GCI_SaturationBand` = 8

    Saturation band of HLS image

  `GCI_LightnessBand` = 9

    Lightness band of HLS image

  `GCI_CyanBand` = 10

    Cyan band of CMYK image

  `GCI_MagentaBand` = 11

    Magenta band of CMYK image

  `GCI_YellowBand` = 12

    Yellow band of CMYK image

  `GCI_BlackBand` = 13

    Black band of CMYK image

  `GCI_YCbCr_YBand` = 14

    Y Luminance

  `GCI_YCbCr_CbBand` = 15

    Cb Chroma

  `GCI_YCbCr_CrBand` = 16

    Cr Chroma

  `GCI_Max` = 16

    Max current value (equals to GCI_YCbCr_CrBand currently)

enum `GDALPaletteInterp`

  Types of color interpretations for a GDALColorTable.

  Values:

  `GPI_Gray` = 0

    Grayscale (in GDALColorEntry.c1)

  `GPI_RGB` = 1

    Red, Green, Blue and Alpha in (in c1, c2, c3 and c4)

  `GPI_CMYK` = 2

    Cyan, Magenta, Yellow and Black (in c1, c2, c3 and c4)

  `GPI_HLS` = 3

    Hue, Lightness and Saturation (in c1, c2, and c3)

enum `GDALExtendedDataTypeClass`

  Enumeration giving the class of a GDALExtendedDataType.

  Since

    GDAL 3.1

  Values:

  `GEDTC_NUMERIC`

    Numeric value.

    Based on GDALDataType enumeration

  `GEDTC_STRING`

    String value.

  `GEDTC_COMPOUND`

    Compound data type.

enum `GDALRATFieldType`

  Field type of raster attribute table.

  Values:

  `GFT_Integer`

    Integer field

  `GFT_Real`

    Floating point (double) field

  `GFT_String`

    String field

enum `GDALRATFieldUsage`

  Field usage of raster attribute table.

  Values:

  `GFU_Generic` = 0

    General purpose field.

  `GFU_PixelCount` = 1

    Histogram pixel count

  `GFU_Name` = 2

    Class name

  `GFU_Min` = 3

    Class range minimum

  `GFU_Max` = 4

    Class range maximum

  `GFU_MinMax` = 5

    Class value (min=max)

  `GFU_Red` = 6

    Red class color (0-255)

  `GFU_Green` = 7

    Green class color (0-255)

  `GFU_Blue` = 8

    Blue class color (0-255)

  `GFU_Alpha` = 9

    Alpha (0=transparent,255=opaque)

  `GFU_RedMin` = 10

    Color Range Red Minimum

  `GFU_GreenMin` = 11

    Color Range Green Minimum

  `GFU_BlueMin` = 12

    Color Range Blue Minimum

  `GFU_AlphaMin` = 13

    Color Range Alpha Minimum

  `GFU_RedMax` = 14

    Color Range Red Maximum

  `GFU_GreenMax` = 15

    Color Range Green Maximum

  `GFU_BlueMax` = 16

    Color Range Blue Maximum

  `GFU_AlphaMax` = 17

    Color Range Alpha Maximum

  `GFU_MaxCount`

    Maximum GFU value (equals to GFU_AlphaMax+1 currently)

enum `GDALRATTableType`

  RAT table type (thematic or athematic)

  Since

    GDAL 2.4

  Values:

  `GRTT_THEMATIC`

    Thematic table type

  `GRTT_ATHEMATIC`

    Athematic table type

enum `GDALTileOrganization`

  ! Enumeration to describe the tile organization

  Values:

  `GTO_TIP`

    Tile Interleaved by Pixel: tile (0,0) with internal band interleaved by pixel organization, tile (1, 0), …

  `GTO_BIT`

    Band Interleaved by Tile : tile (0,0) of first band, tile (0,0) of second band, … tile (1,0) of first band, tile (1,0) of second band, …

  `GTO_BSQ`

    Band SeQuential : all the tiles of first band, all the tiles of following band…

Functions

int `GDALGetDataTypeSize`(GDALDataType eDataType)

  Get data type size in bits.

  Deprecated.

  Returns the size of a GDT_* type in bits, not bytes!

  Use GDALGetDataTypeSizeBytes() for bytes. Use GDALGetDataTypeSizeBits() for bits.

  Return

    the number of bits or zero if it is not recognised.

  Parameters

    - `eDataType`: type, such as GDT_Byte.

int `GDALGetDataTypeSizeBits`(GDALDataType eDataType)

  Get data type size in bits.

  Returns the size of a GDT_* type in bits, not bytes! Use GDALGetDataTypeSizeBytes() for bytes.

  Return

    the number of bits or zero if it is not recognised.

  Parameters

    - `eDataType`: type, such as GDT_Byte.

int `GDALGetDataTypeSizeBytes`(GDALDataType eDataType)

  Get data type size in bytes.

  Returns the size of a GDT_* type in bytes. In contrast, GDALGetDataTypeSize() returns the size in bits.

  Return

    the number of bytes or zero if it is not recognised.

  Parameters

    - `eDataType`: type, such as GDT_Byte.

int `GDALDataTypeIsComplex`(GDALDataType eDataType)

  Is data type complex?

  Return

    TRUE if the passed type is complex (one of GDT_CInt16, GDT_CInt32, GDT_CFloat32 or GDT_CFloat64), that is it consists of a real and imaginary component.

int `GDALDataTypeIsInteger`(GDALDataType eDataType)

  Is data type integer? (might be complex)

  Return

    TRUE if the passed type is integer (one of GDT_Byte, GDT_Int16, GDT_UInt16, GDT_Int32, GDT_UInt32, GDT_CInt16, GDT_CInt32).

  Since

    GDAL 2.3

int `GDALDataTypeIsFloating`(GDALDataType eDataType)

  Is data type floating? (might be complex)

  Return

    TRUE if the passed type is floating (one of GDT_Float32, GDT_Float64, GDT_CFloat32, GDT_CFloat64)

  Since

    GDAL 2.3

int `GDALDataTypeIsSigned`(GDALDataType eDataType)

  Is data type signed?

  Return

    TRUE if the passed type is signed.

  Since

    GDAL 2.3

const char *`GDALGetDataTypeName`(GDALDataType eDataType)

  Get name of data type.

  Returns a symbolic name for the data type. This is essentially the the enumerated item name with the GDT_ prefix removed. So GDT_Byte returns “Byte”. The returned strings are static strings and should not be modified or freed by the application. These strings are useful for reporting datatypes in debug statements, errors and other user output.

  Return

    string corresponding to existing data type or NULL pointer if invalid type given.

  Parameters

    - `eDataType`: type to get name of.

GDALDataType `GDALGetDataTypeByName`(const char *pszName)

  Get data type by symbolic name.

  Returns a data type corresponding to the given symbolic name. This function is opposite to the GDALGetDataTypeName().

  Return

    GDAL data type.

  Parameters

    - `pszName`: string containing the symbolic name of the type.

GDALDataType `GDALDataTypeUnion`(GDALDataType eType1, GDALDataType eType2)

  Return the smallest data type that can fully express both input data types.

  Return

    a data type able to express eType1 and eType2.

  Parameters

    - `eType1`: first data type.

    - `eType2`: second data type.

GDALDataType `GDALDataTypeUnionWithValue`(GDALDataType eDT, double dValue, int bComplex)

  Union a data type with the one found for a value.

  Return

    a data type able to express eDT and dValue.

  Since

    GDAL 2.3

  Parameters

    - `eDT`: the first data type

    - `dValue`: the value for which to find a data type and union with eDT

    - `bComplex`: if the value is complex

GDALDataType `GDALFindDataType`(int nBits, int bSigned, int bFloating, int bComplex)

  Finds the smallest data type able to support the given requirements.

  Return

    a best fit GDALDataType for supporting the requirements

  Since

    GDAL 2.3

  Parameters

    - `nBits`: number of bits necessary

    - `bSigned`: if negative values are necessary

    - `bFloating`: if non-integer values necessary

    - `bComplex`: if complex values are necessary

GDALDataType `GDALFindDataTypeForValue`(double dValue, int bComplex)

  Finds the smallest data type able to support the provided value.

  Return

    a best fit GDALDataType for supporting the value

  Since

    GDAL 2.3

  Parameters

    - `dValue`: value to support

    - `bComplex`: is the value complex

double `GDALAdjustValueToDataType`(GDALDataType eDT, double dfValue, int *pbClamped, int *pbRounded)

  Adjust a value to the output data type.

  Adjustment consist in clamping to minimum/maxmimum values of the data type and rounding for integral types.

  Return

    adjusted value

  Since

    GDAL 2.1

  Parameters

    - `eDT`: target data type.

    - `dfValue`: value to adjust.

    - `pbClamped`: pointer to a integer(boolean) to indicate if clamping has been made, or NULL

    - `pbRounded`: pointer to a integer(boolean) to indicate if rounding has been made, or NULL

GDALDataType `GDALGetNonComplexDataType`(GDALDataType eDataType)

  Return the base data type for the specified input.

  If the input data type is complex this function returns the base type i.e. the data type of the real and imaginary parts (non-complex). If the input data type is already non-complex, then it is returned unchanged.

  Return

    GDAL data type.

  Parameters

    - `eDataType`: type, such as GDT_CFloat32.

int `GDALDataTypeIsConversionLossy`(GDALDataType eTypeFrom, GDALDataType eTypeTo)

  Is conversion from eTypeFrom to eTypeTo potentially lossy.

  Return

    TRUE if conversion from eTypeFrom to eTypeTo potentially lossy.

  Since

    GDAL 2.3

  Parameters

    - `eTypeFrom`: input datatype

    - `eTypeTo`: output datatype

const char *`GDALGetAsyncStatusTypeName`(GDALAsyncStatusType eAsyncStatusType)

  Get name of AsyncStatus data type.

  Returns a symbolic name for the AsyncStatus data type. This is essentially the the enumerated item name with the GARIO_ prefix removed. So GARIO_COMPLETE returns “COMPLETE”. The returned strings are static strings and should not be modified or freed by the application. These strings are useful for reporting datatypes in debug statements, errors and other user output.

  Return

    string corresponding to type.

  Parameters

    - `eAsyncStatusType`: type to get name of.

GDALAsyncStatusType `GDALGetAsyncStatusTypeByName`(const char *pszName)

  Get AsyncStatusType by symbolic name.

  Returns a data type corresponding to the given symbolic name. This function is opposite to the GDALGetAsyncStatusTypeName().

  Return

    GDAL AsyncStatus type.

  Parameters

    - `pszName`: string containing the symbolic name of the type.

const char *`GDALGetColorInterpretationName`(GDALColorInterp eInterp)

  Get name of color interpretation.

  Returns a symbolic name for the color interpretation. This is derived from the enumerated item name with the GCI_ prefix removed, but there are some variations. So GCI_GrayIndex returns “Gray” and GCI_RedBand returns “Red”. The returned strings are static strings and should not be modified or freed by the application.

  Return

    string corresponding to color interpretation or NULL pointer if invalid enumerator given.

  Parameters

    - `eInterp`: color interpretation to get name of.

GDALColorInterp `GDALGetColorInterpretationByName`(const char *pszName)

  Get color interpretation by symbolic name.

  Returns a color interpretation corresponding to the given symbolic name. This function is opposite to the GDALGetColorInterpretationName().

  Return

    GDAL color interpretation.

  Since

    GDAL 1.7.0

  Parameters

    - `pszName`: string containing the symbolic name of the color interpretation.

const char *`GDALGetPaletteInterpretationName`(GDALPaletteInterp eInterp)

  Get name of palette interpretation.

  Returns a symbolic name for the palette interpretation. This is the the enumerated item name with the GPI_ prefix removed. So GPI_Gray returns “Gray”. The returned strings are static strings and should not be modified or freed by the application.

  Return

    string corresponding to palette interpretation.

  Parameters

    - `eInterp`: palette interpretation to get name of.

void `GDALAllRegister`(void)

  Register all known configured GDAL drivers.

  This function will drive any of the following that are configured into GDAL. See raster list and vector full list

  This function should generally be called once at the beginning of the application.

GDALDatasetH `GDALCreate`(GDALDriverH hDriver, const char *pszFilename, int nXSize, int nYSize, int nBands, GDALDataType eBandType, CSLConstList papszOptions)

  Create a new dataset with this driver.

  See

    GDALDriver::Create()

GDALDatasetH `GDALCreateCopy`(GDALDriverH hDriver, const char *pszFilename, GDALDatasetH hSrcDS, int bStrict, CSLConstList papszOptions, GDALProgressFunc pfnProgress, void *pProgressData)

  Create a copy of a dataset.

  See

    GDALDriver::CreateCopy()

GDALDriverH `GDALIdentifyDriver`(const char *pszFilename, CSLConstList papszFileList)

  Identify the driver that can open a raster file.

  This function will try to identify the driver that can open the passed file name by invoking the Identify method of each registered GDALDriver in turn. The first driver that successful identifies the file name will be returned. If all drivers fail then NULL is returned.

  In order to reduce the need for such searches touch the operating system file system machinery, it is possible to give an optional list of files. This is the list of all files at the same level in the file system as the target file, including the target file. The filenames will not include any path components, are essentially just the output of VSIReadDir() on the parent directory. If the target object does not have filesystem semantics then the file list should be NULL.

  Return

    A GDALDriverH handle or NULL on failure. For C++ applications this handle can be cast to a GDALDriver *.

  Parameters

    - `pszFilename`: the name of the file to access. In the case of exotic drivers this may not refer to a physical file, but instead contain information for the driver on how to access a dataset.

    - `papszFileList`: an array of strings, whose last element is the NULL pointer. These strings are filenames that are auxiliary to the main filename. The passed value may be NULL.

GDALDriverH `GDALIdentifyDriverEx`(const char *pszFilename, unsigned int nIdentifyFlags, const char *const *papszAllowedDrivers, const char *const *papszFileList)

  Identify the driver that can open a raster file.

  This function will try to identify the driver that can open the passed file name by invoking the Identify method of each registered GDALDriver in turn. The first driver that successful identifies the file name will be returned. If all drivers fail then NULL is returned.

  In order to reduce the need for such searches touch the operating system file system machinery, it is possible to give an optional list of files. This is the list of all files at the same level in the file system as the target file, including the target file. The filenames will not include any path components, are essentially just the output of VSIReadDir() on the parent directory. If the target object does not have filesystem semantics then the file list should be NULL.

  Return

    A GDALDriverH handle or NULL on failure. For C++ applications this handle can be cast to a GDALDriver *.

  Since

    GDAL 2.2

  Parameters

    - `pszFilename`: the name of the file to access. In the case of exotic drivers this may not refer to a physical file, but instead contain information for the driver on how to access a dataset.

    - `nIdentifyFlags`: a combination of GDAL_OF_RASTER for raster drivers or GDAL_OF_VECTOR for vector drivers. If none of the value is specified, both kinds are implied.

    - `papszAllowedDrivers`: NULL to consider all candidate drivers, or a NULL terminated list of strings with the driver short names that must be considered.

    - `papszFileList`: an array of strings, whose last element is the NULL pointer. These strings are filenames that are auxiliary to the main filename. The passed value may be NULL.

GDALDatasetH `GDALOpen`(const char *pszFilename, GDALAccess eAccess)

  Open a raster file as a GDALDataset.

  This function will try to open the passed file, or virtual dataset name by invoking the Open method of each registered GDALDriver in turn. The first successful open will result in a returned dataset. If all drivers fail then NULL is returned and an error is issued.

  Several recommendations :

  - If you open a dataset object with GA_Update access, it is not recommended to open a new dataset on the same underlying file.

  - The returned dataset should only be accessed by one thread at a time. If you want to use it from different threads, you must add all necessary code (mutexes, etc.) to avoid concurrent use of the object. (Some drivers, such as GeoTIFF, maintain internal state variables that are updated each time a new block is read, thus preventing concurrent use.)

  For drivers supporting the VSI virtual file API, it is possible to open a file in a .zip archive (see VSIInstallZipFileHandler()), in a .tar/.tar.gz/.tgz archive (see VSIInstallTarFileHandler()) or on a HTTP / FTP server (see VSIInstallCurlFileHandler())

  In some situations (dealing with unverified data), the datasets can be opened in another process through the GDAL API Proxy mechanism.

  See

    GDALOpenShared()

  See

    GDALOpenEx()

  Return

    A GDALDatasetH handle or NULL on failure. For C++ applications this handle can be cast to a GDALDataset *.

  Parameters

    - `pszFilename`: the name of the file to access. In the case of exotic drivers this may not refer to a physical file, but instead contain information for the driver on how to access a dataset. It should be in UTF-8 encoding.

    - `eAccess`: the desired access, either GA_Update or GA_ReadOnly. Many drivers support only read only access.

GDALDatasetH `GDALOpenShared`(const char *pszFilename, GDALAccess eAccess)

  Open a raster file as a GDALDataset.

  This function works the same as GDALOpen(), but allows the sharing of GDALDataset handles for a dataset with other callers to GDALOpenShared().

  In particular, GDALOpenShared() will first consult its list of currently open and shared GDALDataset’s, and if the GetDescription() name for one exactly matches the pszFilename passed to GDALOpenShared() it will be referenced and returned.

  Starting with GDAL 1.6.0, if GDALOpenShared() is called on the same pszFilename from two different threads, a different GDALDataset object will be returned as it is not safe to use the same dataset from different threads, unless the user does explicitly use mutexes in its code.

  For drivers supporting the VSI virtual file API, it is possible to open a file in a .zip archive (see VSIInstallZipFileHandler()), in a .tar/.tar.gz/.tgz archive (see VSIInstallTarFileHandler()) or on a HTTP / FTP server (see VSIInstallCurlFileHandler())

  In some situations (dealing with unverified data), the datasets can be opened in another process through the GDAL API Proxy mechanism.

  See

    GDALOpen()

  See

    GDALOpenEx()

  Return

    A GDALDatasetH handle or NULL on failure. For C++ applications this handle can be cast to a GDALDataset *.

  Parameters

    - `pszFilename`: the name of the file to access. In the case of exotic drivers this may not refer to a physical file, but instead contain information for the driver on how to access a dataset. It should be in UTF-8 encoding.

    - `eAccess`: the desired access, either GA_Update or GA_ReadOnly. Many drivers support only read only access.

GDALDatasetH `GDALOpenEx`(const char *pszFilename, unsigned int nOpenFlags, const char *const *papszAllowedDrivers, const char *const *papszOpenOptions, const char *const *papszSiblingFiles)

  Open a raster or vector file as a GDALDataset.

  This function will try to open the passed file, or virtual dataset name by invoking the Open method of each registered GDALDriver in turn. The first successful open will result in a returned dataset. If all drivers fail then NULL is returned and an error is issued.

  Several recommendations :

  - If you open a dataset object with GDAL_OF_UPDATE access, it is not recommended to open a new dataset on the same underlying file.

  - The returned dataset should only be accessed by one thread at a time. If you want to use it from different threads, you must add all necessary code (mutexes, etc.) to avoid concurrent use of the object. (Some drivers, such as GeoTIFF, maintain internal state variables that are updated each time a new block is read, thus preventing concurrent use.)

  For drivers supporting the VSI virtual file API, it is possible to open a file in a .zip archive (see VSIInstallZipFileHandler()), in a .tar/.tar.gz/.tgz archive (see VSIInstallTarFileHandler()) or on a HTTP / FTP server (see VSIInstallCurlFileHandler())

  In some situations (dealing with unverified data), the datasets can be opened in another process through the GDAL API Proxy mechanism.

  In order to reduce the need for searches through the operating system file system machinery, it is possible to give an optional list of files with the papszSiblingFiles parameter. This is the list of all files at the same level in the file system as the target file, including the target file. The filenames must not include any path components, are essentially just the output of VSIReadDir() on the parent directory. If the target object does not have filesystem semantics then the file list should be NULL.

  Return

    A GDALDatasetH handle or NULL on failure. For C++ applications this handle can be cast to a GDALDataset *.

  Since

    GDAL 2.0

  Parameters

    - `pszFilename`: the name of the file to access. In the case of exotic drivers this may not refer to a physical file, but instead contain information for the driver on how to access a dataset. It should be in UTF-8 encoding.

    - `nOpenFlags`: a combination of GDAL_OF_ flags that may be combined through logical or operator.

      - Driver kind: GDAL_OF_RASTER for raster drivers, GDAL_OF_VECTOR for vector drivers, GDAL_OF_GNM for Geographic Network Model drivers. If none of the value is specified, all kinds are implied.

      - Access mode: GDAL_OF_READONLY (exclusive)or GDAL_OF_UPDATE.

      - Shared mode: GDAL_OF_SHARED. If set, it allows the sharing of GDALDataset handles for a dataset with other callers that have set GDAL_OF_SHARED. In particular, GDALOpenEx() will first consult its list of currently open and shared GDALDataset’s, and if the GetDescription() name for one exactly matches the pszFilename passed to GDALOpenEx() it will be referenced and returned, if GDALOpenEx() is called from the same thread.

      - Verbose error: GDAL_OF_VERBOSE_ERROR. If set, a failed attempt to open the file will lead to an error message to be reported.

    - `papszAllowedDrivers`: NULL to consider all candidate drivers, or a NULL terminated list of strings with the driver short names that must be considered.

    - `papszOpenOptions`: NULL, or a NULL terminated list of strings with open options passed to candidate drivers. An option exists for all drivers, OVERVIEW_LEVEL=level, to select a particular overview level of a dataset. The level index starts at 0. The level number can be suffixed by “only” to specify that only this overview level must be visible, and not sub-levels. Open options are validated by default, and a warning is emitted in case the option is not recognized. In some scenarios, it might be not desirable (e.g. when not knowing which driver will open the file), so the special open option VALIDATE_OPEN_OPTIONS can be set to NO to avoid such warnings. Alternatively, since GDAL 2.1, an option name can be preceded by the @ character to indicate that it may not cause a warning if the driver doesn’t declare this option.

    - `papszSiblingFiles`: NULL, or a NULL terminated list of strings that are filenames that are auxiliary to the main filename. If NULL is passed, a probing of the file system will be done.

int `GDALDumpOpenDatasets`(FILE *fp)

  List open datasets.

  Dumps a list of all open datasets (shared or not) to the indicated text file (may be stdout or stderr). This function is primarily intended to assist in debugging “dataset leaks” and reference counting issues. The information reported includes the dataset name, referenced count, shared status, driver name, size, and band count.

GDALDriverH `GDALGetDriverByName`(const char *pszName)

  Fetch a driver based on the short name.

  See

    GDALDriverManager::GetDriverByName()

int `GDALGetDriverCount`(void)

  Fetch the number of registered drivers.

  See

    GDALDriverManager::GetDriverCount()

GDALDriverH `GDALGetDriver`(int iDriver)

  Fetch driver by index.

  See

    GDALDriverManager::GetDriver()

GDALDriverH `GDALCreateDriver`(void)

  Create a GDALDriver.

  Creates a driver in the GDAL heap.

void `GDALDestroyDriver`(GDALDriverH hDriver)

  Destroy a GDALDriver.

  This is roughly equivalent to deleting the driver, but is guaranteed to take place in the GDAL heap. It is important this that function not be called on a driver that is registered with the GDALDriverManager.

  Parameters

    - `hDriver`: the driver to destroy.

int `GDALRegisterDriver`(GDALDriverH hDriver)

  Register a driver for use.

  See

    GDALDriverManager::GetRegisterDriver()

void `GDALDeregisterDriver`(GDALDriverH hDriver)

  Deregister the passed driver.

  See

    GDALDriverManager::GetDeregisterDriver()

void `GDALDestroyDriverManager`(void)

  Destroy the driver manager.

  Incidentally unloads all managed drivers.

  NOTE: This function is not thread safe. It should not be called while other threads are actively using GDAL.

CPLErr `GDALDeleteDataset`(GDALDriverH hDriver, const char *pszFilename)

  Delete named dataset.

  See

    GDALDriver::Delete()

CPLErr `GDALRenameDataset`(GDALDriverH hDriver, const char *pszNewName, const char *pszOldName)

  Rename a dataset.

  See

    GDALDriver::Rename()

CPLErr `GDALCopyDatasetFiles`(GDALDriverH hDriver, const char *pszNewName, const char *pszOldName)

  Copy the files of a dataset.

  See

    GDALDriver::CopyFiles()

int `GDALValidateCreationOptions`(GDALDriverH hDriver, CSLConstList papszCreationOptions)

  Validate the list of creation options that are handled by a driver.

  This is a helper method primarily used by Create() and CreateCopy() to validate that the passed in list of creation options is compatible with the GDAL_DMD_CREATIONOPTIONLIST metadata item defined by some drivers.

  If the GDAL_DMD_CREATIONOPTIONLIST metadata item is not defined, this function will return TRUE. Otherwise it will check that the keys and values in the list of creation options are compatible with the capabilities declared by the GDAL_DMD_CREATIONOPTIONLIST metadata item. In case of incompatibility a (non fatal) warning will be emitted and FALSE will be returned.

  See

    GDALGetDriverCreationOptionList()

  Return

    TRUE if the list of creation options is compatible with the Create() and CreateCopy() method of the driver, FALSE otherwise.

  Parameters

    - `hDriver`: the handle of the driver with whom the lists of creation option must be validated

    - `papszCreationOptions`: the list of creation options. An array of strings, whose last element is a NULL pointer

const char *`GDALGetDriverShortName`(GDALDriverH hDriver)

  Return the short name of a driver.

  This is the string that can be passed to the GDALGetDriverByName() function.

  For the GeoTIFF driver, this is “GTiff”

  Return

    the short name of the driver. The returned string should not be freed and is owned by the driver.

  Parameters

    - `hDriver`: the handle of the driver

const char *`GDALGetDriverLongName`(GDALDriverH hDriver)

  Return the long name of a driver.

  For the GeoTIFF driver, this is “GeoTIFF”

  Return

    the long name of the driver or empty string. The returned string should not be freed and is owned by the driver.

  Parameters

    - `hDriver`: the handle of the driver

const char *`GDALGetDriverHelpTopic`(GDALDriverH hDriver)

  Return the URL to the help that describes the driver.

  That URL is relative to the GDAL documentation directory.

  For the GeoTIFF driver, this is “frmt_gtiff.html”

  Return

    the URL to the help that describes the driver or NULL. The returned string should not be freed and is owned by the driver.

  Parameters

    - `hDriver`: the handle of the driver

const char *`GDALGetDriverCreationOptionList`(GDALDriverH hDriver)

  Return the list of creation options of the driver.

  Return the list of creation options of the driver used by Create() and CreateCopy() as an XML string

  Return

    an XML string that describes the list of creation options or empty string. The returned string should not be freed and is owned by the driver.

  Parameters

    - `hDriver`: the handle of the driver

void `GDALInitGCPs`(int nCount, GDAL_GCP *psGCP)

  Initialize an array of GCPs.

  Numeric values are initialized to 0 and strings to the empty string “” allocated with CPLStrdup() An array initialized with GDALInitGCPs() must be de-initialized with GDALDeinitGCPs().

  Parameters

    - `nCount`: number of GCPs in psGCP

    - `psGCP`: array of GCPs of size nCount.

void `GDALDeinitGCPs`(int nCount, GDAL_GCP *psGCP)

  De-initialize an array of GCPs (initialized with GDALInitGCPs())

  Parameters

    - `nCount`: number of GCPs in psGCP

    - `psGCP`: array of GCPs of size nCount.

GDAL_GCP *`GDALDuplicateGCPs`(int nCount, const GDAL_GCP *pasGCPList)

  Duplicate an array of GCPs.

  The return must be freed with GDALDeinitGCPs() followed by CPLFree()

  Parameters

    - `nCount`: number of GCPs in psGCP

    - `pasGCPList`: array of GCPs of size nCount.

int `GDALGCPsToGeoTransform`(int nGCPCount, const GDAL_GCP *pasGCPs, double *padfGeoTransform, int bApproxOK)

  Generate Geotransform from GCPs.

  Given a set of GCPs perform first order fit as a geotransform.

  Due to imprecision in the calculations the fit algorithm will often return non-zero rotational coefficients even if given perfectly non-rotated inputs. A special case has been implemented for corner corner coordinates given in TL, TR, BR, BL order. So when using this to get a geotransform from 4 corner coordinates, pass them in this order.

  Starting with GDAL 2.2.2, if bApproxOK = FALSE, the GDAL_GCPS_TO_GEOTRANSFORM_APPROX_OK configuration option will be read. If set to YES, then bApproxOK will be overridden with TRUE. Starting with GDAL 2.2.2, when exact fit is asked, the GDAL_GCPS_TO_GEOTRANSFORM_APPROX_THRESHOLD configuration option can be set to give the maximum error threshold in pixel. The default is 0.25.

  Return

    TRUE on success or FALSE if there aren’t enough points to prepare a geotransform, the pointers are ill-determined or if bApproxOK is FALSE and the fit is poor.

  Parameters

    - `nGCPCount`: the number of GCPs being passed in.

    - `pasGCPs`: the list of GCP structures.

    - `padfGeoTransform`: the six double array in which the affine geotransformation will be returned.

    - `bApproxOK`: If FALSE the function will fail if the geotransform is not essentially an exact fit (within 0.25 pixel) for all GCPs.

int `GDALInvGeoTransform`(double *padfGeoTransformIn, double *padfInvGeoTransformOut)

  Invert Geotransform.

  This function will invert a standard 3x2 set of GeoTransform coefficients. This converts the equation from being pixel to geo to being geo to pixel.

  Return

    TRUE on success or FALSE if the equation is uninvertable.

  Parameters

    - `gt_in`: Input geotransform (six doubles - unaltered).

    - `gt_out`: Output geotransform (six doubles - updated).

void `GDALApplyGeoTransform`(double *padfGeoTransform, double dfPixel, double dfLine, double *pdfGeoX, double *pdfGeoY)

  Apply GeoTransform to x/y coordinate.

  Applies the following computation, converting a (pixel, line) coordinate into a georeferenced (geo_x, geo_y) location.

      *pdfGeoX = padfGeoTransform[0] + dfPixel * padfGeoTransform[1]
                                     + dfLine  * padfGeoTransform[2];
      *pdfGeoY = padfGeoTransform[3] + dfPixel * padfGeoTransform[4]
                                     + dfLine  * padfGeoTransform[5];

  Parameters

    - `padfGeoTransform`: Six coefficient GeoTransform to apply.

    - `dfPixel`: Input pixel position.

    - `dfLine`: Input line position.

    - `pdfGeoX`: output location where geo_x (easting/longitude) location is placed.

    - `pdfGeoY`: output location where geo_y (northing/latitude) location is placed.

void `GDALComposeGeoTransforms`(const double *padfGeoTransform1, const double *padfGeoTransform2, double *padfGeoTransformOut)

  Compose two geotransforms.

  The resulting geotransform is the equivalent to padfGT1 and then padfGT2 being applied to a point.

  Parameters

    - `padfGT1`: the first geotransform, six values.

    - `padfGT2`: the second geotransform, six values.

    - `padfGTOut`: the output geotransform, six values, may safely be the same array as padfGT1 or padfGT2.

char **`GDALGetMetadataDomainList`(GDALMajorObjectH hObject)

  Fetch list of metadata domains.

  See

    GDALMajorObject::GetMetadataDomainList()

  Since

    GDAL 1.11

char **`GDALGetMetadata`(GDALMajorObjectH hObject, const char *pszDomain)

  Fetch metadata.

  See

    GDALMajorObject::GetMetadata()

CPLErr `GDALSetMetadata`(GDALMajorObjectH hObject, CSLConstList papszMD, const char *pszDomain)

  Set metadata.

  CAUTION: when using this function on a GDALDatasetH or GDALRasterBandH, depending on the format, older values of the updated information might still be found in the file in a “ghost” state, even if no longer accessible through the GDAL API. This is for example the case of the GTiff format (this is not a exhaustive list)

  See

    GDALMajorObject::SetMetadata(), GDALDataset::SetMetadata(), GDALRasterBand::SetMetadata()

const char *`GDALGetMetadataItem`(GDALMajorObjectH hObject, const char *pszName, const char *pszDomain)

  Fetch single metadata item.

  See

    GDALMajorObject::GetMetadataItem()

CPLErr `GDALSetMetadataItem`(GDALMajorObjectH hObject, const char *pszName, const char *pszValue, const char *pszDomain)

  Set single metadata item.

  CAUTION: when using this function on a GDALDatasetH or GDALRasterBandH, depending on the format, older values of the updated information might still be found in the file in a “ghost” state, even if no longer accessible through the GDAL API. This is for example the case of the GTiff format (this is not a exhaustive list)

  See

    GDALMajorObject::SetMetadataItem(), GDALDataset::SetMetadataItem(), GDALRasterBand::SetMetadataItem()

const char *`GDALGetDescription`(GDALMajorObjectH hObject)

  Fetch object description.

  See

    GDALMajorObject::GetDescription()

void `GDALSetDescription`(GDALMajorObjectH hObject, const char *pszNewDesc)

  Set object description.

  See

    GDALMajorObject::SetDescription()

GDALDriverH `GDALGetDatasetDriver`(GDALDatasetH hDataset)

  Fetch the driver to which this dataset relates.

  See

    GDALDataset::GetDriver()

char **`GDALGetFileList`(GDALDatasetH hDS)

  Fetch files forming dataset.

  See

    GDALDataset::GetFileList()

void `GDALClose`(GDALDatasetH hDS)

  Close GDAL dataset.

  For non-shared datasets (opened with GDALOpen()) the dataset is closed using the C++ “delete” operator, recovering all dataset related resources. For shared datasets (opened with GDALOpenShared()) the dataset is dereferenced, and closed only if the referenced count has dropped below 1.

  Parameters

    - `hDS`: The dataset to close. May be cast from a “GDALDataset *”.

int `GDALGetRasterXSize`(GDALDatasetH hDataset)

  Fetch raster width in pixels.

  See

    GDALDataset::GetRasterXSize().

int `GDALGetRasterYSize`(GDALDatasetH hDataset)

  Fetch raster height in pixels.

  See

    GDALDataset::GetRasterYSize().

int `GDALGetRasterCount`(GDALDatasetH hDS)

  Fetch the number of raster bands on this dataset.

  See

    GDALDataset::GetRasterCount().

GDALRasterBandH `GDALGetRasterBand`(GDALDatasetH hDS, int nBandId)

  Fetch a band object for a dataset.

  See

    GDALDataset::GetRasterBand().

CPLErr `GDALAddBand`(GDALDatasetH hDS, GDALDataType eType, CSLConstList papszOptions)

  Add a band to a dataset.

  See

    GDALDataset::AddBand().

GDALAsyncReaderH `GDALBeginAsyncReader`(GDALDatasetH hDS, int nXOff, int nYOff, int nXSize, int nYSize, void *pBuf, int nBufXSize, int nBufYSize, GDALDataType eBufType, int nBandCount, int *panBandMap, int nPixelSpace, int nLineSpace, int nBandSpace, CSLConstList papszOptions)

  Sets up an asynchronous data request.

  This method establish an asynchronous raster read request for the indicated window on the dataset into the indicated buffer. The parameters for windowing, buffer size, buffer type and buffer organization are similar to those for GDALDataset::RasterIO(); however, this call only launches the request and filling the buffer is accomplished via calls to GetNextUpdatedRegion() on the return GDALAsyncReader session object.

  Once all processing for the created session is complete, or if no further refinement of the request is required, the GDALAsyncReader object should be destroyed with the GDALDataset::EndAsyncReader() method.

  Note that the data buffer (pData) will potentially continue to be updated as long as the session lives, but it is not deallocated when the session (GDALAsyncReader) is destroyed with EndAsyncReader(). It should be deallocated by the application at that point.

  Additional information on asynchronous IO in GDAL may be found at: http://trac.osgeo.org/gdal/wiki/rfc24_progressive_data_support

  This method is the same as the C++ GDALDataset::BeginAsyncReader() method.

  Return

    handle representing the request.

  Parameters

    - `hDS`: handle to the dataset object.

    - `nXOff`: The pixel offset to the top left corner of the region of the band to be accessed. This would be zero to start from the left side.

    - `nYOff`: The line offset to the top left corner of the region of the band to be accessed. This would be zero to start from the top.

    - `nXSize`: The width of the region of the band to be accessed in pixels.

    - `nYSize`: The height of the region of the band to be accessed in lines.

    - `pBuf`: The buffer into which the data should be read. This buffer must contain at least nBufXSize * nBufYSize * nBandCount words of type eBufType. It is organized in left to right,top to bottom pixel order. Spacing is controlled by the nPixelSpace, and nLineSpace parameters.

    - `nBufXSize`: the width of the buffer image into which the desired region is to be read, or from which it is to be written.

    - `nBufYSize`: the height of the buffer image into which the desired region is to be read, or from which it is to be written.

    - `eBufType`: the type of the pixel values in the pData data buffer. The pixel values will automatically be translated to/from the GDALRasterBand data type as needed.

    - `nBandCount`: the number of bands being read or written.

    - `panBandMap`: the list of nBandCount band numbers being read/written. Note band numbers are 1 based. This may be NULL to select the first nBandCount bands.

    - `nPixelSpace`: The byte offset from the start of one pixel value in pData to the start of the next pixel value within a scanline. If defaulted (0) the size of the datatype eBufType is used.

    - `nLineSpace`: The byte offset from the start of one scanline in pData to the start of the next. If defaulted the size of the datatype eBufType * nBufXSize is used.

    - `nBandSpace`: the byte offset from the start of one bands data to the start of the next. If defaulted (zero) the value will be nLineSpace * nBufYSize implying band sequential organization of the data buffer.

    - `papszOptions`: Driver specific control options in a string list or NULL. Consult driver documentation for options supported.

void `GDALEndAsyncReader`(GDALDatasetH hDS, GDALAsyncReaderH hAsynchReaderH)

  End asynchronous request.

  This method destroys an asynchronous io request and recovers all resources associated with it.

  This method is the same as the C++ method GDALDataset::EndAsyncReader().

  Parameters

    - `hDS`: handle to the dataset object.

    - `hAsyncReaderH`: handle returned by GDALBeginAsyncReader()

CPLErr `GDALDatasetRasterIO`(GDALDatasetH hDS, GDALRWFlag eRWFlag, int nDSXOff, int nDSYOff, int nDSXSize, int nDSYSize, void *pBuffer, int nBXSize, int nBYSize, GDALDataType eBDataType, int nBandCount, int *panBandCount, int nPixelSpace, int nLineSpace, int nBandSpace)

  Read/write a region of image data from multiple bands.

  Use GDALDatasetRasterIOEx() if 64 bit spacings or extra arguments (resampling resolution, progress callback, etc. are needed)

  See

    GDALDataset::RasterIO()

CPLErr `GDALDatasetRasterIOEx`(GDALDatasetH hDS, GDALRWFlag eRWFlag, int nDSXOff, int nDSYOff, int nDSXSize, int nDSYSize, void *pBuffer, int nBXSize, int nBYSize, GDALDataType eBDataType, int nBandCount, int *panBandCount, GSpacing nPixelSpace, GSpacing nLineSpace, GSpacing nBandSpace, GDALRasterIOExtraArg *psExtraArg)

  Read/write a region of image data from multiple bands.

  See

    GDALDataset::RasterIO()

  Since

    GDAL 2.0

CPLErr `GDALDatasetAdviseRead`(GDALDatasetH hDS, int nDSXOff, int nDSYOff, int nDSXSize, int nDSYSize, int nBXSize, int nBYSize, GDALDataType eBDataType, int nBandCount, int *panBandCount, CSLConstList papszOptions)

  Advise driver of upcoming read requests.

  See

    GDALDataset::AdviseRead()

const char *`GDALGetProjectionRef`(GDALDatasetH hDS)

  Fetch the projection definition string for this dataset.

  See

    GDALDataset::GetProjectionRef()

OGRSpatialReferenceH `GDALGetSpatialRef`(GDALDatasetH hDS)

  Fetch the projection definition string for this dataset.

  Since

    GDAL 3.0

  See

    GDALDataset::GetSpatialRef()

CPLErr `GDALSetProjection`(GDALDatasetH hDS, const char *pszProjection)

  Set the projection reference string for this dataset.

  See

    GDALDataset::SetProjection()

CPLErr `GDALSetSpatialRef`(GDALDatasetH hDS, OGRSpatialReferenceH hSRS)

  Set the spatial reference system for this dataset.

  Since

    GDAL 3.0

  See

    GDALDataset::SetSpatialRef()

CPLErr `GDALGetGeoTransform`(GDALDatasetH hDS, double *padfTransform)

  Fetch the affine transformation coefficients.

  See

    GDALDataset::GetGeoTransform()

CPLErr `GDALSetGeoTransform`(GDALDatasetH hDS, double *padfTransform)

  Set the affine transformation coefficients.

  See

    GDALDataset::SetGeoTransform()

int `GDALGetGCPCount`(GDALDatasetH hDS)

  Get number of GCPs.

  See

    GDALDataset::GetGCPCount()

const char *`GDALGetGCPProjection`(GDALDatasetH hDS)

  Get output projection for GCPs.

  See

    GDALDataset::GetGCPProjection()

OGRSpatialReferenceH `GDALGetGCPSpatialRef`(GDALDatasetH hDS)

  Get output spatial reference system for GCPs.

  Since

    GDAL 3.0

  See

    GDALDataset::GetGCPSpatialRef()

const GDAL_GCP *`GDALGetGCPs`(GDALDatasetH hDS)

  Fetch GCPs.

  See

    GDALDataset::GetGCPs()

CPLErr `GDALSetGCPs`(GDALDatasetH hDS, int nGCPCount, const GDAL_GCP *pasGCPList, const char *pszGCPProjection)

  Assign GCPs.

  See

    GDALDataset::SetGCPs(int, const GDAL_GCP*, const char*)

CPLErr `GDALSetGCPs2`(GDALDatasetH hDS, int nGCPCount, const GDAL_GCP *pasGCPList, OGRSpatialReferenceH hSRS)

  Assign GCPs.

  Since

    GDAL 3.0

  See

    GDALDataset::SetGCPs(int, const GDAL_GCP*, const OGRSpatialReference*)

void *`GDALGetInternalHandle`(GDALDatasetH hDS, const char *pszRequest)

  Fetch a format specific internally meaningful handle.

  See

    GDALDataset::GetInternalHandle()

int `GDALReferenceDataset`(GDALDatasetH hDataset)

  Add one to dataset reference count.

  See

    GDALDataset::Reference()

int `GDALDereferenceDataset`(GDALDatasetH hDataset)

  Subtract one from dataset reference count.

  See

    GDALDataset::Dereference()

int `GDALReleaseDataset`(GDALDatasetH hDataset)

  Drop a reference to this object, and destroy if no longer referenced.

  See

    GDALDataset::ReleaseRef()

  Since

    GDAL 2.2

CPLErr `GDALBuildOverviews`(GDALDatasetH hDataset, const char *pszResampling, int nOverviews, int *panOverviewList, int nListBands, int *panBandList, GDALProgressFunc pfnProgress, void *pProgressData)

  Build raster overview(s)

  See

    GDALDataset::BuildOverviews()

void `GDALGetOpenDatasets`(GDALDatasetH **hDS, int *pnCount)

  Fetch all open GDAL dataset handles.

  See

    GDALDataset::GetOpenDatasets()

int `GDALGetAccess`(GDALDatasetH hDS)

  Return access flag.

  See

    GDALDataset::GetAccess()

void `GDALFlushCache`(GDALDatasetH hDS)

  Flush all write cached data to disk.

  See

    GDALDataset::FlushCache().

CPLErr `GDALCreateDatasetMaskBand`(GDALDatasetH hDS, int nFlags)

  Adds a mask band to the dataset.

  See

    GDALDataset::CreateMaskBand()

CPLErr `GDALDatasetCopyWholeRaster`(GDALDatasetH hSrcDS, GDALDatasetH hDstDS, CSLConstList papszOptions, GDALProgressFunc pfnProgress, void *pProgressData)

  Copy all dataset raster data.

  This function copies the complete raster contents of one dataset to another similarly configured dataset. The source and destination dataset must have the same number of bands, and the same width and height. The bands do not have to have the same data type.

  This function is primarily intended to support implementation of driver specific CreateCopy() functions. It implements efficient copying, in particular “chunking” the copy in substantial blocks and, if appropriate, performing the transfer in a pixel interleaved fashion.

  Currently the only papszOptions value supported are :

  - “INTERLEAVE=PIXEL” to force pixel interleaved operation

  - “COMPRESSED=YES” to force alignment on target dataset block sizes to achieve best compression.

  - “SKIP_HOLES=YES” to skip chunks for which GDALGetDataCoverageStatus() returns GDAL_DATA_COVERAGE_STATUS_EMPTY (GDAL >= 2.2)

  More options may be supported in the future.

  Return

    CE_None on success, or CE_Failure on failure.

  Parameters

    - `hSrcDS`: the source dataset

    - `hDstDS`: the destination dataset

    - `papszOptions`: transfer hints in “StringList” Name=Value format.

    - `pfnProgress`: progress reporting function.

    - `pProgressData`: callback data for progress function.

CPLErr `GDALRasterBandCopyWholeRaster`(GDALRasterBandH hSrcBand, GDALRasterBandH hDstBand, const char *const *constpapszOptions, GDALProgressFunc pfnProgress, void *pProgressData)

  Copy a whole raster band.

  This function copies the complete raster contents of one band to another similarly configured band. The source and destination bands must have the same width and height. The bands do not have to have the same data type.

  It implements efficient copying, in particular “chunking” the copy in substantial blocks.

  Currently the only papszOptions value supported are :

  - “COMPRESSED=YES” to force alignment on target dataset block sizes to achieve best compression.

  - “SKIP_HOLES=YES” to skip chunks for which GDALGetDataCoverageStatus() returns GDAL_DATA_COVERAGE_STATUS_EMPTY (GDAL >= 2.2)

  Return

    CE_None on success, or CE_Failure on failure.

  Parameters

    - `hSrcBand`: the source band

    - `hDstBand`: the destination band

    - `papszOptions`: transfer hints in “StringList” Name=Value format.

    - `pfnProgress`: progress reporting function.

    - `pProgressData`: callback data for progress function.

CPLErr `GDALRegenerateOverviews`(GDALRasterBandH hSrcBand, int nOverviewCount, GDALRasterBandH *pahOverviewBands, const char *pszResampling, GDALProgressFunc pfnProgress, void *pProgressData)

  Generate downsampled overviews.

  This function will generate one or more overview images from a base image using the requested downsampling algorithm. Its primary use is for generating overviews via GDALDataset::BuildOverviews(), but it can also be used to generate downsampled images in one file from another outside the overview architecture.

  The output bands need to exist in advance.

  The full set of resampling algorithms is documented in GDALDataset::BuildOverviews().

  This function will honour properly NODATA_VALUES tuples (special dataset metadata) so that only a given RGB triplet (in case of a RGB image) will be considered as the nodata value and not each value of the triplet independently per band.

  Return

    CE_None on success or CE_Failure on failure.

  Parameters

    - `hSrcBand`: the source (base level) band.

    - `nOverviewCount`: the number of downsampled bands being generated.

    - `pahOvrBands`: the list of downsampled bands to be generated.

    - `pszResampling`: Resampling algorithm (e.g. “AVERAGE”).

    - `pfnProgress`: progress report function.

    - `pProgressData`: progress function callback data.

int `GDALDatasetGetLayerCount`(GDALDatasetH hDS)

  Get the number of layers in this dataset.

  This function is the same as the C++ method GDALDataset::GetLayerCount()

  Since

    GDAL 2.0

  Return

    layer count.

  Parameters

    - `hDS`: the dataset handle.

OGRLayerH `GDALDatasetGetLayer`(GDALDatasetH hDS, int iLayer)

  Fetch a layer by index.

  The returned layer remains owned by the GDALDataset and should not be deleted by the application.

  This function is the same as the C++ method GDALDataset::GetLayer()

  Since

    GDAL 2.0

  Return

    the layer, or NULL if iLayer is out of range or an error occurs.

  Parameters

    - `hDS`: the dataset handle.

    - `iLayer`: a layer number between 0 and GetLayerCount()-1.

OGRLayerH `GDALDatasetGetLayerByName`(GDALDatasetH hDS, const char *pszName)

  Fetch a layer by name.

  The returned layer remains owned by the GDALDataset and should not be deleted by the application.

  This function is the same as the C++ method GDALDataset::GetLayerByName()

  Since

    GDAL 2.0

  Return

    the layer, or NULL if Layer is not found or an error occurs.

  Parameters

    - `hDS`: the dataset handle.

    - `pszName`: the layer name of the layer to fetch.

OGRErr `GDALDatasetDeleteLayer`(GDALDatasetH hDS, int iLayer)

  Delete the indicated layer from the datasource.

  If this function is supported the ODsCDeleteLayer capability will test TRUE on the GDALDataset.

  This method is the same as the C++ method GDALDataset::DeleteLayer().

  Since

    GDAL 2.0

  Return

    OGRERR_NONE on success, or OGRERR_UNSUPPORTED_OPERATION if deleting layers is not supported for this datasource.

  Parameters

    - `hDS`: the dataset handle.

    - `iLayer`: the index of the layer to delete.

OGRLayerH `GDALDatasetCreateLayer`(GDALDatasetH hDS, const char *pszName, OGRSpatialReferenceH hSpatialRef, OGRwkbGeometryType eGType, CSLConstList papszOptions)

  This function attempts to create a new layer on the dataset with the indicated name, coordinate system, geometry type.

  The papszOptions argument can be used to control driver specific creation options. These options are normally documented in the format specific documentation.

  This method is the same as the C++ method GDALDataset::CreateLayer().

  Example:

      #include "gdal.h"
      #include "cpl_string.h"

      ...

              OGRLayerH  hLayer;
              char     **papszOptions;

              if( !GDALDatasetTestCapability( hDS, ODsCCreateLayer ) )
              {
              ...
              }

              papszOptions = CSLSetNameValue( papszOptions, "DIM", "2" );
              hLayer = GDALDatasetCreateLayer( hDS, "NewLayer", NULL, wkbUnknown,
                                               papszOptions );
              CSLDestroy( papszOptions );

              if( hLayer == NULL )
              {
                  ...
              }

  Since

    GDAL 2.0

  Return

    NULL is returned on failure, or a new OGRLayer handle on success.

  Parameters

    - `hDS`: the dataset handle

    - `pszName`: the name for the new layer. This should ideally not match any existing layer on the datasource.

    - `hSpatialRef`: the coordinate system to use for the new layer, or NULL if no coordinate system is available. The driver might only increase the reference counter of the object to take ownership, and not make a full copy, so do not use OSRDestroySpatialReference(), but OSRRelease() instead when you are done with the object.

    - `eGType`: the geometry type for the layer. Use wkbUnknown if there are no constraints on the types geometry to be written.

    - `papszOptions`: a StringList of name=value options. Options are driver specific.

OGRLayerH `GDALDatasetCopyLayer`(GDALDatasetH hDS, OGRLayerH hSrcLayer, const char *pszNewName, CSLConstList papszOptions)

  Duplicate an existing layer.

  This function creates a new layer, duplicate the field definitions of the source layer and then duplicate each features of the source layer. The papszOptions argument can be used to control driver specific creation options. These options are normally documented in the format specific documentation. The source layer may come from another dataset.

  This method is the same as the C++ method GDALDataset::CopyLayer()

  Since

    GDAL 2.0

  Return

    an handle to the layer, or NULL if an error occurs.

  Parameters

    - `hDS`: the dataset handle.

    - `hSrcLayer`: source layer.

    - `pszNewName`: the name of the layer to create.

    - `papszOptions`: a StringList of name=value options. Options are driver specific.

void `GDALDatasetResetReading`(GDALDatasetH hDS)

  Reset feature reading to start on the first feature.

  This affects GDALDatasetGetNextFeature().

  Depending on drivers, this may also have the side effect of calling OGR_L_ResetReading() on the layers of this dataset.

  This method is the same as the C++ method GDALDataset::ResetReading()

  Since

    GDAL 2.2

  Parameters

    - `hDS`: dataset handle

OGRFeatureH `GDALDatasetGetNextFeature`(GDALDatasetH hDS, OGRLayerH *phBelongingLayer, double *pdfProgressPct, GDALProgressFunc pfnProgress, void *pProgressData)

  Fetch the next available feature from this dataset.

  This method is intended for the few drivers where OGR_L_GetNextFeature() is not efficient, but in general OGR_L_GetNextFeature() is a more natural API.

  The returned feature becomes the responsibility of the caller to delete with OGRFeature::DestroyFeature().

  Depending on the driver, this method may return features from layers in a non sequential way. This is what may happen when the ODsCRandomLayerRead capability is declared (for example for the OSM and GMLAS drivers). When datasets declare this capability, it is strongly advised to use GDALDataset::GetNextFeature() instead of OGRLayer::GetNextFeature(), as the later might have a slow, incomplete or stub implementation.

  The default implementation, used by most drivers, will however iterate over each layer, and then over each feature within this layer.

  This method takes into account spatial and attribute filters set on layers that will be iterated upon.

  The ResetReading() method can be used to start at the beginning again.

  Depending on drivers, this may also have the side effect of calling OGRLayer::GetNextFeature() on the layers of this dataset.

  This method is the same as the C++ method GDALDataset::GetNextFeature()

  Return

    a feature, or NULL if no more features are available.

  Since

    GDAL 2.2

  Parameters

    - `hDS`: dataset handle.

    - `phBelongingLayer`: a pointer to a OGRLayer* variable to receive the layer to which the object belongs to, or NULL. It is possible that the output of *ppoBelongingLayer to be NULL despite the feature not being NULL.

    - `pdfProgressPct`: a pointer to a double variable to receive the percentage progress (in [0,1] range), or NULL. On return, the pointed value might be negative if determining the progress is not possible.

    - `pfnProgress`: a progress callback to report progress (for GetNextFeature() calls that might have a long duration) and offer cancellation possibility, or NULL

    - `pProgressData`: user data provided to pfnProgress, or NULL

int `GDALDatasetTestCapability`(GDALDatasetH hDS, const char *pszCap)

  Test if capability is available.

  One of the following dataset capability names can be passed into this function, and a TRUE or FALSE value will be returned indicating whether or not the capability is available for this object.

  - ODsCCreateLayer: True if this datasource can create new layers.

  - ODsCDeleteLayer: True if this datasource can delete existing layers.

  - ODsCCreateGeomFieldAfterCreateLayer: True if the layers of this datasource support CreateGeomField() just after layer creation.

  - ODsCCurveGeometries: True if this datasource supports curve geometries.

  - ODsCTransactions: True if this datasource supports (efficient) transactions.

  - ODsCEmulatedTransactions: True if this datasource supports transactions through emulation.

  - ODsCRandomLayerRead: True if this datasource has a dedicated GetNextFeature() implementation, potentially returning features from layers in a non sequential way.

  - ODsCRandomLayerWrite: True if this datasource supports calling CreateFeature() on layers in a non sequential way.

  The #define macro forms of the capability names should be used in preference to the strings themselves to avoid misspelling.

  This function is the same as the C++ method GDALDataset::TestCapability()

  Since

    GDAL 2.0

  Return

    TRUE if capability available otherwise FALSE.

  Parameters

    - `hDS`: the dataset handle.

    - `pszCap`: the capability to test.

OGRLayerH `GDALDatasetExecuteSQL`(GDALDatasetH hDS, const char *pszStatement, OGRGeometryH hSpatialFilter, const char *pszDialect)

  Execute an SQL statement against the data store.

  The result of an SQL query is either NULL for statements that are in error, or that have no results set, or an OGRLayer pointer representing a results set from the query. Note that this OGRLayer is in addition to the layers in the data store and must be destroyed with ReleaseResultSet() before the dataset is closed (destroyed).

  This method is the same as the C++ method GDALDataset::ExecuteSQL()

  For more information on the SQL dialect supported internally by OGR review the OGR SQL document. Some drivers (i.e. Oracle and PostGIS) pass the SQL directly through to the underlying RDBMS.

  Starting with OGR 1.10, the SQLITE dialect can also be used.

  Since

    GDAL 2.0

  Return

    an OGRLayer containing the results of the query. Deallocate with ReleaseResultSet().

  Parameters

    - `hDS`: the dataset handle.

    - `pszStatement`: the SQL statement to execute.

    - `hSpatialFilter`: geometry which represents a spatial filter. Can be NULL.

    - `pszDialect`: allows control of the statement dialect. If set to NULL, the OGR SQL engine will be used, except for RDBMS drivers that will use their dedicated SQL engine, unless OGRSQL is explicitly passed as the dialect. Starting with OGR 1.10, the SQLITE dialect can also be used.

void `GDALDatasetReleaseResultSet`(GDALDatasetH hDS, OGRLayerH hLayer)

  Release results of ExecuteSQL().

  This function should only be used to deallocate OGRLayers resulting from an ExecuteSQL() call on the same GDALDataset. Failure to deallocate a results set before destroying the GDALDataset may cause errors.

  This function is the same as the C++ method GDALDataset::ReleaseResultSet()

  Since

    GDAL 2.0

  Parameters

    - `hDS`: the dataset handle.

    - `hLayer`: the result of a previous ExecuteSQL() call.

OGRStyleTableH `GDALDatasetGetStyleTable`(GDALDatasetH hDS)

  Returns dataset style table.

  This function is the same as the C++ method GDALDataset::GetStyleTable()

  Since

    GDAL 2.0

  Return

    handle to a style table which should not be modified or freed by the caller.

  Parameters

    - `hDS`: the dataset handle

void `GDALDatasetSetStyleTableDirectly`(GDALDatasetH hDS, OGRStyleTableH hStyleTable)

  Set dataset style table.

  This function operate exactly as GDALDatasetSetStyleTable() except that it assumes ownership of the passed table.

  This function is the same as the C++ method GDALDataset::SetStyleTableDirectly()

  Since

    GDAL 2.0

  Parameters

    - `hDS`: the dataset handle

    - `hStyleTable`: style table handle to set

void `GDALDatasetSetStyleTable`(GDALDatasetH hDS, OGRStyleTableH hStyleTable)

  Set dataset style table.

  This function operate exactly as GDALDatasetSetStyleTableDirectly() except that it assumes ownership of the passed table.

  This function is the same as the C++ method GDALDataset::SetStyleTable()

  Since

    GDAL 2.0

  Parameters

    - `hDS`: the dataset handle

    - `hStyleTable`: style table handle to set

OGRErr `GDALDatasetStartTransaction`(GDALDatasetH hDS, int bForce)

  For datasources which support transactions, StartTransaction creates a transaction.

  If starting the transaction fails, will return OGRERR_FAILURE. Datasources which do not support transactions will always return OGRERR_UNSUPPORTED_OPERATION.

  Nested transactions are not supported.

  All changes done after the start of the transaction are definitely applied in the datasource if CommitTransaction() is called. They may be canceled by calling RollbackTransaction() instead.

  At the time of writing, transactions only apply on vector layers.

  Datasets that support transactions will advertise the ODsCTransactions capability. Use of transactions at dataset level is generally preferred to transactions at layer level, whose scope is rarely limited to the layer from which it was started.

  In case StartTransaction() fails, neither CommitTransaction() or RollbackTransaction() should be called.

  If an error occurs after a successful StartTransaction(), the whole transaction may or may not be implicitly canceled, depending on drivers. (e.g. the PG driver will cancel it, SQLite/GPKG not). In any case, in the event of an error, an explicit call to RollbackTransaction() should be done to keep things balanced.

  By default, when bForce is set to FALSE, only “efficient” transactions will be attempted. Some drivers may offer an emulation of transactions, but sometimes with significant overhead, in which case the user must explicitly allow for such an emulation by setting bForce to TRUE. Drivers that offer emulated transactions should advertise the ODsCEmulatedTransactions capability (and not ODsCTransactions).

  This function is the same as the C++ method GDALDataset::StartTransaction()

  Return

    OGRERR_NONE on success.

  Since

    GDAL 2.0

  Parameters

    - `hDS`: the dataset handle.

    - `bForce`: can be set to TRUE if an emulation, possibly slow, of a transaction mechanism is acceptable.

OGRErr `GDALDatasetCommitTransaction`(GDALDatasetH hDS)

  For datasources which support transactions, CommitTransaction commits a transaction.

  If no transaction is active, or the commit fails, will return OGRERR_FAILURE. Datasources which do not support transactions will always return OGRERR_UNSUPPORTED_OPERATION.

  Depending on drivers, this may or may not abort layer sequential readings that are active.

  This function is the same as the C++ method GDALDataset::CommitTransaction()

  Return

    OGRERR_NONE on success.

  Since

    GDAL 2.0

OGRErr `GDALDatasetRollbackTransaction`(GDALDatasetH hDS)

  For datasources which support transactions, RollbackTransaction will roll back a datasource to its state before the start of the current transaction.

  If no transaction is active, or the rollback fails, will return OGRERR_FAILURE. Datasources which do not support transactions will always return OGRERR_UNSUPPORTED_OPERATION.

  This function is the same as the C++ method GDALDataset::RollbackTransaction().

  Return

    OGRERR_NONE on success.

  Since

    GDAL 2.0

GDALDataType `GDALGetRasterDataType`(GDALRasterBandH hBand)

  Fetch the pixel data type for this band.

  See

    GDALRasterBand::GetRasterDataType()

void `GDALGetBlockSize`(GDALRasterBandH hBand, int *pnXSize, int *pnYSize)

  Fetch the “natural” block size of this band.

  See

    GDALRasterBand::GetBlockSize()

CPLErr `GDALGetActualBlockSize`(GDALRasterBandH hBand, int nXBlockOff, int nYBlockOff, int *pnXValid, int *pnYValid)

  Retrieve the actual block size for a given block offset.

  See

    GDALRasterBand::GetActualBlockSize()

CPLErr `GDALRasterAdviseRead`(GDALRasterBandH hRB, int nDSXOff, int nDSYOff, int nDSXSize, int nDSYSize, int nBXSize, int nBYSize, GDALDataType eBDataType, CSLConstList papszOptions)

  Advise driver of upcoming read requests.

  See

    GDALRasterBand::AdviseRead()

CPLErr `GDALRasterIO`(GDALRasterBandH hRBand, GDALRWFlag eRWFlag, int nDSXOff, int nDSYOff, int nDSXSize, int nDSYSize, void *pBuffer, int nBXSize, int nBYSize, GDALDataType eBDataType, int nPixelSpace, int nLineSpace)

  Read/write a region of image data for this band.

  Use GDALRasterIOEx() if 64 bit spacings or extra arguments (resampling resolution, progress callback, etc. are needed)

  See

    GDALRasterBand::RasterIO()

CPLErr `GDALRasterIOEx`(GDALRasterBandH hRBand, GDALRWFlag eRWFlag, int nDSXOff, int nDSYOff, int nDSXSize, int nDSYSize, void *pBuffer, int nBXSize, int nBYSize, GDALDataType eBDataType, GSpacing nPixelSpace, GSpacing nLineSpace, GDALRasterIOExtraArg *psExtraArg)

  Read/write a region of image data for this band.

  See

    GDALRasterBand::RasterIO()

  Since

    GDAL 2.0

CPLErr `GDALReadBlock`(GDALRasterBandH hBand, int nXOff, int nYOff, void *pData)

  Read a block of image data efficiently.

  See

    GDALRasterBand::ReadBlock()

CPLErr `GDALWriteBlock`(GDALRasterBandH hBand, int nXOff, int nYOff, void *pData)

  Write a block of image data efficiently.

  See

    GDALRasterBand::WriteBlock()

int `GDALGetRasterBandXSize`(GDALRasterBandH hBand)

  Fetch XSize of raster.

  See

    GDALRasterBand::GetXSize()

int `GDALGetRasterBandYSize`(GDALRasterBandH hBand)

  Fetch YSize of raster.

  See

    GDALRasterBand::GetYSize()

GDALAccess `GDALGetRasterAccess`(GDALRasterBandH hBand)

  Find out if we have update permission for this band.

  See

    GDALRasterBand::GetAccess()

int `GDALGetBandNumber`(GDALRasterBandH hBand)

  Fetch the band number.

  See

    GDALRasterBand::GetBand()

GDALDatasetH `GDALGetBandDataset`(GDALRasterBandH hBand)

  Fetch the owning dataset handle.

  See

    GDALRasterBand::GetDataset()

GDALColorInterp `GDALGetRasterColorInterpretation`(GDALRasterBandH hBand)

  How should this band be interpreted as color?

  See

    GDALRasterBand::GetColorInterpretation()

CPLErr `GDALSetRasterColorInterpretation`(GDALRasterBandH hBand, GDALColorInterp eColorInterp)

  Set color interpretation of a band.

  See

    GDALRasterBand::SetColorInterpretation()

GDALColorTableH `GDALGetRasterColorTable`(GDALRasterBandH hBand)

  Fetch the color table associated with band.

  See

    GDALRasterBand::GetColorTable()

CPLErr `GDALSetRasterColorTable`(GDALRasterBandH hBand, GDALColorTableH hCT)

  Set the raster color table.

  See

    GDALRasterBand::SetColorTable()

int `GDALHasArbitraryOverviews`(GDALRasterBandH hBand)

  Check for arbitrary overviews.

  See

    GDALRasterBand::HasArbitraryOverviews()

int `GDALGetOverviewCount`(GDALRasterBandH hBand)

  Return the number of overview layers available.

  See

    GDALRasterBand::GetOverviewCount()

GDALRasterBandH `GDALGetOverview`(GDALRasterBandH hBand, int i)

  Fetch overview raster band object.

  See

    GDALRasterBand::GetOverview()

double `GDALGetRasterNoDataValue`(GDALRasterBandH hBand, int *pbSuccess)

  Fetch the no data value for this band.

  See

    GDALRasterBand::GetNoDataValue()

CPLErr `GDALSetRasterNoDataValue`(GDALRasterBandH hBand, double dfValue)

  Set the no data value for this band.

  Depending on drivers, changing the no data value may or may not have an effect on the pixel values of a raster that has just been created. It is thus advised to explicitly called Fill() if the intent is to initialize the raster to the nodata value. In ay case, changing an existing no data value, when one already exists and the dataset exists or has been initialized, has no effect on the pixel whose value matched the previous nodata value.

  See

    GDALRasterBand::SetNoDataValue()

CPLErr `GDALDeleteRasterNoDataValue`(GDALRasterBandH hBand)

  Remove the no data value for this band.

  See

    GDALRasterBand::DeleteNoDataValue()

  Since

    GDAL 2.1

char **`GDALGetRasterCategoryNames`(GDALRasterBandH hBand)

  Fetch the list of category names for this raster.

  See

    GDALRasterBand::GetCategoryNames()

CPLErr `GDALSetRasterCategoryNames`(GDALRasterBandH hBand, CSLConstList papszNames)

  Set the category names for this band.

  See

    GDALRasterBand::SetCategoryNames()

double `GDALGetRasterMinimum`(GDALRasterBandH hBand, int *pbSuccess)

  Fetch the minimum value for this band.

  See

    GDALRasterBand::GetMinimum()

double `GDALGetRasterMaximum`(GDALRasterBandH hBand, int *pbSuccess)

  Fetch the maximum value for this band.

  See

    GDALRasterBand::GetMaximum()

CPLErr `GDALGetRasterStatistics`(GDALRasterBandH hBand, int bApproxOK, int bForce, double *pdfMin, double *pdfMax, double *pdfMean, double *pdfStdDev)

  Fetch image statistics.

  See

    GDALRasterBand::GetStatistics()

CPLErr `GDALComputeRasterStatistics`(GDALRasterBandH hBand, int bApproxOK, double *pdfMin, double *pdfMax, double *pdfMean, double *pdfStdDev, GDALProgressFunc pfnProgress, void *pProgressData)

  Compute image statistics.

  See

    GDALRasterBand::ComputeStatistics()

CPLErr `GDALSetRasterStatistics`(GDALRasterBandH hBand, double dfMin, double dfMax, double dfMean, double dfStdDev)

  Set statistics on band.

  See

    GDALRasterBand::SetStatistics()

GDALMDArrayH `GDALRasterBandAsMDArray`(GDALRasterBandH hBand)

  Return a view of this raster band as a 2D multidimensional GDALMDArray.

  The band must be linked to a GDALDataset. If this dataset is not already marked as shared, it will be, so that the returned array holds a reference to it.

  If the dataset has a geotransform attached, the X and Y dimensions of the returned array will have an associated indexing variable.

  The returned pointer must be released with GDALMDArrayRelease().

  This is the same as the C++ method GDALRasterBand::AsMDArray().

  Return

    a new array, or NULL.

  Since

    GDAL 3.1

const char *`GDALGetRasterUnitType`(GDALRasterBandH hBand)

  Return raster unit type.

  See

    GDALRasterBand::GetUnitType()

CPLErr `GDALSetRasterUnitType`(GDALRasterBandH hBand, const char *pszNewValue)

  Set unit type.

  See

    GDALRasterBand::SetUnitType()

  Since

    GDAL 1.8.0

double `GDALGetRasterOffset`(GDALRasterBandH hBand, int *pbSuccess)

  Fetch the raster value offset.

  See

    GDALRasterBand::GetOffset()

CPLErr `GDALSetRasterOffset`(GDALRasterBandH hBand, double dfNewOffset)

  Set scaling offset.

  See

    GDALRasterBand::SetOffset()

double `GDALGetRasterScale`(GDALRasterBandH hBand, int *pbSuccess)

  Fetch the raster value scale.

  See

    GDALRasterBand::GetScale()

CPLErr `GDALSetRasterScale`(GDALRasterBandH hBand, double dfNewOffset)

  Set scaling ratio.

  See

    GDALRasterBand::SetScale()

void `GDALComputeRasterMinMax`(GDALRasterBandH hBand, int bApproxOK, double adfMinMax[2])

  Compute the min/max values for a band.

  See

    GDALRasterBand::ComputeRasterMinMax()

CPLErr `GDALFlushRasterCache`(GDALRasterBandH hBand)

  Flush raster data cache.

  See

    GDALRasterBand::FlushCache()

CPLErr `GDALGetRasterHistogram`(GDALRasterBandH hBand, double dfMin, double dfMax, int nBuckets, int *panHistogram, int bIncludeOutOfRange, int bApproxOK, GDALProgressFunc pfnProgress, void *pProgressData)

  Compute raster histogram.

  Use GDALGetRasterHistogramEx() instead to get correct counts for values exceeding 2 billion.

  See

    GDALRasterBand::GetHistogram()

  See

    GDALGetRasterHistogramEx()

CPLErr `GDALGetRasterHistogramEx`(GDALRasterBandH hBand, double dfMin, double dfMax, int nBuckets, GUIntBig *panHistogram, int bIncludeOutOfRange, int bApproxOK, GDALProgressFunc pfnProgress, void *pProgressData)

  Compute raster histogram.

  See

    GDALRasterBand::GetHistogram()

  Since

    GDAL 2.0

CPLErr `GDALGetDefaultHistogram`(GDALRasterBandH hBand, double *pdfMin, double *pdfMax, int *pnBuckets, int **ppanHistogram, int bForce, GDALProgressFunc pfnProgress, void *pProgressData)

  Fetch default raster histogram.

  Use GDALGetRasterHistogramEx() instead to get correct counts for values exceeding 2 billion.

  See

    GDALRasterBand::GDALGetDefaultHistogram()

  See

    GDALGetRasterHistogramEx()

CPLErr `GDALGetDefaultHistogramEx`(GDALRasterBandH hBand, double *pdfMin, double *pdfMax, int *pnBuckets, GUIntBig **ppanHistogram, int bForce, GDALProgressFunc pfnProgress, void *pProgressData)

  Fetch default raster histogram.

  See

    GDALRasterBand::GetDefaultHistogram()

  Since

    GDAL 2.0

CPLErr `GDALSetDefaultHistogram`(GDALRasterBandH hBand, double dfMin, double dfMax, int nBuckets, int *panHistogram)

  Set default histogram.

  Use GDALSetRasterHistogramEx() instead to be able to set counts exceeding 2 billion.

  See

    GDALRasterBand::SetDefaultHistogram()

  See

    GDALSetRasterHistogramEx()

CPLErr `GDALSetDefaultHistogramEx`(GDALRasterBandH hBand, double dfMin, double dfMax, int nBuckets, GUIntBig *panHistogram)

  Set default histogram.

  See

    GDALRasterBand::SetDefaultHistogram()

  Since

    GDAL 2.0

int `GDALGetRandomRasterSample`(GDALRasterBandH hBand, int nSamples, float *pafSampleBuf)

  Undocumented.

  Return

    undocumented

  Parameters

    - `hBand`: undocumented.

    - `nSamples`: undocumented.

    - `pafSampleBuf`: undocumented.

GDALRasterBandH `GDALGetRasterSampleOverview`(GDALRasterBandH hBand, int nDesiredSamples)

  Fetch best sampling overview.

  Use GDALGetRasterSampleOverviewEx() to be able to specify more than 2 billion samples.

  See

    GDALRasterBand::GetRasterSampleOverview()

  See

    GDALGetRasterSampleOverviewEx()

GDALRasterBandH `GDALGetRasterSampleOverviewEx`(GDALRasterBandH hBand, GUIntBig nDesiredSamples)

  Fetch best sampling overview.

  See

    GDALRasterBand::GetRasterSampleOverview()

  Since

    GDAL 2.0

CPLErr `GDALFillRaster`(GDALRasterBandH hBand, double dfRealValue, double dfImaginaryValue)

  Fill this band with a constant value.

  See

    GDALRasterBand::Fill()

CPLErr `GDALComputeBandStats`(GDALRasterBandH hBand, int nSampleStep, double *pdfMean, double *pdfStdDev, GDALProgressFunc pfnProgress, void *pProgressData)

  Undocumented.

  Return

    undocumented

  Parameters

    - `hSrcBand`: undocumented.

    - `nSampleStep`: undocumented.

    - `pdfMean`: undocumented.

    - `pdfStdDev`: undocumented.

    - `pfnProgress`: undocumented.

    - `pProgressData`: undocumented.

CPLErr `GDALOverviewMagnitudeCorrection`(GDALRasterBandH hBaseBand, int nOverviewCount, GDALRasterBandH *pahOverviews, GDALProgressFunc pfnProgress, void *pProgressData)

  Undocumented.

  Return

    undocumented

  Parameters

    - `hBaseBand`: undocumented.

    - `nOverviewCount`: undocumented.

    - `pahOverviews`: undocumented.

    - `pfnProgress`: undocumented.

    - `pProgressData`: undocumented.

GDALRasterAttributeTableH `GDALGetDefaultRAT`(GDALRasterBandH hBand)

  Fetch default Raster Attribute Table.

  See

    GDALRasterBand::GetDefaultRAT()

CPLErr `GDALSetDefaultRAT`(GDALRasterBandH hBand, GDALRasterAttributeTableH hRAT)

  Set default Raster Attribute Table.

  See

    GDALRasterBand::GDALSetDefaultRAT()

CPLErr `GDALAddDerivedBandPixelFunc`(const char *pszName, GDALDerivedPixelFunc pfnPixelFunc)

  This adds a pixel function to the global list of available pixel functions for derived bands.

  Pixel functions must be registered in this way before a derived band tries to access data.

  Derived bands are stored with only the name of the pixel function that it will apply, and if a pixel function matching the name is not found the IRasterIO() call will do nothing.

  Return

    CE_None, invalid (NULL) parameters are currently ignored.

  Parameters

    - `pszFuncName`: Name used to access pixel function

    - `pfnNewFunction`: Pixel function associated with name. An existing pixel function registered with the same name will be replaced with the new one.

GDALRasterBandH `GDALGetMaskBand`(GDALRasterBandH hBand)

  Return the mask band associated with the band.

  See

    GDALRasterBand::GetMaskBand()

int `GDALGetMaskFlags`(GDALRasterBandH hBand)

  Return the status flags of the mask band associated with the band.

  See

    GDALRasterBand::GetMaskFlags()

CPLErr `GDALCreateMaskBand`(GDALRasterBandH hBand, int nFlags)

  Adds a mask band to the current band.

  See

    GDALRasterBand::CreateMaskBand()

int `GDALGetDataCoverageStatus`(GDALRasterBandH hBand, int nXOff, int nYOff, int nXSize, int nYSize, int nMaskFlagStop, double *pdfDataPct)

  Get the coverage status of a sub-window of the raster.

  Returns whether a sub-window of the raster contains only data, only empty blocks or a mix of both. This function can be used to determine quickly if it is worth issuing RasterIO / ReadBlock requests in datasets that may be sparse.

  Empty blocks are blocks that are generally not physically present in the file, and when read through GDAL, contain only pixels whose value is the nodata value when it is set, or whose value is 0 when the nodata value is not set.

  The query is done in an efficient way without reading the actual pixel values. If not possible, or not implemented at all by the driver, GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED | GDAL_DATA_COVERAGE_STATUS_DATA will be returned.

  The values that can be returned by the function are the following, potentially combined with the binary or operator :

  - GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED : the driver does not implement GetDataCoverageStatus(). This flag should be returned together with GDAL_DATA_COVERAGE_STATUS_DATA.

  - GDAL_DATA_COVERAGE_STATUS_DATA: There is (potentially) data in the queried window.

  - GDAL_DATA_COVERAGE_STATUS_EMPTY: There is nodata in the queried window. This is typically identified by the concept of missing block in formats that supports it.

  Note that GDAL_DATA_COVERAGE_STATUS_DATA might have false positives and should be interpreted more as hint of potential presence of data. For example if a GeoTIFF file is created with blocks filled with zeroes (or set to the nodata value), instead of using the missing block mechanism, GDAL_DATA_COVERAGE_STATUS_DATA will be returned. On the contrary, GDAL_DATA_COVERAGE_STATUS_EMPTY should have no false positives.

  The nMaskFlagStop should be generally set to 0. It can be set to a binary-or’ed mask of the above mentioned values to enable a quick exiting of the function as soon as the computed mask matches the nMaskFlagStop. For example, you can issue a request on the whole raster with nMaskFlagStop = GDAL_DATA_COVERAGE_STATUS_EMPTY. As soon as one missing block is encountered, the function will exit, so that you can potentially refine the requested area to find which particular region(s) have missing blocks.

  See

    GDALRasterBand::GetDataCoverageStatus()

  Return

    a binary-or’ed combination of possible values GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED, GDAL_DATA_COVERAGE_STATUS_DATA and GDAL_DATA_COVERAGE_STATUS_EMPTY

  Note

    Added in GDAL 2.2

  Parameters

    - `hBand`: raster band

    - `nXOff`: The pixel offset to the top left corner of the region of the band to be queried. This would be zero to start from the left side.

    - `nYOff`: The line offset to the top left corner of the region of the band to be queried. This would be zero to start from the top.

    - `nXSize`: The width of the region of the band to be queried in pixels.

    - `nYSize`: The height of the region of the band to be queried in lines.

    - `nMaskFlagStop`: 0, or a binary-or’ed mask of possible values GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED, GDAL_DATA_COVERAGE_STATUS_DATA and GDAL_DATA_COVERAGE_STATUS_EMPTY. As soon as the computation of the coverage matches the mask, the computation will be stopped. *pdfDataPct will not be valid in that case.

    - `pdfDataPct`: Optional output parameter whose pointed value will be set to the (approximate) percentage in [0,100] of pixels in the queried sub-window that have valid values. The implementation might not always be able to compute it, in which case it will be set to a negative value.

GDALAsyncStatusType `GDALARGetNextUpdatedRegion`(GDALAsyncReaderH hARIO, double dfTimeout, int *pnXBufOff, int *pnYBufOff, int *pnXBufSize, int *pnYBufSize)

  Get async IO update.

  Provide an opportunity for an asynchronous IO request to update the image buffer and return an indication of the area of the buffer that has been updated.

  The dfTimeout parameter can be used to wait for additional data to become available. The timeout does not limit the amount of time this method may spend actually processing available data.

  The following return status are possible.

  - GARIO_PENDING: No imagery was altered in the buffer, but there is still activity pending, and the application should continue to call GetNextUpdatedRegion() as time permits.

  - GARIO_UPDATE: Some of the imagery has been updated, but there is still activity pending.

  - GARIO_ERROR: Something has gone wrong. The asynchronous request should be ended.

  - GARIO_COMPLETE: An update has occurred and there is no more pending work on this request. The request should be ended and the buffer used.

  This is the same as GDALAsyncReader::GetNextUpdatedRegion()

  Return

    GARIO_ status, details described above.

  Parameters

    - `hARIO`: handle to the async reader.

    - `dfTimeout`: the number of seconds to wait for additional updates. Use -1 to wait indefinitely, or zero to not wait at all if there is no data available.

    - `pnBufXOff`: location to return the X offset of the area of the request buffer that has been updated.

    - `pnBufYOff`: location to return the Y offset of the area of the request buffer that has been updated.

    - `pnBufXSize`: location to return the X size of the area of the request buffer that has been updated.

    - `pnBufYSize`: location to return the Y size of the area of the request buffer that has been updated.

int `GDALARLockBuffer`(GDALAsyncReaderH hARIO, double dfTimeout)

  Lock image buffer.

  Locks the image buffer passed into GDALDataset::BeginAsyncReader(). This is useful to ensure the image buffer is not being modified while it is being used by the application. UnlockBuffer() should be used to release this lock when it is no longer needed.

  This is the same as GDALAsyncReader::LockBuffer()

  Return

    TRUE if successful, or FALSE on an error.

  Parameters

    - `hARIO`: handle to async reader.

    - `dfTimeout`: the time in seconds to wait attempting to lock the buffer. -1.0 to wait indefinitely and 0 to not wait at all if it can’t be acquired immediately. Default is -1.0 (infinite wait).

void `GDALARUnlockBuffer`(GDALAsyncReaderH hARIO)

  Unlock image buffer.

  Releases a lock on the image buffer previously taken with LockBuffer().

  This is the same as GDALAsyncReader::UnlockBuffer()

  Parameters

    - `hARIO`: handle to async reader.

int `GDALGeneralCmdLineProcessor`(int nArgc, char ***ppapszArgv, int nOptions)

  General utility option processing.

  This function is intended to provide a variety of generic commandline options for all GDAL commandline utilities. It takes care of the following commandline options:

  version: report version of GDAL in use. build: report build info about GDAL in use. license: report GDAL license info. formats: report all format drivers configured. format [format]: report details of one format driver. optfile filename: expand an option file into the argument list. config key value: set system configuration option. debug [on/off/value]: set debug level. mempreload dir: preload directory contents into /vsimem pause: Pause for user input (allows time to attach debugger) locale [locale]: Install a locale using setlocale() (debugging) help-general: report detailed help on general options.

  The argument array is replaced “in place” and should be freed with CSLDestroy() when no longer needed. The typical usage looks something like the following. Note that the formats should be registered so that the formats and format options will work properly.

  int main( int argc, char ** argv ) { GDALAllRegister();

  argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 ); if( argc < 1 ) exit( -argc );

  Return

    updated nArgc argument count. Return of 0 requests terminate without error, return of -1 requests exit with error code.

  Parameters

    - `nArgc`: number of values in the argument list.

    - `ppapszArgv`: pointer to the argument list array (will be updated in place).

    - `nOptions`: a or-able combination of GDAL_OF_RASTER and GDAL_OF_VECTOR to determine which drivers should be displayed by formats. If set to 0, GDAL_OF_RASTER is assumed.

void `GDALSwapWords`(void *pData, int nWordSize, int nWordCount, int nWordSkip)

  Byte swap words in-place.

  This function will byte swap a set of 2, 4 or 8 byte words “in place” in a memory array. No assumption is made that the words being swapped are word aligned in memory. Use the CPL_LSB and CPL_MSB macros from cpl_port.h to determine if the current platform is big endian or little endian. Use The macros like CPL_SWAP32() to byte swap single values without the overhead of a function call.

  Parameters

    - `pData`: pointer to start of data buffer.

    - `nWordSize`: size of words being swapped in bytes. Normally 2, 4 or 8.

    - `nWordCount`: the number of words to be swapped in this call.

    - `nWordSkip`: the byte offset from the start of one word to the start of the next. For packed buffers this is the same as nWordSize.

void `GDALSwapWordsEx`(void *pData, int nWordSize, size_t nWordCount, int nWordSkip)

  Byte swap words in-place.

  This function will byte swap a set of 2, 4 or 8 byte words “in place” in a memory array. No assumption is made that the words being swapped are word aligned in memory. Use the CPL_LSB and CPL_MSB macros from cpl_port.h to determine if the current platform is big endian or little endian. Use The macros like CPL_SWAP32() to byte swap single values without the overhead of a function call.

  Since

    GDAL 2.1

  Parameters

    - `pData`: pointer to start of data buffer.

    - `nWordSize`: size of words being swapped in bytes. Normally 2, 4 or 8.

    - `nWordCount`: the number of words to be swapped in this call.

    - `nWordSkip`: the byte offset from the start of one word to the start of the next. For packed buffers this is the same as nWordSize.

void `GDALCopyWords`(const void *pSrcData, GDALDataType eSrcType, int nSrcPixelOffset, void *pDstData, GDALDataType eDstType, int nDstPixelOffset, int nWordCount)

  Copy pixel words from buffer to buffer.

  See

    GDALCopyWords64()

void `GDALCopyWords64`(const void *pSrcData, GDALDataType eSrcType, int nSrcPixelOffset, void *pDstData, GDALDataType eDstType, int nDstPixelOffset, GPtrDiff_t nWordCount)

  Copy pixel words from buffer to buffer.

  This function is used to copy pixel word values from one memory buffer to another, with support for conversion between data types, and differing step factors. The data type conversion is done using the normal GDAL rules. Values assigned to a lower range integer type are clipped. For instance assigning GDT_Int16 values to a GDT_Byte buffer will cause values less the 0 to be set to 0, and values larger than 255 to be set to 255. Assignment from floating point to integer uses default C type casting semantics. Assignment from non-complex to complex will result in the imaginary part being set to zero on output. Assignment from complex to non-complex will result in the complex portion being lost and the real component being preserved (not magnitude!).

  No assumptions are made about the source or destination words occurring on word boundaries. It is assumed that all values are in native machine byte order.

  Note

    When adding a new data type to GDAL, you must do the following to support it properly within the GDALCopyWords function:

    1. Add the data type to the switch on eSrcType in GDALCopyWords. This should invoke the appropriate GDALCopyWordsFromT wrapper.

    2. Add the data type to the switch on eDstType in GDALCopyWordsFromT. This should call the appropriate GDALCopyWordsT template.

    3. If appropriate, overload the appropriate CopyWord template in the above namespace. This will ensure that any conversion issues are handled (cases like the float -> int32 case, where the min/max) values are subject to roundoff error.

  Parameters

    - `pSrcData`: Pointer to source data to be converted.

    - `eSrcType`: the source data type (see GDALDataType enum)

    - `nSrcPixelStride`: Source pixel stride (i.e. distance between 2 words), in bytes

    - `pDstData`: Pointer to buffer where destination data should go

    - `eDstType`: the destination data type (see GDALDataType enum)

    - `nDstPixelStride`: Destination pixel stride (i.e. distance between 2 words), in bytes

    - `nWordCount`: number of words to be copied

void `GDALCopyBits`(const GByte *pabySrcData, int nSrcOffset, int nSrcStep, GByte *pabyDstData, int nDstOffset, int nDstStep, int nBitCount, int nStepCount)

  Bitwise word copying.

  A function for moving sets of partial bytes around. Loosely speaking this is a bitwise analog to GDALCopyWords().

  It copies nStepCount “words” where each word is nBitCount bits long. The nSrcStep and nDstStep are the number of bits from the start of one word to the next (same as nBitCount if they are packed). The nSrcOffset and nDstOffset are the offset into the source and destination buffers to start at, also measured in bits.

  All bit offsets are assumed to start from the high order bit in a byte (i.e. most significant bit first). Currently this function is not very optimized, but it may be improved for some common cases in the future as needed.

  Parameters

    - `pabySrcData`: the source data buffer.

    - `nSrcOffset`: the offset (in bits) in pabySrcData to the start of the first word to copy.

    - `nSrcStep`: the offset in bits from the start one source word to the start of the next.

    - `pabyDstData`: the destination data buffer.

    - `nDstOffset`: the offset (in bits) in pabyDstData to the start of the first word to copy over.

    - `nDstStep`: the offset in bits from the start one word to the start of the next.

    - `nBitCount`: the number of bits in a word to be copied.

    - `nStepCount`: the number of words to copy.

int `GDALLoadWorldFile`(const char *pszFilename, double *padfGeoTransform)

  Read ESRI world file.

  This function reads an ESRI style world file, and formats a geotransform from its contents.

  The world file contains an affine transformation with the parameters in a different order than in a geotransform array.

  - geotransform[1] : width of pixel

  - geotransform[4] : rotational coefficient, zero for north up images.

  - geotransform[2] : rotational coefficient, zero for north up images.

  - geotransform[5] : height of pixel (but negative)

  - geotransform[0] + 0.5 * geotransform[1] + 0.5 * geotransform[2] : x offset to center of top left pixel.

  - geotransform[3] + 0.5 * geotransform[4] + 0.5 * geotransform[5] : y offset to center of top left pixel.

  Return

    TRUE on success or FALSE on failure.

  Parameters

    - `pszFilename`: the world file name.

    - `padfGeoTransform`: the six double array into which the geotransformation should be placed.

int `GDALReadWorldFile`(const char *pszBaseFilename, const char *pszExtension, double *padfGeoTransform)

  Read ESRI world file.

  This function reads an ESRI style world file, and formats a geotransform from its contents. It does the same as GDALLoadWorldFile() function, but it will form the filename for the worldfile from the filename of the raster file referred and the suggested extension. If no extension is provided, the code will internally try the unix style and windows style world file extensions (eg. for .tif these would be .tfw and .tifw).

  The world file contains an affine transformation with the parameters in a different order than in a geotransform array.

  - geotransform[1] : width of pixel

  - geotransform[4] : rotational coefficient, zero for north up images.

  - geotransform[2] : rotational coefficient, zero for north up images.

  - geotransform[5] : height of pixel (but negative)

  - geotransform[0] + 0.5 * geotransform[1] + 0.5 * geotransform[2] : x offset to center of top left pixel.

  - geotransform[3] + 0.5 * geotransform[4] + 0.5 * geotransform[5] : y offset to center of top left pixel.

  Return

    TRUE on success or FALSE on failure.

  Parameters

    - `pszBaseFilename`: the target raster file.

    - `pszExtension`: the extension to use (i.e. “wld”) or NULL to derive it from the pszBaseFilename

    - `padfGeoTransform`: the six double array into which the geotransformation should be placed.

int `GDALWriteWorldFile`(const char *pszBaseFilename, const char *pszExtension, double *padfGeoTransform)

  Write ESRI world file.

  This function writes an ESRI style world file from the passed geotransform.

  The world file contains an affine transformation with the parameters in a different order than in a geotransform array.

  - geotransform[1] : width of pixel

  - geotransform[4] : rotational coefficient, zero for north up images.

  - geotransform[2] : rotational coefficient, zero for north up images.

  - geotransform[5] : height of pixel (but negative)

  - geotransform[0] + 0.5 * geotransform[1] + 0.5 * geotransform[2] : x offset to center of top left pixel.

  - geotransform[3] + 0.5 * geotransform[4] + 0.5 * geotransform[5] : y offset to center of top left pixel.

  Return

    TRUE on success or FALSE on failure.

  Parameters

    - `pszBaseFilename`: the target raster file.

    - `pszExtension`: the extension to use (i.e. “wld”). Must not be NULL

    - `padfGeoTransform`: the six double array from which the geotransformation should be read.

int `GDALLoadTabFile`(const char *pszFilename, double *padfGeoTransform, char **ppszWKT, int *pnGCPCount, GDAL_GCP **ppasGCPs)

  Helper function for translator implementer wanting support for MapInfo .tab files.

  Return

    TRUE in case of success, FALSE otherwise.

  Parameters

    - `pszFilename`: filename of .tab

    - `padfGeoTransform`: output geotransform. Must hold 6 doubles.

    - `ppszWKT`: output pointer to a string that will be allocated with CPLMalloc().

    - `pnGCPCount`: output pointer to GCP count.

    - `ppasGCPs`: outputer pointer to an array of GCPs.

int `GDALReadTabFile`(const char *pszBaseFilename, double *padfGeoTransform, char **ppszWKT, int *pnGCPCount, GDAL_GCP **ppasGCPs)

  Helper function for translator implementer wanting support for MapInfo .tab files.

  Return

    TRUE in case of success, FALSE otherwise.

  Parameters

    - `pszBaseFilename`: filename whose basename will help building the .tab filename.

    - `padfGeoTransform`: output geotransform. Must hold 6 doubles.

    - `ppszWKT`: output pointer to a string that will be allocated with CPLMalloc().

    - `pnGCPCount`: output pointer to GCP count.

    - `ppasGCPs`: outputer pointer to an array of GCPs.

int `GDALLoadOziMapFile`(const char *pszFilename, double *padfGeoTransform, char **ppszWKT, int *pnGCPCount, GDAL_GCP **ppasGCPs)

  Helper function for translator implementer wanting support for OZI .map.

  Return

    TRUE in case of success, FALSE otherwise.

  Parameters

    - `pszFilename`: filename of .tab file

    - `padfGeoTransform`: output geotransform. Must hold 6 doubles.

    - `ppszWKT`: output pointer to a string that will be allocated with CPLMalloc().

    - `pnGCPCount`: output pointer to GCP count.

    - `ppasGCPs`: outputer pointer to an array of GCPs.

int `GDALReadOziMapFile`(const char *pszBaseFilename, double *padfGeoTransform, char **ppszWKT, int *pnGCPCount, GDAL_GCP **ppasGCPs)

  Helper function for translator implementer wanting support for OZI .map.

  Return

    TRUE in case of success, FALSE otherwise.

  Parameters

    - `pszBaseFilename`: filename whose basename will help building the .map filename.

    - `padfGeoTransform`: output geotransform. Must hold 6 doubles.

    - `ppszWKT`: output pointer to a string that will be allocated with CPLMalloc().

    - `pnGCPCount`: output pointer to GCP count.

    - `ppasGCPs`: outputer pointer to an array of GCPs.

const char *`GDALDecToDMS`(double, const char *, int)

  Translate a decimal degrees value to a DMS string with hemisphere.

double `GDALPackedDMSToDec`(double dfPacked)

  Convert a packed DMS value (DDDMMMSSS.SS) into decimal degrees.

  See CPLPackedDMSToDec().

double `GDALDecToPackedDMS`(double dfDec)

  Convert decimal degrees into packed DMS value (DDDMMMSSS.SS).

  See CPLDecToPackedDMS().

const char *`GDALVersionInfo`(const char *pszRequest)

  Get runtime version information.

  Available pszRequest values:

  - “VERSION_NUM”: Returns GDAL_VERSION_NUM formatted as a string. i.e. “1170” Note: starting with GDAL 1.10, this string will be longer than 4 characters.

  - “RELEASE_DATE”: Returns GDAL_RELEASE_DATE formatted as a string. i.e. “20020416”.

  - “RELEASE_NAME”: Returns the GDAL_RELEASE_NAME. ie. “1.1.7”

  - “–version”: Returns one line version message suitable for use in response to version requests. i.e. “GDAL 1.1.7, released 2002/04/16”

  - “LICENSE”: Returns the content of the LICENSE.TXT file from the GDAL_DATA directory. Before GDAL 1.7.0, the returned string was leaking memory but this is now resolved. So the result should not been freed by the caller.

  - “BUILD_INFO”: List of NAME=VALUE pairs separated by newlines with information on build time options.

  Return

    an internal string containing the requested information.

  Parameters

    - `pszRequest`: the type of version info desired, as listed above.

int `GDALCheckVersion`(int nVersionMajor, int nVersionMinor, const char *pszCallingComponentName)

  Return TRUE if GDAL library version at runtime matches nVersionMajor.nVersionMinor.

  The purpose of this method is to ensure that calling code will run with the GDAL version it is compiled for. It is primarily intended for external plugins.

  Return

    TRUE if GDAL library version at runtime matches nVersionMajor.nVersionMinor, FALSE otherwise.

  Parameters

    - `nVersionMajor`: Major version to be tested against

    - `nVersionMinor`: Minor version to be tested against

    - `pszCallingComponentName`: If not NULL, in case of version mismatch, the method will issue a failure mentioning the name of the calling component.

int `GDALExtractRPCInfo`(CSLConstList papszMD, GDALRPCInfo *psRPC)

  Extract RPC info from metadata, and apply to an RPCInfo structure.

  The inverse of this function is RPCInfoToMD() in alg/gdal_rpc.cpp

  Return

    TRUE in case of success. FALSE in case of failure.

  Parameters

    - `papszMD`: Dictionary of metadata representing RPC

    - `psRPC`: (output) Pointer to structure to hold the RPC values.

GDALColorTableH `GDALCreateColorTable`(GDALPaletteInterp eInterp)

  Construct a new color table.

  This function is the same as the C++ method GDALColorTable::GDALColorTable()

void `GDALDestroyColorTable`(GDALColorTableH hTable)

  Destroys a color table.

  This function is the same as the C++ method GDALColorTable::~GDALColorTable()

GDALColorTableH `GDALCloneColorTable`(GDALColorTableH hTable)

  Make a copy of a color table.

  This function is the same as the C++ method GDALColorTable::Clone()

GDALPaletteInterp `GDALGetPaletteInterpretation`(GDALColorTableH hTable)

  Fetch palette interpretation.

  This function is the same as the C++ method GDALColorTable::GetPaletteInterpretation()

int `GDALGetColorEntryCount`(GDALColorTableH hTable)

  Get number of color entries in table.

  This function is the same as the C++ method GDALColorTable::GetColorEntryCount()

const GDALColorEntry *`GDALGetColorEntry`(GDALColorTableH hTable, int i)

  Fetch a color entry from table.

  This function is the same as the C++ method GDALColorTable::GetColorEntry()

int `GDALGetColorEntryAsRGB`(GDALColorTableH hTable, int i, GDALColorEntry *poEntry)

  Fetch a table entry in RGB format.

  This function is the same as the C++ method GDALColorTable::GetColorEntryAsRGB().

void `GDALSetColorEntry`(GDALColorTableH hTable, int i, const GDALColorEntry *poEntry)

  Set entry in color table.

  This function is the same as the C++ method GDALColorTable::SetColorEntry()

void `GDALCreateColorRamp`(GDALColorTableH hTable, int nStartIndex, const GDALColorEntry *psStartColor, int nEndIndex, const GDALColorEntry *psEndColor)

  Create color ramp.

  This function is the same as the C++ method GDALColorTable::CreateColorRamp()

GDALRasterAttributeTableH `GDALCreateRasterAttributeTable`(void)

  Construct empty table.

  This function is the same as the C++ method GDALDefaultRasterAttributeTable::GDALDefaultRasterAttributeTable()

void `GDALDestroyRasterAttributeTable`(GDALRasterAttributeTableH hRAT)

  Destroys a RAT.

  This function is the same as the C++ method GDALRasterAttributeTable::~GDALRasterAttributeTable()

int `GDALRATGetColumnCount`(GDALRasterAttributeTableH hRAT)

  Fetch table column count.

  This function is the same as the C++ method GDALRasterAttributeTable::GetColumnCount()

const char *`GDALRATGetNameOfCol`(GDALRasterAttributeTableH hRAT, int iCol)

  Fetch name of indicated column.

  This function is the same as the C++ method GDALRasterAttributeTable::GetNameOfCol()

  Return

    name.

  Parameters

    - `hRAT`: RAT handle.

    - `iCol`: column index.

GDALRATFieldUsage `GDALRATGetUsageOfCol`(GDALRasterAttributeTableH hRAT, int iCol)

  Fetch column usage value.

  This function is the same as the C++ method GDALRasterAttributeTable::GetUsageOfCol()

  Return

    usage.

  Parameters

    - `hRAT`: RAT handle.

    - `iCol`: column index.

GDALRATFieldType `GDALRATGetTypeOfCol`(GDALRasterAttributeTableH hRAT, int iCol)

  Fetch column type.

  This function is the same as the C++ method GDALRasterAttributeTable::GetTypeOfCol()

  Return

    type.

  Parameters

    - `hRAT`: RAT handle.

    - `iCol`: column index.

int `GDALRATGetColOfUsage`(GDALRasterAttributeTableH hRAT, GDALRATFieldUsage eUsage)

  Fetch column index for given usage.

  This function is the same as the C++ method GDALRasterAttributeTable::GetColOfUsage()

int `GDALRATGetRowCount`(GDALRasterAttributeTableH hRAT)

  Fetch row count.

  This function is the same as the C++ method GDALRasterAttributeTable::GetRowCount()

const char *`GDALRATGetValueAsString`(GDALRasterAttributeTableH hRAT, int iRow, int iField)

  Fetch field value as a string.

  This function is the same as the C++ method GDALRasterAttributeTable::GetValueAsString()

int `GDALRATGetValueAsInt`(GDALRasterAttributeTableH hRAT, int iRow, int iField)

  Fetch field value as a integer.

  This function is the same as the C++ method GDALRasterAttributeTable::GetValueAsInt()

double `GDALRATGetValueAsDouble`(GDALRasterAttributeTableH hRAT, int iRow, int iField)

  Fetch field value as a double.

  This function is the same as the C++ method GDALRasterAttributeTable::GetValueAsDouble()

void `GDALRATSetValueAsString`(GDALRasterAttributeTableH hRAT, int iRow, int iField, const char *pszValue)

  Set field value from string.

  This function is the same as the C++ method GDALRasterAttributeTable::SetValue()

  Parameters

    - `hRAT`: RAT handle.

    - `iRow`: row index.

    - `iField`: field index.

    - `pszValue`: value.

void `GDALRATSetValueAsInt`(GDALRasterAttributeTableH hRAT, int iRow, int iField, int nValue)

  Set field value from integer.

  This function is the same as the C++ method GDALRasterAttributeTable::SetValue()

void `GDALRATSetValueAsDouble`(GDALRasterAttributeTableH hRAT, int iRow, int iField, double dfValue)

  Set field value from double.

  This function is the same as the C++ method GDALRasterAttributeTable::SetValue()

int `GDALRATChangesAreWrittenToFile`(GDALRasterAttributeTableH hRAT)

  Determine whether changes made to this RAT are reflected directly in the dataset.

  This function is the same as the C++ method GDALRasterAttributeTable::ChangesAreWrittenToFile()

CPLErr `GDALRATValuesIOAsDouble`(GDALRasterAttributeTableH hRAT, GDALRWFlag eRWFlag, int iField, int iStartRow, int iLength, double *pdfData)

  Read or Write a block of doubles to/from the Attribute Table.

  This function is the same as the C++ method GDALRasterAttributeTable::ValuesIO()

CPLErr `GDALRATValuesIOAsInteger`(GDALRasterAttributeTableH hRAT, GDALRWFlag eRWFlag, int iField, int iStartRow, int iLength, int *pnData)

  Read or Write a block of ints to/from the Attribute Table.

  This function is the same as the C++ method GDALRasterAttributeTable::ValuesIO()

CPLErr `GDALRATValuesIOAsString`(GDALRasterAttributeTableH hRAT, GDALRWFlag eRWFlag, int iField, int iStartRow, int iLength, CSLConstList papszStrList)

  Read or Write a block of strings to/from the Attribute Table.

  This function is the same as the C++ method GDALRasterAttributeTable::ValuesIO()

void `GDALRATSetRowCount`(GDALRasterAttributeTableH hRAT, int nNewCount)

  Set row count.

  This function is the same as the C++ method GDALRasterAttributeTable::SetRowCount()

  Parameters

    - `hRAT`: RAT handle.

    - `nNewCount`: the new number of rows.

CPLErr `GDALRATCreateColumn`(GDALRasterAttributeTableH hRAT, const char *pszFieldName, GDALRATFieldType eFieldType, GDALRATFieldUsage eFieldUsage)

  Create new column.

  This function is the same as the C++ method GDALRasterAttributeTable::CreateColumn()

CPLErr `GDALRATSetLinearBinning`(GDALRasterAttributeTableH hRAT, double dfRow0Min, double dfBinSize)

  Set linear binning information.

  This function is the same as the C++ method GDALRasterAttributeTable::SetLinearBinning()

int `GDALRATGetLinearBinning`(GDALRasterAttributeTableH hRAT, double *pdfRow0Min, double *pdfBinSize)

  Get linear binning information.

  This function is the same as the C++ method GDALRasterAttributeTable::GetLinearBinning()

CPLErr `GDALRATSetTableType`(GDALRasterAttributeTableH hRAT, const GDALRATTableType eInTableType)

  Set RAT Table Type.

  This function is the same as the C++ method

  GDALRasterAttributeTable::SetTableType()
  Since

    GDAL 2.4

GDALRATTableType `GDALRATGetTableType`(GDALRasterAttributeTableH hRAT)

  Get Rat Table Type.

  This function is the same as the C++ method

  GDALRasterAttributeTable::GetTableType()
  Since

    GDAL 2.4

CPLErr `GDALRATInitializeFromColorTable`(GDALRasterAttributeTableH hRAT, GDALColorTableH hCT)

  Initialize from color table.

  This function is the same as the C++ method GDALRasterAttributeTable::InitializeFromColorTable()

GDALColorTableH `GDALRATTranslateToColorTable`(GDALRasterAttributeTableH hRAT, int nEntryCount)

  Translate to a color table.

  This function is the same as the C++ method GDALRasterAttributeTable::TranslateToColorTable()

void `GDALRATDumpReadable`(GDALRasterAttributeTableH hRAT, FILE *fp)

  Dump RAT in readable form.

  This function is the same as the C++ method GDALRasterAttributeTable::DumpReadable()

GDALRasterAttributeTableH `GDALRATClone`(const GDALRasterAttributeTableH hRAT)

  Copy Raster Attribute Table.

  This function is the same as the C++ method GDALRasterAttributeTable::Clone()

void *`GDALRATSerializeJSON`(GDALRasterAttributeTableH hRAT)

  Serialize Raster Attribute Table in Json format.

  This function is the same as the C++ method GDALRasterAttributeTable::SerializeJSON()

int `GDALRATGetRowOfValue`(GDALRasterAttributeTableH hRAT, double dfValue)

  Get row for pixel value.

  This function is the same as the C++ method GDALRasterAttributeTable::GetRowOfValue()

void `GDALRATRemoveStatistics`(GDALRasterAttributeTableH hRAT)

  Remove Statistics from RAT.

  This function is the same as the C++ method GDALRasterAttributeTable::RemoveStatistics()

  Since

    GDAL 2.4

void `GDALSetCacheMax`(int nBytes)

  Set maximum cache memory.

  This function sets the maximum amount of memory that GDAL is permitted to use for GDALRasterBlock caching. The unit of the value is bytes.

  The maximum value is 2GB, due to the use of a signed 32 bit integer. Use GDALSetCacheMax64() to be able to set a higher value.

  Parameters

    - `nNewSizeInBytes`: the maximum number of bytes for caching.

int `GDALGetCacheMax`(void)

  Get maximum cache memory.

  Gets the maximum amount of memory available to the GDALRasterBlock caching system for caching GDAL read/write imagery.

  The first type this function is called, it will read the GDAL_CACHEMAX configuration option to initialize the maximum cache memory. Starting with GDAL 2.1, the value can be expressed as x% of the usable physical RAM (which may potentially be used by other processes). Otherwise it is expected to be a value in MB.

  This function cannot return a value higher than 2 GB. Use GDALGetCacheMax64() to get a non-truncated value.

  Return

    maximum in bytes.

int `GDALGetCacheUsed`(void)

  Get cache memory used.

  Return

    the number of bytes of memory currently in use by the GDALRasterBlock memory caching.

void `GDALSetCacheMax64`(GIntBig nBytes)

  Set maximum cache memory.

  This function sets the maximum amount of memory that GDAL is permitted to use for GDALRasterBlock caching. The unit of the value is bytes.

  Note: On 32 bit platforms, the maximum amount of memory that can be addressed by a process might be 2 GB or 3 GB, depending on the operating system capabilities. This function will not make any attempt to check the consistency of the passed value with the effective capabilities of the OS.

  Since

    GDAL 1.8.0

  Parameters

    - `nNewSizeInBytes`: the maximum number of bytes for caching.

GIntBig `GDALGetCacheMax64`(void)

  Get maximum cache memory.

  Gets the maximum amount of memory available to the GDALRasterBlock caching system for caching GDAL read/write imagery.

  The first type this function is called, it will read the GDAL_CACHEMAX configuration option to initialize the maximum cache memory. Starting with GDAL 2.1, the value can be expressed as x% of the usable physical RAM (which may potentially be used by other processes). Otherwise it is expected to be a value in MB.

  Return

    maximum in bytes.

  Since

    GDAL 1.8.0

GIntBig `GDALGetCacheUsed64`(void)

  Get cache memory used.

  Return

    the number of bytes of memory currently in use by the GDALRasterBlock memory caching.

  Since

    GDAL 1.8.0

int `GDALFlushCacheBlock`(void)

  Try to flush one cached raster block.

  This function will search the first unlocked raster block and will flush it to release the associated memory.

  Return

    TRUE if one block was flushed, FALSE if there are no cached blocks or if they are currently locked.

CPLVirtualMem *`GDALDatasetGetVirtualMem`(GDALDatasetH hDS, GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize, int nBufXSize, int nBufYSize, GDALDataType eBufType, int nBandCount, int *panBandMap, int nPixelSpace, GIntBig nLineSpace, GIntBig nBandSpace, size_t nCacheSize, size_t nPageSizeHint, int bSingleThreadUsage, CSLConstList papszOptions)

  Create a CPLVirtualMem object from a GDAL dataset object.

  Only supported on Linux for now.

  This method allows creating a virtual memory object for a region of one or more GDALRasterBands from this dataset. The content of the virtual memory object is automatically filled from dataset content when a virtual memory page is first accessed, and it is released (or flushed in case of a “dirty” page) when the cache size limit has been reached.

  The pointer to access the virtual memory object is obtained with CPLVirtualMemGetAddr(). It remains valid until CPLVirtualMemFree() is called. CPLVirtualMemFree() must be called before the dataset object is destroyed.

  If p is such a pointer and base_type the C type matching eBufType, for default values of spacing parameters, the element of image coordinates (x, y) (relative to xOff, yOff) for band b can be accessed with ((base_type*)p)[x + y * nBufXSize + (b-1)*nBufXSize*nBufYSize].

  Note that the mechanism used to transparently fill memory pages when they are accessed is the same (but in a controlled way) than what occurs when a memory error occurs in a program. Debugging software will generally interrupt program execution when that happens. If needed, CPLVirtualMemPin() can be used to avoid that by ensuring memory pages are allocated before being accessed.

  The size of the region that can be mapped as a virtual memory object depends on hardware and operating system limitations. On Linux AMD64 platforms, the maximum value is 128 TB. On Linux x86 platforms, the maximum value is 2 GB.

  Data type translation is automatically done if the data type (eBufType) of the buffer is different than that of the GDALRasterBand.

  Image decimation / replication is currently not supported, i.e. if the size of the region being accessed (nXSize x nYSize) is different from the buffer size (nBufXSize x nBufYSize).

  The nPixelSpace, nLineSpace and nBandSpace parameters allow reading into or writing from various organization of buffers. Arbitrary values for the spacing parameters are not supported. Those values must be multiple of the size of thebuffer data type, and must be either band sequential organization (typically nPixelSpace = GDALGetDataTypeSizeBytes(eBufType), nLineSpace = nPixelSpace * nBufXSize, nBandSpace = nLineSpace * nBufYSize), or pixel-interleaved organization (typically nPixelSpace = nBandSpace * nBandCount, nLineSpace = nPixelSpace * nBufXSize, nBandSpace = GDALGetDataTypeSizeBytes(eBufType))

  Return

    a virtual memory object that must be freed by CPLVirtualMemFree(), or NULL in case of failure.

  Since

    GDAL 1.11

  Parameters

    - `hDS`: Dataset object

    - `eRWFlag`: Either GF_Read to read a region of data, or GF_Write to write a region of data.

    - `nXOff`: The pixel offset to the top left corner of the region of the band to be accessed. This would be zero to start from the left side.

    - `nYOff`: The line offset to the top left corner of the region of the band to be accessed. This would be zero to start from the top.

    - `nXSize`: The width of the region of the band to be accessed in pixels.

    - `nYSize`: The height of the region of the band to be accessed in lines.

    - `nBufXSize`: the width of the buffer image into which the desired region is to be read, or from which it is to be written.

    - `nBufYSize`: the height of the buffer image into which the desired region is to be read, or from which it is to be written.

    - `eBufType`: the type of the pixel values in the data buffer. The pixel values will automatically be translated to/from the GDALRasterBand data type as needed.

    - `nBandCount`: the number of bands being read or written.

    - `panBandMap`: the list of nBandCount band numbers being read/written. Note band numbers are 1 based. This may be NULL to select the first nBandCount bands.

    - `nPixelSpace`: The byte offset from the start of one pixel value in the buffer to the start of the next pixel value within a scanline. If defaulted (0) the size of the datatype eBufType is used.

    - `nLineSpace`: The byte offset from the start of one scanline in the buffer to the start of the next. If defaulted (0) the size of the datatype eBufType * nBufXSize is used.

    - `nBandSpace`: the byte offset from the start of one bands data to the start of the next. If defaulted (0) the value will be nLineSpace * nBufYSize implying band sequential organization of the data buffer.

    - `nCacheSize`: size in bytes of the maximum memory that will be really allocated (must ideally fit into RAM)

    - `nPageSizeHint`: hint for the page size. Must be a multiple of the system page size, returned by CPLGetPageSize(). Minimum value is generally 4096. Might be set to 0 to let the function determine a default page size.

    - `bSingleThreadUsage`: set to TRUE if there will be no concurrent threads that will access the virtual memory mapping. This can optimize performance a bit. If set to FALSE, CPLVirtualMemDeclareThread() must be called.

    - `papszOptions`: NULL terminated list of options. Unused for now.

CPLVirtualMem *`GDALRasterBandGetVirtualMem`(GDALRasterBandH hBand, GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize, int nBufXSize, int nBufYSize, GDALDataType eBufType, int nPixelSpace, GIntBig nLineSpace, size_t nCacheSize, size_t nPageSizeHint, int bSingleThreadUsage, CSLConstList papszOptions)

  Create a CPLVirtualMem object from a GDAL raster band object.

  Only supported on Linux for now.

  This method allows creating a virtual memory object for a region of a GDALRasterBand. The content of the virtual memory object is automatically filled from dataset content when a virtual memory page is first accessed, and it is released (or flushed in case of a “dirty” page) when the cache size limit has been reached.

  The pointer to access the virtual memory object is obtained with CPLVirtualMemGetAddr(). It remains valid until CPLVirtualMemFree() is called. CPLVirtualMemFree() must be called before the raster band object is destroyed.

  If p is such a pointer and base_type the C type matching eBufType, for values of spacing parameters, the element of image coordinates (x, y) default (relative to xOff, yOff) can be accessed with ((base_type*)p)[x + y * nBufXSize].

  Note that the mechanism used to transparently fill memory pages when they are accessed is the same (but in a controlled way) than what occurs when a memory error occurs in a program. Debugging software will generally interrupt program execution when that happens. If needed, CPLVirtualMemPin() can be used to avoid that by ensuring memory pages are allocated before being accessed.

  The size of the region that can be mapped as a virtual memory object depends on hardware and operating system limitations. On Linux AMD64 platforms, the maximum value is 128 TB. On Linux x86 platforms, the maximum value is 2 GB.

  Data type translation is automatically done if the data type (eBufType) of the buffer is different than that of the GDALRasterBand.

  Image decimation / replication is currently not supported, i.e. if the size of the region being accessed (nXSize x nYSize) is different from the buffer size (nBufXSize x nBufYSize).

  The nPixelSpace and nLineSpace parameters allow reading into or writing from various organization of buffers. Arbitrary values for the spacing parameters are not supported. Those values must be multiple of the size of the buffer data type and must be such that nLineSpace >= nPixelSpace * nBufXSize.

  Return

    a virtual memory object that must be freed by CPLVirtualMemFree(), or NULL in case of failure.

  Since

    GDAL 1.11

  Parameters

    - `hBand`: Rasterband object

    - `eRWFlag`: Either GF_Read to read a region of data, or GF_Write to write a region of data.

    - `nXOff`: The pixel offset to the top left corner of the region of the band to be accessed. This would be zero to start from the left side.

    - `nYOff`: The line offset to the top left corner of the region of the band to be accessed. This would be zero to start from the top.

    - `nXSize`: The width of the region of the band to be accessed in pixels.

    - `nYSize`: The height of the region of the band to be accessed in lines.

    - `nBufXSize`: the width of the buffer image into which the desired region is to be read, or from which it is to be written.

    - `nBufYSize`: the height of the buffer image into which the desired region is to be read, or from which it is to be written.

    - `eBufType`: the type of the pixel values in the data buffer. The pixel values will automatically be translated to/from the GDALRasterBand data type as needed.

    - `nPixelSpace`: The byte offset from the start of one pixel value in the buffer to the start of the next pixel value within a scanline. If defaulted (0) the size of the datatype eBufType is used.

    - `nLineSpace`: The byte offset from the start of one scanline in the buffer to the start of the next. If defaulted (0) the size of the datatype eBufType * nBufXSize is used.

    - `nCacheSize`: size in bytes of the maximum memory that will be really allocated (must ideally fit into RAM)

    - `nPageSizeHint`: hint for the page size. Must be a multiple of the system page size, returned by CPLGetPageSize(). Minimum value is generally 4096. Might be set to 0 to let the function determine a default page size.

    - `bSingleThreadUsage`: set to TRUE if there will be no concurrent threads that will access the virtual memory mapping. This can optimize performance a bit. If set to FALSE, CPLVirtualMemDeclareThread() must be called.

    - `papszOptions`: NULL terminated list of options. Unused for now.

CPLVirtualMem *`GDALGetVirtualMemAuto`(GDALRasterBandH hBand, GDALRWFlag eRWFlag, int *pnPixelSpace, GIntBig *pnLineSpace, CSLConstList papszOptions)

  Create a CPLVirtualMem object from a GDAL raster band object.

  See

    GDALRasterBand::GetVirtualMemAuto()

CPLVirtualMem *`GDALDatasetGetTiledVirtualMem`(GDALDatasetH hDS, GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize, int nTileXSize, int nTileYSize, GDALDataType eBufType, int nBandCount, int *panBandMap, GDALTileOrganization eTileOrganization, size_t nCacheSize, int bSingleThreadUsage, CSLConstList papszOptions)

  Create a CPLVirtualMem object from a GDAL dataset object, with tiling organization.

  Only supported on Linux for now.

  This method allows creating a virtual memory object for a region of one or more GDALRasterBands from this dataset. The content of the virtual memory object is automatically filled from dataset content when a virtual memory page is first accessed, and it is released (or flushed in case of a “dirty” page) when the cache size limit has been reached.

  Contrary to GDALDatasetGetVirtualMem(), pixels will be organized by tiles instead of scanlines. Different ways of organizing pixel within/across tiles can be selected with the eTileOrganization parameter.

  If nXSize is not a multiple of nTileXSize or nYSize is not a multiple of nTileYSize, partial tiles will exists at the right and/or bottom of the region of interest. Those partial tiles will also have nTileXSize * nTileYSize dimension, with padding pixels.

  The pointer to access the virtual memory object is obtained with CPLVirtualMemGetAddr(). It remains valid until CPLVirtualMemFree() is called. CPLVirtualMemFree() must be called before the dataset object is destroyed.

  If p is such a pointer and base_type the C type matching eBufType, for default values of spacing parameters, the element of image coordinates (x, y) (relative to xOff, yOff) for band b can be accessed with:

  - for eTileOrganization = GTO_TIP, ((base_type*)p)[tile_number(x,y)*nBandCount*tile_size + offset_in_tile(x,y)*nBandCount + (b-1)].

  - for eTileOrganization = GTO_BIT, ((base_type*)p)[(tile_number(x,y)*nBandCount + (b-1)) * tile_size + offset_in_tile(x,y)].

  - for eTileOrganization = GTO_BSQ, ((base_type*)p)[(tile_number(x,y) + (b-1)*nTilesCount) * tile_size + offset_in_tile(x,y)].

  where nTilesPerRow = ceil(nXSize / nTileXSize) nTilesPerCol = ceil(nYSize / nTileYSize) nTilesCount = nTilesPerRow * nTilesPerCol tile_number(x,y) = (y / nTileYSize) * nTilesPerRow + (x / nTileXSize) offset_in_tile(x,y) = (y % nTileYSize) * nTileXSize + (x % nTileXSize) tile_size = nTileXSize * nTileYSize

  Note that for a single band request, all tile organizations are equivalent.

  Note that the mechanism used to transparently fill memory pages when they are accessed is the same (but in a controlled way) than what occurs when a memory error occurs in a program. Debugging software will generally interrupt program execution when that happens. If needed, CPLVirtualMemPin() can be used to avoid that by ensuring memory pages are allocated before being accessed.

  The size of the region that can be mapped as a virtual memory object depends on hardware and operating system limitations. On Linux AMD64 platforms, the maximum value is 128 TB. On Linux x86 platforms, the maximum value is 2 GB.

  Data type translation is automatically done if the data type (eBufType) of the buffer is different than that of the GDALRasterBand.

  Return

    a virtual memory object that must be freed by CPLVirtualMemFree(), or NULL in case of failure.

  Since

    GDAL 1.11

  Parameters

    - `hDS`: Dataset object

    - `eRWFlag`: Either GF_Read to read a region of data, or GF_Write to write a region of data.

    - `nXOff`: The pixel offset to the top left corner of the region of the band to be accessed. This would be zero to start from the left side.

    - `nYOff`: The line offset to the top left corner of the region of the band to be accessed. This would be zero to start from the top.

    - `nXSize`: The width of the region of the band to be accessed in pixels.

    - `nYSize`: The height of the region of the band to be accessed in lines.

    - `nTileXSize`: the width of the tiles.

    - `nTileYSize`: the height of the tiles.

    - `eBufType`: the type of the pixel values in the data buffer. The pixel values will automatically be translated to/from the GDALRasterBand data type as needed.

    - `nBandCount`: the number of bands being read or written.

    - `panBandMap`: the list of nBandCount band numbers being read/written. Note band numbers are 1 based. This may be NULL to select the first nBandCount bands.

    - `eTileOrganization`: tile organization.

    - `nCacheSize`: size in bytes of the maximum memory that will be really allocated (must ideally fit into RAM)

    - `bSingleThreadUsage`: set to TRUE if there will be no concurrent threads that will access the virtual memory mapping. This can optimize performance a bit. If set to FALSE, CPLVirtualMemDeclareThread() must be called.

    - `papszOptions`: NULL terminated list of options. Unused for now.

CPLVirtualMem *`GDALRasterBandGetTiledVirtualMem`(GDALRasterBandH hBand, GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize, int nTileXSize, int nTileYSize, GDALDataType eBufType, size_t nCacheSize, int bSingleThreadUsage, CSLConstList papszOptions)

  Create a CPLVirtualMem object from a GDAL rasterband object, with tiling organization.

  Only supported on Linux for now.

  This method allows creating a virtual memory object for a region of one GDALRasterBand. The content of the virtual memory object is automatically filled from dataset content when a virtual memory page is first accessed, and it is released (or flushed in case of a “dirty” page) when the cache size limit has been reached.

  Contrary to GDALDatasetGetVirtualMem(), pixels will be organized by tiles instead of scanlines.

  If nXSize is not a multiple of nTileXSize or nYSize is not a multiple of nTileYSize, partial tiles will exists at the right and/or bottom of the region of interest. Those partial tiles will also have nTileXSize * nTileYSize dimension, with padding pixels.

  The pointer to access the virtual memory object is obtained with CPLVirtualMemGetAddr(). It remains valid until CPLVirtualMemFree() is called. CPLVirtualMemFree() must be called before the raster band object is destroyed.

  If p is such a pointer and base_type the C type matching eBufType, for default values of spacing parameters, the element of image coordinates (x, y) (relative to xOff, yOff) can be accessed with: ((base_type*)p)[tile_number(x,y)*tile_size + offset_in_tile(x,y)].

  where nTilesPerRow = ceil(nXSize / nTileXSize) nTilesCount = nTilesPerRow * nTilesPerCol tile_number(x,y) = (y / nTileYSize) * nTilesPerRow + (x / nTileXSize) offset_in_tile(x,y) = (y % nTileYSize) * nTileXSize + (x % nTileXSize) tile_size = nTileXSize * nTileYSize

  Note that the mechanism used to transparently fill memory pages when they are accessed is the same (but in a controlled way) than what occurs when a memory error occurs in a program. Debugging software will generally interrupt program execution when that happens. If needed, CPLVirtualMemPin() can be used to avoid that by ensuring memory pages are allocated before being accessed.

  The size of the region that can be mapped as a virtual memory object depends on hardware and operating system limitations. On Linux AMD64 platforms, the maximum value is 128 TB. On Linux x86 platforms, the maximum value is 2 GB.

  Data type translation is automatically done if the data type (eBufType) of the buffer is different than that of the GDALRasterBand.

  Return

    a virtual memory object that must be freed by CPLVirtualMemFree(), or NULL in case of failure.

  Since

    GDAL 1.11

  Parameters

    - `hBand`: Rasterband object

    - `eRWFlag`: Either GF_Read to read a region of data, or GF_Write to write a region of data.

    - `nXOff`: The pixel offset to the top left corner of the region of the band to be accessed. This would be zero to start from the left side.

    - `nYOff`: The line offset to the top left corner of the region of the band to be accessed. This would be zero to start from the top.

    - `nXSize`: The width of the region of the band to be accessed in pixels.

    - `nYSize`: The height of the region of the band to be accessed in lines.

    - `nTileXSize`: the width of the tiles.

    - `nTileYSize`: the height of the tiles.

    - `eBufType`: the type of the pixel values in the data buffer. The pixel values will automatically be translated to/from the GDALRasterBand data type as needed.

    - `nCacheSize`: size in bytes of the maximum memory that will be really allocated (must ideally fit into RAM)

    - `bSingleThreadUsage`: set to TRUE if there will be no concurrent threads that will access the virtual memory mapping. This can optimize performance a bit. If set to FALSE, CPLVirtualMemDeclareThread() must be called.

    - `papszOptions`: NULL terminated list of options. Unused for now.

GDALDatasetH `GDALCreatePansharpenedVRT`(const char *pszXML, GDALRasterBandH hPanchroBand, int nInputSpectralBands, GDALRasterBandH *pahInputSpectralBands)

  Create a virtual pansharpened dataset.

  This function will create a virtual pansharpened dataset.

  Note that no reference will be taken on the passed bands. Consequently, they or their dataset to which they belong to must be kept open until this virtual pansharpened dataset is closed.

  The returned dataset will have no associated filename for itself. If you want to write the virtual dataset description to a file, use the GDALSetDescription() function (or SetDescription() method) on the dataset to assign a filename before it is closed.

  Return

    NULL on failure, or a new virtual dataset handle on success to be closed with GDALClose().

  Since

    GDAL 2.1

  Parameters

    - `pszXML`: Pansharpened VRT XML where <SpectralBand> elements have no explicit SourceFilename and SourceBand. The spectral bands in the XML will be assigned the successive values of the pahInputSpectralBands array. Must not be NULL.

    - `hPanchroBand`: Panchromatic band. Must not be NULL.

    - `nInputSpectralBands`: Number of input spectral bands. Must be greater than zero.

    - `pahInputSpectralBands`: Array of nInputSpectralBands spectral bands.

CPLXMLNode *`GDALGetJPEG2000Structure`(const char *pszFilename, CSLConstList papszOptions)

  Dump the structure of a JPEG2000 file as a XML tree.

  Return

    XML tree (to be freed with CPLDestroyXMLNode()) or NULL in case of error

  Since

    GDAL 2.0

  Parameters

    - `pszFilename`: filename.

    - `papszOptions`: NULL terminated list of options, or NULL. Allowed options are BINARY_CONTENT=YES, TEXT_CONTENT=YES, CODESTREAM=YES, ALL=YES.

GDALDatasetH `GDALCreateMultiDimensional`(GDALDriverH hDriver, const char *pszName, CSLConstList papszRootGroupOptions, CSLConstList papszOptions)

  Create a new multidimensioanl dataset with this driver.

  This is the same as the C++ method GDALDriver::CreateMultiDimensional().

GDALExtendedDataTypeH `GDALExtendedDataTypeCreate`(GDALDataType eType)

  Return a new GDALExtendedDataType of class GEDTC_NUMERIC.

  This is the same as the C++ method GDALExtendedDataType::Create()

  The returned handle should be freed with GDALExtendedDataTypeRelease().

  Return

    a new GDALExtendedDataTypeH handle, or nullptr.

  Parameters

    - `eType`: Numeric data type.

GDALExtendedDataTypeH `GDALExtendedDataTypeCreateString`(size_t nMaxStringLength)

  Return a new GDALExtendedDataType of class GEDTC_STRING.

  This is the same as the C++ method GDALExtendedDataType::CreateString()

  The returned handle should be freed with GDALExtendedDataTypeRelease().

  Return

    a new GDALExtendedDataTypeH handle, or nullptr.

GDALExtendedDataTypeH `GDALExtendedDataTypeCreateCompound`(const char *pszName, size_t nTotalSize, size_t nComponents, const GDALEDTComponentH *comps)

  Return a new GDALExtendedDataType of class GEDTC_COMPOUND.

  This is the same as the C++ method GDALExtendedDataType::Create(const std::string&, size_t, std::vector<std::unique_ptr<GDALEDTComponent>>&&)

  The returned handle should be freed with GDALExtendedDataTypeRelease().

  Return

    a new GDALExtendedDataTypeH handle, or nullptr.

  Parameters

    - `pszName`: Type name.

    - `nTotalSize`: Total size of the type in bytes. Should be large enough to store all components.

    - `nComponents`: Number of components in comps array.

    - `comps`: Components.

void `GDALExtendedDataTypeRelease`(GDALExtendedDataTypeH hEDT)

  Release the GDAL in-memory object associated with a GDALExtendedDataTypeH.

  Note: when applied on a object coming from a driver, this does not destroy the object in the file, database, etc…

const char *`GDALExtendedDataTypeGetName`(GDALExtendedDataTypeH hEDT)

  Return type name.

  This is the same as the C++ method GDALExtendedDataType::GetName()

GDALExtendedDataTypeClass `GDALExtendedDataTypeGetClass`(GDALExtendedDataTypeH hEDT)

  Return type class.

  This is the same as the C++ method GDALExtendedDataType::GetClass()

GDALDataType `GDALExtendedDataTypeGetNumericDataType`(GDALExtendedDataTypeH hEDT)

  Return numeric data type (only valid when GetClass() == GEDTC_NUMERIC)

  This is the same as the C++ method GDALExtendedDataType::GetNumericDataType()

size_t `GDALExtendedDataTypeGetSize`(GDALExtendedDataTypeH hEDT)

  Return data type size in bytes.

  This is the same as the C++ method GDALExtendedDataType::GetSize()

size_t `GDALExtendedDataTypeGetMaxStringLength`(GDALExtendedDataTypeH hEDT)

  Return the maximum length of a string in bytes.

  0 indicates unknown/unlimited string.

  This is the same as the C++ method GDALExtendedDataType::GetMaxStringLength()

GDALEDTComponentH *`GDALExtendedDataTypeGetComponents`(GDALExtendedDataTypeH hEDT, size_t *pnCount)

  Return the components of the data type (only valid when GetClass() == GEDTC_COMPOUND)

  The returned array and its content must be freed with GDALExtendedDataTypeFreeComponents(). If only the array itself needs to be freed, CPLFree() should be called (and GDALExtendedDataTypeRelease() on individual array members).

  This is the same as the C++ method GDALExtendedDataType::GetComponents()

  Return

    an array of *pnCount components.

  Parameters

    - `hEDT`: Data type

    - `pnCount`: Pointer to the number of values returned. Must NOT be NULL.

void `GDALExtendedDataTypeFreeComponents`(GDALEDTComponentH *components, size_t nCount)

  Free the return of GDALExtendedDataTypeGetComponents().

  Parameters

    - `components`: return value of GDALExtendedDataTypeGetComponents()

    - `nCount`: *pnCount value returned by GDALExtendedDataTypeGetComponents()

int `GDALExtendedDataTypeCanConvertTo`(GDALExtendedDataTypeH hSourceEDT, GDALExtendedDataTypeH hTargetEDT)

  Return whether this data type can be converted to the other one.

  This is the same as the C function GDALExtendedDataType::CanConvertTo()

  Return

    TRUE if hSourceEDT can be convert to hTargetEDT. FALSE otherwise.

  Parameters

    - `hSourceEDT`: Source data type for the conversion being considered.

    - `hTargetEDT`: Target data type for the conversion being considered.

int `GDALExtendedDataTypeEquals`(GDALExtendedDataTypeH hFirstEDT, GDALExtendedDataTypeH hSecondEDT)

  Return whether this data type is equal to another one.

  This is the same as the C++ method GDALExtendedDataType::operator==()

  Return

    TRUE if they are equal. FALSE otherwise.

  Parameters

    - `hFirstEDT`: First data type.

    - `hSecondEDT`: Second data type.

GDALEDTComponentH `GDALEDTComponentCreate`(const char *pszName, size_t nOffset, GDALExtendedDataTypeH hType)

  Create a new GDALEDTComponent.

  The returned value must be freed with GDALEDTComponentRelease().

  This is the same as the C++ constructor GDALEDTComponent::GDALEDTComponent().

void `GDALEDTComponentRelease`(GDALEDTComponentH hComp)

  Release the GDAL in-memory object associated with a GDALEDTComponentH.

  Note: when applied on a object coming from a driver, this does not destroy the object in the file, database, etc…

const char *`GDALEDTComponentGetName`(GDALEDTComponentH hComp)

  Return the name.

  The returned pointer is valid until hComp is released.

  This is the same as the C++ method GDALEDTComponent::GetName().

size_t `GDALEDTComponentGetOffset`(GDALEDTComponentH hComp)

  Return the offset (in bytes) of the component in the compound data type.

  This is the same as the C++ method GDALEDTComponent::GetOffset().

GDALExtendedDataTypeH `GDALEDTComponentGetType`(GDALEDTComponentH hComp)

  Return the data type of the component.

  This is the same as the C++ method GDALEDTComponent::GetType().

GDALGroupH `GDALDatasetGetRootGroup`(GDALDatasetH hDS)

  Return the root GDALGroup of this dataset.

  Only valid for multidimensional datasets.

  The returned value must be freed with GDALGroupRelease().

  This is the same as the C++ method GDALDataset::GetRootGroup().

  Since

    GDAL 3.1

void `GDALGroupRelease`(GDALGroupH hGroup)

  Release the GDAL in-memory object associated with a GDALGroupH.

  Note: when applied on a object coming from a driver, this does not destroy the object in the file, database, etc…

const char *`GDALGroupGetName`(GDALGroupH hGroup)

  Return the name of the group.

  The returned pointer is valid until hGroup is released.

  This is the same as the C++ method GDALGroup::GetName().

const char *`GDALGroupGetFullName`(GDALGroupH hGroup)

  Return the full name of the group.

  The returned pointer is valid until hGroup is released.

  This is the same as the C++ method GDALGroup::GetFullName().

char **`GDALGroupGetMDArrayNames`(GDALGroupH hGroup, CSLConstList papszOptions)

  Return the list of multidimensional array names contained in this group.

  This is the same as the C++ method GDALGroup::GetGroupNames().

  Return

    the array names, to be freed with CSLDestroy()

GDALMDArrayH `GDALGroupOpenMDArray`(GDALGroupH hGroup, const char *pszMDArrayName, CSLConstList papszOptions)

  Open and return a multidimensional array.

  This is the same as the C++ method GDALGroup::OpenMDArray().

  Return

    the array, to be freed with GDALMDArrayRelease(), or nullptr.

char **`GDALGroupGetGroupNames`(GDALGroupH hGroup, CSLConstList papszOptions)

  Return the list of sub-groups contained in this group.

  This is the same as the C++ method GDALGroup::GetGroupNames().

  Return

    the group names, to be freed with CSLDestroy()

GDALGroupH `GDALGroupOpenGroup`(GDALGroupH hGroup, const char *pszSubGroupName, CSLConstList papszOptions)

  Open and return a sub-group.

  This is the same as the C++ method GDALGroup::OpenGroup().

  Return

    the sub-group, to be freed with GDALGroupRelease(), or nullptr.

GDALDimensionH *`GDALGroupGetDimensions`(GDALGroupH hGroup, size_t *pnCount, CSLConstList papszOptions)

  Return the list of dimensions contained in this group and used by its arrays.

  The returned array must be freed with GDALReleaseDimensions(). If only the array itself needs to be freed, CPLFree() should be called (and GDALDimensionRelease() on individual array members).

  This is the same as the C++ method GDALGroup::GetDimensions().

  Return

    an array of *pnCount dimensions.

  Parameters

    - `hGroup`: Group.

    - `pnCount`: Pointer to the number of values returned. Must NOT be NULL.

    - `papszOptions`: Driver specific options determining how dimensions should be retrieved. Pass nullptr for default behaviour.

GDALAttributeH `GDALGroupGetAttribute`(GDALGroupH hGroup, const char *pszName)

  Return an attribute by its name.

  This is the same as the C++ method GDALIHasAttribute::GetAttribute()

  The returned attribute must be freed with GDALAttributeRelease().

GDALAttributeH *`GDALGroupGetAttributes`(GDALGroupH hGroup, size_t *pnCount, CSLConstList papszOptions)

  Return the list of attributes contained in this group.

  The returned array must be freed with GDALReleaseAttributes(). If only the array itself needs to be freed, CPLFree() should be called (and GDALAttributeRelease() on individual array members).

  This is the same as the C++ method GDALGroup::GetAttributes().

  Return

    an array of *pnCount attributes.

  Parameters

    - `hGroup`: Group.

    - `pnCount`: Pointer to the number of values returned. Must NOT be NULL.

    - `papszOptions`: Driver specific options determining how attributes should be retrieved. Pass nullptr for default behaviour.

CSLConstList `GDALGroupGetStructuralInfo`(GDALGroupH hGroup)

  Return structural information on the group.

  This may be the compression, etc..

  The return value should not be freed and is valid until GDALGroup is released or this function called again.

  This is the same as the C++ method GDALGroup::GetStruturalInfo().

GDALGroupH `GDALGroupCreateGroup`(GDALGroupH hGroup, const char *pszSubGroupName, CSLConstList papszOptions)

  Create a sub-group within a group.

  This is the same as the C++ method GDALGroup::CreateGroup().

  Return

    the sub-group, to be freed with GDALGroupRelease(), or nullptr.

GDALDimensionH `GDALGroupCreateDimension`(GDALGroupH hGroup, const char *pszName, const char *pszType, const char *pszDirection, GUInt64 nSize, CSLConstList papszOptions)

  Create a dimension within a group.

  This is the same as the C++ method GDALGroup::CreateDimension().

  Return

    the dimension, to be freed with GDALDimensionRelease(), or nullptr.

GDALMDArrayH `GDALGroupCreateMDArray`(GDALGroupH hGroup, const char *pszName, size_t nDimensions, GDALDimensionH *pahDimensions, GDALExtendedDataTypeH hEDT, CSLConstList papszOptions)

  Create a multidimensional array within a group.

  This is the same as the C++ method GDALGroup::CreateMDArray().

  Return

    the array, to be freed with GDALMDArrayRelease(), or nullptr.

GDALAttributeH `GDALGroupCreateAttribute`(GDALGroupH hGroup, const char *pszName, size_t nDimensions, const GUInt64 *panDimensions, GDALExtendedDataTypeH hEDT, CSLConstList papszOptions)

  Create a attribute within a group.

  This is the same as the C++ method GDALGroup::CreateAttribute().

  Return

    the attribute, to be freed with GDALAttributeRelease(), or nullptr.

void `GDALMDArrayRelease`(GDALMDArrayH hMDArray)

  Release the GDAL in-memory object associated with a GDALMDArray.

  Note: when applied on a object coming from a driver, this does not destroy the object in the file, database, etc…

const char *`GDALMDArrayGetName`(GDALMDArrayH hArray)

  Return array name.

  This is the same as the C++ method GDALMDArray::GetName()

const char *`GDALMDArrayGetFullName`(GDALMDArrayH hArray)

  Return array full name.

  This is the same as the C++ method GDALMDArray::GetFullName()

GUInt64 `GDALMDArrayGetTotalElementsCount`(GDALMDArrayH hArray)

  Return the total number of values in the array.

  This is the same as the C++ method GDALAbstractMDArray::GetTotalElementsCount()

size_t `GDALMDArrayGetDimensionCount`(GDALMDArrayH hArray)

  Return the number of dimensions.

  This is the same as the C++ method GDALAbstractMDArray::GetDimensionCount()

GDALDimensionH *`GDALMDArrayGetDimensions`(GDALMDArrayH hArray, size_t *pnCount)

  Return the dimensions of the array.

  The returned array must be freed with GDALReleaseDimensions(). If only the array itself needs to be freed, CPLFree() should be called (and GDALDimensionRelease() on individual array members).

  This is the same as the C++ method GDALAbstractMDArray::GetDimensions()

  Return

    an array of *pnCount dimensions.

  Parameters

    - `hArray`: Array.

    - `pnCount`: Pointer to the number of values returned. Must NOT be NULL.

GDALExtendedDataTypeH `GDALMDArrayGetDataType`(GDALMDArrayH hArray)

  Return the data type.

  The return must be freed with GDALExtendedDataTypeRelease().

int `GDALMDArrayRead`(GDALMDArrayH hArray, const GUInt64 *arrayStartIdx, const size_t *count, const GInt64 *arrayStep, const GPtrDiff_t *bufferStride, GDALExtendedDataTypeH bufferDatatype, void *pDstBuffer, const void *pDstBufferAllocStart, size_t nDstBufferllocSize)

  Read part or totality of a multidimensional array.

  This is the same as the C++ method GDALAbstractMDArray::Read()

  Return

    TRUE in case of success.

int `GDALMDArrayWrite`(GDALMDArrayH hArray, const GUInt64 *arrayStartIdx, const size_t *count, const GInt64 *arrayStep, const GPtrDiff_t *bufferStride, GDALExtendedDataTypeH bufferDatatype, const void *pSrcBuffer, const void *psrcBufferAllocStart, size_t nSrcBufferllocSize)

  Write part or totality of a multidimensional array.

  This is the same as the C++ method GDALAbstractMDArray::Write()

  Return

    TRUE in case of success.

GDALAttributeH `GDALMDArrayGetAttribute`(GDALMDArrayH hArray, const char *pszName)

  Return an attribute by its name.

  This is the same as the C++ method GDALIHasAttribute::GetAttribute()

  The returned attribute must be freed with GDALAttributeRelease().

GDALAttributeH *`GDALMDArrayGetAttributes`(GDALMDArrayH hArray, size_t *pnCount, CSLConstList papszOptions)

  Return the list of attributes contained in this array.

  The returned array must be freed with GDALReleaseAttributes(). If only the array itself needs to be freed, CPLFree() should be called (and GDALAttributeRelease() on individual array members).

  This is the same as the C++ method GDALMDArray::GetAttributes().

  Return

    an array of *pnCount attributes.

  Parameters

    - `hArray`: Array.

    - `pnCount`: Pointer to the number of values returned. Must NOT be NULL.

    - `papszOptions`: Driver specific options determining how attributes should be retrieved. Pass nullptr for default behaviour.

GDALAttributeH `GDALMDArrayCreateAttribute`(GDALMDArrayH hArray, const char *pszName, size_t nDimensions, const GUInt64 *panDimensions, GDALExtendedDataTypeH hEDT, CSLConstList papszOptions)

  Create a attribute within an array.

  This is the same as the C++ method GDALMDArray::CreateAttribute().

  Return

    the attribute, to be freed with GDALAttributeRelease(), or nullptr.

const void *`GDALMDArrayGetRawNoDataValue`(GDALMDArrayH hArray)

  Return the nodata value as a “raw” value.

  The value returned might be nullptr in case of no nodata value. When a nodata value is registered, a non-nullptr will be returned whose size in bytes is GetDataType().GetSize().

  The returned value should not be modified or freed.

  This is the same as the ++ method GDALMDArray::GetRawNoDataValue().

  Return

    nullptr or a pointer to GetDataType().GetSize() bytes.

double `GDALMDArrayGetNoDataValueAsDouble`(GDALMDArrayH hArray, int *pbHasNoDataValue)

  Return the nodata value as a double.

  The value returned might be nullptr in case of no nodata value. When a nodata value is registered, a non-nullptr will be returned whose size in bytes is GetDataType().GetSize().

  This is the same as the C++ method GDALMDArray::GetNoDataValueAsDouble().

  Return

    the nodata value as a double. A 0.0 value might also indicate the absence of a nodata value or an error in the conversion (*pbHasNoDataValue will be set to false then).

  Parameters

    - `hArray`: Array handle.

    - `pbHasNoDataValue`: Pointer to a output boolean that will be set to true if a nodata value exists and can be converted to double. Might be nullptr.

int `GDALMDArraySetRawNoDataValue`(GDALMDArrayH hArray, const void *pNoData)

  Set the nodata value as a “raw” value.

  The value passed might be nullptr in case of no nodata value. When a nodata value is registered, a non-nullptr whose size in bytes is GetDataType().GetSize() must be passed.

  This is the same as the C++ method GDALMDArray::SetRawNoDataValue(const void*).

  Return

    TRUE in case of success.

int `GDALMDArraySetNoDataValueAsDouble`(GDALMDArrayH hArray, double dfNoDataValue)

  Set the nodata value as a double.

  If the natural data type of the attribute/array is not double, type conversion will occur to the type returned by GetDataType().

  This is the same as the C++ method GDALMDArray::SetNoDataValue(double).

  Return

    TRUE in case of success.

int `GDALMDArraySetScale`(GDALMDArrayH hArray, double dfScale)

  Set the scale value to apply to raw values.

  unscaled_value = raw_value * GetScale() + GetOffset()

  This is the same as the C++ method GDALMDArray::SetScale().

  Return

    TRUE in case of success.

double `GDALMDArrayGetScale`(GDALMDArrayH hArray, int *pbHasValue)

  Get the scale value to apply to raw values.

  unscaled_value = raw_value * GetScale() + GetOffset()

  This is the same as the C++ method GDALMDArray::GetScale().

  Return

    the scale value

int `GDALMDArraySetOffset`(GDALMDArrayH hArray, double dfOffset)

  Set the scale value to apply to raw values.

  unscaled_value = raw_value * GetScale() + GetOffset()

  This is the same as the C++ method GDALMDArray::SetOffset().

  Return

    TRUE in case of success.

double `GDALMDArrayGetOffset`(GDALMDArrayH hArray, int *pbHasValue)

  Get the scale value to apply to raw values.

  unscaled_value = raw_value * GetScale() + GetOffset()

  This is the same as the C++ method GDALMDArray::GetOffset().

  Return

    the scale value

GUInt64 *`GDALMDArrayGetBlockSize`(GDALMDArrayH hArray, size_t *pnCount)

  Return the “natural” block size of the array along all dimensions.

  Some drivers might organize the array in tiles/blocks and reading/writing aligned on those tile/block boundaries will be more efficient.

  The returned number of elements in the vector is the same as GetDimensionCount(). A value of 0 should be interpretated as no hint regarding the natural block size along the considered dimension. “Flat” arrays will typically return a vector of values set to 0.

  The default implementation will return a vector of values set to 0.

  This method is used by GetProcessingChunkSize().

  Pedantic note: the returned type is GUInt64, so in the highly unlikeley theoretical case of a 32-bit platform, this might exceed its size_t allocation capabilities.

  This is the same as the C++ method GDALAbstractMDArray::GetBlockSize().

  Return

    the block size, in number of elemnts along each dimension.

int `GDALMDArraySetUnit`(GDALMDArrayH hArray, const char *pszUnit)

  Set the variable unit.

  Values should conform as much as possible with those allowed by the NetCDF CF conventions: http://cfconventions.org/Data/cf-conventions/cf-conventions-1.7/cf-conventions.html#units but others might be returned.

  Few examples are “meter”, “degrees”, “second”, … Empty value means unknown.

  This is the same as the C function GDALMDArraySetUnit()

  Return

    TRUE in case of success.

  Parameters

    - `hArray`: array.

    - `pszUnit`: unit name.

const char *`GDALMDArrayGetUnit`(GDALMDArrayH hArray)

  Return the array unit.

  Values should conform as much as possible with those allowed by the NetCDF CF conventions: http://cfconventions.org/Data/cf-conventions/cf-conventions-1.7/cf-conventions.html#units but others might be returned.

  Few examples are “meter”, “degrees”, “second”, … Empty value means unknown.

  The return value should not be freed and is valid until GDALMDArray is released or this function called again.

  This is the same as the C++ method GDALMDArray::GetUnit().

int `GDALMDArraySetSpatialRef`(GDALMDArrayH hArray, OGRSpatialReferenceH hSRS)

  Assign a spatial reference system object to the the array.

  This is the same as the C++ method GDALMDArray::SetSpatialRef().

  Return

    TRUE in case of success.

OGRSpatialReferenceH `GDALMDArrayGetSpatialRef`(GDALMDArrayH hArray)

  Return the spatial reference system object associated with the array.

  This is the same as the C++ method GDALMDArray::GetSpatialRef().

  The returned object must be freed with OSRDestroySpatialReference().

size_t *`GDALMDArrayGetProcessingChunkSize`(GDALMDArrayH hArray, size_t *pnCount, size_t nMaxChunkMemory)

  Return an optimal chunk size for read/write oerations, given the natural block size and memory constraints specified.

  This method will use GetBlockSize() to define a chunk whose dimensions are multiple of those returned by GetBlockSize() (unless the block define by GetBlockSize() is larger than nMaxChunkMemory, in which case it will be returned by this method).

  This is the same as the C++ method GDALAbstractMDArray::GetProcessingChunkSize().

  Return

    the chunk size, in number of elemnts along each dimension.

  Parameters

    - `hArray`: Array.

    - `pnCount`: Pointer to the number of values returned. Must NOT be NULL.

    - `nMaxChunkMemory`: Maximum amount of memory, in bytes, to use for the chunk.

CSLConstList `GDALMDArrayGetStructuralInfo`(GDALMDArrayH hArray)

  Return structural information on the array.

  This may be the compression, etc..

  The return value should not be freed and is valid until GDALMDArray is released or this function called again.

  This is the same as the C++ method GDALMDArray::GetStruturalInfo().

GDALMDArrayH `GDALMDArrayGetView`(GDALMDArrayH hArray, const char *pszViewExpr)

  Return a view of the array using slicing or field access.

  The returned object should be released with GDALMDArrayRelease().

  This is the same as the C++ method GDALMDArray::GetView().

GDALMDArrayH `GDALMDArrayTranspose`(GDALMDArrayH hArray, size_t nNewAxisCount, const int *panMapNewAxisToOldAxis)

  Return a view of the array whose axis have been reordered.

  The returned object should be released with GDALMDArrayRelease().

  This is the same as the C++ method GDALMDArray::Transpose().

GDALMDArrayH `GDALMDArrayGetUnscaled`(GDALMDArrayH hArray)

  Return an array that is the unscaled version of the current one.

  That is each value of the unscaled array will be unscaled_value = raw_value * GetScale() + GetOffset()

  The returned object should be released with GDALMDArrayRelease().

  This is the same as the C++ method GDALMDArray::GetUnscaled().

GDALMDArrayH `GDALMDArrayGetMask`(GDALMDArrayH hArray, CSLConstList papszOptions)

  Return an array that is a mask for the current array.

  This array will be of type Byte, with values set to 0 to indicate invalid pixels of the current array, and values set to 1 to indicate valid pixels.

  The returned object should be released with GDALMDArrayRelease().

  This is the same as the C++ method GDALMDArray::GetMask().

GDALDatasetH `GDALMDArrayAsClassicDataset`(GDALMDArrayH hArray, size_t iXDim, size_t iYDim)

  Return a view of this array as a “classic” GDALDataset (ie 2D)

  Only 2D or more arrays are supported.

  In the case of > 2D arrays, additional dimensions will be represented as raster bands.

  The “reverse” method is GDALRasterBand::AsMDArray().

  This is the same as the C++ method GDALMDArray::AsClassicDataset().

  Return

    a new GDALDataset that must be freed with GDALClose(), or nullptr

  Parameters

    - `hArray`: Array.

    - `iXDim`: Index of the dimension that will be used as the X/width axis.

    - `iYDim`: Index of the dimension that will be used as the Y/height axis.

void `GDALAttributeRelease`(GDALAttributeH hAttr)

  Release the GDAL in-memory object associated with a GDALAttribute.

  Note: when applied on a object coming from a driver, this does not destroy the object in the file, database, etc…

void `GDALReleaseAttributes`(GDALAttributeH *attributes, size_t nCount)

  Free the return of GDALGroupGetAttributes() or GDALMDArrayGetAttributes()

  Parameters

    - `attributes`: return pointer of above methods

    - `nCount`: *pnCount value returned by above methods

const char *`GDALAttributeGetName`(GDALAttributeH hAttr)

  Return the name of the attribute.

  The returned pointer is valid until hAttr is released.

  This is the same as the C++ method GDALAttribute::GetName().

const char *`GDALAttributeGetFullName`(GDALAttributeH hAttr)

  Return the full name of the attribute.

  The returned pointer is valid until hAttr is released.

  This is the same as the C++ method GDALAttribute::GetFullName().

GUInt64 `GDALAttributeGetTotalElementsCount`(GDALAttributeH hAttr)

  Return the total number of values in the attribute.

  This is the same as the C++ method GDALAbstractMDArray::GetTotalElementsCount()

size_t `GDALAttributeGetDimensionCount`(GDALAttributeH hAttr)

  Return the number of dimensions.

  This is the same as the C++ method GDALAbstractMDArray::GetDimensionCount()

GUInt64 *`GDALAttributeGetDimensionsSize`(GDALAttributeH hAttr, size_t *pnCount)

  Return the dimension sizes of the attribute.

  The returned array must be freed with CPLFree()

  Return

    an array of *pnCount values.

  Parameters

    - `hAttr`: Attribute.

    - `pnCount`: Pointer to the number of values returned. Must NOT be NULL.

GDALExtendedDataTypeH `GDALAttributeGetDataType`(GDALAttributeH hAttr)

  Return the data type.

  The return must be freed with GDALExtendedDataTypeRelease().

GByte *`GDALAttributeReadAsRaw`(GDALAttributeH hAttr, size_t *pnSize)

  Return the raw value of an attribute.

  This is the same as the C++ method GDALAttribute::ReadAsRaw().

  The returned buffer must be freed with GDALAttributeFreeRawResult()

  Return

    a buffer of *pnSize bytes.

  Parameters

    - `hAttr`: Attribute.

    - `pnSize`: Pointer to the number of bytes returned. Must NOT be NULL.

void `GDALAttributeFreeRawResult`(GDALAttributeH hAttr, GByte *raw, size_t nSize)

  Free the return of GDALAttributeAsRaw()

const char *`GDALAttributeReadAsString`(GDALAttributeH hAttr)

  Return the value of an attribute as a string.

  The returned string should not be freed, and its lifetime does not excess a next call to ReadAsString() on the same object, or the deletion of the object itself.

  This function will only return the first element if there are several.

  This is the same as the C++ method GDALAttribute::ReadAsString()

  Return

    a string, or nullptr.

int `GDALAttributeReadAsInt`(GDALAttributeH hAttr)

  Return the value of an attribute as a integer.

  This function will only return the first element if there are several.

  It can fail if its value can be converted to integer.

  This is the same as the C++ method GDALAttribute::ReadAsInt()

  Return

    a integer, or INT_MIN in case of error.

double `GDALAttributeReadAsDouble`(GDALAttributeH hAttr)

  Return the value of an attribute as a double.

  This function will only return the first element if there are several.

  It can fail if its value can be converted to double.

  This is the same as the C++ method GDALAttribute::ReadAsDoubl()

  Return

    a double value.

char **`GDALAttributeReadAsStringArray`(GDALAttributeH hAttr)

  Return the value of an attribute as an array of strings.

  This is the same as the C++ method GDALAttribute::ReadAsStringArray()

  The return value must be freed with CSLDestroy().

int *`GDALAttributeReadAsIntArray`(GDALAttributeH hAttr, size_t *pnCount)

  Return the value of an attribute as an array of integers.

  This is the same as the C++ method GDALAttribute::ReadAsIntArray()

  Return

    array to be freed with CPLFree(), or nullptr.

  Parameters

    - `hAttr`: Attribute

    - `pnCount`: Pointer to the number of values returned. Must NOT be NULL.

double *`GDALAttributeReadAsDoubleArray`(GDALAttributeH hAttr, size_t *pnCount)

  Return the value of an attribute as an array of doubles.

  This is the same as the C++ method GDALAttribute::ReadAsDoubleArray()

  Return

    array to be freed with CPLFree(), or nullptr.

  Parameters

    - `hAttr`: Attribute

    - `pnCount`: Pointer to the number of values returned. Must NOT be NULL.

int `GDALAttributeWriteRaw`(GDALAttributeH hAttr, const void *pabyValue, size_t nLength)

  Write an attribute from raw values expressed in GetDataType()

  The values should be provided in the type of GetDataType() and there should be exactly GetTotalElementsCount() of them. If GetDataType() is a string, each value should be a char* pointer.

  This is the same as the C++ method GDALAttribute::Write(const void*, size_t).

  Return

    TRUE in case of success.

  Parameters

    - `hAttr`: Attribute

    - `pabyValue`: Buffer of nLen bytes.

    - `nLength`: Size of pabyValue in bytes. Should be equal to GetTotalElementsCount() * GetDataType().GetSize()

int `GDALAttributeWriteString`(GDALAttributeH hAttr, const char *pszVal)

  Write an attribute from a string value.

  Type conversion will be performed if needed. If the attribute contains multiple values, only the first one will be updated.

  This is the same as the C++ method GDALAttribute::Write(const char*)

  Return

    TRUE in case of success.

  Parameters

    - `hAttr`: Attribute

    - `pszVal`: Pointer to a string.

int `GDALAttributeWriteStringArray`(GDALAttributeH hAttr, CSLConstList papszValues)

  Write an attribute from an array of strings.

  Type conversion will be performed if needed.

  Exactly GetTotalElementsCount() strings must be provided

  This is the same as the C++ method GDALAttribute::Write(CSLConstList)

  Return

    TRUE in case of success.

  Parameters

    - `hAttr`: Attribute

    - `papszValues`: Array of strings.

int `GDALAttributeWriteInt`(GDALAttributeH hAttr, int nVal)

  Write an attribute from a integer value.

  Type conversion will be performed if needed. If the attribute contains multiple values, only the first one will be updated.

  This is the same as the C++ method GDALAttribute::WriteInt()

  Return

    TRUE in case of success.

  Parameters

    - `hAttr`: Attribute

    - `nVal`: Value.

int `GDALAttributeWriteDouble`(GDALAttributeH hAttr, double dfVal)

  Write an attribute from a double value.

  Type conversion will be performed if needed. If the attribute contains multiple values, only the first one will be updated.

  This is the same as the C++ method GDALAttribute::Write(double);

  Return

    TRUE in case of success.

  Parameters

    - `hAttr`: Attribute

    - `dfVal`: Value.

int `GDALAttributeWriteDoubleArray`(GDALAttributeH hAttr, const double *padfValues, size_t nCount)

  Write an attribute from an array of double.

  Type conversion will be performed if needed.

  Exactly GetTotalElementsCount() strings must be provided

  This is the same as the C++ method GDALAttribute::Write(const double *, size_t)

  Return

    TRUE in case of success.

  Parameters

    - `hAttr`: Attribute

    - `padfValues`: Array of double.

    - `nCount`: Should be equal to GetTotalElementsCount().

void `GDALDimensionRelease`(GDALDimensionH hDim)

  Release the GDAL in-memory object associated with a GDALDimension.

  Note: when applied on a object coming from a driver, this does not destroy the object in the file, database, etc…

void `GDALReleaseDimensions`(GDALDimensionH *dims, size_t nCount)

  Free the return of GDALGroupGetDimensions() or GDALMDArrayGetDimensions()

  Parameters

    - `dims`: return pointer of above methods

    - `nCount`: *pnCount value returned by above methods

const char *`GDALDimensionGetName`(GDALDimensionH hDim)

  Return dimension name.

  This is the same as the C++ method GDALDimension::GetName()

const char *`GDALDimensionGetFullName`(GDALDimensionH hDim)

  Return dimension full name.

  This is the same as the C++ method GDALDimension::GetFullName()

const char *`GDALDimensionGetType`(GDALDimensionH hDim)

  Return dimension type.

  This is the same as the C++ method GDALDimension::GetType()

const char *`GDALDimensionGetDirection`(GDALDimensionH hDim)

  Return dimension direction.

  This is the same as the C++ method GDALDimension::GetDirection()

GUInt64 `GDALDimensionGetSize`(GDALDimensionH hDim)

  Return the size, that is the number of values along the dimension.

  This is the same as the C++ method GDALDimension::GetSize()

GDALMDArrayH `GDALDimensionGetIndexingVariable`(GDALDimensionH hDim)

  Return the variable that is used to index the dimension (if there is one).

  This is the array, typically one-dimensional, describing the values taken by the dimension.

  The returned value should be freed with GDALMDArrayRelease().

  This is the same as the C++ method GDALDimension::GetIndexingVariable()

int `GDALDimensionSetIndexingVariable`(GDALDimensionH hDim, GDALMDArrayH hArray)

  Set the variable that is used to index the dimension.

  This is the array, typically one-dimensional, describing the values taken by the dimension.

  This is the same as the C++ method GDALDimension::SetIndexingVariable()

  Return

    TRUE in case of success.

struct `GDALRasterIOExtraArg`
  #include <gdal.h>

  Structure to pass extra arguments to RasterIO() method.

  Since

    GDAL 2.0

  Public Members

  int `nVersion`

    Version of structure (to allow future extensions of the structure)

  GDALRIOResampleAlg `eResampleAlg`

    Resampling algorithm

  GDALProgressFunc `pfnProgress`

    Progress callback

  void *`pProgressData`

    Progress callback user data

  int `bFloatingPointWindowValidity`

    Indicate if dfXOff, dfYOff, dfXSize and dfYSize are set. Mostly reserved from the VRT driver to communicate a more precise source window. Must be such that dfXOff - nXOff < 1.0 and dfYOff - nYOff < 1.0 and nXSize - dfXSize < 1.0 and nYSize - dfYSize < 1.0

  double `dfXOff`

    Pixel offset to the top left corner. Only valid if bFloatingPointWindowValidity = TRUE

  double `dfYOff`

    Line offset to the top left corner. Only valid if bFloatingPointWindowValidity = TRUE

  double `dfXSize`

    Width in pixels of the area of interest. Only valid if bFloatingPointWindowValidity = TRUE

  double `dfYSize`

    Height in pixels of the area of interest. Only valid if bFloatingPointWindowValidity = TRUE

struct `GDAL_GCP`
  #include <gdal.h>

  Ground Control Point.

  Public Members

  char *`pszId`

    Unique identifier, often numeric.

  char *`pszInfo`

    Informational message or “”.

  double `dfGCPPixel`

    Pixel (x) location of GCP on raster.

  double `dfGCPLine`

    Line (y) location of GCP on raster.

  double `dfGCPX`

    X position of GCP in georeferenced space.

  double `dfGCPY`

    Y position of GCP in georeferenced space.

  double `dfGCPZ`

    Elevation of GCP, or zero if not known.

struct `GDALRPCInfo`
  #include <gdal.h>

  Structure to store Rational Polynomial Coefficients / Rigorous Projection Model.

  See http://geotiff.maptools.org/rpc_prop.html

  Public Members

  double `dfLINE_OFF`

    Line offset

  double `dfSAMP_OFF`

    Sample/Pixel offset

  double `dfLAT_OFF`

    Latitude offset

  double `dfLONG_OFF`

    Longitude offset

  double `dfHEIGHT_OFF`

    Height offset

  double `dfLINE_SCALE`

    Line scale

  double `dfSAMP_SCALE`

    Sample/Pixel scale

  double `dfLAT_SCALE`

    Latitude scale

  double `dfLONG_SCALE`

    Longitude scale

  double `dfHEIGHT_SCALE`

    Height scale

  double `adfLINE_NUM_COEFF`[20]

    Line Numerator Coefficients

  double `adfLINE_DEN_COEFF`[20]

    Line Denominator Coefficients

  double `adfSAMP_NUM_COEFF`[20]

    Sample/Pixel Numerator Coefficients

  double `adfSAMP_DEN_COEFF`[20]

    Sample/Pixel Denominator Coefficients

  double `dfMIN_LONG`

    Minimum longitude

  double `dfMIN_LAT`

    Minimum latitude

  double `dfMAX_LONG`

    Maximum longitude

  double `dfMAX_LAT`

    Maximum latitude

struct `GDALColorEntry`
  #include <gdal.h>

  Color tuple.

  Public Members

  short `c1`

    gray, red, cyan or hue

  short `c2`

    green, magenta, or lightness

  short `c3`

    blue, yellow, or saturation

  short `c4`

    alpha or blackband