all.pm

Go to the documentation of this file.

#** @class Geo::GDAL
# @brief GDAL utility functions and a root class for raster classes.
# @details Geo::GDAL wraps many GDAL utility functions and is as a root class
# for all GDAL raster classes. A "raster" is an object, whose core is
# a rectagular grid of cells, called a "band" in GDAL. Each cell
# contains a numeric value of a specific data type.
#*
package Geo::GDAL;
 
#** @method ApplyVerticalShiftGrid()
#*
sub ApplyVerticalShiftGrid {
}
 
#** @method BuildVRT()
#*
sub BuildVRT {
     for (keys %Geo::GDAL::Const::) {
         next if /TypeCount/;
         push(@DATA_TYPES, $1), next if /^GDT_(\w+)/;
         push(@OPEN_FLAGS, $1), next if /^OF_(\w+)/;
         push(@RESAMPLING_TYPES, $1), next if /^GRA_(\w+)/;
         push(@RIO_RESAMPLING_TYPES, $1), next if /^GRIORA_(\w+)/;
         push(@NODE_TYPES, $1), next if /^CXT_(\w+)/;
     }
     for my $string (@DATA_TYPES) {
         my $int = eval "\$Geo::GDAL::Const::GDT_$string";
         $S2I{data_type}{$string} = $int;
         $I2S{data_type}{$int} = $string;
     }
     for my $string (@OPEN_FLAGS) {
         my $int = eval "\$Geo::GDAL::Const::OF_$string";
         $S2I{open_flag}{$string} = $int;
     }
     for my $string (@RESAMPLING_TYPES) {
         my $int = eval "\$Geo::GDAL::Const::GRA_$string";
         $S2I{resampling}{$string} = $int;
         $I2S{resampling}{$int} = $string;
     }
     for my $string (@RIO_RESAMPLING_TYPES) {
         my $int = eval "\$Geo::GDAL::Const::GRIORA_$string";
         $S2I{rio_resampling}{$string} = $int;
         $I2S{rio_resampling}{$int} = $string;
     }
     for my $string (@NODE_TYPES) {
         my $int = eval "\$Geo::GDAL::Const::CXT_$string";
         $S2I{node_type}{$string} = $int;
         $I2S{node_type}{$int} = $string;
     }
     our $HAVE_PDL;
     eval 'require PDL';
     $HAVE_PDL = 1 unless $@;
}
 
#** @method CPLBinaryToHex()
#*
sub CPLBinaryToHex {
}
 
#** @method CPLHexToBinary()
#*
sub CPLHexToBinary {
}
 
#** @method ContourGenerateEx()
#*
sub ContourGenerateEx {
}
 
#** @method CreatePansharpenedVRT()
#*
sub CreatePansharpenedVRT {
}
 
#** @method scalar DataTypeIsComplex($DataType)
# Package subroutine.
# @param DataType A GDAL raster cell data type (one of those listed by Geo::GDAL::DataTypes).
# @return true if the data type is a complex number.
#*
sub DataTypeIsComplex {
    return _DataTypeIsComplex(s2i(data_type => shift));
}
 
#** @method list DataTypeValueRange($DataType)
# Package subroutine.
# @param DataType Data type (one of those listed by Geo::GDAL::DataTypes).
# @note Some returned values are inaccurate.
# 
# @return the minimum, maximum range of the data type.
#*
sub DataTypeValueRange {
    my $t = shift;
    s2i(data_type => $t);
    # these values are from gdalrasterband.cpp
    return (0,255) if $t =~ /Byte/;
    return (0,65535) if $t =~/UInt16/;
    return (-32768,32767) if $t =~/Int16/;
    return (0,4294967295) if $t =~/UInt32/;
    return (-2147483648,2147483647) if $t =~/Int32/;
    return (-4294967295.0,4294967295.0) if $t =~/Float32/;
    return (-4294967295.0,4294967295.0) if $t =~/Float64/;
}
 
#** @method list DataTypes()
# Package subroutine.
# @return a list of GDAL raster cell data types. These are currently:
# Byte, CFloat32, CFloat64, CInt16, CInt32, Float32, Float64, Int16, Int32, UInt16, UInt32, and Unknown.
#*
sub DataTypes {
    return @DATA_TYPES;
}
 
#** @method scalar DecToDMS($angle, $axis, $precision=2)
# Package subroutine.
# Convert decimal degrees to degrees, minutes, and seconds string
# @param angle A number
# @param axis A string specifying latitude or longitude ('Long').
# @param precision
# @return a string nndnn'nn.nn'"L where n is a number and L is either
# N or E
#*
sub DecToDMS {
}
 
#** @method scalar DecToPackedDMS($dec)
# Package subroutine.
# @param dec Decimal degrees
# @return packed DMS, i.e., a number DDDMMMSSS.SS
#*
sub DecToPackedDMS {
}
 
#** @method DontUseExceptions()
# Package subroutine.
# Do not use the Perl exception mechanism for GDAL messages. Instead
# the messages are printed to standard error.
#*
sub DontUseExceptions {
}
 
#** @method Geo::GDAL::Driver Driver($Name)
# Package subroutine.
# Access a format driver.
# @param Name The short name of the driver. One of
# Geo::GDAL::DriverNames or Geo::OGR::DriverNames.
# @note This subroutine is imported into the main namespace if Geo::GDAL
# is used with qw/:all/.
# @return a Geo::GDAL::Driver object.
#*
sub Driver {
    return 'Geo::GDAL::Driver' unless @_;
    my $name = shift;
    my $driver = GetDriver($name);
    error("Driver \"$name\" not found. Is it built in? Check with Geo::GDAL::Drivers or Geo::OGR::Drivers.")
        unless $driver;
    return $driver;
}
 
#** @method list DriverNames()
# Package subroutine.
# Available raster format drivers.
# \code
# perl -MGeo::GDAL -e '@d=Geo::GDAL::DriverNames;print "@d\n"'
# \endcode
# @note Use Geo::OGR::DriverNames for vector drivers.
# @return a list of the short names of all available GDAL raster drivers.
#*
sub DriverNames {
}
 
#** @method list Drivers()
# Package subroutine.
# @note Use Geo::OGR::Drivers for vector drivers.
# @return a list of all available GDAL raster drivers.
#*
sub Drivers {
    my @drivers;
    for my $i (0..GetDriverCount()-1) {
        my $driver = GetDriver($i);
        push @drivers, $driver if $driver->TestCapability('RASTER');
    }
    return @drivers;
}
 
#** @method EscapeString()
#*
sub EscapeString {
}
 
#** @method scalar FindFile($basename)
# Package subroutine.
# Search for GDAL support files.
# 
# An example:
# \code
# use Geo::GDAL;
# $a = Geo::GDAL::FindFile('pcs.csv');
# print STDERR "$a\n";
# \endcode
# Prints (for example):
# \code
# c:\msys\1.0\local\share\gdal\pcs.csv
# \endcode
# 
# @param basename The name of the file to search for. For example
# 'pcs.csv'.
# @return the path to the searched file or undef.
#*
sub FindFile {
    if (@_ == 1) {
        _FindFile('', @_);
    } else {
        _FindFile(@_);
    }
}
 
#** @method FinderClean()
# Package subroutine.
# Clear the set of support file search paths.
#*
sub FinderClean {
}
 
#** @method GDALMultiDimInfo()
#*
sub GDALMultiDimInfo {
}
 
#** @method GEDTC_COMPOUND()
#*
sub GEDTC_COMPOUND {
}
 
#** @method GEDTC_NUMERIC()
#*
sub GEDTC_NUMERIC {
}
 
#** @method GEDTC_STRING()
#*
sub GEDTC_STRING {
}
 
#** @method GOA2GetAccessToken()
#*
sub GOA2GetAccessToken {
}
 
#** @method GOA2GetAuthorizationURL()
#*
sub GOA2GetAuthorizationURL {
}
 
#** @method GOA2GetRefreshToken()
#*
sub GOA2GetRefreshToken {
}
 
#** @method GVM_Diagonal()
#*
sub GVM_Diagonal {
}
 
#** @method GVM_Edge()
#*
sub GVM_Edge {
}
 
#** @method GVM_Max()
#*
sub GVM_Max {
}
 
#** @method GVM_Min()
#*
sub GVM_Min {
}
 
#** @method GVOT_MIN_TARGET_HEIGHT_FROM_DEM()
#*
sub GVOT_MIN_TARGET_HEIGHT_FROM_DEM {
}
 
#** @method GVOT_MIN_TARGET_HEIGHT_FROM_GROUND()
#*
sub GVOT_MIN_TARGET_HEIGHT_FROM_GROUND {
    # keeper maintains child -> parent relationships
    # child is kept as a key, i.e., string not the real object
    # parent is kept as the value, i.e., a real object
    # a child may have only one parent!
    # call these as Geo::GDAL::*
    my %keeper;
    my %notes;
}
 
#** @method GVOT_NORMAL()
#*
sub GVOT_NORMAL {
}
 
#** @method GetActualURL()
#*
sub GetActualURL {
}
 
#** @method scalar GetCacheMax()
# Package subroutine.
# @return maximum amount of memory (as bytes) for caching within GDAL.
#*
sub GetCacheMax {
}
 
#** @method scalar GetCacheUsed()
# Package subroutine.
# @return the amount of memory currently used for caching within GDAL.
#*
sub GetCacheUsed {
}
 
#** @method scalar GetConfigOption($key)
# Package subroutine.
# @param key A GDAL config option.  Consult <a
# href="https://trac.osgeo.org/gdal/wiki/ConfigOptions">the GDAL
# documentation</a> for available options and their use.
# @return the value of the GDAL config option.
#*
sub GetConfigOption {
}
 
#** @method scalar GetDataTypeSize($DataType)
# Package subroutine.
# @param DataType A GDAL raster cell data type (one of those listed by Geo::GDAL::DataTypes).
# @return the size as the number of bits.
#*
sub GetDataTypeSize {
    return _GetDataTypeSize(s2i(data_type => shift, 1));
}
 
#** @method GetErrorCounter()
#*
sub GetErrorCounter {
}
 
#** @method GetFileMetadata()
#*
sub GetFileMetadata {
}
 
#** @method GetFileSystemOptions()
#*
sub GetFileSystemOptions {
}
 
#** @method GetFileSystemsPrefixes()
#*
sub GetFileSystemsPrefixes {
}
 
#** @method GetJPEG2000StructureAsString()
#*
sub GetJPEG2000StructureAsString {
}
 
#** @method GetSignedURL()
#*
sub GetSignedURL {
}
 
#** @method Geo::GDAL::Driver IdentifyDriver($path, $siblings)
# Package subroutine.
# @param path a dataset path.
# @param siblings [optional] A list of names of files that belong to the data format.
# @return a Geo::GDAL::Driver.
#*
sub IdentifyDriver {
}
 
#** @method IdentifyDriverEx()
#*
sub IdentifyDriverEx {
}
 
#** @method MkdirRecursive()
#*
sub MkdirRecursive {
}
 
#** @method NetworkStatsGetAsSerializedJSON()
#*
sub NetworkStatsGetAsSerializedJSON {
}
 
#** @method NetworkStatsReset()
#*
sub NetworkStatsReset {
}
 
#** @method Geo::GDAL::Dataset Open(%params)
# Package subroutine.
# Open a dataset.
# An example, which opens an existing raster dataset for editing:
# \code
# use Geo::GDAL qw/:all/;
# $ds = Open(Name => 'existing.tiff', Access => 'Update');
# \endcode
# @param params Named parameters:
# - \a Name Dataset string (typically a filename). Default is '.'.
# - \a Access Access type, either 'ReadOnly' or 'Update'. Default is 'ReadOnly'.
# - \a Type Dataset type, either 'Raster', 'Vector', or 'Any'. Default is 'Any'.
# - \a Options A hash of GDAL open options passed to candidate drivers. Default is {}.
# - \a Files A list of names of files that are auxiliary to the main file. Default is [].
# 
# @note This subroutine is imported into the main namespace if Geo::GDAL
# is use'd with qw/:all/.
# 
# @note Some datasets / dataset strings do not explicitly imply the
# dataset type (for example a PostGIS database). If the type is not
# specified in such a case the returned dataset may be of either type.
# 
# @return a new Geo::GDAL::Dataset object if success.
#*
sub Open {
    my $p = named_parameters(\@_, Name => '.', Access => 'ReadOnly', Type => 'Any', Options => {}, Files => []);
    my @flags;
    my %o = (READONLY => 1, UPDATE => 1);
    error(1, $p->{access}, \%o) unless $o{uc($p->{access})};
    push @flags, uc($p->{access});
    %o = (RASTER => 1, VECTOR => 1, ANY => 1);
    error(1, $p->{type}, \%o) unless $o{uc($p->{type})};
    push @flags, uc($p->{type}) unless uc($p->{type}) eq 'ANY';
    my $dataset = OpenEx(Name => $p->{name}, Flags => \@flags, Options => $p->{options}, Files => $p->{files});
    unless ($dataset) {
        my $t = "Failed to open $p->{name}.";
        $t .= " Is it a ".lc($p->{type})." dataset?" unless uc($p->{type}) eq 'ANY';
        error($t);
    }
    return $dataset;
}
 
#** @method Geo::GDAL::Dataset OpenEx(%params)
# Package subroutine.
# The generic dataset open method, used internally by all Open and OpenShared methods.
# @param params Named parameters:
# - \a Name The name of the data set or source to open. (Default is '.')
# - \a Flags A list of access mode flags. Available flags are listed by Geo::GDAL::OpenFlags(). (Default is [])
# - \a Drivers A list of short names of drivers that may be used. Empty list means all. (Default is [])
# - \a Options A hash of GDAL open options passed to candidate drivers. (Default is {})
# - \a Files A list of names of files that are auxiliary to the main file. (Default is [])
# 
# An example
# \code
# $ds = Geo::GDAL::OpenEx(Name => 'existing.tiff', Flags => [qw/RASTER UPDATE/]);
# \endcode
# @return a new Geo::GDAL::Dataset object.
#*
sub OpenEx {
    my $p = named_parameters(\@_, Name => '.', Flags => [], Drivers => [], Options => {}, Files => []);
    unless ($p) {
        my $name = shift // '';
        my @flags = @_;
        $p = {name => $name, flags => \@flags, drivers => [], options => {}, files => []};
    }
    if ($p->{flags}) {
        my $f = 0;
        for my $flag (@{$p->{flags}}) {
            $f |= s2i(open_flag => $flag);
        }
        $p->{flags} = $f;
    }
    return _OpenEx($p->{name}, $p->{flags}, $p->{drivers}, $p->{options}, $p->{files});
}
 
#** @method list OpenFlags()
# Package subroutine.
# @return a list of GDAL data set open modes. These are currently:
# ALL, GNM, MULTIDIM_RASTER, RASTER, READONLY, SHARED, UPDATE, VECTOR, and VERBOSE_ERROR.
#*
sub OpenFlags {
    return @DATA_TYPES;
}
 
#** @method scalar PackCharacter($DataType)
# Package subroutine.
# Get the character that is needed for Perl's pack and unpack when
# they are used with Geo::GDAL::Band::ReadRaster and
# Geo::GDAL::Band::WriteRaster. Note that Geo::GDAL::Band::ReadTile
# and Geo::GDAL::Band::WriteTile have simpler interfaces that do not
# require pack and unpack.
# @param DataType A GDAL raster cell data type, typically from $band->DataType.
# @return a character which can be used in Perl's pack and unpack.
#*
sub PackCharacter {
    my $t = shift;
    $t = i2s(data_type => $t);
    s2i(data_type => $t); # test
    my $is_big_endian = unpack("h*", pack("s", 1)) =~ /01/; # from Programming Perl
    return 'C' if $t =~ /^Byte$/;
    return ($is_big_endian ? 'n': 'v') if $t =~ /^UInt16$/;
    return 's' if $t =~ /^Int16$/;
    return ($is_big_endian ? 'N' : 'V') if $t =~ /^UInt32$/;
    return 'l' if $t =~ /^Int32$/;
    return 'f' if $t =~ /^Float32$/;
    return 'd' if $t =~ /^Float64$/;
}
 
#** @method scalar PackedDMSToDec($packed)
# Package subroutine.
# @param packed DMS as a number DDDMMMSSS.SS
# @return decimal degrees
#*
sub PackedDMSToDec {
}
 
#** @method PopFinderLocation()
# Package subroutine.
# Remove the latest addition from the set of support file search
# paths. Note that calling this subroutine may remove paths GDAL put
# into the finder.
#*
sub PopFinderLocation {
}
 
#** @method PushFinderLocation($path)
# Package subroutine.
# Add a path to the set of paths from where GDAL support files are
# sought. Note that GDAL puts initially into the finder the current
# directory and value of GDAL_DATA environment variable (if it
# exists), installation directory (prepended with '/share/gdal' or
# '/Resources/gdal'), or '/usr/local/share/gdal'. It is usually only
# needed to add paths to the finder if using an alternate set of data
# files or a non-installed GDAL is used (as in testing).
#*
sub PushFinderLocation {
}
 
#** @method list RIOResamplingTypes()
# Package subroutine.
# @return a list of GDAL raster IO resampling methods. These are currently:
# Average, Bilinear, Cubic, CubicSpline, Gauss, Lanczos, Mode, and NearestNeighbour.
#*
sub RIOResamplingTypes {
    return @RIO_RESAMPLING_TYPES;
}
 
#** @method list ResamplingTypes()
# Package subroutine.
# @return a list of GDAL resampling methods. These are currently:
# Average, Bilinear, Cubic, CubicSpline, Lanczos, Max, Med, Min, Mode, NearestNeighbour, Q1, and Q3.
#*
sub ResamplingTypes {
    return @RESAMPLING_TYPES;
}
 
#** @method RmdirRecursive()
#*
sub RmdirRecursive {
}
 
#** @method SetCacheMax($Bytes)
# Package subroutine.
# @param Bytes New maximum amount of memory for caching within GDAL.
#*
sub SetCacheMax {
}
 
#** @method SetConfigOption($key, $value)
# Package subroutine.
# @param key A GDAL config option.  Consult <a
# href="https://trac.osgeo.org/gdal/wiki/ConfigOptions">the GDAL
# documentation</a> for available options and their use.
# @param value A value for the option, typically 'YES', 'NO',
# undef, path, numeric value, or a filename.
#*
sub SetConfigOption {
}
 
#** @method SetCurrentErrorHandlerCatchDebug()
#*
sub SetCurrentErrorHandlerCatchDebug {
}
 
#** @method SetFileMetadata()
#*
sub SetFileMetadata {
}
 
#** @method UnlinkBatch()
#*
sub UnlinkBatch {
}
 
#** @method UseExceptions()
# Package subroutine.
# Use the Perl exception mechanism for GDAL messages (failures are
# confessed and warnings are warned) and collect the messages
# into \@Geo::GDAL::error. This is the default.
#*
sub UseExceptions {
}
 
#** @method VSICurlClearCache()
#*
sub VSICurlClearCache {
}
 
#** @method VSICurlPartialClearCache()
#*
sub VSICurlPartialClearCache {
}
 
#** @method VSIErrorReset()
#*
sub VSIErrorReset {
}
 
#** @method VSIFEofL()
#*
sub VSIFEofL {
}
 
#** @method VSIFFlushL()
#*
sub VSIFFlushL {
}
 
#** @method VSIFOpenExL()
#*
sub VSIFOpenExL {
}
 
#** @method VSIGetLastErrorMsg()
#*
sub VSIGetLastErrorMsg {
}
 
#** @method VSIGetLastErrorNo()
#*
sub VSIGetLastErrorNo {
}
 
#** @method scalar VersionInfo($request = 'VERSION_NUM')
# Package subroutine.
# @param request A string specifying the request. Currently either
# "VERSION_NUM", "RELEASE_DATE", "RELEASE_NAME", or
# "--version". Default is "VERSION_NUM".
# @return Requested information.
#*
sub VersionInfo {
}
 
#** @method ViewshedGenerate()
#*
sub ViewshedGenerate {
}
 
#** @method scalar errstr()
# Package subroutine.
# Clear the error stack and return all generated GDAL error messages in one (possibly multiline) string.
# @return the chomped error stack joined with newlines.
#*
sub errstr {
    my @stack = @error;
    chomp(@stack);
    @error = ();
    return join("\n", @stack);
}
# usage: named_parameters(\@_, key value list of default parameters);
# returns parameters in a hash with low-case-without-_ keys
}
 
#** @method wrapper_GDALMultiDimTranslateDestName()
#*
sub wrapper_GDALMultiDimTranslateDestName {
}
 
#** @class Geo::GDAL::AsyncReader
# @brief Enable asynchronous requests.
# @details This class is not yet documented nor tested in the GDAL Perl wrappers
# @todo Test and document.
#*
package Geo::GDAL::AsyncReader;
 
use base qw(Geo::GDAL)
 
#** @method GetNextUpdatedRegion()
#*
sub GetNextUpdatedRegion {
}
 
#** @method LockBuffer()
#*
sub LockBuffer {
}
 
#** @method UnlockBuffer()
#*
sub UnlockBuffer {
}
 
#** @class Geo::GDAL::Attribute
#*
package Geo::GDAL::Attribute;
 
use base qw(Geo::GDAL)
 
#** @method GetDataType()
#*
sub GetDataType {
}
 
#** @method GetDimensionCount()
#*
sub GetDimensionCount {
}
 
#** @method GetFullName()
#*
sub GetFullName {
}
 
#** @method GetName()
#*
sub GetName {
}
 
#** @method GetTotalElementsCount()
#*
sub GetTotalElementsCount {
}
 
#** @method ReadAsDouble()
#*
sub ReadAsDouble {
}
 
#** @method ReadAsInt()
#*
sub ReadAsInt {
}
 
#** @method ReadAsString()
#*
sub ReadAsString {
}
 
#** @method ReadAsStringArray()
#*
sub ReadAsStringArray {
}
 
#** @method WriteDouble()
#*
sub WriteDouble {
}
 
#** @method WriteInt()
#*
sub WriteInt {
}
 
#** @method WriteString()
#*
sub WriteString {
}
 
#** @method WriteStringArray()
#*
sub WriteStringArray {
}
 
#** @class Geo::GDAL::Band
# @brief A raster band.
# @details
#*
package Geo::GDAL::Band;
 
use base qw(Geo::GDAL::MajorObject Geo::GDAL)
 
#** @attr $XSize 
# Object attribute.
# scalar (access as $band->{XSize})
#*
 
#** @attr $YSize 
# Object attribute.
# scalar (access as $band->{YSize})
#*
 
#** @method AdviseRead()
#*
sub AdviseRead {
}
 
#** @method AsMDArray()
#*
sub AsMDArray {
}
 
#** @method Geo::GDAL::RasterAttributeTable AttributeTable($AttributeTable)
# Object method.
# @param AttributeTable [optional] A Geo::GDAL::RasterAttributeTable object.
# @return a new Geo::GDAL::RasterAttributeTable object, whose data is
# contained within the band.
#*
sub AttributeTable {
    my $self = shift;
    SetDefaultRAT($self, $_[0]) if @_ and defined $_[0];
    return unless defined wantarray;
    my $r = GetDefaultRAT($self);
    keep($r, $self) if $r;
}
 
#** @method list BlockSize()
# Object method.
# A.k.a GetBlockSize
# @return The size of a preferred i/o raster block size as a list
# (width, height).
#*
sub BlockSize {
}
 
#** @method list CategoryNames(@names)
# Object method.
# @param names [optional]
# @return
#*
sub CategoryNames {
    my $self = shift;
    SetRasterCategoryNames($self, \@_) if @_;
    return unless defined wantarray;
    my $n = GetRasterCategoryNames($self);
    return @$n;
}
 
#** @method scalar Checksum($xoff = 0, $yoff = 0, $xsize = undef, $ysize = undef)
# Object method.
# Computes a checksum from the raster or a part of it.
# @param xoff
# @param yoff
# @param xsize
# @param ysize
# @return the checksum.
#*
sub Checksum {
}
 
#** @method hashref ClassCounts($classifier, $progress = undef, $progress_data = undef)
# Object method.
# Compute the counts of cell values or number of cell values in ranges.
# @note Classifier is required only for float bands.
# @note NoData values are counted similar to other values when
# classifier is not defined for integer rasters.
# 
# @param classifier Anonymous array of format [ $comparison,
# $classifier ], where $comparison is a string '<', '<=', '>', or '>='
# and $classifier is an anonymous array of format [ $value,
# $value|$classifier, $value|$classifier ], where $value is a numeric
# value against which the reclassified value is compared to. If the
# comparison returns true, then the second $value or $classifier is
# applied, and if not then the third $value or $classifier.
# 
# In the example below, the line is divided into ranges
# [-inf..3), [3..5), and [5..inf], i.e., three ranges with class
# indexes 0, 1, and 2. Note that the indexes are used as keys for
# class counts and not the class values (here 1.0, 2.0, and 3.0),
# which are used in Geo::GDAL::Band::Reclassify.
# \code
# $classifier = [ '<', [5.0, [3.0, 1.0, 2.0], 3.0] ];
# # Howto create this $classifier from @class_boundaries:
# my $classifier = ['<='];
# my $tree = [$class_boundaries[0], 0, 1];
# for my $i (1 .. $#class_boundaries) {
#     $tree = [$class_boundaries[$i], [@$tree], $i+1];
# }
# push @$classifier, $tree;
# \endcode
# @return a reference to an anonymous hash, which contains the class
# values (indexes) as keys and the number of cells with that value or
# in that range as values. If the subroutine is user terminated an
# error is raised.
#*
sub ClassCounts {
}
 
#** @method scalar ColorInterpretation($color_interpretation)
# Object method.
# @note a.k.a. GetRasterColorInterpretation and GetColorInterpretation
# (get only and returns an integer), SetRasterColorInterpretation and
# SetColorInterpretation (set only and requires an integer)
# @param color_interpretation [optional] new color interpretation, one
# of Geo::GDAL::Band::ColorInterpretations.
# @return The color interpretation of this band. One of Geo::GDAL::Band::ColorInterpretations.
#*
sub ColorInterpretation {
    my($self, $ci) = @_;
    if (defined $ci) {
        $ci = s2i(color_interpretation => $ci);
        SetRasterColorInterpretation($self, $ci);
    }
    return unless defined wantarray;
    i2s(color_interpretation => GetRasterColorInterpretation($self));
}
 
#** @method ColorInterpretations()
# Package subroutine.
# @return a list of types of color interpretation for raster
# bands. These are currently:
# AlphaBand, BlackBand, BlueBand, CyanBand, GrayIndex, GreenBand, HueBand, LightnessBand, MagentaBand, PaletteIndex, RedBand, SaturationBand, Undefined, YCbCr_CbBand, YCbCr_CrBand, YCbCr_YBand, and YellowBand.
#*
sub ColorInterpretations {
    return @COLOR_INTERPRETATIONS;
}
 
#** @method Geo::GDAL::ColorTable ColorTable($ColorTable)
# Object method.
# Get or set the color table of this band.
# @param ColorTable [optional] a Geo::GDAL::ColorTable object
# @return A new Geo::GDAL::ColorTable object which represents the
# internal color table associated with this band. Returns undef this
# band does not have an associated color table.
#*
sub ColorTable {
    my $self = shift;
    SetRasterColorTable($self, $_[0]) if @_ and defined $_[0];
    return unless defined wantarray;
    GetRasterColorTable($self);
}
 
#** @method ComputeBandStats($samplestep = 1)
# Object method.
# @param samplestep the row increment in computing the statistics.
# @note Returns uncorrected sample standard deviation.
# 
# See also Geo::GDAL::Band::ComputeStatistics.
# @return a list (mean, stddev).
#*
sub ComputeBandStats {
}
 
#** @method ComputeRasterMinMax($approx_ok = 0)
# Object method.
# @return arrayref MinMax = [min, max]
#*
sub ComputeRasterMinMax {
}
 
#** @method list ComputeStatistics($approx_ok, $progress = undef, $progress_data = undef)
# Object method.
# @param approx_ok Whether it is allowed to compute the statistics
# based on overviews or similar.
# @note Returns uncorrected sample standard deviation.
# 
# See also Geo::GDAL::Band::ComputeBandStats.
# @return a list ($min, $max, $mean, $stddev).
#*
sub ComputeStatistics {
}
 
#** @method Geo::OGR::Layer Contours($DataSource, hashref LayerConstructor, $ContourInterval, $ContourBase, arrayref FixedLevels, $NoDataValue, $IDField, $ElevField, coderef Progress, $ProgressData)
# Object method.
# Generate contours for this raster band. This method can also be used with named parameters.
# @note This method is a wrapper for ContourGenerate.
# 
# An example:
# \code
# use Geo::GDAL;
# $dem = Geo::GDAL::Open('dem.gtiff');
# $contours = $dem->Band->Contours(ContourInterval => 10, ElevField => 'z');
# $n = $contours->GetFeatureCount;
# \endcode
# 
# @param DataSource a Geo::OGR::DataSource object, default is a Memory data source
# @param LayerConstructor data for Geo::OGR::DataSource::CreateLayer, default is {Name => 'contours'}
# @param ContourInterval default is 100
# @param ContourBase default is 0
# @param FixedLevels a reference to a list of fixed contour levels, default is []
# @param NoDataValue default is undef
# @param IDField default is '', i.e., no field (the field is created if this is given)
# @param ElevField default is '', i.e., no field (the field is created if this is given)
# @param progress [optional] a reference to a subroutine, which will
# be called with parameters (number progress, string msg, progress_data)
# @param progress_data [optional]
# @return
#*
sub Contours {
    my $self = shift;
    my $p = named_parameters(\@_,
                             DataSource => undef,
                             LayerConstructor => {Name => 'contours'},
                             ContourInterval => 100,
                             ContourBase => 0,
                             FixedLevels => [],
                             NoDataValue => undef,
                             IDField => -1,
                             ElevField => -1,
                             Progress => undef,
                             ProgressData => undef);
    $p->{datasource} //= Geo::OGR::GetDriver('Memory')->CreateDataSource('ds');
    $p->{layerconstructor}->{Schema} //= {};
    $p->{layerconstructor}->{Schema}{Fields} //= [];
    my %fields;
    unless ($p->{idfield} =~ /^[+-]?\d+$/ or $fields{$p->{idfield}}) {
        push @{$p->{layerconstructor}->{Schema}{Fields}}, {Name => $p->{idfield}, Type => 'Integer'};
    }
    unless ($p->{elevfield} =~ /^[+-]?\d+$/ or $fields{$p->{elevfield}}) {
        my $type = $self->DataType() =~ /Float/ ? 'Real' : 'Integer';
        push @{$p->{layerconstructor}->{Schema}{Fields}}, {Name => $p->{elevfield}, Type => $type};
    }
    my $layer = $p->{datasource}->CreateLayer($p->{layerconstructor});
    my $schema = $layer->GetLayerDefn;
    for ('idfield', 'elevfield') {
        $p->{$_} = $schema->GetFieldIndex($p->{$_}) unless $p->{$_} =~ /^[+-]?\d+$/;
    }
    $p->{progressdata} = 1 if $p->{progress} and not defined $p->{progressdata};
    ContourGenerate($self, $p->{contourinterval}, $p->{contourbase}, $p->{fixedlevels},
                    $p->{nodatavalue}, $layer, $p->{idfield}, $p->{elevfield},
                    $p->{progress}, $p->{progressdata});
    return $layer;
}
 
#** @method CreateMaskBand(@flags)
# Object method.
# @note May invalidate any previous mask band obtained with Geo::GDAL::Band::GetMaskBand.
# 
# @param flags one or more mask flags. The flags are Geo::GDAL::Band::MaskFlags.
#*
sub CreateMaskBand {
    my $self = shift;
    my $f = 0;
    if (@_ and $_[0] =~ /^\d$/) {
        $f = shift;
    } else {
        for my $flag (@_) {
            carp "Unknown mask flag: '$flag'." unless $MASK_FLAGS{$flag};
            $f |= $MASK_FLAGS{$flag};
        }
    }
    $self->_CreateMaskBand($f);
}
 
#** @method scalar DataType()
# Object method.
# @return The data type of this band. One of Geo::GDAL::DataTypes.
#*
sub DataType {
    my $self = shift;
    return i2s(data_type => $self->{DataType});
}
 
#** @method Geo::GDAL::Dataset Dataset()
# Object method.
# @return The dataset which this band belongs to.
#*
sub Dataset {
    my $self = shift;
    parent($self);
}
 
#** @method scalar DeleteNoDataValue()
# Object method.
#*
sub DeleteNoDataValue {
}
 
#** @method Geo::GDAL::Band Distance(%params)
# Object method.
# Compute distances to specific cells of this raster.
# @param params Named parameters:
# - \a Distance A raster band, into which the distances are computed. If not given, a not given, a new in-memory raster band is created and returned. The data type of the raster can be given in the options.
# - \a Options Hash of options. Options are:
#   - \a Values A list of cell values in this band to measure the distance from. If this option is not provided, the distance will be computed to non-zero pixel values. Currently pixel values are internally processed as integers.
#   - \a DistUnits=PIXEL|GEO Indicates whether distances will be computed in cells or in georeferenced units. The default is pixel units. This also determines the interpretation of MaxDist.
#   - \a MaxDist=n The maximum distance to search. Distances greater than this value will not be computed. Instead output cells will be set to a NoData value.
#   - \a NoData=n The NoData value to use on the distance band for cells that are beyond MaxDist. If not provided, the distance band will be queried for a NoData value. If one is not found, 65535 will be used (255 if the type is Byte).
#   - \a Use_Input_NoData=YES|NO If this option is set, the NoData value of this band will be respected. Leaving NoData cells in the input as NoData pixels in the distance raster.
#   - \a Fixed_Buf_Val=n If this option is set, all cells within the MaxDist threshold are set to this value instead of the distance value.
#   - \a DataType The data type for the result if it is not given.
# - \a Progress Progress function.
# - \a ProgressData Additional parameter for the progress function.
# 
# @note This GDAL function behind this API is called GDALComputeProximity.
# 
# @return The distance raster.
#*
sub Distance {
    my $self = shift;
    my $p = named_parameters(\@_, Distance => undef, Options => undef, Progress => undef, ProgressData => undef);
    for my $key (keys %{$p->{options}}) {
        $p->{options}{uc($key)} = $p->{options}{$key};
    }
    $p->{options}{TYPE} //= $p->{options}{DATATYPE} //= 'Float32';
    unless ($p->{distance}) {
        my ($w, $h) = $self->Size;
        $p->{distance} = Geo::GDAL::Driver('MEM')->Create(Name => 'distance', Width => $w, Height => $h, Type => $p->{options}{TYPE})->Band;
    }
    Geo::GDAL::ComputeProximity($self, $p->{distance}, $p->{options}, $p->{progress}, $p->{progressdata});
    return $p->{distance};
}
 
#** @method Domains()
#*
sub Domains {
    return @DOMAINS;
}
 
#** @method Fill($real_part, $imag_part = 0.0)
# Object method.
# Fill the band with a constant value.
# @param real_part Real component of fill value.
# @param imag_part Imaginary component of fill value.
# 
#*
sub Fill {
}
 
#** @method FillNoData($mask, $max_search_dist, $smoothing_iterations, $options, coderef progress, $progress_data)
# Object method.
# Interpolate values for cells in this raster. The cells to fill
# should be marked in the mask band with zero.
# 
# @param mask [optional] a mask band indicating cells to be interpolated (zero valued) (default is to get it with Geo::GDAL::Band::GetMaskBand).
# @param max_search_dist [optional] the maximum number of cells to
# search in all directions to find values to interpolate from (default is 10).
# @param smoothing_iterations [optional] the number of 3x3 smoothing filter passes to run (0 or more) (default is 0).
# @param options [optional] A reference to a hash. No options have been defined so far for this algorithm (default is {}).
# @param progress [optional] a reference to a subroutine, which will
# be called with parameters (number progress, string msg, progress_data) (default is undef).
# @param progress_data [optional] (default is undef).
# 
# <a href="http://www.gdal.org/gdal__alg_8h.html">Documentation for GDAL algorithms</a>
#*
sub FillNoData {
}
 
#** @method FlushCache()
# Object method.
# Write cached data to disk. There is usually no need to call this
# method.
#*
sub FlushCache {
}
 
#** @method scalar GetBandNumber()
# Object method.
# @return The index of this band in the parent dataset list of bands.
#*
sub GetBandNumber {
}
 
#** @method GetBlockSize()
#*
sub GetBlockSize {
}
 
#** @method list GetDefaultHistogram($force = 1, coderef progress = undef, $progress_data = undef)
# Object method.
# @param force true to force the computation
# @param progress [optional] a reference to a subroutine, which will
# be called with parameters (number progress, string msg, progress_data)
# @param progress_data [optional]
# @note See Note in Geo::GDAL::Band::GetHistogram.
# @return a list: ($min, $max, arrayref histogram).
#*
sub GetDefaultHistogram {
}
 
#** @method list GetHistogram(%parameters)
# Object method.
# Compute histogram from the raster.
# @param parameters Named parameters:
# - \a Min the lower bound, default is -0.5
# - \a Max the upper bound, default is 255.5
# - \a Buckets the number of buckets in the histogram, default is 256
# - \a IncludeOutOfRange whether to use the first and last values in the returned list
# for out of range values, default is false;
# the bucket size is (Max-Min) / Buckets if this is false and
# (Max-Min) / (Buckets-2) if this is true
# - \a ApproxOK if histogram can be computed from overviews, default is false
# - \a Progress an optional progress function, the default is undef
# - \a ProgressData data for the progress function, the default is undef
# @note Histogram counts are treated as strings in the bindings to be
# able to use large integers (if GUIntBig is larger than Perl IV). In
# practice this is only important if you have a 32 bit machine and
# very large bucket counts. In those cases it may also be necessary to
# use Math::BigInt.
# @return a list which contains the count of values in each bucket
#*
sub GetHistogram {
    my $self = shift;
    my $p = named_parameters(\@_,
                             Min => -0.5,
                             Max => 255.5,
                             Buckets => 256,
                             IncludeOutOfRange => 0,
                             ApproxOK => 0,
                             Progress => undef,
                             ProgressData => undef);
    $p->{progressdata} = 1 if $p->{progress} and not defined $p->{progressdata};
    _GetHistogram($self, $p->{min}, $p->{max}, $p->{buckets},
                  $p->{includeoutofrange}, $p->{approxok},
                  $p->{progress}, $p->{progressdata});
}
 
#** @method Geo::GDAL::Band GetMaskBand()
# Object method.
# @return the mask band associated with this
# band.
#*
sub GetMaskBand {
    my $self = shift;
    my $band = _GetMaskBand($self);
    keep($band, $self);
}
 
#** @method list GetMaskFlags()
# Object method.
# @return the mask flags of the mask band associated with this
# band. The flags are one or more of Geo::GDAL::Band::MaskFlags.
#*
sub GetMaskFlags {
    my $self = shift;
    my $f = $self->_GetMaskFlags;
    my @f;
    for my $flag (keys %MASK_FLAGS) {
        push @f, $flag if $f & $MASK_FLAGS{$flag};
    }
    return wantarray ? @f : $f;
}
 
#** @method scalar GetMaximum()
# Object method.
# @note Call Geo::GDAL::Band::ComputeStatistics before calling
# GetMaximum to make sure the value is computed.
# 
# @return statistical minimum of the band or undef if statistics are
# not kept or computed in scalar context. In list context returns the
# maximum value or a (kind of) maximum value supported by the data
# type and a boolean value, which indicates which is the case (true is
# first, false is second).
#*
sub GetMaximum {
}
 
#** @method scalar GetMinimum()
# Object method.
# @note Call Geo::GDAL::Band::ComputeStatistics before calling
# GetMinimum to make sure the value is computed.
# 
# @return statistical minimum of the band or undef if statistics are
# not kept or computed in scalar context. In list context returns the
# minimum value or a (kind of) minimum value supported by the data
# type and a boolean value, which indicates which is the case (true is
# first, false is second).
#*
sub GetMinimum {
}
 
#** @method Geo::GDAL::Band GetOverview($index)
# Object method.
# @param index 0..GetOverviewCount-1
# @return a Geo::GDAL::Band object, which represents the internal
# overview band, or undef.  if the index is out of bounds.
#*
sub GetOverview {
    my ($self, $index) = @_;
    my $band = _GetOverview($self, $index);
    keep($band, $self);
}
 
#** @method scalar GetOverviewCount()
# Object method.
# @return the number of overviews available of the band.
#*
sub GetOverviewCount {
}
 
#** @method list GetStatistics($approx_ok, $force)
# Object method.
# @param approx_ok Whether it is allowed to compute the statistics
# based on overviews or similar.
# @param force Whether to force scanning of the whole raster.
# @note Uses Geo::GDAL::Band::ComputeStatistics internally.
# 
# @return a list ($min, $max, $mean, $stddev).
#*
sub GetStatistics {
}
 
#** @method HasArbitraryOverviews()
# Object method.
# @return true or false.
#*
sub HasArbitraryOverviews {
}
 
#** @method list MaskFlags()
# Package subroutine.
# @return the list of mask flags. These are
# - \a AllValid: There are no invalid cell, all mask values will be 255.
# When used this will normally be the only flag set.
# - \a PerDataset: The mask band is shared between all bands on the dataset.
# - \a Alpha: The mask band is actually an alpha band and may have values
# other than 0 and 255.
# - \a NoData: Indicates the mask is actually being generated from NoData values.
# (mutually exclusive of Alpha).
#*
sub MaskFlags {
    my @f = sort {$MASK_FLAGS{$a} <=> $MASK_FLAGS{$b}} keys %MASK_FLAGS;
    return @f;
}
 
#** @method scalar NoDataValue($NoDataValue)
# Object method.
# Get or set the "no data" value.
# @param NoDataValue [optional]
# @note $band->NoDataValue(undef) sets the NoData value to the
# Posix floating point maximum. Use Geo::GDAL::Band::DeleteNoDataValue
# to stop this band using a NoData value.
# @return The NoData value or undef in scalar context. An undef
# value indicates that there is no NoData value associated with this
# band.
#*
sub NoDataValue {
    my $self = shift;
    if (@_ > 0) {
        if (defined $_[0]) {
            SetNoDataValue($self, $_[0]);
        } else {
            SetNoDataValue($self, POSIX::FLT_MAX); # hopefully an "out of range" value
        }
    }
    GetNoDataValue($self);
}
 
#** @method scalar PackCharacter()
# Object method.
# @return The character to use in Perl pack and unpack for the data of this band.
#*
sub PackCharacter {
    my $self = shift;
    return Geo::GDAL::PackCharacter($self->DataType);
}
 
#** @method Piddle($piddle, $xoff = 0, $yoff = 0, $xsize = <width>, $ysize = <height>, $xdim, $ydim)
# Object method.
# Read or write band data from/into a piddle.
# 
# \note The PDL module must be available for this method to work. Also, you
# should 'use PDL' in the code that you use this method.
# 
# @param piddle [only when writing] The piddle from which to read the data to be written into the band.
# @param xoff, yoff The offset for data in the band, default is top left (0, 0).
# @param xsize, ysize [optional] The size of the window in the band.
# @param xdim, ydim [optional, only when reading from a band] The size of the piddle to create.
# @return A new piddle when reading from a band (no not use when writing into a band).
#*
sub Piddle {
    # TODO: add Piddle sub to dataset too to make Width x Height x Bands piddles
    error("PDL is not available.") unless $Geo::GDAL::HAVE_PDL;
    my $self = shift;
    my $t = $self->{DataType};
    unless (defined wantarray) {
        my $pdl = shift;
        error("The datatype of the Piddle and the band do not match.")
          unless $PDL2DATATYPE{$pdl->get_datatype} == $t;
        my ($xoff, $yoff, $xsize, $ysize) = @_;
        $xoff //= 0;
        $yoff //= 0;
        my $data = $pdl->get_dataref();
        my ($xdim, $ydim) = $pdl->dims();
        if ($xdim > $self->{XSize} - $xoff) {
            warn "Piddle XSize too large ($xdim) for this raster band (width = $self->{XSize}, offset = $xoff).";
            $xdim = $self->{XSize} - $xoff;
        }
        if ($ydim > $self->{YSize} - $yoff) {
            $ydim = $self->{YSize} - $yoff;
            warn "Piddle YSize too large ($ydim) for this raster band (height = $self->{YSize}, offset = $yoff).";
        }
        $xsize //= $xdim;
        $ysize //= $ydim;
        $self->_WriteRaster($xoff, $yoff, $xsize, $ysize, $data, $xdim, $ydim, $t, 0, 0);
        return;
    }
    my ($xoff, $yoff, $xsize, $ysize, $xdim, $ydim, $alg) = @_;
    $xoff //= 0;
    $yoff //= 0;
    $xsize //= $self->{XSize} - $xoff;
    $ysize //= $self->{YSize} - $yoff;
    $xdim //= $xsize;
    $ydim //= $ysize;
    $alg //= 'NearestNeighbour';
    $alg = s2i(rio_resampling => $alg);
    my $buf = $self->_ReadRaster($xoff, $yoff, $xsize, $ysize, $xdim, $ydim, $t, 0, 0, $alg);
    my $pdl = PDL->new;
    my $datatype = $DATATYPE2PDL{$t};
    error("The band datatype is not supported by PDL.") if $datatype < 0;
    $pdl->set_datatype($datatype);
    $pdl->setdims([$xdim, $ydim]);
    my $data = $pdl->get_dataref();
    $$data = $buf;
    $pdl->upd_data;
    # FIXME: we want approximate equality since no data value can be very large floating point value
    my $bad = GetNoDataValue($self);
    return $pdl->setbadif($pdl == $bad) if defined $bad;
    return $pdl;
}
 
#** @method Geo::OGR::Layer Polygonize(%params)
# Object method.
# Polygonize this raster band.
# 
# @param params Named parameters:
# - \a Mask A raster band, which is used as a mask to select polygonized areas. Default is undef.
# - \a OutLayer A vector layer into which the polygons are written. If not given, an in-memory layer 'polygonized' is created and returned.
# - \a PixValField The name of the field in the output layer into which the cell value of the polygon area is stored. Default is 'val'.
# - \a Options Hash or list of options. Connectedness can be set to 8
# to use 8-connectedness, otherwise 4-connectedness is
# used. ForceIntPixel can be set to 1 to force using a 32 bit int buffer
# for cell values in the process. If this is not set and the data type
# of this raster does not fit into a 32 bit int buffer, a 32 bit float
# buffer is used.
# - \a Progress Progress function.
# - \a ProgressData Additional parameter for the progress function.
# 
# @return Output vector layer.
#*
sub Polygonize {
    my $self = shift;
    my $p = named_parameters(\@_, Mask => undef, OutLayer => undef, PixValField => 'val', Options => undef, Progress => undef, ProgressData => undef);
    my %known_options = (Connectedness => 1, ForceIntPixel => 1, DATASET_FOR_GEOREF => 1, '8CONNECTED' => 1);
    for my $option (keys %{$p->{options}}) {
        error(1, $option, \%known_options) unless exists $known_options{$option};
    }
    my $dt = $self->DataType;
    my %leInt32 = (Byte => 1, Int16 => 1, Int32 => 1, UInt16 => 1);
    my $leInt32 = $leInt32{$dt};
    $dt = $dt =~ /Float/ ? 'Real' : 'Integer';
    $p->{outlayer} //= Geo::OGR::Driver('Memory')->Create()->
        CreateLayer(Name => 'polygonized',
                    Fields => [{Name => 'val', Type => $dt},
                               {Name => 'geom', Type => 'Polygon'}]);
    $p->{pixvalfield} = $p->{outlayer}->GetLayerDefn->GetFieldIndex($p->{pixvalfield});
    $p->{options}{'8CONNECTED'} = 1 if $p->{options}{Connectedness} && $p->{options}{Connectedness} == 8;
    if ($leInt32 || $p->{options}{ForceIntPixel}) {
        Geo::GDAL::_Polygonize($self, $p->{mask}, $p->{outlayer}, $p->{pixvalfield}, $p->{options}, $p->{progress}, $p->{progressdata});
    } else {
        Geo::GDAL::FPolygonize($self, $p->{mask}, $p->{outlayer}, $p->{pixvalfield}, $p->{options}, $p->{progress}, $p->{progressdata});
    }
    set the srs of the outlayer if it was created here
    return $p->{outlayer};
}
 
#** @method RasterAttributeTable()
#*
sub RasterAttributeTable {
}
 
#** @method scalar ReadRaster(%params)
# Object method.
# Read data from the band.
# 
# @param params Named parameters:
# - \a XOff x offset (cell coordinates) (default is 0)
# - \a YOff y offset (cell coordinates) (default is 0)
# - \a XSize width of the area to read (default is the width of the band)
# - \a YSize height of the area to read (default is the height of the band)
# - \a BufXSize (default is undef, i.e., the same as XSize)
# - \a BufYSize (default is undef, i.e., the same as YSize)
# - \a BufType data type of the buffer (default is the data type of the band)
# - \a BufPixelSpace (default is 0)
# - \a BufLineSpace (default is 0)
# - \a ResampleAlg one of Geo::GDAL::RIOResamplingTypes (default is 'NearestNeighbour'),
# - \a Progress reference to a progress function (default is undef)
# - \a ProgressData (default is undef)
# 
# <a href="http://www.gdal.org/classGDALDataset.html">Entry in GDAL docs (method RasterIO)</a>
# @return a buffer, open the buffer with \a unpack function of Perl. See Geo::GDAL::Band::PackCharacter.
#*
sub ReadRaster {
    my $self = shift;
    my ($width, $height) = $self->Size;
    my ($type) = $self->DataType;
    my $p = named_parameters(\@_,
                             XOff => 0,
                             YOff => 0,
                             XSize => $width,
                             YSize => $height,
                             BufXSize => undef,
                             BufYSize => undef,
                             BufType => $type,
                             BufPixelSpace => 0,
                             BufLineSpace => 0,
                             ResampleAlg => 'NearestNeighbour',
                             Progress => undef,
                             ProgressData => undef
        );
    $p->{resamplealg} = s2i(rio_resampling => $p->{resamplealg});
    $p->{buftype} = s2i(data_type => $p->{buftype}, 1);
    $self->_ReadRaster($p->{xoff},$p->{yoff},$p->{xsize},$p->{ysize},$p->{bufxsize},$p->{bufysize},$p->{buftype},$p->{bufpixelspace},$p->{buflinespace},$p->{resamplealg},$p->{progress},$p->{progressdata});
}
 
#** @method array reference ReadTile($xoff = 0, $yoff = 0, $xsize = <width>, $ysize = <height>)
# Object method.
# Read band data into a Perl array.
# 
# \note Accessing band data in this way is slow. Consider using PDL and Geo::GDAL::Band::Piddle.
# 
# Usage example (print the data from a band):
# \code
# print "@$_\n" for ( @{ $band->ReadTile() } );
# \endcode
# Another usage example (process the data of a large dataset that has one band):
# \code
# my($W,$H) = $dataset->Band()->Size();
# my($xoff,$yoff,$w,$h) = (0,0,200,200);
# while (1) {
#     if ($xoff >= $W) {
#         $xoff = 0;
#         $yoff += $h;
#         last if $yoff >= $H;
#     }
#     my $data = $dataset->Band(1)->ReadTile($xoff,$yoff,min($W-$xoff,$w),min($H-$yoff,$h));
#     # add your data processing code here
#     $dataset->Band(1)->WriteTile($data,$xoff,$yoff);
#     $xoff += $w;
# }
# 
# sub min {
#     return $_[0] < $_[1] ? $_[0] : $_[1];
# }
# \endcode
# @param xoff Number of cell to skip before starting to read from a row. Pixels are read from left to right.
# @param yoff Number of cells to skip before starting to read from a column. Pixels are read from top to bottom.
# @param xsize Number of cells to read from each row.
# @param ysize Number of cells to read from each column.
# @return a two-dimensional Perl array, organizes as data->[y][x], y =
# 0..height-1, x = 0..width-1. I.e., y is row and x is column.
#*
sub ReadTile {
    my($self, $xoff, $yoff, $xsize, $ysize, $w_tile, $h_tile, $alg) = @_;
    $xoff //= 0;
    $yoff //= 0;
    $xsize //= $self->{XSize} - $xoff;
    $ysize //= $self->{YSize} - $yoff;
    $w_tile //= $xsize;
    $h_tile //= $ysize;
    $alg //= 'NearestNeighbour';
    $alg = s2i(rio_resampling => $alg);
    my $t = $self->{DataType};
    my $buf = $self->_ReadRaster($xoff, $yoff, $xsize, $ysize, $w_tile, $h_tile, $t, 0, 0, $alg);
    my $pc = Geo::GDAL::PackCharacter($t);
    my $w = $w_tile * Geo::GDAL::GetDataTypeSize($t)/8;
    my $offset = 0;
    my @data;
    for my $y (0..$h_tile-1) {
        my @d = unpack($pc."[$w_tile]", substr($buf, $offset, $w));
        push @data, \@d;
        $offset += $w;
    }
    return \@data;
}
 
#** @method Reclassify($classifier, $progress = undef, $progress_data = undef)
# Object method.
# Reclassify the cells in the band.
# @note NoData values in integer rasters are reclassified if
# explicitly specified in the hash classifier. However, they are not
# reclassified to the default value, if one is specified. In real
# valued rasters nodata cells are not reclassified.
# @note If the subroutine is user terminated or the classifier is
# incorrect, already reclassified cells will stay reclassified but an
# error is raised.
# @param classifier For integer rasters an anonymous hash, which
# contains old class values as keys and new class values as values, or
# an array classifier as in Geo::GDAL::Band::ClassCounts. In a hash
# classifier a special key '*' (star) can be used as default, to act
# as a fallback new class value. For real valued rasters the
# classifier is as in Geo::GDAL::Band::ClassCounts.
#*
sub Reclassify {
}
 
#** @method RegenerateOverview(Geo::GDAL::Band overview, $resampling, coderef progress, $progress_data)
# Object method.
# @param overview a Geo::GDAL::Band object for the overview.
# @param resampling [optional] the resampling method (one of Geo::GDAL::RIOResamplingTypes) (default is Average).
# @param progress [optional] a reference to a subroutine, which will
# be called with parameters (number progress, string msg, progress_data)
# @param progress_data [optional]
#*
sub RegenerateOverview {
    my $self = shift;
    #Geo::GDAL::Band overview, scalar resampling, subref callback, scalar callback_data
    my @p = @_;
    Geo::GDAL::RegenerateOverview($self, @p);
}
 
#** @method RegenerateOverviews(arrayref overviews, $resampling, coderef progress, $progress_data)
# Object method.
# @todo This is not yet available
# 
# @param overviews a list of Geo::GDAL::Band objects for the overviews.
# @param resampling [optional] the resampling method (one of Geo::GDAL::RIOResamplingTypes) (default is Average).
# @param progress [optional] a reference to a subroutine, which will
# be called with parameters (number progress, string msg, progress_data)
# @param progress_data [optional]
#*
sub RegenerateOverviews {
    my $self = shift;
    #arrayref overviews, scalar resampling, subref callback, scalar callback_data
    my @p = @_;
    Geo::GDAL::RegenerateOverviews($self, @p);
}
 
#** @method ScaleAndOffset($scale, $offset)
# Object method.
# Scale and offset are used to transform raw cell values into the
# units returned by GetUnits(). The conversion function is:
# \code
# Units value = (raw value * scale) + offset
# \endcode
# @return a list ($scale, $offset), the values are undefined if they
# are not set.
# @since version 1.9 of the bindings.
#*
sub ScaleAndOffset {
    my $self = shift;
    SetScale($self, $_[0]) if @_ > 0 and defined $_[0];
    SetOffset($self, $_[1]) if @_ > 1 and defined $_[1];
    return unless defined wantarray;
    my $scale = GetScale($self);
    my $offset = GetOffset($self);
    return ($scale, $offset);
}
 
#** @method list SetDefaultHistogram($min, $max, $histogram)
# Object method.
# @param min
# @param max
# @note See Note in Geo::GDAL::Band::GetHistogram.
# @param histogram reference to an array containing the histogram
#*
sub SetDefaultHistogram {
}
 
#** @method SetStatistics($min, $max, $mean, $stddev)
# Object method.
# Save the statistics of the band if possible (the format can save
# arbitrary metadata).
# @param min
# @param max
# @param mean
# @param stddev
#*
sub SetStatistics {
}
 
#** @method Geo::GDAL::Band Sieve(%params)
# Object method.
# Remove small areas by merging them into the largest neighbour area.
# @param params Named parameters:
# - \a Mask A raster band, which is used as a mask to select sieved areas. Default is undef.
# - \a Dest A raster band into which the result is written. If not given, an new in-memory raster band is created and returned.
# - \a Threshold The smallest area size (in number of cells) which are not sieved away.
# - \a Options Hash or list of options. {Connectedness => 4} can be specified to use 4-connectedness, otherwise 8-connectedness is used.
# - \a Progress Progress function.
# - \a ProgressData Additional parameter for the progress function.
# 
# @return The filtered raster band.
#*
sub Sieve {
    my $self = shift;
    my $p = named_parameters(\@_, Mask => undef, Dest => undef, Threshold => 10, Options => undef, Progress => undef, ProgressData => undef);
    unless ($p->{dest}) {
        my ($w, $h) = $self->Size;
        $p->{dest} = Geo::GDAL::Driver('MEM')->Create(Name => 'sieved', Width => $w, Height => $h, Type => $self->DataType)->Band;
    }
    my $c = 8;
    if ($p->{options}{Connectedness}) {
        $c = $p->{options}{Connectedness};
        delete $p->{options}{Connectedness};
    }
    Geo::GDAL::SieveFilter($self, $p->{mask}, $p->{dest}, $p->{threshold}, $c, $p->{options}, $p->{progress}, $p->{progressdata});
    return $p->{dest};
}
 
#** @method list Size()
# Object method.
# @return The size of the band as a list (width, height).
#*
sub Size {
    my $self = shift;
    return ($self->{XSize}, $self->{YSize});
}
 
#** @method Unit($type)
# Object method.
# @param type [optional] the unit (a string).
# @note $band->Unit(undef) sets the unit value to an empty string.
# @return the unit (a string).
# @since version 1.9 of the bindings.
#*
sub Unit {
    my $self = shift;
    if (@_ > 0) {
        my $unit = shift;
        $unit //= '';
        SetUnitType($self, $unit);
    }
    return unless defined wantarray;
    GetUnitType($self);
}
 
#** @method WriteRaster(%params)
# Object method.
# Write data into the band.
# 
# @param params Named parameters:
# - \a XOff x offset (cell coordinates) (default is 0)
# - \a YOff y offset (cell coordinates) (default is 0)
# - \a XSize width of the area to write (default is the width of the band)
# - \a YSize height of the area to write (default is the height of the band)
# - \a Buf a buffer (or a reference to a buffer) containing the data. Create the buffer with \a pack function of Perl. See Geo::GDAL::Band::PackCharacter.
# - \a BufXSize (default is undef, i.e., the same as XSize)
# - \a BufYSize (default is undef, i.e., the same as YSize)
# - \a BufType data type of the buffer (default is the data type of the band)
# - \a BufPixelSpace (default is 0)
# - \a BufLineSpace (default is 0)
# 
# <a href="http://www.gdal.org/classGDALDataset.html">Entry in GDAL docs (method RasterIO)</a>
#*
sub WriteRaster {
    my $self = shift;
    my ($width, $height) = $self->Size;
    my ($type) = $self->DataType;
    my $p = named_parameters(\@_,
                             XOff => 0,
                             YOff => 0,
                             XSize => $width,
                             YSize => $height,
                             Buf => undef,
                             BufXSize => undef,
                             BufYSize => undef,
                             BufType => $type,
                             BufPixelSpace => 0,
                             BufLineSpace => 0
        );
    confess "Usage: \$band->WriteRaster( Buf => \$data, ... )" unless defined $p->{buf};
    $p->{buftype} = s2i(data_type => $p->{buftype}, 1);
    $self->_WriteRaster($p->{xoff},$p->{yoff},$p->{xsize},$p->{ysize},$p->{buf},$p->{bufxsize},$p->{bufysize},$p->{buftype},$p->{bufpixelspace},$p->{buflinespace});
}
 
#** @method WriteTile($data, $xoff = 0, $yoff = 0)
# Object method.
# Write band data from a Perl array.
# 
# \note Accessing band data in this way is slow. Consider using PDL and Geo::GDAL::Band::Piddle.
# 
# @param data A two-dimensional Perl array, organizes as data->[y][x], y =
# 0..height-1, x = 0..width-1.
# @param xoff
# @param yoff
# 
#*
sub WriteTile {
    my($self, $data, $xoff, $yoff) = @_;
    $xoff //= 0;
    $yoff //= 0;
    error('The data must be in a two-dimensional array') unless ref $data eq 'ARRAY' && ref $data->[0] eq 'ARRAY';
    my $xsize = @{$data->[0]};
    if ($xsize > $self->{XSize} - $xoff) {
        warn "Buffer XSize too large ($xsize) for this raster band (width = $self->{XSize}, offset = $xoff).";
        $xsize = $self->{XSize} - $xoff;
    }
    my $ysize = @{$data};
    if ($ysize > $self->{YSize} - $yoff) {
        $ysize = $self->{YSize} - $yoff;
        warn "Buffer YSize too large ($ysize) for this raster band (height = $self->{YSize}, offset = $yoff).";
    }
    my $pc = Geo::GDAL::PackCharacter($self->{DataType});
    for my $i (0..$ysize-1) {
        my $scanline = pack($pc."[$xsize]", @{$data->[$i]});
        $self->WriteRaster( $xoff, $yoff+$i, $xsize, 1, $scanline );
    }
}
 
#** @class Geo::GDAL::ColorTable
# @brief A color table from a raster band or a color table, which can be used for a band.
# @details
#*
package Geo::GDAL::ColorTable;
 
use base qw(Geo::GDAL)
 
#** @method Geo::GDAL::ColorTable Clone()
# Object method.
# Clone an existing color table.
# @return a new Geo::GDAL::ColorTable object
#*
sub Clone {
}
 
#** @method list Color($index, @color)
# Object method.
# Get or set a color in this color table.
# @param index The index of the color in the table. Note that the
# color table may expand if the index is larger than the current max
# index of this table and a color is given. An attempt to retrieve a
# color out of the current size of the table causes an error.
# @param color [optional] The color, either a list or a reference to a
# list. If the list is too short or has undef values, the undef values
# are taken as 0 except for alpha, which is taken as 255.
# @note A color is an array of four integers having a value between 0
# and 255: (gray, red, cyan or hue; green, magenta, or lightness;
# blue, yellow, or saturation; alpha or blackband)
# @return A color, in list context a list and in scalar context a reference to an anonymous array.
#*
sub Color {
}
 
#** @method list Colors(@colors)
# Object method.
# Get or set the colors in this color table.
# @note The color table will expand to the size of the input list but
# it will not shrink.
# @param colors [optional] A list of all colors (a list of lists) for this color table.
# @return A list of colors (a list of lists).
#*
sub Colors {
}
 
#** @method CreateColorRamp($start_index, arrayref start_color, $end_index, arrayref end_color)
# Object method.
# @param start_index
# @param start_color
# @param end_index
# @param end_color
#*
sub CreateColorRamp {
}
 
#** @method scalar GetCount()
# Object method.
# @return The number of colors in this color table.
#*
sub GetCount {
}
 
#** @method scalar GetPaletteInterpretation()
# Object method.
# @return palette interpretation (string)
#*
sub GetPaletteInterpretation {
    my $self = shift;
    return i2s(palette_interpretation => GetPaletteInterpretation($self));
}
 
#** @method Geo::GDAL::ColorTable new($GDALPaletteInterp = 'RGB')
# Class method.
# Create a new empty color table.
# @return a new Geo::GDAL::ColorTable object
#*
sub new {
    my($pkg, $pi) = @_;
    $pi //= 'RGB';
    $pi = s2i(palette_interpretation => $pi);
    my $self = Geo::GDALc::new_ColorTable($pi);
    bless $self, $pkg if defined($self);
}
 
#** @class Geo::GDAL::Dataset
# @brief A set of associated raster bands or vector layer source.
# @details
#*
package Geo::GDAL::Dataset;
 
use base qw(Geo::GDAL::MajorObject Geo::GDAL)
 
#** @attr $RasterCount 
# scalar (access as $dataset->{RasterCount})
#*
 
#** @attr $RasterXSize 
# scalar (access as $dataset->{RasterXSize})
#*
 
#** @attr $RasterYSize 
# scalar (access as $dataset->{RasterYSize})
#*
 
#** @method AbortSQL()
#*
sub AbortSQL {
}
 
#** @method AddBand($datatype = 'Byte', hashref options = {})
# Object method.
# Add a new band to the dataset. The driver must support the action.
# @param datatype GDAL raster cell data type (one of those listed by Geo::GDAL::DataTypes).
# @param options reference to a hash of format specific options.
# @return The added band.
#*
sub AddBand {
    my ($self, $type, $options) = @_;
    $type //= 'Byte';
    $type = s2i(data_type => $type);
    $self->_AddBand($type, $options);
    return unless defined wantarray;
    return $self->GetRasterBand($self->{RasterCount});
}
 
#** @method AdviseRead()
#*
sub AdviseRead {
}
 
#** @method Geo::GDAL::Band Band($index)
# Object method.
# Create a band object for the band within the dataset.
# @note a.k.a. GetRasterBand
# @param index 1...RasterCount, default is 1.
# @return a new Geo::GDAL::Band object
#*
sub Band {
}
 
#** @method list Bands()
# Object method.
# @return a list of new Geo::GDAL::Band objects
#*
sub Bands {
    my $self = shift;
    my @bands;
    for my $i (1..$self->{RasterCount}) {
        push @bands, GetRasterBand($self, $i);
    }
    return @bands;
}
 
#** @method BuildOverviews($resampling, arrayref overviews, coderef progress, $progress_data)
# Object method.
# @param resampling the resampling method, one of Geo::GDAL::RIOResamplingTypes.
# @param overviews The list of overview decimation factors to
# build. For example [2,4,8].
# @param progress [optional] a reference to a subroutine, which will
# be called with parameters (number progress, string msg, progress_data)
# @param progress_data [optional]
#*
sub BuildOverviews {
    my $self = shift;
    my @p = @_;
    $p[0] = uc($p[0]) if $p[0];
    eval {
        $self->_BuildOverviews(@p);
    };
    confess(last_error()) if $@;
}
 
#** @method Geo::GDAL::Dataset BuildVRT($Dest, arrayref Sources, hashref Options, coderef progress, $progress_data)
# Object method.
# Build a virtual dataset from a set of datasets.
# @param Dest Destination raster dataset definition string (typically
# filename), or an object, which implements write and close.
# @param Sources A list of filenames of input datasets or a list of
# dataset objects.
# @param Options See section \ref index_processing_options.
# @return Dataset object
# 
# @note This subroutine is imported into the main namespace if Geo::GDAL
# is use'd with qw/:all/.
#*
sub BuildVRT {
    my ($dest, $sources, $options, $progress, $progress_data) = @_;
    $options = Geo::GDAL::GDALBuildVRTOptions->new(make_processing_options($options));
    error("Usage: Geo::GDAL::DataSet::BuildVRT(\$vrt_file_name, \\\@sources)")
        unless ref $sources eq 'ARRAY' && defined $sources->[0];
    unless (blessed($dest)) {
        if (blessed($sources->[0])) {
            return Geo::GDAL::wrapper_GDALBuildVRT_objects($dest, $sources, $options, $progress, $progress_data);
        } else {
            return Geo::GDAL::wrapper_GDALBuildVRT_names($dest, $sources, $options, $progress, $progress_data);
        }
    } else {
        if (blessed($sources->[0])) {
            return stdout_redirection_wrapper(
                $sources, $dest,
                \&Geo::GDAL::wrapper_GDALBuildVRT_objects,
                $options, $progress, $progress_data);
        } else {
            return stdout_redirection_wrapper(
                $sources, $dest,
                \&Geo::GDAL::wrapper_GDALBuildVRT_names,
                $options, $progress, $progress_data);
        }
    }
}
 
#** @method ClearStatistics()
#*
sub ClearStatistics {
}
 
#** @method CommitTransaction()
#*
sub CommitTransaction {
}
 
#** @method Geo::GDAL::ColorTable ComputeColorTable(%params)
# Object method.
# Compute a color table from an RGB image
# @param params Named parameters:
# - \a Red The red band, the default is to use the red band of this dataset.
# - \a Green The green band, the default is to use the green band of this dataset.
# - \a Blue The blue band, the default is to use the blue band of this dataset.
# - \a NumColors The number of colors in the computed color table. Default is 256.
# - \a Progress reference to a progress function (default is undef)
# - \a ProgressData (default is undef)
# - \a Method The computation method. The default and currently only option is the median cut algorithm.
# 
# @return a new color table object.
#*
sub ComputeColorTable {
    my $self = shift;
    my $p = named_parameters(\@_,
                             Red => undef,
                             Green => undef,
                             Blue => undef,
                             NumColors => 256,
                             Progress => undef,
                             ProgressData => undef,
                             Method => 'MedianCut');
    for my $b ($self->Bands) {
        for my $cion ($b->ColorInterpretation) {
            if ($cion eq 'RedBand') { $p->{red} //= $b; last; }
            if ($cion eq 'GreenBand') { $p->{green} //= $b; last; }
            if ($cion eq 'BlueBand') { $p->{blue} //= $b; last; }
        }
    }
    my $ct = Geo::GDAL::ColorTable->new;
    Geo::GDAL::ComputeMedianCutPCT($p->{red},
                                   $p->{green},
                                   $p->{blue},
                                   $p->{numcolors},
                                   $ct, $p->{progress},
                                   $p->{progressdata});
    return $ct;
}
 
#** @method Geo::OGR::Layer CopyLayer($layer, $name, hashref options = undef)
# Object method.
# @param layer A Geo::OGR::Layer object to be copied.
# @param name A name for the new layer.
# @param options A ref to a hash of format specific options.
# @return a new Geo::OGR::Layer object.
#*
sub CopyLayer {
}
 
#** @method Geo::OGR::Layer CreateLayer(%params)
# Object method.
# @brief Create a new vector layer into this dataset.
# 
# @param %params Named parameters:
# - \a Name (scalar) name for the new layer.
# - \a Fields (array reference) a list of (scalar and geometry) field definitions as in
# Geo::OGR::Layer::CreateField.
# - \a ApproxOK (boolean value, default is true) a flag, which is forwarded to Geo::OGR::Layer::CreateField.
# - \a Options (hash reference) driver specific hash of layer creation options.
# - \a Schema (hash reference, deprecated, use \a Fields and \a Name) may contain keys Name, Fields, GeomFields, GeometryType.
# - \a SRS (scalar) the spatial reference for the default geometry field.
# - \a GeometryType (scalar) the type of the default geometry field
# (if only one geometry field). Default is 'Unknown'.
# 
# @note If Fields or Schema|Fields is not given, a default geometry
# field (Name => '', GeometryType => 'Unknown') is created. If it is
# given and it contains spatial fields, both GeometryType and SRS are
# ignored. The type can be also set with the named parameter.
# 
# Example:
# \code
# my $roads = Geo::OGR::Driver('Memory')->Create('road')->
#    CreateLayer(
#        Fields => [ { Name => 'class',
#                      Type => 'Integer' },
#                    { Name => 'geom',
#                      Type => 'LineString25D' } ] );
# \endcode
# 
# @note Many formats allow only one spatial field, which currently
# requires the use of GeometryType.
# 
# @return a new Geo::OGR::Layer object.
#*
sub CreateLayer {
    my $self = shift;
    my $p = named_parameters(\@_,
                             Name => 'unnamed',
                             SRS => undef,
                             GeometryType => 'Unknown',
                             Options => {},
                             Schema => undef,
                             Fields => undef,
                             ApproxOK => 1);
    error("The 'Fields' argument must be an array reference.") if $p->{fields} && ref($p->{fields}) ne 'ARRAY';
    if (defined $p->{schema}) {
        my $s = $p->{schema};
        $p->{geometrytype} = $s->{GeometryType} if exists $s->{GeometryType};
        $p->{fields} = $s->{Fields} if exists $s->{Fields};
        $p->{name} = $s->{Name} if exists $s->{Name};
    }
    $p->{fields} = [] unless ref($p->{fields}) eq 'ARRAY';
    # if fields contains spatial fields, then do not create default one
    for my $f (@{$p->{fields}}) {
        error("Field definitions must be hash references.") unless ref $f eq 'HASH';
        if ($f->{GeometryType} || ($f->{Type} && s_exists(geometry_type => $f->{Type}))) {
            $p->{geometrytype} = 'None';
            last;
        }
    }
    my $gt = s2i(geometry_type => $p->{geometrytype});
    my $layer = _CreateLayer($self, $p->{name}, $p->{srs}, $gt, $p->{options});
    for my $f (@{$p->{fields}}) {
        $layer->CreateField($f);
    }
    keep($layer, $self);
}
 
#** @method CreateMaskBand()
# Object method.
# Add a mask band to the dataset.
#*
sub CreateMaskBand {
    return _CreateMaskBand(@_);
}
 
#** @method Geo::GDAL::Dataset DEMProcessing($Dest, $Processing, $ColorFilename, hashref Options, coderef progress, $progress_data)
# Object method.
# Apply a DEM processing to this dataset.
# @param Dest Destination raster dataset definition string (typically filename) or an object, which implements write and close.
# @param Processing Processing to apply, one of "hillshade", "slope", "aspect", "color-relief", "TRI", "TPI", or "Roughness".
# @param ColorFilename The color palette for color-relief.
# @param Options See section \ref index_processing_options.
# @param progress [optional] A reference to a subroutine, which will
# be called with parameters (number progress, string msg, progress_data).
# @param progress_data [optional]
# 
#*
sub DEMProcessing {
    my ($self, $dest, $Processing, $ColorFilename, $options, $progress, $progress_data) = @_;
    $options = Geo::GDAL::GDALDEMProcessingOptions->new(make_processing_options($options));
    return $self->stdout_redirection_wrapper(
        $dest,
        \&Geo::GDAL::wrapper_GDALDEMProcessing,
        $Processing, $ColorFilename, $options, $progress, $progress_data
    );
}
 
#** @method Dataset()
#*
sub Dataset {
    my $self = shift;
    parent($self);
}
 
#** @method DeleteLayer($name)
# Object method.
# Deletes a layer from the data source. Note that if there is a layer
# object for the deleted layer, it becomes unusable.
# @param name name of the layer to delete.
#*
sub DeleteLayer {
    my ($self, $name) = @_;
    my $index;
    for my $i (0..$self->GetLayerCount-1) {
        my $layer = GetLayerByIndex($self, $i);
        $index = $i, last if $layer->GetName eq $name;
    }
    error(2, $name, 'Layer') unless defined $index;
    _DeleteLayer($self, $index);
}
 
#** @method Geo::GDAL::Band Dither(%params)
# Object method.
# Compute one band with color table image from an RGB image
# @params params Named parameters:
# - \a Red The red band, the default is to use the red band of this dataset.
# - \a Green The green band, the default is to use the green band of this dataset.
# - \a Blue The blue band, the default is to use the blue band of this dataset.
# - \a Dest The destination band. If this is not defined, a new in-memory band (and a dataset) will be created.
# - \a ColorTable The color table for the result. If this is not defined, and the destination band does not contain one, it will be computed with the ComputeColorTable method.
# - \a Progress Reference to a progress function (default is undef). Note that if ColorTable is computed using ComputeColorTable method, the progress will run twice from 0 to 1.
# - \a ProgressData (default is undef)
# 
# @return the destination band.
# 
# Usage example. This code converts an RGB JPEG image into a one band PNG image with a color table.
# \code
# my $d = Geo::GDAL::Open('pic.jpg');
# Geo::GDAL::Driver('PNG')->Copy(Name => 'test.png', Src => $d->Dither->Dataset);
# \endcode
#*
sub Dither {
    my $self = shift;
    my $p = named_parameters(\@_,
                             Red => undef,
                             Green => undef,
                             Blue => undef,
                             Dest => undef,
                             ColorTable => undef,
                             Progress => undef,
                             ProgressData => undef);
    for my $b ($self->Bands) {
        for my $cion ($b->ColorInterpretation) {
            if ($cion eq 'RedBand') { $p->{red} //= $b; last; }
            if ($cion eq 'GreenBand') { $p->{green} //= $b; last; }
            if ($cion eq 'BlueBand') { $p->{blue} //= $b; last; }
        }
    }
    my ($w, $h) = $self->Size;
    $p->{dest} //= Geo::GDAL::Driver('MEM')->Create(Name => 'dithered',
                                                    Width => $w,
                                                    Height => $h,
                                                    Type => 'Byte')->Band;
    $p->{colortable}
        //= $p->{dest}->ColorTable
            // $self->ComputeColorTable(Red => $p->{red},
                                        Green => $p->{green},
                                        Blue => $p->{blue},
                                        Progress => $p->{progress},
                                        ProgressData => $p->{progressdata});
    Geo::GDAL::DitherRGB2PCT($p->{red},
                             $p->{green},
                             $p->{blue},
                             $p->{dest},
                             $p->{colortable},
                             $p->{progress},
                             $p->{progressdata});
    $p->{dest}->ColorTable($p->{colortable});
    return $p->{dest};
}
 
#** @method Domains()
#*
sub Domains {
    return @DOMAINS;
}
 
#** @method Geo::GDAL::Driver Driver()
# Object method.
# @note a.k.a. GetDriver
# @return a Geo::GDAL::Driver object that was used to open or create this dataset.
#*
sub Driver {
}
 
#** @method Geo::OGR::Layer ExecuteSQL($statement, $geom = undef, $dialect = "")
# Object method.
# @param statement A SQL statement.
# @param geom A Geo::OGR::Geometry object.
# @param dialect
# @return a new Geo::OGR::Layer object. The data source object will
# exist as long as the layer object exists.
#*
sub ExecuteSQL {
    my $self = shift;
    my $layer = $self->_ExecuteSQL(@_);
    note($layer, "is result set");
    keep($layer, $self);
}
 
#** @method Geo::GDAL::Extent Extent(@params)
# Object method.
# @param params nothing, or a list ($xoff, $yoff, $w, $h)
# @return A new Geo::GDAL::Extent object that represents the area that
# this raster or the specified tile covers.
#*
sub Extent {
    my $self = shift;
    my $t = $self->GeoTransform;
    my $extent = $t->Extent($self->Size);
    if (@_) {
        my ($xoff, $yoff, $w, $h) = @_;
        my ($x, $y) = $t->Apply([$xoff, $xoff+$w, $xoff+$w, $xoff], [$yoff, $yoff, $yoff+$h, $yoff+$h]);
        my $xmin = shift @$x;
        my $xmax = $xmin;
        for my $x (@$x) {
            $xmin = $x if $x < $xmin;
            $xmax = $x if $x > $xmax;
        }
        my $ymin = shift @$y;
        my $ymax = $ymin;
        for my $y (@$y) {
            $ymin = $y if $y < $ymin;
            $ymax = $y if $y > $ymax;
        }
        $extent = Geo::GDAL::Extent->new($xmin, $ymin, $xmax, $ymax);
    }
    return $extent;
}
 
#** @method list GCPs(@GCPs, Geo::OSR::SpatialReference sr)
# Object method.
# Get or set the GCPs and their projection.
# @param GCPs [optional] a list of Geo::GDAL::GCP objects
# @param sr [optional] the projection of the GCPs.
# @return a list of Geo::GDAL::GCP objects followed by a Geo::OSR::SpatialReference object.
#*
sub GCPs {
    my $self = shift;
    if (@_ > 0) {
        my $proj = pop @_;
        $proj = $proj->Export('WKT') if $proj and ref($proj);
        SetGCPs($self, \@_, $proj);
    }
    return unless defined wantarray;
    my $proj = Geo::OSR::SpatialReference->new(GetGCPProjection($self));
    my $GCPs = GetGCPs($self);
    return (@$GCPs, $proj);
}
 
#** @method Geo::GDAL::GeoTransform GeoTransform(Geo::GDAL::GeoTransform $geo_transform)
# Object method.
# Transformation from cell coordinates (column,row) to projection
# coordinates (x,y)
# \code
# x = geo_transform[0] + column*geo_transform[1] + row*geo_transform[2]
# y = geo_transform[3] + column*geo_transform[4] + row*geo_transform[5]
# \endcode
# @param geo_transform [optional]
# @return the geo transform in a non-void context.
#*
sub GeoTransform {
    my $self = shift;
    eval {
        if (@_ == 1) {
            SetGeoTransform($self, $_[0]);
        } elsif (@_ > 1) {
            SetGeoTransform($self, \@_);
        }
    };
    confess(last_error()) if $@;
    return unless defined wantarray;
    my $t = GetGeoTransform($self);
    if (wantarray) {
        return @$t;
    } else {
        return Geo::GDAL::GeoTransform->new($t);
    }
}
 
#** @method GetDriver()
#*
sub GetDriver {
}
 
#** @method list GetFileList()
# Object method.
# @return list of files GDAL believes to be part of this dataset.
#*
sub GetFileList {
}
 
#** @method scalar GetGCPProjection()
# Object method.
# @return projection string.
#*
sub GetGCPProjection {
}
 
#** @method GetGCPSpatialRef()
#*
sub GetGCPSpatialRef {
}
 
#** @method Geo::OGR::Layer GetLayer($name)
# Object method.
# @param name the name of the requested layer. If not given, then
# returns the first layer in the data source.
# @return a new Geo::OGR::Layer object that represents the layer
# in the data source.
#*
sub GetLayer {
    my($self, $name) = @_;
    my $layer = defined $name ? GetLayerByName($self, "$name") : GetLayerByIndex($self, 0);
    $name //= '';
    error(2, $name, 'Layer') unless $layer;
    keep($layer, $self);
}
 
#** @method list GetLayerNames()
# Object method.
# @note Delivers the functionality of undocumented method GetLayerCount.
# @return a list of the names of the layers this data source provides.
#*
sub GetLayerNames {
    my $self = shift;
    my @names;
    for my $i (0..$self->GetLayerCount-1) {
        my $layer = GetLayerByIndex($self, $i);
        push @names, $layer->GetName;
    }
    return @names;
}
 
#** @method GetNextFeature()
#*
sub GetNextFeature {
}
 
#** @method GetRootGroup()
#*
sub GetRootGroup {
}
 
#** @method GetSpatialRef()
#*
sub GetSpatialRef {
}
 
#** @method GetStyleTable()
#*
sub GetStyleTable {
}
 
#** @method Geo::GDAL::Dataset Grid($Dest, hashref Options)
# Object method.
# Creates a regular raster grid from this data source.
# This is equivalent to the gdal_grid utility.
# @param Dest Destination raster dataset definition string (typically
# filename) or an object, which implements write and close.
# @param Options See section \ref index_processing_options.
#*
sub Grid {
    my ($self, $dest, $options, $progress, $progress_data) = @_;
    $options = Geo::GDAL::GDALGridOptions->new(make_processing_options($options));
    return $self->stdout_redirection_wrapper(
        $dest,
        \&Geo::GDAL::wrapper_GDALGrid,
        $options, $progress, $progress_data
    );
}
 
#** @method scalar Info(hashref Options)
# Object method.
# Information about this dataset.
# @param Options See section \ref index_processing_options.
#*
sub Info {
    my ($self, $o) = @_;
    $o = Geo::GDAL::GDALInfoOptions->new(make_processing_options($o));
    return GDALInfo($self, $o);
}
 
#** @method Geo::GDAL::Dataset Nearblack($Dest, hashref Options, coderef progress, $progress_data)
# Object method.
# Convert nearly black/white pixels to black/white.
# @param Dest Destination raster dataset definition string (typically
# filename), destination dataset to which to add an alpha or mask
# band, or an object, which implements write and close.
# @param Options See section \ref index_processing_options.
# @return Dataset if destination dataset definition string was given,
# otherwise a boolean for success/fail but the method croaks if there
# was an error.
#*
sub Nearblack {
    my ($self, $dest, $options, $progress, $progress_data) = @_;
    $options = Geo::GDAL::GDALNearblackOptions->new(make_processing_options($options));
    my $b = blessed($dest);
    if ($b && $b eq 'Geo::GDAL::Dataset') {
        Geo::GDAL::wrapper_GDALNearblackDestDS($dest, $self, $options, $progress, $progress_data);
    } else {
        return $self->stdout_redirection_wrapper(
            $dest,
            \&Geo::GDAL::wrapper_GDALNearblackDestName,
            $options, $progress, $progress_data
        );
    }
}
 
#** @method Geo::GDAL::Dataset Open()
# Package subroutine.
# The same as Geo::GDAL::Open
#*
sub Open {
}
 
#** @method Geo::GDAL::Dataset OpenShared()
# Package subroutine.
# The same as Geo::GDAL::OpenShared
#*
sub OpenShared {
}
 
#** @method Geo::GDAL::Dataset Rasterize($Dest, hashref Options, coderef progress, $progress_data)
# Object method.
# Render data from this data source into a raster.
# @param Dest Destination raster dataset definition string (typically
# filename), destination dataset, or an object, which implements write and close.
# @param Options See section \ref index_processing_options.
# @return Dataset if destination dataset definition string was given,
# otherwise a boolean for success/fail but the method croaks if there
# was an error.
# 
#*
sub Rasterize {
    my ($self, $dest, $options, $progress, $progress_data) = @_;
    $options = Geo::GDAL::GDALRasterizeOptions->new(make_processing_options($options));
    my $b = blessed($dest);
    if ($b && $b eq 'Geo::GDAL::Dataset') {
        Geo::GDAL::wrapper_GDALRasterizeDestDS($dest, $self, $options, $progress, $progress_data);
    } else {
        # TODO: options need to force a new raster be made, otherwise segfault
        return $self->stdout_redirection_wrapper(
            $dest,
            \&Geo::GDAL::wrapper_GDALRasterizeDestName,
            $options, $progress, $progress_data
        );
    }
}
 
#** @method scalar ReadRaster(%params)
# Object method.
# Read data from the dataset.
# 
# @param params Named parameters:
# - \a XOff x offset (cell coordinates) (default is 0)
# - \a YOff y offset (cell coordinates) (default is 0)
# - \a XSize width of the area to read (default is the width of the dataset)
# - \a YSize height of the area to read (default is the height of the dataset)
# - \a BufXSize (default is undef, i.e., the same as XSize)
# - \a BufYSize (default is undef, i.e., the same as YSize)
# - \a BufType data type of the buffer (default is the data type of the first band)
# - \a BandList a reference to an array of band indices (default is [1])
# - \a BufPixelSpace (default is 0)
# - \a BufLineSpace (default is 0)
# - \a BufBandSpace (default is 0)
# - \a ResampleAlg one of Geo::GDAL::RIOResamplingTypes (default is 'NearestNeighbour'),
# - \a Progress reference to a progress function (default is undef)
# - \a ProgressData (default is undef)
# 
# <a href="http://www.gdal.org/classGDALDataset.html">Entry in GDAL docs (method RasterIO)</a>
# @return a buffer, open the buffer with \a unpack function of Perl. See Geo::GDAL::Band::PackCharacter.
#*
sub ReadRaster {
    my $self = shift;
    my ($width, $height) = $self->Size;
    my ($type) = $self->Band->DataType;
    my $p = named_parameters(\@_,
                             XOff => 0,
                             YOff => 0,
                             XSize => $width,
                             YSize => $height,
                             BufXSize => undef,
                             BufYSize => undef,
                             BufType => $type,
                             BandList => [1],
                             BufPixelSpace => 0,
                             BufLineSpace => 0,
                             BufBandSpace => 0,
                             ResampleAlg => 'NearestNeighbour',
                             Progress => undef,
                             ProgressData => undef
        );
    $p->{resamplealg} = s2i(rio_resampling => $p->{resamplealg});
    $p->{buftype} = s2i(data_type => $p->{buftype}, 1);
    $self->_ReadRaster($p->{xoff},$p->{yoff},$p->{xsize},$p->{ysize},$p->{bufxsize},$p->{bufysize},$p->{buftype},$p->{bandlist},$p->{bufpixelspace},$p->{buflinespace},$p->{bufbandspace},$p->{resamplealg},$p->{progress},$p->{progressdata});
}
 
#** @method ReadTile()
#*
sub ReadTile {
    my ($self, $xoff, $yoff, $xsize, $ysize, $w_tile, $h_tile, $alg) = @_;
    my @data;
    for my $i (0..$self->Bands-1) {
        $data[$i] = $self->Band($i+1)->ReadTile($xoff, $yoff, $xsize, $ysize, $w_tile, $h_tile, $alg);
    }
    return \@data;
}
 
#** @method ReleaseResultSet($layer)
# Object method.
# @param layer A layer the has been created with ExecuteSQL.
# @note There is no need to call this method. The result set layer is
# released in the destructor of the layer that was created with SQL.
#*
sub ReleaseResultSet {
    # a no-op, _ReleaseResultSet is called from Layer::DESTROY
}
 
#** @method ResetReading()
#*
sub ResetReading {
}
 
#** @method RollbackTransaction()
#*
sub RollbackTransaction {
}
 
#** @method SetGCPs2()
#*
sub SetGCPs2 {
}
 
#** @method SetSpatialRef()
#*
sub SetSpatialRef {
}
 
#** @method SetStyleTable()
#*
sub SetStyleTable {
}
 
#** @method list Size()
# Object method.
# @return (width, height)
#*
sub Size {
    my $self = shift;
    return ($self->{RasterXSize}, $self->{RasterYSize});
}
 
#** @method Geo::OSR::SpatialReference SpatialReference(Geo::OSR::SpatialReference sr)
# Object method.
# Get or set the projection of this dataset.
# @param sr [optional] a Geo::OSR::SpatialReference object,
# which replaces the existing projection definition of this dataset.
# @return a Geo::OSR::SpatialReference object, which represents the
# projection of this dataset.
# @note Methods GetProjection, SetProjection, and Projection return WKT strings.
#*
sub SpatialReference {
    my($self, $sr) = @_;
    SetProjection($self, $sr->As('WKT')) if defined $sr;
    if (defined wantarray) {
        my $p = GetProjection($self);
        return unless $p;
        return Geo::OSR::SpatialReference->new(WKT => $p);
    }
}
 
#** @method StartTransaction()
#*
sub StartTransaction {
}
 
#** @method TestCapability()
#*
sub TestCapability {
    return _TestCapability(@_);
}
 
#** @method Tile(Geo::GDAL::Extent e)
# Object method.
# Compute the top left cell coordinates and width and height of the
# tile that covers the given extent.
# @param e The extent whose tile is needed.
# @note Requires that the raster is a strictly north up one.
# @return A list ($xoff, $yoff, $xsize, $ysize).
#*
sub Tile {
    my ($self, $e) = @_;
    my ($w, $h) = $self->Size;
    my $t = $self->GeoTransform;
    confess "GeoTransform is not \"north up\"." unless $t->NorthUp;
    my $xoff = floor(($e->[0] - $t->[0])/$t->[1]);
    $xoff = 0 if $xoff < 0;
    my $yoff = floor(($e->[1] - $t->[3])/$t->[5]);
    $yoff = 0 if $yoff < 0;
    my $xsize = ceil(($e->[2] - $t->[0])/$t->[1]) - $xoff;
    $xsize = $w - $xoff if $xsize > $w - $xoff;
    my $ysize = ceil(($e->[3] - $t->[3])/$t->[5]) - $yoff;
    $ysize = $h - $yoff if $ysize > $h - $yoff;
    return ($xoff, $yoff, $xsize, $ysize);
}
 
#** @method Geo::GDAL::Dataset Translate($Dest, hashref Options, coderef progress, $progress_data)
# Object method.
# Convert this dataset into another format.
# @param Dest Destination dataset definition string (typically
# filename) or an object, which implements write and close.
# @param Options See section \ref index_processing_options.
# @return New dataset object if destination dataset definition
# string was given, otherwise a boolean for success/fail but the
# method croaks if there was an error.
#*
sub Translate {
    my ($self, $dest, $options, $progress, $progress_data) = @_;
    return $self->stdout_redirection_wrapper(
        $dest,
}
 
#** @method Geo::GDAL::Dataset Warp($Dest, hashref Options, coderef progress, $progress_data)
# Object method.
# Reproject this dataset.
# @param Dest Destination raster dataset definition string (typically
# filename) or an object, which implements write and close.
# @param Options See section \ref index_processing_options.
# @note This method can be run as a package subroutine with a list of
# datasets as the first argument to mosaic several datasets.
#*
sub Warp {
    my ($self, $dest, $options, $progress, $progress_data) = @_;
    # can be run as object method (one dataset) and as package sub (a list of datasets)
    $options = Geo::GDAL::GDALWarpAppOptions->new(make_processing_options($options));
    my $b = blessed($dest);
    $self = [$self] unless ref $self eq 'ARRAY';
    if ($b && $b eq 'Geo::GDAL::Dataset') {
        Geo::GDAL::wrapper_GDALWarpDestDS($dest, $self, $options, $progress, $progress_data);
    } else {
        return stdout_redirection_wrapper(
            $self,
            $dest,
            \&Geo::GDAL::wrapper_GDALWarpDestName,
            $options, $progress, $progress_data
        );
    }
}
 
#** @method Geo::GDAL::Dataset Warped(%params)
# Object method.
# Create a virtual warped dataset from this dataset.
# 
# @param params Named parameters:
# - \a SrcSRS Override the spatial reference system of this dataset if there is one (default is undef).
# - \a DstSRS The target spatial reference system of the result (default is undef).
# - \a ResampleAlg The resampling algorithm (default is 'NearestNeighbour').
# - \a MaxError Maximum error measured in input cellsize that is allowed in approximating the transformation (default is 0 for exact calculations).
# 
# # <a href="http://www.gdal.org/gdalwarper_8h.html">Documentation for GDAL warper.</a>
# 
# @return a new Geo::GDAL::Dataset object
#*
sub Warped {
    my $self = shift;
    my $p = named_parameters(\@_, SrcSRS => undef, DstSRS => undef, ResampleAlg => 'NearestNeighbour', MaxError => 0);
    for my $srs (qw/srcsrs dstsrs/) {
        $p->{$srs} = $p->{$srs}->ExportToWkt if $p->{$srs} && blessed $p->{$srs};
    }
    $p->{resamplealg} = s2i(resampling => $p->{resamplealg});
    my $warped = Geo::GDAL::_AutoCreateWarpedVRT($self, $p->{srcsrs}, $p->{dstsrs}, $p->{resamplealg}, $p->{maxerror});
    keep($warped, $self) if $warped; # self must live as long as warped
}
 
#** @method WriteRaster(%params)
# Object method.
# Write data into the dataset.
# 
# @param params Named parameters:
# - \a XOff x offset (cell coordinates) (default is 0)
# - \a YOff y offset (cell coordinates) (default is 0)
# - \a XSize width of the area to write (default is the width of the dataset)
# - \a YSize height of the area to write (default is the height of the dataset)
# - \a Buf a buffer (or a reference to a buffer) containing the data. Create the buffer with \a pack function of Perl. See Geo::GDAL::Band::PackCharacter.
# - \a BufXSize (default is undef, i.e., the same as XSize)
# - \a BufYSize (default is undef, i.e., the same as YSize)
# - \a BufType data type of the buffer (default is the data type of the first band)
# - \a BandList a reference to an array of band indices (default is [1])
# - \a BufPixelSpace (default is 0)
# - \a BufLineSpace (default is 0)
# - \a BufBandSpace (default is 0)
# 
# <a href="http://www.gdal.org/classGDALDataset.html">Entry in GDAL docs (method RasterIO)</a>
#*
sub WriteRaster {
    my $self = shift;
    my ($width, $height) = $self->Size;
    my ($type) = $self->Band->DataType;
    my $p = named_parameters(\@_,
                             XOff => 0,
                             YOff => 0,
                             XSize => $width,
                             YSize => $height,
                             Buf => undef,
                             BufXSize => undef,
                             BufYSize => undef,
                             BufType => $type,
                             BandList => [1],
                             BufPixelSpace => 0,
                             BufLineSpace => 0,
                             BufBandSpace => 0
        );
    $p->{buftype} = s2i(data_type => $p->{buftype}, 1);
    $self->_WriteRaster($p->{xoff},$p->{yoff},$p->{xsize},$p->{ysize},$p->{buf},$p->{bufxsize},$p->{bufysize},$p->{buftype},$p->{bandlist},$p->{bufpixelspace},$p->{buflinespace},$p->{bufbandspace});
}
 
#** @method WriteTile()
#*
sub WriteTile {
    my ($self, $data, $xoff, $yoff) = @_;
    $xoff //= 0;
    $yoff //= 0;
    for my $i (0..$self->Bands-1) {
        $self->Band($i+1)->WriteTile($data->[$i], $xoff, $yoff);
    }
}
 
#** @class Geo::GDAL::Dimension
#*
package Geo::GDAL::Dimension;
 
use base qw(Geo::GDAL)
 
#** @method GetDirection()
#*
sub GetDirection {
}
 
#** @method GetFullName()
#*
sub GetFullName {
}
 
#** @method GetIndexingVariable()
#*
sub GetIndexingVariable {
}
 
#** @method GetName()
#*
sub GetName {
}
 
#** @method GetSize()
#*
sub GetSize {
}
 
#** @method GetType()
#*
sub GetType {
}
 
#** @method SetIndexingVariable()
#*
sub SetIndexingVariable {
}
 
#** @class Geo::GDAL::Driver
# @brief A driver for a specific dataset format.
# @details
#*
package Geo::GDAL::Driver;
 
use base qw(Geo::GDAL::MajorObject Geo::GDAL)
 
#** @attr $HelpTopic 
# $driver->{HelpTopic}
#*
 
#** @attr $LongName 
# $driver->{LongName}
#*
 
#** @attr $ShortName 
# $driver->{ShortName}
#*
 
#** @method list Capabilities()
# Object method.
# @return A list of capabilities. When executed as a package subroutine
# returns a list of all potential capabilities a driver may have. When
# executed as an object method returns a list of all capabilities the
# driver has.
# 
# Currently capabilities are:
# CREATE, CREATECOPY, DEFAULT_FIELDS, NOTNULL_FIELDS, NOTNULL_GEOMFIELDS, OPEN, RASTER, UNIQUE_FIELDS, VECTOR, and VIRTUALIO.
# 
# Examples.
# \code
# @all_capabilities = Geo::GDAL::Driver::Capabilities;
# @capabilities_of_the_geotiff_driver = Geo::GDAL::Driver('GTiff')->Capabilities;
# \endcode
#*
sub Capabilities {
    my $self = shift;
    return @CAPABILITIES unless $self;
    my $h = $self->GetMetadata;
    my @cap;
    for my $cap (@CAPABILITIES) {
        my $test = $h->{'DCAP_'.uc($cap)};
        push @cap, $cap if defined($test) and $test eq 'YES';
    }
    return @cap;
}
 
#** @method Geo::GDAL::Dataset Copy(%params)
# Object method.
# Create a new raster Geo::GDAL::Dataset as a copy of an existing dataset.
# @note a.k.a. CreateCopy
# 
# @param params Named parameters:
# - \a Name name for the new raster dataset.
# - \a Src the source Geo::GDAL::Dataset object.
# - \a Strict 1 (default) if the copy must be strictly equivalent, or 0 if the copy may adapt.
# - \a Options an anonymous hash of driver specific options.
# - \a Progress [optional] a reference to a subroutine, which will
# be called with parameters (number progress, string msg, progress_data).
# - \a ProgressData [optional]
# @return a new Geo::GDAL::Dataset object.
#*
sub Copy {
    my $self = shift;
    my $p = named_parameters(\@_, Name => 'unnamed', Src => undef, Strict => 1, Options => {}, Progress => undef, ProgressData => undef);
    return $self->stdout_redirection_wrapper(
        $p->{name},
        $self->can('_CreateCopy'),
        $p->{src}, $p->{strict}, $p->{options}, $p->{progress}, $p->{progressdata});
}
 
#** @method CopyFiles($NewName, $OldName)
# Object method.
# Copy the files of a dataset.
# @param NewName String.
# @param OldName String.
#*
sub CopyFiles {
}
 
#** @method Geo::GDAL::Dataset Create(%params)
# Object method.
# Create a raster dataset using this driver.
# @note a.k.a. CreateDataset
# 
# @param params Named parameters:
# - \a Name The name for the dataset (default is 'unnamed') or an object, which implements write and close.
# - \a Width The width for the raster dataset (default is 256).
# - \a Height The height for the raster dataset (default is 256).
# - \a Bands The number of bands to create into the raster dataset (default is 1).
# - \a Type The data type for the raster cells (default is 'Byte'). One of Geo::GDAL::Driver::CreationDataTypes.
# - \a Options Driver creation options as a reference to a hash (default is {}).
# 
# @return A new Geo::GDAL::Dataset object.
#*
sub Create {
    my $self = shift;
    my $p = named_parameters(\@_, Name => 'unnamed', Width => 256, Height => 256, Bands => 1, Type => 'Byte', Options => {});
    my $type = s2i(data_type => $p->{type});
    return $self->stdout_redirection_wrapper(
        $p->{name},
        $self->can('_Create'),
        $p->{width}, $p->{height}, $p->{bands}, $type, $p->{options}
    );
}
 
#** @method CreateMultiDimensional()
#*
sub CreateMultiDimensional {
}
 
#** @method list CreationDataTypes()
# Object method.
# @return a list of data types that can be used for new datasets of this format. A subset of Geo::GDAL::DataTypes
#*
sub CreationDataTypes {
    my $self = shift;
    my $h = $self->GetMetadata;
    return split /\s+/, $h->{DMD_CREATIONDATATYPES} if $h->{DMD_CREATIONDATATYPES};
}
 
#** @method list CreationOptionList()
# Object method.
# @return a list of options, each option is a hashref, the keys are
# name, type and description or Value. Value is a listref.
#*
sub CreationOptionList {
    my $self = shift;
    my @options;
    my $h = $self->GetMetadata->{DMD_CREATIONOPTIONLIST};
    if ($h) {
        $h = ParseXMLString($h);
        my($type, $value) = NodeData($h);
        if ($value eq 'CreationOptionList') {
            for my $o (Children($h)) {
                my %option;
                for my $a (Children($o)) {
                    my(undef, $key) = NodeData($a);
                    my(undef, $value) = NodeData(Child($a, 0));
                    if ($key eq 'Value') {
                        push @{$option{$key}}, $value;
                    } else {
                        $option{$key} = $value;
                    }
                }
                push @options, \%option;
            }
        }
    }
    return @options;
}
 
#** @method Delete($name)
# Object method.
# @param name
#*
sub Delete {
}
 
#** @method Domains()
#*
sub Domains {
    return @DOMAINS;
}
 
#** @method scalar Extension()
# Object method.
# @note The returned extension does not contain a '.' prefix.
# @return a suggested single extension or a list of extensions (in
# list context) for datasets.
#*
sub Extension {
    my $self = shift;
    my $h = $self->GetMetadata;
    if (wantarray) {
        my $e = $h->{DMD_EXTENSIONS};
        my @e = split / /, $e;
        @e = split /\//, $e if $e =~ /\//; # ILWIS returns mpr/mpl
        for my $i (0..$#e) {
            $e[$i] =~ s/^\.//; # CALS returns extensions with a dot prefix
        }
        return @e;
    } else {
        my $e = $h->{DMD_EXTENSION};
        return '' if $e =~ /\//; # ILWIS returns mpr/mpl
        $e =~ s/^\.//;
        return $e;
    }
}
 
#** @method scalar MIMEType()
# Object method.
# @return a suggested MIME type for datasets.
#*
sub MIMEType {
    my $self = shift;
    my $h = $self->GetMetadata;
    return $h->{DMD_MIMETYPE};
}
 
#** @method scalar Name()
# Object method.
# @return The short name of the driver.
#*
sub Name {
    my $self = shift;
    return $self->{ShortName};
}
 
#** @method Open()
# Object method.
# The same as Geo::GDAL::Open except that only this driver is allowed.
#*
sub Open {
    my $self = shift;
    my @p = @_; # name, update
    my @flags = qw/RASTER/;
    push @flags, qw/READONLY/ if $p[1] eq 'ReadOnly';
    push @flags, qw/UPDATE/ if $p[1] eq 'Update';
    my $dataset = OpenEx($p[0], \@flags, [$self->Name()]);
    error("Failed to open $p[0]. Is it a raster dataset?") unless $dataset;
    return $dataset;
}
 
#** @method Rename($NewName, $OldName)
# Object method.
# Rename (move) a GDAL dataset.
# @param NewName String.
# @param OldName String.
#*
sub Rename {
}
 
#** @method scalar TestCapability($cap)
# Object method.
# Test whether the driver has the specified capability.
# @param cap A capability string (one of those returned by Capabilities).
# @return a boolean value.
#*
sub TestCapability {
    my($self, $cap) = @_;
    my $h = $self->GetMetadata->{'DCAP_'.uc($cap)};
    return (defined($h) and $h eq 'YES') ? 1 : undef;
}
 
#** @method stdout_redirection_wrapper()
#*
sub stdout_redirection_wrapper {
    my ($self, $name, $sub, @params) = @_;
    my $object = 0;
    if ($name && blessed $name) {
        $object = $name;
        my $ref = $object->can('write');
        VSIStdoutSetRedirection($ref);
        $name = '/vsistdout/';
    }
    my $ds;
    eval {
        $ds = $sub->($self, $name, @params);
    };
    if ($object) {
        if ($ds) {
            $Geo::GDAL::stdout_redirection{tied(%$ds)} = $object;
        } else {
            VSIStdoutUnsetRedirection();
            $object->close;
        }
    }
    confess(last_error()) if $@;
    confess("Failed. Use Geo::OGR::Driver for vector drivers.") unless $ds;
    return $ds;
}
 
#** @class Geo::GDAL::EDTComponent
#*
package Geo::GDAL::EDTComponent;
 
use base qw(Geo::GDAL)
 
#** @method GetName()
#*
sub GetName {
}
 
#** @method GetOffset()
#*
sub GetOffset {
}
 
#** @method GetType()
#*
sub GetType {
}
 
#** @class Geo::GDAL::ExtendedDataType
#*
package Geo::GDAL::ExtendedDataType;
 
use base qw(Geo::GDAL)
 
#** @method CanConvertTo()
#*
sub CanConvertTo {
}
 
#** @method CreateString()
#*
sub CreateString {
}
 
#** @method Equals()
#*
sub Equals {
}
 
#** @method GetClass()
#*
sub GetClass {
}
 
#** @method GetMaxStringLength()
#*
sub GetMaxStringLength {
}
 
#** @method GetName()
#*
sub GetName {
}
 
#** @method GetNumericDataType()
#*
sub GetNumericDataType {
}
 
#** @method GetSize()
#*
sub GetSize {
}
 
#** @class Geo::GDAL::Extent
# @brief A rectangular area in projection coordinates: xmin, ymin, xmax, ymax.
#*
package Geo::GDAL::Extent;
 
#** @method ExpandToInclude($extent)
# Package subroutine.
# Extends this extent to include the other extent.
# @param extent Another Geo::GDAL::Extent object.
#*
sub ExpandToInclude {
    my ($self, $e) = @_;
    return if $e->IsEmpty;
    if ($self->IsEmpty) {
        @$self = @$e;
    } else {
        $self->[0] = $e->[0] if $e->[0] < $self->[0];
        $self->[1] = $e->[1] if $e->[1] < $self->[1];
        $self->[2] = $e->[2] if $e->[2] > $self->[2];
        $self->[3] = $e->[3] if $e->[3] > $self->[3];
    }
}
 
#** @method IsEmpty()
#*
sub IsEmpty {
    my $self = shift;
    return $self->[2] < $self->[0];
}
 
#** @method scalar Overlap($extent)
# Package subroutine.
# @param extent Another Geo::GDAL::Extent object.
# @return A new, possibly empty, Geo::GDAL::Extent object, which
# represents the joint area of the two extents.
#*
sub Overlap {
    my ($self, $e) = @_;
    return Geo::GDAL::Extent->new() unless $self->Overlaps($e);
    my $ret = Geo::GDAL::Extent->new($self);
    $ret->[0] = $e->[0] if $self->[0] < $e->[0];
    $ret->[1] = $e->[1] if $self->[1] < $e->[1];
    $ret->[2] = $e->[2] if $self->[2] > $e->[2];
    $ret->[3] = $e->[3] if $self->[3] > $e->[3];
    return $ret;
}
 
#** @method scalar Overlaps($extent)
# Package subroutine.
# @param extent Another Geo::GDAL::Extent object.
# @return True if this extent overlaps the other extent, false otherwise.
#*
sub Overlaps {
    my ($self, $e) = @_;
    return $self->[0] < $e->[2] && $self->[2] > $e->[0] && $self->[1] < $e->[3] && $self->[3] > $e->[1];
}
 
#** @method list Size()
# Package subroutine.
# @return A list ($width, $height).
#*
sub Size {
    my $self = shift;
    return (0,0) if $self->IsEmpty;
    return ($self->[2] - $self->[0], $self->[3] - $self->[1]);
}
 
#** @method Geo::GDAL::Extent new(@params)
# Package subroutine.
# @param params nothing, a list ($xmin, $ymin, $xmax, $ymax), or an Extent object
# @return A new Extent object (empty if no parameters, a copy of the parameter if it is an Extent object).
#*
sub new {
    my $class = shift;
    my $self;
    if (@_ == 0) {
        $self = [0,0,-1,0];
    } elsif (ref $_[0]) {
        @$self = @{$_[0]};
    } else {
        @$self = @_;
    }
    bless $self, $class;
    return $self;
}
 
#** @class Geo::GDAL::GCP
# @brief A ground control point for georeferencing rasters.
# @details
#*
package Geo::GDAL::GCP;
 
use base qw(Geo::GDAL)
 
#** @attr $Column 
# cell x coordinate (access as $gcp->{Column})
#*
 
#** @attr $Id 
# unique identifier (string) (access as $gcp->{Id})
#*
 
#** @attr $Info 
# informational message (access as $gcp->{Info})
#*
 
#** @attr $Row 
# cell y coordinate (access as $gcp->{Row})
#*
 
#** @attr $X 
# projection coordinate (access as $gcp->{X})
#*
 
#** @attr $Y 
# projection coordinate (access as $gcp->{Y})
#*
 
#** @attr $Z 
# projection coordinate (access as $gcp->{Z})
#*
 
#** @method scalar new($x = 0.0, $y = 0.0, $z = 0.0, $column = 0.0, $row = 0.0, $info = "", $id = "")
# Class method.
# @param x projection coordinate
# @param y projection coordinate
# @param z projection coordinate
# @param column cell x coordinate
# @param row cell y coordinate
# @param info informational message
# @param id unique identifier (string)
# @return a new Geo::GDAL::GCP object
#*
sub new {
    my $pkg = shift;
    my $self = Geo::GDALc::new_GCP(@_);
    bless $self, $pkg if defined($self);
}
 
#** @class Geo::GDAL::GDALMultiDimInfoOptions
#*
package Geo::GDAL::GDALMultiDimInfoOptions;
 
use base qw(Geo::GDAL)
 
#** @method new()
#*
sub new {
    my $pkg = shift;
    my $self = Geo::GDALc::new_GDALMultiDimInfoOptions(@_);
    bless $self, $pkg if defined($self);
}
 
#** @class Geo::GDAL::GDALMultiDimTranslateOptions
#*
package Geo::GDAL::GDALMultiDimTranslateOptions;
 
use base qw(Geo::GDAL)
 
#** @method new()
#*
sub new {
    my $pkg = shift;
    my $self = Geo::GDALc::new_GDALMultiDimTranslateOptions(@_);
    bless $self, $pkg if defined($self);
}
 
#** @class Geo::GDAL::GeoTransform
# @brief An array of affine transformation coefficients.
# @details The geo transformation has the form
# \code
# x = a + column * b + row * c
# y = d + column * e + row * f
# \endcode
# where
# (column,row) is the location in cell coordinates, and
# (x,y) is the location in projection coordinates, or vice versa.
# A Geo::GDAL::GeoTransform object is a reference to an anonymous array [a,b,c,d,e,f].
#*
package Geo::GDAL::GeoTransform;
 
#** @method Apply($x, $y)
# Object method.
# @param x Column or x, or a reference to an array of columns or x's
# @param y Row or y, or a reference to an array of rows or y's
# @return a list (x, y), where x and y are the transformed coordinates
# or references to arrays of transformed coordinates.
#*
sub Apply {
    my ($self, $columns, $rows) = @_;
    return Geo::GDAL::ApplyGeoTransform($self, $columns, $rows) unless ref($columns) eq 'ARRAY';
    my (@x, @y);
    for my $i (0..$#$columns) {
        ($x[$i], $y[$i]) =
            Geo::GDAL::ApplyGeoTransform($self, $columns->[$i], $rows->[$i]);
    }
    return (\@x, \@y);
}
 
#** @method Inv()
# Object method.
# @return a new Geo::GDAL::GeoTransform object, which is the inverse
# of this one (in void context changes this object).
#*
sub Inv {
    my $self = shift;
    my @inv = Geo::GDAL::InvGeoTransform($self);
    return Geo::GDAL::GeoTransform->new(@inv) if defined wantarray;
    @$self = @inv;
}
 
#** @method NorthUp()
#*
sub NorthUp {
    my $self = shift;
    return $self->[2] == 0 && $self->[4] == 0;
}
 
#** @method new(@params)
# Class method.
# @param params nothing, a reference to an array [a,b,c,d,e,f], a list
# (a,b,c,d,e,f), or named parameters
# - \a GCPs A reference to an array of Geo::GDAL::GCP objects.
# - \a ApproxOK Minimize the error in the coefficients (integer, default is 1 (true), used with GCPs).
# - \a Extent A Geo::GDAL::Extent object used to obtain the coordinates of the up left corner position.
# - \a CellSize The cell size (width and height) (default is 1, used with Extent).
# 
# @note When Extent is specifid, the created geo transform will be
# north up, have square cells, and coefficient f will be -1 times the
# cell size (image y - row - will increase downwards and projection y
# will increase upwards).
# @return a new Geo::GDAL::GeoTransform object.
#*
sub new {
    my $class = shift;
    my $self;
    if (@_ == 0) {
        $self = [0,1,0,0,0,1];
    } elsif (ref $_[0]) {
        @$self = @{$_[0]};
    } elsif ($_[0] =~ /^[a-zA-Z]/i) {
        my $p = named_parameters(\@_, GCPs => undef, ApproxOK => 1, Extent => undef, CellSize => 1);
        if ($p->{gcps}) {
            $self = Geo::GDAL::GCPsToGeoTransform($p->{gcps}, $p->{approxok});
        } elsif ($p->{extent}) {
            $self = Geo::GDAL::GeoTransform->new($p->{extent}[0], $p->{cellsize}, 0, $p->{extent}[2], 0, -$p->{cellsize});
        } else {
            error("Missing GCPs or Extent");
        }
    } else {
        my @a = @_;
        $self = \@a;
    }
    bless $self, $class;
}
 
#** @class Geo::GDAL::Group
#*
package Geo::GDAL::Group;
 
use base qw(Geo::GDAL)
 
#** @method CreateAttribute()
#*
sub CreateAttribute {
}
 
#** @method CreateDimension()
#*
sub CreateDimension {
}
 
#** @method CreateGroup()
#*
sub CreateGroup {
}
 
#** @method GetAttribute()
#*
sub GetAttribute {
}
 
#** @method GetFullName()
#*
sub GetFullName {
}
 
#** @method GetGroupNames()
#*
sub GetGroupNames {
}
 
#** @method GetMDArrayNames()
#*
sub GetMDArrayNames {
}
 
#** @method GetName()
#*
sub GetName {
}
 
#** @method GetStructuralInfo()
#*
sub GetStructuralInfo {
}
 
#** @method OpenGroup()
#*
sub OpenGroup {
}
 
#** @method OpenGroupFromFullname()
#*
sub OpenGroupFromFullname {
}
 
#** @method OpenMDArray()
#*
sub OpenMDArray {
}
 
#** @method OpenMDArrayFromFullname()
#*
sub OpenMDArrayFromFullname {
}
 
#** @method ResolveMDArray()
#*
sub ResolveMDArray {
}
 
#** @class Geo::GDAL::MDArray
#*
package Geo::GDAL::MDArray;
 
use base qw(Geo::GDAL)
 
#** @method AsClassicDataset()
#*
sub AsClassicDataset {
}
 
#** @method ComputeStatistics()
#*
sub ComputeStatistics {
}
 
#** @method CreateAttribute()
#*
sub CreateAttribute {
}
 
#** @method DeleteNoDataValue()
#*
sub DeleteNoDataValue {
}
 
#** @method GetAttribute()
#*
sub GetAttribute {
}
 
#** @method GetDataType()
#*
sub GetDataType {
}
 
#** @method GetDimensionCount()
#*
sub GetDimensionCount {
}
 
#** @method GetFullName()
#*
sub GetFullName {
}
 
#** @method GetMask()
#*
sub GetMask {
}
 
#** @method GetName()
#*
sub GetName {
}
 
#** @method GetNoDataValueAsDouble()
#*
sub GetNoDataValueAsDouble {
}
 
#** @method GetOffset()
#*
sub GetOffset {
}
 
#** @method GetScale()
#*
sub GetScale {
}
 
#** @method GetSpatialRef()
#*
sub GetSpatialRef {
}
 
#** @method GetStatistics()
#*
sub GetStatistics {
}
 
#** @method GetStructuralInfo()
#*
sub GetStructuralInfo {
}
 
#** @method GetTotalElementsCount()
#*
sub GetTotalElementsCount {
}
 
#** @method GetUnit()
#*
sub GetUnit {
}
 
#** @method GetUnscaled()
#*
sub GetUnscaled {
}
 
#** @method GetView()
#*
sub GetView {
}
 
#** @method SetNoDataValueDouble()
#*
sub SetNoDataValueDouble {
}
 
#** @method SetOffset()
#*
sub SetOffset {
}
 
#** @method SetScale()
#*
sub SetScale {
}
 
#** @method SetSpatialRef()
#*
sub SetSpatialRef {
}
 
#** @method SetUnit()
#*
sub SetUnit {
}
 
#** @method Transpose()
#*
sub Transpose {
}
 
#** @class Geo::GDAL::MajorObject
# @brief An object, which holds meta data.
# @details
#*
package Geo::GDAL::MajorObject;
 
use base qw(Geo::GDAL)
 
#** @method scalar Description($description)
# Object method.
# @param description [optional]
# @return the description in a non-void context.
#*
sub Description {
    my($self, $desc) = @_;
    SetDescription($self, $desc) if defined $desc;
    GetDescription($self) if defined wantarray;
}
 
#** @method Domains()
# Package subroutine.
# @return the class specific DOMAINS list
#*
sub Domains {
    return @DOMAINS;
}
 
#** @method scalar GetDescription()
# Object method.
# @return
#*
sub GetDescription {
}
 
#** @method hash reference GetMetadata($domain = "")
# Object method.
# @note see Metadata
# @param domain
# @return
#*
sub GetMetadata {
}
 
#** @method GetMetadataDomainList()
#*
sub GetMetadataDomainList {
}
 
#** @method hash reference Metadata(hashref metadata = undef, $domain = '')
# Object method.
# @param metadata
# @param domain
# @return the metadata in a non-void context.
#*
sub Metadata {
    my $self = shift,
    my $metadata = ref $_[0] ? shift : undef;
    my $domain = shift // '';
    SetMetadata($self, $metadata, $domain) if defined $metadata;
    GetMetadata($self, $domain) if defined wantarray;
}
 
#** @method SetDescription($NewDesc)
# Object method.
# @param NewDesc
# 
#*
sub SetDescription {
}
 
#** @method SetMetadata(hashref metadata, $domain = "")
# Object method.
# @note see Metadata
# @param metadata
# @param domain
# 
#*
sub SetMetadata {
}
 
#** @class Geo::GDAL::RasterAttributeTable
# @brief An attribute table in a raster band.
# @details
#*
package Geo::GDAL::RasterAttributeTable;
 
use base qw(Geo::GDAL)
 
#** @method Band()
#*
sub Band {
    my $self = shift;
    parent($self);
}
 
#** @method ChangesAreWrittenToFile()
#*
sub ChangesAreWrittenToFile {
}
 
#** @method Geo::GDAL::RasterAttributeTable Clone()
# Object method.
# @return a new Geo::GDAL::RasterAttributeTable object
#*
sub Clone {
}
 
#** @method hash Columns(%columns)
# Object method.
# A get/set method for the columns of the RAT
# @param columns optional, a the keys are column names and the values are anonymous
# hashes with keys Type and Usage
# @return a hash similar to the optional input parameter
#*
sub Columns {
    my $self = shift;
    my %columns;
    if (@_) { # create columns
        %columns = @_;
        for my $name (keys %columns) {
            $self->CreateColumn($name, $columns{$name}{Type}, $columns{$name}{Usage});
        }
    }
    %columns = ();
    for my $c (0..$self->GetColumnCount-1) {
        my $name = $self->GetNameOfCol($c);
        $columns{$name}{Type} = $self->GetTypeOfCol($c);
        $columns{$name}{Usage} = $self->GetUsageOfCol($c);
    }
    return %columns;
}
 
#** @method CreateColumn($name, $type, $usage)
# Object method.
# @param name
# @param type one of FieldTypes
# @param usage one of FieldUsages
#*
sub CreateColumn {
    my($self, $name, $type, $usage) = @_;
    for my $color (qw/Red Green Blue Alpha/) {
        carp "RAT column type will be 'Integer' for usage '$color'." if $usage eq $color and $type ne 'Integer';
    }
    $type = s2i(rat_field_type => $type);
    $usage = s2i(rat_field_usage => $usage);
    _CreateColumn($self, $name, $type, $usage);
}
 
#** @method DumpReadable()
#*
sub DumpReadable {
}
 
#** @method list FieldTypes()
# Package subroutine.
# @return
#*
sub FieldTypes {
    return @FIELD_TYPES;
}
 
#** @method list FieldUsages()
# Package subroutine.
# @return
#*
sub FieldUsages {
    return @FIELD_USAGES;
}
 
#** @method scalar GetColOfUsage($usage)
# Object method.
# @param usage
# @return
#*
sub GetColOfUsage {
    my($self, $usage) = @_;
    _GetColOfUsage($self, s2i(rat_field_usage => $usage));
}
 
#** @method scalar GetColumnCount()
# Object method.
# @return
#*
sub GetColumnCount {
}
 
#** @method scalar GetNameOfCol($column)
# Object method.
# @param column
# @return
#*
sub GetNameOfCol {
}
 
#** @method scalar GetRowCount()
# Object method.
#*
sub GetRowCount {
}
 
#** @method scalar GetRowOfValue($value)
# Object method.
# @param value a cell value
# @return row index or -1
#*
sub GetRowOfValue {
}
 
#** @method GetTableType()
#*
sub GetTableType {
}
 
#** @method scalar GetTypeOfCol($column)
# Object method.
# @param column
# @return
#*
sub GetTypeOfCol {
    my($self, $col) = @_;
    i2s(rat_field_type => _GetTypeOfCol($self, $col));
}
 
#** @method scalar GetUsageOfCol($column)
# Object method.
# @param column
# @return
#*
sub GetUsageOfCol {
    my($self, $col) = @_;
    i2s(rat_field_usage => _GetUsageOfCol($self, $col));
}
 
#** @method scalar GetValueAsDouble($row, $column)
# Object method.
# @param row
# @param column
# @return
#*
sub GetValueAsDouble {
}
 
#** @method scalar GetValueAsInt($row, $column)
# Object method.
# @param row
# @param column
# @return
#*
sub GetValueAsInt {
}
 
#** @method scalar GetValueAsString($row, $column)
# Object method.
# @param row
# @param column
# @return
#*
sub GetValueAsString {
}
 
#** @method LinearBinning($Row0MinIn, $BinSizeIn)
# Object method.
# @param Row0MinIn [optional] the lower bound (cell value) of the first category.
# @param BinSizeIn [optional] the width of each category (in cell value units).
# @return ($Row0MinIn, $BinSizeIn) or an empty list if LinearBinning is not set.
#*
sub LinearBinning {
    my $self = shift;
    SetLinearBinning($self, @_) if @_ > 0;
    return unless defined wantarray;
    my @a = GetLinearBinning($self);
    return $a[0] ? ($a[1], $a[2]) : ();
}
 
#** @method SetRowCount($count)
# Object method.
# @param count
# 
#*
sub SetRowCount {
}
 
#** @method SetTableType()
#*
sub SetTableType {
}
 
#** @method SetValueAsDouble($row, $column, $value)
# Object method.
# @param row
# @param column
# @param value
# 
#*
sub SetValueAsDouble {
}
 
#** @method SetValueAsInt($row, $column, $value)
# Object method.
# @param row
# @param column
# @param value
# 
#*
sub SetValueAsInt {
}
 
#** @method SetValueAsString($row, $column, $value)
# Object method.
# @param row
# @param column
# @param value
# 
#*
sub SetValueAsString {
}
 
#** @method scalar Value($row, $column, $value)
# Object method.
# @param row
# @param column
# @param value [optional]
# @return
#*
sub Value {
    my($self, $row, $column) = @_;
    SetValueAsString($self, $row, $column, $_[3]) if defined $_[3];
    return unless defined wantarray;
    GetValueAsString($self, $row, $column);
}
 
#** @method Geo::GDAL::RasterAttributeTable new()
# Class method.
# @return a new Geo::GDAL::RasterAttributeTable object
#*
sub new {
    my $pkg = shift;
    my $self = Geo::GDALc::new_RasterAttributeTable(@_);
    bless $self, $pkg if defined($self);
}
 
#** @class Geo::GDAL::Statistics
#*
package Geo::GDAL::Statistics;
 
use base qw(Geo::GDAL)
 
#** @method new()
#*
sub new {
    my $pkg = shift;
    my $self = Geo::GDALc::new_Statistics(@_);
    bless $self, $pkg if defined($self);
}
 
#** @class Geo::GDAL::Transformer
# @brief
# @details This class is not yet documented for the GDAL Perl bindings.
# @todo Test and document.
#*
package Geo::GDAL::Transformer;
 
use base qw(Geo::GDAL)
 
#** @method TransformGeolocations()
#*
sub TransformGeolocations {
}
 
#** @method TransformPoint()
#*
sub TransformPoint {
}
 
#** @method new()
#*
sub new {
    my $pkg = shift;
    my $self = Geo::GDALc::new_Transformer(@_);
    bless $self, $pkg if defined($self);
}
 
#** @class Geo::GDAL::VSIF
# @brief A GDAL virtual file system.
# @details
#*
package Geo::GDAL::VSIF;
 
use base qw(Exporter)
 
#** @method Close()
# Object method.
#*
sub Close {
    my ($self) = @_;
    Geo::GDAL::VSIFCloseL($self);
}
 
#** @method Flush()
#*
sub Flush {
    my ($self) = @_;
    Geo::GDAL::VSIFFlushL($self);
}
 
#** @method MkDir($path)
# Package subroutine.
# Make a directory.
# @param path The directory to make.
# @note The name of this method is VSIMkdir in GDAL.
#*
sub MkDir {
    my ($path) = @_;
    # mode unused in CPL
    Geo::GDAL::Mkdir($path, 0);
}
 
#** @method Geo::GDAL::VSIF Open($filename, $mode)
# Package subroutine.
# @param filename Name of the file to open. For example "/vsimem/x".
# @param mode Access mode. 'r', 'r+', 'w', etc.
# @return A file handle on success.
#*
sub Open {
    my ($path, $mode) = @_;
    my $self = Geo::GDAL::VSIFOpenL($path, $mode);
    bless $self, 'Geo::GDAL::VSIF';
}
 
#** @method scalar Read($count)
# Object method.
# @param count The number of bytes to read from the file.
# @return A byte string.
#*
sub Read {
    my ($self, $count) = @_;
    Geo::GDAL::VSIFReadL($count, $self);
}
 
#** @method list ReadDir($dir)
# Package subroutine.
# @return Contents of a directory in an anonymous array or as a list.
#*
sub ReadDir {
    my ($path) = @_;
    Geo::GDAL::ReadDir($path);
}
 
#** @method scalar ReadDirRecursive($dir)
# Package subroutine.
# @note Give the directory in the form '/vsimem', i.e., without trailing '/'.
# @return Contents of a directory tree in an anonymous array.
#*
sub ReadDirRecursive {
    my ($path) = @_;
    Geo::GDAL::ReadDirRecursive($path);
}
 
#** @method Rename($old, $new)
# Package subroutine.
# Rename a file.
# @note The name of this method is VSIRename in GDAL.
#*
sub Rename {
    my ($old, $new) = @_;
    Geo::GDAL::Rename($old, $new);
}
 
#** @method RmDir($path)
# Package subroutine.
# Remove a directory.
# @note The name of this method is VSIRmdir in GDAL.
#*
sub RmDir {
    my ($dirname, $recursive) = @_;
    eval {
        if (!$recursive) {
            Geo::GDAL::Rmdir($dirname);
        } else {
            for my $f (ReadDir($dirname)) {
                next if $f eq '..' or $f eq '.';
                my @s = Stat($dirname.'/'.$f);
                if ($s[0] eq 'f') {
                    Unlink($dirname.'/'.$f);
                } elsif ($s[0] eq 'd') {
                    Rmdir($dirname.'/'.$f, 1);
                    Rmdir($dirname.'/'.$f);
                }
            }
            RmDir($dirname);
        }
    };
    if ($@) {
        my $r = $recursive ? ' recursively' : '';
        error("Cannot remove directory \"$dirname\"$r.");
    }
}
 
#** @method Seek($offset, $whence)
# Object method.
#*
sub Seek {
    my ($self, $offset, $whence) = @_;
    Geo::GDAL::VSIFSeekL($self, $offset, $whence);
}
 
#** @method list Stat($filename)
# Package subroutine.
# @return ($filemode, $filesize). filemode is f for a plain file, d
# for a directory, l for a symbolic link, p for a named pipe (FIFO), S
# for a socket, b for a block special file, and c for a character
# special file.
#*
sub Stat {
    my ($path) = @_;
    Geo::GDAL::Stat($path);
}
 
#** @method scalar Tell()
# Object method.
#*
sub Tell {
    my ($self) = @_;
    Geo::GDAL::VSIFTellL($self);
}
 
#** @method Truncate($new_size)
# Object method.
#*
sub Truncate {
    my ($self, $new_size) = @_;
    Geo::GDAL::VSIFTruncateL($self, $new_size);
}
 
#** @method Unlink($filename)
# Package subroutine.
# @param filename The file to delete.
# @return 0 on success and -1 on an error.
#*
sub Unlink {
    my ($filename) = @_;
    Geo::GDAL::Unlink($filename);
}
 
#** @method Write($scalar)
# Object method.
# @param scalar The byte string to write to the file.
# @return Number of bytes written into the file.
#*
sub Write {
    my ($self, $data) = @_;
    Geo::GDAL::VSIFWriteL($data, $self);
}
 
#** @class Geo::GDAL::VSILFILE
#*
package Geo::GDAL::VSILFILE;
 
use base qw(Geo::GDAL)
 
#** @class Geo::GDAL::XML
# @brief A simple XML parser
# @details
#*
package Geo::GDAL::XML;
 
#** @method new($string)
# Object method.
# @param string String containing XML.
# @return A new Geo::GDAL::XML object, which is a reference to an anonymous array.
#*
sub new {
    my $class = shift;
    my $xml = shift // '';
    my $self = ParseXMLString($xml);
    bless $self, $class;
    $self->traverse(sub {my $node = shift; bless $node, $class});
    return $self;
}
 
#** @method serialize()
# Object method.
# @return The XML serialized into a string.
#*
sub serialize {
    my $self = shift;
    return SerializeXMLTree($self);
}
1;
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.1
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
}
 
#** @method traverse(coderef subroutine)
# Object method.
# @param subroutine Code reference, which will be called for each node in the XML with parameters: node, node_type, node_value. Node type is either Attribute, Comment, Element, Literal, or Text.
#*
sub traverse {
    my ($self, $sub) = @_;
    my $type = $self->[0];
    my $data = $self->[1];
    $type = NodeType($type);
    $sub->($self, $type, $data);
    for my $child (@{$self}[2..$#$self]) {
        traverse($child, $sub);
    }
}
 
#** @class Geo::GNM
# @brief Base class for geographical networks in GDAL.
# @details
#*
package Geo::GNM;
 
#** @method CastToGenericNetwork()
#*
sub CastToGenericNetwork {
}
 
#** @method CastToNetwork()
#*
sub CastToNetwork {
}
 
#** @method GATConnectedComponents()
#*
sub GATConnectedComponents {
}
 
#** @method GATDijkstraShortestPath()
#*
sub GATDijkstraShortestPath {
}
 
#** @method GATKShortestPath()
#*
sub GATKShortestPath {
}
 
#** @method GNM_EDGE_DIR_BOTH()
#*
sub GNM_EDGE_DIR_BOTH {
}
 
#** @method GNM_EDGE_DIR_SRCTOTGT()
#*
sub GNM_EDGE_DIR_SRCTOTGT {
}
 
#** @method GNM_EDGE_DIR_TGTTOSRC()
#*
sub GNM_EDGE_DIR_TGTTOSRC {
     1;
}
 
#** @class Geo::GNM::GenericNetwork
# @details
#*
package Geo::GNM::GenericNetwork;
 
use base qw(Geo::GNM::Network Geo::GNM)
 
#** @method ChangeAllBlockState()
#*
sub ChangeAllBlockState {
}
 
#** @method ChangeBlockState()
#*
sub ChangeBlockState {
}
 
#** @method ConnectFeatures()
#*
sub ConnectFeatures {
}
 
#** @method ConnectPointsByLines()
#*
sub ConnectPointsByLines {
}
 
#** @method CreateRule()
#*
sub CreateRule {
}
 
#** @method DeleteAllRules()
#*
sub DeleteAllRules {
}
 
#** @method DeleteRule()
#*
sub DeleteRule {
}
 
#** @method DisconnectFeatures()
#*
sub DisconnectFeatures {
}
 
#** @method DisconnectFeaturesWithId()
#*
sub DisconnectFeaturesWithId {
}