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 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 GOA2GetAccessToken()
#*
sub GOA2GetAccessToken {
}

#** @method GOA2GetAuthorizationURL()
#*
sub GOA2GetAuthorizationURL {
}

#** @method GOA2GetRefreshToken()
#*
sub GOA2GetRefreshToken {
}

#** @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 GetJPEG2000StructureAsString()
#*
sub GetJPEG2000StructureAsString {
}

#** @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 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, 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 RELEASE_PARENT()
#*
sub RELEASE_PARENT {
}

#** @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, Mode, and NearestNeighbour.
#*
sub ResamplingTypes {
    return @RESAMPLING_TYPES;
}

#** @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 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 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 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 i2s()
#*
sub i2s {
    my ($class, $int) = @_;
    return $I2S{$class}{$int} if exists $I2S{$class}{$int};
    return $int;
}

#** @method keep()
#*
sub keep {
   my ($child, $parent) = @_;
   $keeper{tied(%$child)} = $parent;
   return $child;
}
# this is called from RELEASE_PARENT, so the child is already the tied one
}

#** @method note()
#*
sub note {
   my ($object, $note) = @_;
   if (defined wantarray) {
       return unless $note{$object};
       return $notes{$object}{$note};
   }
   $notes{$object}{$note} = 1;
}

#** @method parent()
#*
sub parent {
   my ($child) = @_;
   $child = tied(%$child) if $child->isa('HASH');
   return $keeper{$child};
}

#** @method s2i()
#*
sub s2i {
    my ($class, $string, $backwards, $default) = @_;
    $string = $default if defined $default && !defined $string;
    return unless defined $string;
    return $string if $backwards && exists $I2S{$class}{$string};
    error(1, $string, $S2I{$class}) unless exists $S2I{$class}{$string};
    $S2I{$class}{$string};
}

#** @method s_exists()
#*
sub s_exists {
    my ($class, $string) = @_;
    return exists $S2I{$class}{$string};
}

#** @method unkeep()
#*
sub unkeep {
   my ($child) = @_;
   delete $keeper{$child};
}

#** @method unnote()
#*
sub unnote {
   my ($object, $note) = @_;
   if ($note) {
       delete $notes{$object}{$note};
   } else {
       delete $notes{$object};
   }
}

#** @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::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 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. Do not specify
# one for integer bands.
# @note NoData values are counted similar to other values.
# 
# @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 numeric
# value against which the reclassified value is compared to.
# @note Numeric value requires decimal point.
# 
# In the example below, the real line is divided into ranges
# [-inf..3), [3..5), and [5..inf], i.e., three ranges with indexes 0,
# 1, and 2.
# \code
# $classifier = [ '<', [5.0, [3.0, 1.0, 2.0], 3.0] ];
# \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 RELEASE_PARENT()
#*
sub RELEASE_PARENT {
    my $self = shift;
    unkeep($self);
}

#** @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 This method is defined only for integer bands.
# @note NoData values are reclassified if explicitly specified in the
# map. However, they are not reclassified to the default value, if one
# is specified.
# @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. A
# special key '*' (star) can be used as default, to act as a fallback
# new class value. For float rasters 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 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 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 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, GeometryType is 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 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 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 RELEASE_PARENT()
#*
sub RELEASE_PARENT {
    my $self = shift;
    unkeep($self);
}

#** @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 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::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, 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 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::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::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::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 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 RELEASE_PARENT()
#*
sub RELEASE_PARENT {
    my $self = shift;
    unkeep($self);
}

#** @method SetRowCount($count)
# Object method.
# @param count
# 
#*
sub SetRowCount {
}

#** @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::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(our Exporter)

#** @method Close()
# Object method.
#*
sub Close {
    my ($self, $data) = @_;
    Geo::GDAL::VSIFCloseL($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::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 2.0.7
#
# 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 {
}

#** @method GetRules()
#*
sub GetRules {
}

#** @method ReconnectFeatures()
#*
sub ReconnectFeatures {
}

#** @class Geo::GNM::MajorObject
# @details
#*
package Geo::GNM::MajorObject;

#** @class Geo::GNM::Network
# @details
#*
package Geo::GNM::Network;

use base qw(Geo::GDAL::MajorObject Geo::GNM)

#** @method CommitTransaction()
#*
sub CommitTransaction {
}

#** @method CopyLayer()
#*
sub CopyLayer {
}

#** @method DisconnectAll()
#*
sub DisconnectAll {
}

#** @method GetFeatureByGlobalFID()
#*
sub GetFeatureByGlobalFID {
}

#** @method GetFileList()
#*
sub GetFileList {
}

#** @method GetLayerByIndex()
#*
sub GetLayerByIndex {
}

#** @method GetLayerByName()
#*
sub GetLayerByName {
}

#** @method GetLayerCount()
#*
sub GetLayerCount {
}

#** @method GetName()
#*
sub GetName {
}

#** @method GetPath()
#*
sub GetPath {
}

#** @method GetProjection()
#*
sub GetProjection {
}

#** @method GetProjectionRef()
#*
sub GetProjectionRef {
}

#** @method GetVersion()
#*
sub GetVersion {
}

#** @method RollbackTransaction()
#*
sub RollbackTransaction {
}

#** @method StartTransaction()
#*
sub StartTransaction {
}

#** @class Geo::OGR
# @brief OGR utility functions.
# @details A wrapper for many OGR utility functions and a root class for all
# OGR classes.
#*
package Geo::OGR;

#** @method list ByteOrders()
# Package subroutine.
# @return a list of byte order types, XDR and NDR. XDR denotes
# big-endian and NDR denotes little-endian.
#*
sub ByteOrders {
}

#** @method Geo::GDAL::Driver Driver($name)
# Package subroutine.
# A.k.a GetDriver.
# @param name the short name of the driver.
# @note No check is made that the driver is actually a vector driver.
# @return a Geo::GDAL::Driver object.
#*
sub Driver {
    return 'Geo::GDAL::Driver' unless @_;
    bless Geo::GDAL::Driver(@_), 'Geo::OGR::Driver';
}

#** @method list DriverNames()
# Package subroutine.
# A.k.a GetDriverNames
# \code
# perl -MGeo::GDAL -e '@d=Geo::OGR::DriverNames;print "@d\n"'
# \endcode
# @note Use Geo::GDAL::DriverNames for raster drivers.
# @return a list of the short names of all available GDAL vector drivers.
#*
sub DriverNames {
}

#** @method list Drivers()
# Package subroutine.
# @note Use Geo::GDAL::Drivers for raster drivers.
# @return a list of all available GDAL vector drivers.
#*
sub Drivers {
    my @drivers;
    for my $i (0..GetDriverCount()-1) {
        my $driver = Geo::GDAL::GetDriver($i);
        push @drivers, $driver if $driver->TestCapability('VECTOR');
    }
    return @drivers;
}

#** @method Flatten()
#*
sub Flatten {
}

#** @method scalar GeometryTypeModify($type, $modifier)
# Object method.
# @param type a geometry type (one of Geo::OGR::GeometryTypes).
# @param modifier one of 'flatten', 'set_Z', 'make_collection', 'make_curve', or 'make_linear'.
# @return modified geometry type.
#*
sub GeometryTypeModify {
    my($type, $modifier) = @_;
    $type = s2i(geometry_type => $type);
    return i2s(geometry_type => GT_Flatten($type)) if $modifier =~ /flat/i;
    return i2s(geometry_type => GT_SetZ($type)) if $modifier =~ /z/i;
    return i2s(geometry_type => GT_GetCollection($type)) if $modifier =~ /collection/i;
    return i2s(geometry_type => GT_GetCurve($type)) if $modifier =~ /curve/i;
    return i2s(geometry_type => GT_GetLinear($type)) if $modifier =~ /linear/i;
    error(1, $modifier, {Flatten => 1, SetZ => 1, GetCollection => 1, GetCurve => 1, GetLinear => 1});
}

#** @method scalar GeometryTypeTest($type, $test, $type2)
# Object method.
# @param type a geometry type (one of Geo::OGR::GeometryTypes).
# @param test one of 'has_z', 'is_subclass_of', 'is_curve', 'is_surface', or 'is_non_linear'.
# @param type2 a geometry type (one of Geo::OGR::GeometryTypes). Required for 'is_subclass_of' test.
# @return result of the test.
#*
sub GeometryTypeTest {
    my($type, $test, $type2) = @_;
    $type = s2i(geometry_type => $type);
    if (defined $type2) {
        $type = s2i(geometry_type => $type);
    } else {
        error("Usage: GeometryTypeTest(type1, 'is_subclass_of', type2).") if $test =~ /subclass/i;
    }
    return GT_HasZ($type) if $test =~ /z/i;
    return GT_IsSubClassOf($type, $type2) if $test =~ /subclass/i;
    return GT_IsCurve($type) if $test =~ /curve/i;
    return GT_IsSurface($type) if $test =~ /surface/i;
    return GT_IsNonLinear($type) if $test =~ /linear/i;
    error(1, $test, {HasZ => 1, IsSubClassOf => 1, IsCurve => 1, IsSurface => 1, IsNonLinear => 1});
}

#** @method list GeometryTypes()
# Package subroutine.
# @return a list of all geometry types, currently:
# CircularString, CircularStringM, CircularStringZ, CircularStringZM, CompoundCurve, CompoundCurveM, CompoundCurveZ, CompoundCurveZM, Curve, CurveM, CurvePolygon, CurvePolygonM, CurvePolygonZ, CurvePolygonZM, CurveZ, CurveZM, GeometryCollection, GeometryCollection25D, GeometryCollectionM, GeometryCollectionZM, LineString, LineString25D, LineStringM, LineStringZM, LinearRing, MultiCurve, MultiCurveM, MultiCurveZ, MultiCurveZM, MultiLineString, MultiLineString25D, MultiLineStringM, MultiLineStringZM, MultiPoint, MultiPoint25D, MultiPointM, MultiPointZM, MultiPolygon, MultiPolygon25D, MultiPolygonM, MultiPolygonZM, MultiSurface, MultiSurfaceM, MultiSurfaceZ, MultiSurfaceZM, None, Point, Point25D, PointM, PointZM, Polygon, Polygon25D, PolygonM, PolygonZM, PolyhedralSurface, PolyhedralSurfaceM, PolyhedralSurfaceZ, PolyhedralSurfaceZM, Surface, SurfaceM, SurfaceZ, SurfaceZM, TIN, TINM, TINZ, TINZM, Triangle, TriangleM, TriangleZ, TriangleZM, and Unknown.
#*
sub GeometryTypes {
     1;
     # This file was automatically generated by SWIG (http://www.swig.org).
     # Version 2.0.7
     #
     # Do not make changes to this file unless you know what you are doing--modify
     # the SWIG interface file instead.
}

#** @method GetNonLinearGeometriesEnabledFlag()
#*
sub GetNonLinearGeometriesEnabledFlag {
}

#** @method GetOpenDSCount()
#*
sub GetOpenDSCount {
}

#** @method HasM()
#*
sub HasM {
}

#** @method HasZ()
#*
sub HasZ {
}

#** @method Geo::GDAL::Dataset Open($name, $update = 0)
# Object method.
# Open a vector data source.
# @param name The data source string (directory, filename, etc.).
# @param update Whether to open the data source in update mode (default is not).
# @return a new Geo::GDAL::Dataset object.
#*
sub Open {
    my @p = @_; # name, update
    my @flags = qw/VECTOR/;
    push @flags, qw/UPDATE/ if $p[1];
    my $dataset = Geo::GDAL::OpenEx($p[0], \@flags);
    error("Failed to open $p[0]. Is it a vector dataset?") unless $dataset;
    return $dataset;
}

#** @method Geo::GDAL::Dataset OpenShared($name, $update = 0)
# Object method.
# Open a vector data source in shared mode.
# @param name The data source string (directory, filename, etc.).
# @param update Whether to open the data source in update mode.
# @return a new Geo::GDAL::Dataset object.
#*
sub OpenShared {
    my @p = @_; # name, update
    my @flags = qw/VECTOR SHARED/;
    push @flags, qw/UPDATE/ if $p[1];
    my $dataset = Geo::GDAL::OpenEx($p[0], \@flags);
    error("Failed to open $p[0]. Is it a vector dataset?") unless $dataset;
    return $dataset;
}

#** @method RELEASE_PARENT()
#*
sub RELEASE_PARENT {
}

#** @method SetGenerate_DB2_V72_BYTE_ORDER($Generate_DB2_V72_BYTE_ORDER)
# Object method.
# Needed only on IBM DB2.
#*
sub SetGenerate_DB2_V72_BYTE_ORDER {
}

#** @method SetNonLinearGeometriesEnabledFlag()
#*
sub SetNonLinearGeometriesEnabledFlag {
}

#** @class Geo::OGR::DataSource
# @brief A vector dataset.
# @details This is a legacy class which should not be
# used in new code. Use Geo::GDAL::Dataset.
#*
package Geo::OGR::DataSource;

#** @method Geo::GDAL::Dataset Open()
# Package subroutine.
# The same as Geo::OGR::Open
#*
sub Open {
}

#** @method Geo::GDAL::Dataset OpenShared()
# Package subroutine.
# The same as Geo::OGR::OpenShared
#*
sub OpenShared {
}

#** @class Geo::OGR::Driver
# @brief A vector format driver.
# @details This is a legacy class which
# should not be used in new code. Use Geo::GDAL::Driver.
#*
package Geo::OGR::Driver;

use base qw(our /Geo::GDAL::Driver/)

#** @method Geo::GDAL::Dataset Copy(Geo::GDAL::Dataset source, $name, arrayref options = undef)
# Object method.
# Copy a vector data source into a new data source with this driver.
# @param source The Geo::GDAL::Dataset object to be copied.
# @param name The name for the new data source.
# @param options Driver specific options. In addition to options
# specified in GDAL documentation the option STRICT can be set to 'NO'
# for a more relaxed copy. Otherwise the STRICT is 'YES'.
# @note The order of the first two parameters is different from that in Geo::GDAL::Driver::Copy.
# @return a new Geo::GDAL::Dataset object.
#*
sub Copy {
    my ($self, @p) = @_; # src, name, options
    my $strict = 1; # the default in bindings
    $strict = 0 if $p[2] && $p[2]->{STRICT} eq 'NO';
    $self->SUPER::Copy($p[1], $p[0], $strict, @{$p[2..4]}); # path, src, strict, options, cb, cb_data
}

#** @method Geo::GDAL::Dataset Create($name, hashref options = undef )
# Object method.
# Create a new vector data source using this driver.
# @param name The data source name.
# @param options Driver specific dataset creation options.
#*
sub Create {
    my ($self, $name, $options) = @_; # name, options
    $options //= {};
    $self->SUPER::Create(Name => $name, Width => 0, Height => 0, Bands => 0, Type => 'Byte', Options => $options);
}

#** @method Open()
# Object method.
# The same as Geo::OGR::Open except that only this driver is allowed.
#*
sub Open {
    my $self = shift;
    my @p = @_; # name, update
    my @flags = qw/VECTOR/;
    push @flags, qw/UPDATE/ if $p[1];
    my $dataset = Geo::GDAL::OpenEx($p[0], \@flags, [$self->Name()]);
    error("Failed to open $p[0]. Is it a vector dataset?") unless $dataset;
    return $dataset;
}

#** @class Geo::OGR::Feature
# @brief A collection of non-spatial and spatial attributes.
# @details A feature is a collection of non-spatial and spatial attributes and
# an id, which is a special attribute, and data records according to
# this data model. Attributes are called fields and some fields are
# spatial, i.e., their value is a geometry. Fields have at least a
# name and a type. Features may exist within a layer or
# separetely. The data model of a feature is a definition object.
#*
package Geo::OGR::Feature;

use base qw(Geo::OGR)

#** @method Geo::OGR::Feature Clone()
# Object method.
# @return a new Geo::OGR::Feature object
#*
sub Clone {
}

#** @method DumpReadable()
# Object method.
# Write the contents of this feature to stdout.
#*
sub DumpReadable {
}

#** @method scalar Equal($feature)
# Object method.
# @param feature a Geo::OGR::Feature object for comparison
# @return boolean
#*
sub Equal {
}

#** @method scalar FID($id)
# Object method.
# @brief Get or set the id of this feature.
# @param id [optional] the id to set for this feature.
# @return integer the id of this feature.
#*
sub FID {
    my $self = shift;
    $self->SetFID($_[0]) if @_;
    return unless defined wantarray;
    $self->GetFID;
}

#** @method Field($name, $value, ...)
# Object method.
# @brief Get, set, or unset the field value.
# @param name the name (or the index) of the field.
# @param value a scalar, a list of scalars or a reference to a
# list. If undef, the field is unset. If a scalar or a list of
# scalars, the field is set from them.
# @note Non-scalar fields (for example Date) can be set either from a
# scalar, which is then assumed to be a string and parsed, or from a
# list of values (for example year, month, day for Date).
# @note Setting and getting Integer64 fields requires 'use bigint' if
# \$Config{ivsize} is smaller than 8, i.e., in a 32 bit machine.
# @return in non-void context the value of the field, which may be a
# scalar or a list, depending on the field type. For unset fields the
# undef value is returned.
#*
sub Field {
    my $self = shift;
    my $field = $self->GetFieldIndex(shift // 0);
    $self->SetField($field, @_) if @_;
    $self->GetField($field) if defined wantarray;
}

#** @method FillUnsetWithDefault()
#*
sub FillUnsetWithDefault {
}

#** @method Geometry($name, $geometry)
# Object method.
# @brief Get or set the value of a geometry field.
# @note This method delivers the functionality of undocumented methods
# SetGeometry($geometry), SetGeometryDirectly, SetGeomField,
# SetGeomFieldDirectly, GetGeometry, GetGeometryRef.
# 
# Set or get the geometry in the feature. When setting, does a check
# against the schema (GeometryType) of the feature. If the parameter
# is a geometry object, it is cloned.
# @param name [optional] the name of the spatial field,
# whose geometry is to be set. If not given, sets or gets the geometry
# of the first (or the single) spatial field.
# @param geometry [optional] a Geo::OGR::Geometry object or a
# reference to a hash from which such can be created (using
# Geo::OGR::Geometry::new).
# @return in a non-void context the indicated geometry in the feature
# as a Geo::OGR::Geometry object. The returned object contains a
# reference to the actual geometry data in the feature (the geometry
# is not cloned) and to the feature object, thus keeping the feature
# object from being destroyed while the geometry object exists.
#*
sub Geometry {
    my $self = shift;
    my $field = ((@_ > 0 and ref($_[0]) eq '') or (@_ > 2 and @_ % 2 == 1)) ? shift : 0;
    $field = $self->GetGeomFieldIndex($field);
    my $geometry;
    if (@_ and @_ % 2 == 0) {
        %$geometry = @_;
    } else {
        $geometry = shift;
    }
    if ($geometry) {
        my $type = $self->GetDefn->GetGeomFieldDefn($field)->Type;
        if (blessed($geometry) and $geometry->isa('Geo::OGR::Geometry')) {
            my $gtype = $geometry->GeometryType;
            error("The type of the inserted geometry ('$gtype') is not the same as the type of the field ('$type').")
                if $type ne 'Unknown' and $type ne $gtype;
            eval {
                $self->SetGeomFieldDirectly($field, $geometry->Clone);
            };
            confess last_error() if $@;
        } elsif (ref($geometry) eq 'HASH') {
            $geometry->{GeometryType} //= $type;
            eval {
                $geometry = Geo::OGR::Geometry->new($geometry);
            };
            my $gtype = $geometry->GeometryType;
            error("The type of the inserted geometry ('$gtype') is not the same as the type of the field ('$type').")
                if $type ne 'Unknown' and $type ne $gtype;
            eval {
                $self->SetGeomFieldDirectly($field, $geometry);
            };
            confess last_error() if $@;
        } else {
            error("Usage: \$feature->Geometry([field],[geometry])");
        }
    }
    return unless defined wantarray;
    $geometry = $self->GetGeomFieldRef($field);
    return unless $geometry;
    keep($geometry, $self);
}

#** @method Geo::OGR::FeatureDefn GetDefn()
# Object method.
# @note A.k.a GetDefnRef.
# @return a Geo::OGR::FeatureDefn object, which represents the definition of this feature.
#*
sub GetDefn {
    my $self = shift;
    my $defn = $self->GetDefnRef;
    keep($defn, $self);
}

#** @method scalar GetFID()
# Object method.
# @return the feature id (an integer).
#*
sub GetFID {
}

#** @method list GetField($name)
# Object method.
# See Field().
#*
sub GetField {
    my ($self, $field) = @_;
    $field = $self->GetFieldIndex($field);
    return unless IsFieldSet($self, $field);
    my $type = GetFieldType($self, $field);
    return GetFieldAsInteger($self, $field) if $type == $Geo::OGR::OFTInteger;
    return GetFieldAsInteger64($self, $field) if $type == $Geo::OGR::OFTInteger64;
    return GetFieldAsDouble($self, $field) if $type == $Geo::OGR::OFTReal;
    return GetFieldAsString($self, $field) if $type == $Geo::OGR::OFTString;
    if ($type == $Geo::OGR::OFTIntegerList) {
        my $ret = GetFieldAsIntegerList($self, $field);
        return wantarray ? @$ret : $ret;
    }
    if ($type == $Geo::OGR::OFTInteger64List) {
        my $ret = GetFieldAsInteger64List($self, $field);
        return wantarray ? @$ret : $ret;
    }
    if ($type == $Geo::OGR::OFTRealList) {
        my $ret = GetFieldAsDoubleList($self, $field);
        return wantarray ? @$ret : $ret;
    }
    if ($type == $Geo::OGR::OFTStringList) {
        my $ret = GetFieldAsStringList($self, $field);
        return wantarray ? @$ret : $ret;
    }
    if ($type == $Geo::OGR::OFTBinary) {
        return GetFieldAsBinary($self, $field);
    }
    if ($type == $Geo::OGR::OFTDate) {
        my @ret = GetFieldAsDateTime($self, $field);
        # year, month, day, hour, minute, second, timezone
        return wantarray ? @ret[0..2] : [@ret[0..2]];
    }
    if ($type == $Geo::OGR::OFTTime) {
        my @ret = GetFieldAsDateTime($self, $field);
        return wantarray ? @ret[3..6] : [@ret[3..6]];
    }
    if ($type == $Geo::OGR::OFTDateTime) {
        my @ret = GetFieldAsDateTime($self, $field);
        return wantarray ? @ret : [@ret];
    }
    error("Perl bindings do not support the field type '".i2s(field_type => $type)."'.");
}

#** @method scalar GetFieldDefn($name)
# Object method.
# Get the definition of a field.
# @param name the name of the field.
# @return a Geo::OGR::FieldDefn object.
#*
sub GetFieldDefn {
    my $self = shift;
    my $field = $self->GetFieldIndex(shift);
    return $self->GetFieldDefnRef($field);
}

#** @method list GetFieldNames()
# Object method.
# Get the names of the fields in this feature.
#*
sub GetFieldNames {
}

#** @method scalar GetGeomFieldDefn($name)
# Object method.
# Get the definition of a spatial field.
# @param name the name of the spatial field.
# @return a Geo::OGR::GeomFieldDefn object.
#*
sub GetGeomFieldDefn {
    my $self = shift;
    my $field = $self->GetGeomFieldIndex(shift);
    return $self->GetGeomFieldDefnRef($field);
}

#** @method GetNativeData()
#*
sub GetNativeData {
}

#** @method GetNativeMediaType()
#*
sub GetNativeMediaType {
}

#** @method hash reference GetSchema()
# Object method.
# @brief Get the schema of this feature.
# 
# @return the schema as a hash whose keywords are Name, StyleIgnored
# and Fields. Fields is an anonymous array of first non-spatial and
# then spatial field schemas as in Geo::OGR::FieldDefn::Schema() and
# Geo::OGR::GeomFieldDefn::Schema().
#*
sub GetSchema {
    my $self = shift;
    error("Schema of a feature cannot be set directly.") if @_;
    return $self->GetDefnRef->Schema;
}

#** @method scalar GetStyleString()
# Object method.
# @return a string
#*
sub GetStyleString {
}

#** @method IsFieldNull()
#*
sub IsFieldNull {
}

#** @method IsFieldSetAndNotNull()
#*
sub IsFieldSetAndNotNull {
}

#** @method Geo::OGR::Layer Layer()
# Object method.
# @return the layer to which this feature belongs to or undef.
#*
sub Layer {
    my $self = shift;
    parent($self);
}

#** @method RELEASE_PARENT()
#*
sub RELEASE_PARENT {
    my $self = shift;
    unkeep($self);
}

#** @method hash reference Row(%row)
# Object method.
# @note This method discards the data the destination feature (or
# layer) does not support. Changes in data due to differences between
# field types may also occur.
# 
# Get and/or set the data of the feature. The key of the (key,value)
# pairs of the row is the field name. Special field names FID and
# Geometry are used for feature id and (single) geometry
# respectively. The geometry/ies is/are set and get using the
# Geo::OGR::Feature::Geometry method. Field values are set using the
# Geo::OGR::Feature::Field method.
# @param row [optional] feature data in a hash.
# @return a reference to feature data in a hash. Spatial fields are
# returned as Geo::OGR::Geometry objects.
#*
sub Row {
    my $self = shift;
    my $nf = $self->GetFieldCount;
    my $ngf = $self->GetGeomFieldCount;
    if (@_) { # update
        my %row;
        if (@_ == 1 and ref($_[0]) eq 'HASH') {
            %row = %{$_[0]};
        } elsif (@_ and @_ % 2 == 0) {
            %row = @_;
        } else {
            error('Usage: $feature->Row(%FeatureData).');
        }
        $self->SetFID($row{FID}) if defined $row{FID};
        #$self->Geometry($schema, $row{Geometry}) if $row{Geometry};
        for my $name (keys %row) {
            next if $name eq 'FID';
            if ($name eq 'Geometry') {
                $self->Geometry(0, $row{$name});
                next;
            }
            my $f = 0;
            for my $i (0..$nf-1) {
                if ($self->GetFieldDefnRef($i)->Name eq $name) {
                    $self->SetField($i, $row{$name});
                    $f = 1;
                    last;
                }
            }
            next if $f;
            for my $i (0..$ngf-1) {
                if ($self->GetGeomFieldDefnRef($i)->Name eq $name) {
                    $self->Geometry($i, $row{$name});
                    $f = 1;
                    last;
                }
            }
            next if $f;
            carp "Unknown field: '$name'.";
        }
    }
    return unless defined wantarray;
    my %row = ();
    for my $i (0..$nf-1) {
        my $name = $self->GetFieldDefnRef($i)->Name;
        $row{$name} = $self->GetField($i);
    }
    for my $i (0..$ngf-1) {
        my $name = $self->GetGeomFieldDefnRef($i)->Name || 'Geometry';
        $row{$name} = $self->GetGeometry($i);
    }
    $row{FID} = $self->GetFID;
    return \%row;
}

#** @method SetFID($id)
# Object method.
# @param id the feature id.
#*
sub SetFID {
}

#** @method SetField($name, @Value)
# Object method.
# See Field().
#*
sub SetField {
    my $self = shift;
    my $field = $self->GetFieldIndex(shift);
    my $arg = $_[0];
    if (@_ == 0 or !defined($arg)) {
        _UnsetField($self, $field);
        return;
    }
    $arg = [@_] if @_ > 1;
    my $type = $self->GetFieldType($field);
    if (ref($arg)) {
        if ($type == $Geo::OGR::OFTIntegerList) {
            SetFieldIntegerList($self, $field, $arg);
        }
        elsif ($type == $Geo::OGR::OFTInteger64List) {
            SetFieldInteger64List($self, $field, $arg);
        }
        elsif ($type == $Geo::OGR::OFTRealList) {
            SetFieldDoubleList($self, $field, $arg);
        }
        elsif ($type == $Geo::OGR::OFTStringList) {
            SetFieldStringList($self, $field, $arg);
        }
        elsif ($type == $Geo::OGR::OFTDate) {
            _SetField($self, $field, @$arg[0..2], 0, 0, 0, 0);
        }
        elsif ($type == $Geo::OGR::OFTTime) {
            $arg->[3] //= 0;
            _SetField($self, $field, 0, 0, 0, @$arg[0..3]);
        }
        elsif ($type == $Geo::OGR::OFTDateTime) {
            $arg->[6] //= 0;
            _SetField($self, $field, @$arg[0..6]);
        }
        elsif ($type == $Geo::OGR::OFTInteger64)
        {
            SetFieldInteger64($self, $field, $arg);
        }
        else {
            $type = i2s(field_type => $type);
            my $name = $self->GetFieldDefnRef($field)->Name;
            error("'$arg' is not a suitable value for field $name($type).");
        }
    } else {
        if ($type == $Geo::OGR::OFTBinary) {
            #$arg = unpack('H*', $arg); # remove when SetFieldBinary is available
            $self->SetFieldBinary($field, $arg);
        }
        elsif ($type == $Geo::OGR::OFTInteger64)
        {
            SetFieldInteger64($self, $field, $arg);
        }
        elsif ($type == $Geo::OGR::OFTInteger or $type == $Geo::OGR::OFTReal or $type == $Geo::OGR::OFTString)
        {
            _SetField($self, $field, $arg);
        }
        else {
            $type = i2s(field_type => $type);
            my $name = $self->GetFieldDefnRef($field)->Name;
            error("'$arg' is not a suitable value for field $name($type).");
        }
    }
}

#** @method SetFieldNull()
#*
sub SetFieldNull {
}

#** @method SetFrom($other, $forgiving = 1, hashref map)
# Object method.
# @param other a Geo::OGR::Feature object
# @param forgiving [optional] set to false if the operation should not
# continue if output fields do not match some of the source fields
# @param map [optional] a mapping from output field indexes to source
# fields, include into the hash all field indexes of this feature
# which should be set
#*
sub SetFrom {
    my($self, $other) = @_;
    _SetFrom($self, $other), return if @_ <= 2;
    my $forgiving = $_[2];
    _SetFrom($self, $other, $forgiving), return if @_ <= 3;
    my $map = $_[3];
    my @list;
    for my $i (1..GetFieldCount($self)) {
        push @list, ($map->{$i} || -1);
    }
    SetFromWithMap($self, $other, 1, \@list);
}

#** @method SetNativeData()
#*
sub SetNativeData {
}

#** @method SetNativeMediaType()
#*
sub SetNativeMediaType {
}

#** @method SetStyleString($string)
# Object method.
# @param string
#*
sub SetStyleString {
}

#** @method list Tuple(@tuple)
# Object method.
# @note This method discards the data the destination feature (or
# layer) does not support. Changes in data due to differences between
# field types may also occur.
# 
# @note The schema of the tuple needs to be the same as that of the
# feature.
# 
# Get and/set the data of the feature. The expected data in the tuple
# is ([feature_id,] non-spatial fields, spatial fields). The fields in
# the tuple are in the order they are in the schema. Field values are
# set using the Geo::OGR::Feature::Field method. Geometries are set
# and get using the Geo::OGR::Feature::Geometry method.
# @param tuple [optional] feature data in an array
# @return feature data in an array
#*
sub Tuple {
    my $self = shift;
    my $nf = $self->GetFieldCount;
    my $ngf = $self->GetGeomFieldCount;
    if (@_) {
        my $values = ref $_[0] ? $_[0] : \@_;
        my $FID;
        $FID = shift @$values if @$values == $nf + $ngf + 1;
        $self->SetFID($FID) if defined $FID;
        if (@$values != $nf + $ngf) {
            my $n = $nf + $ngf;
            error("Too many or too few attribute values for a feature (need $n).");
        }
        my $index = 0; # index to non-geometry and geometry fields
        for my $i (0..$nf-1) {
            $self->SetField($i, $values->[$i]);
        }
        for my $i (0..$ngf-1) {
            $self->Geometry($i, $values->[$nf+$i]);
        }
    }
    return unless defined wantarray;
    my @ret = ($self->GetFID);
    for my $i (0..$nf-1) {
        my $v = $self->GetField($i);
        push @ret, $v;
    }
    for my $i (0..$ngf-1) {
        my $v = $self->GetGeometry($i);
        push @ret, $v;
    }
    return @ret;
}

#** @method scalar Validate(list flags)
# Object method.
# @param flags one of more of null, geom_type, width,
# allow_null_when_default, or all.
# @exception croaks with an error message if the feature is not valid.
# @return integer denoting the validity of the feature object.
#*
sub Validate {
    my $self = shift;
    my $flags = 0;
    for my $flag (@_) {
        my $f = eval '$Geo::OGR::'.uc($flag);
        $flags |= $f;
    }
    _Validate($self, $flags);
}

#** @method Geo::OGR::Feature new(%schema)
# Class method.
# @brief Create a new feature.
# @param Named parameters:
# - \a Schema a reference to a schema hash, or a Geo::OGR::Layer,
#      Geo::OGR::Feature, or Geo::OGR::FeatureDefn object.
# - \a Values values for the feature attributes.
# - \a StyleIgnored whether the style can be omitted when fetching
#      features. (default is false)
# 
# Schema is a hash with the following keys:
# - \a Name name of the schema (not used).
# - \a Fields a list of Geo::OGR::FieldDefn or Geo::OGR::GeomFieldDefn
# objects or references to hashes from which fields can be created.
# - \a GeometryType the geometry type if the feature has only one spatial field.
# 
# @note Do not mix GeometryType and geometry fields in Fields list.
# @note Old syntax where the argument is a Geo::OGR::FeatureDefn
# object or Schema hash is supported.
# 
# @return a new Geo::OGR::Feature object.
#*
sub new {
    my $pkg = shift;
    my $arg;
    if (ref $_[0]) {
        if (ref $_[0] eq 'HASH' && $_[0]->{Schema}) {
            $arg = $_[0];
        } else {
            $arg = {Schema => $_[0]};
        }
    } elsif (@_ and @_ % 2 == 0) {
        %$arg = @_;
        unless ($arg->{Schema}) {
            my %tmp = @_;
            $arg->{Schema} = \%tmp;
        }
    } else {
        error("The argument must be either a schema or a hash.");
    }
    error("Missing schema.") unless $arg->{Schema};
    my $defn;
    for (ref $arg->{Schema}) {
        (/Geo::OGR::Layer$/ || /Geo::OGR::Feature$/) && do {
            $defn = $arg->{Schema}->GetDefn;
            last;
        };
        /Geo::OGR::FeatureDefn$/ && do {
            $defn = $arg->{Schema};
            last;
        };
        $defn = Geo::OGR::FeatureDefn->new($arg->{Schema});
    }
    my $self = Geo::OGRc::new_Feature($defn);
    error("Feature creation failed.") unless $self;
    bless $self, $pkg;
    for (ref $arg->{Values}) {
        /ARRAY/  && do {
            $self->Tuple($arg->{Values});
            last;
        };
        /HASH/ && do {
            $self->Row($arg->{Values});
            last;
        };
        /Geo::OGR::Feature$/ && do {
            $self->Tuple($arg->{Values}->Tuple);
            last;
        };
        /^$/ && do {
            last;
        };
        error("Value parameter must be an array, hash, or another feature. Not $_.");
    }
    return $self;
}

#** @class Geo::OGR::FeatureDefn
# @brief The schema of a feature or a layer.
# @details A FeatureDefn object is a collection of field definition objects. A
# read-only FeatureDefn object can be obtained from a layer
# (Geo::OGR::Layer::GetDefn()) or a feature
# (Geo::OGR::Feature::GetDefn()).
#*
package Geo::OGR::FeatureDefn;

use base qw(Geo::OGR)

#** @method AddField(%params)
# Object method.
# @param params Named parameters to create a new Geo::OGR::FieldDefn
# or Geo::OGR::GeomFieldDefn object.
#*
sub AddField {
    my $self = shift;
    error("Read-only definition.") if parent($self);
    my %params;
    if (@_ == 0) {
    } elsif (ref($_[0]) eq 'HASH') {
        %params = %{$_[0]};
    } elsif (@_ % 2 == 0) {
        %params = @_;
    }
    $params{Type} //= '';
    if (s_exists(field_type => $params{Type})) {
        my $fd = Geo::OGR::FieldDefn->new(%params);
        $self->AddFieldDefn($fd);
    } else {
        my $fd = Geo::OGR::GeomFieldDefn->new(%params);
        $self->AddGeomFieldDefn($fd);
    }
}

#** @method DeleteField($name)
# Object method.
# @note Currently only geometry fields can be deleted.
# @param index the index of the geometry field to be deleted.
#*
sub DeleteField {
    my ($self, $name) = @_;
    error("Read-only definition.") if parent($self);
    for my $i (0..$self->GetFieldCount-1) {
        error("Non-spatial fields cannot be deleted.") if $self->_GetFieldDefn($i)->Name eq $name;
    }
    for my $i (0..$self->GetGeomFieldCount-1) {
        $self->DeleteGeomFieldDefn($i) if $self->_GetGeomFieldDefn($i)->Name eq $name;
    }
    error(2, $name, 'Field');
}

#** @method Feature()
#*
sub Feature {
    my $self = shift;
    return parent($self);
}

#** @method scalar GetFieldDefn($name)
# Object method.
# Get the definition of a field.
# @param name the name of the field.
# @return a Geo::OGR::FieldDefn object.
#*
sub GetFieldDefn {
    my $self = shift;
    my $field = $self->GetFieldIndex(shift);
    return $self->_GetFieldDefn($field);
}

#** @method list GetFieldNames()
# Object method.
# The names of the fields in this layer or feature definition.
# @return the list of field names.
#*
sub GetFieldNames {
    my $self = shift;
    my @names = ();
    for my $i (0..$self->GetFieldCount-1) {
        push @names, $self->_GetFieldDefn($i)->Name;
    }
    for my $i (0..$self->GetGeomFieldCount-1) {
        push @names, $self->_GetGeomFieldDefn($i)->Name;
    }
    return @names;
}

#** @method scalar GetGeomFieldDefn($name)
# Object method.
# Get the definition of a spatial field.
# @param name the name of the spatial field.
# @return a Geo::OGR::GeomFieldDefn object.
#*
sub GetGeomFieldDefn {
    my $self = shift;
    my $field = $self->GetGeomFieldIndex(shift);
    return $self->_GetGeomFieldDefn($field);
}

#** @method scalar GetName()
# Object method.
# @return the name of this layer or feature definition.
#*
sub GetName {
}

#** @method hash reference GetSchema()
# Object method.
# @brief Get the schema of this feature or layer definition.
# 
# @return the schema as a hash whose keywords are Name, StyleIgnored
# and Fields. Fields is an anonymous array of first non-spatial and
# then spatial field schemas as in Geo::OGR::FieldDefn::Schema() and
# Geo::OGR::GeomFieldDefn::Schema().
#*
sub GetSchema {
    my $self = shift;
    carp "Schema of a feature definition should not be set directly." if @_;
    if (@_ and @_ % 2 == 0) {
        my %schema = @_;
        if ($schema{Fields}) {
            for my $field (@{$schema{Fields}}) {
                $self->AddField($field);
            }
        }
    }
    my %schema;
    $schema{Name} = $self->Name();
    $schema{StyleIgnored} = $self->StyleIgnored();
    $schema{Fields} = [];
    for my $i (0..$self->GetFieldCount-1) {
        my $s = $self->_GetFieldDefn($i)->Schema;
        push @{$schema{Fields}}, $s;
    }
    for my $i (0..$self->GetGeomFieldCount-1) {
        my $s = $self->_GetGeomFieldDefn($i)->Schema;
        push @{$schema{Fields}}, $s;
    }
    return wantarray ? %schema : \%schema;
}

#** @method IsSame(Geo::OGR::FeatureDefn defn)
# Object method.
# @return true if this definition is similar to the other definition,
# false otherwise.
#*
sub IsSame {
}

#** @method scalar IsStyleIgnored()
# Object method.
# Get the ignore status of style information when fetching features.
# @return the ignore status of style information
# @since 1.9.0
#*
sub IsStyleIgnored {
}

#** @method RELEASE_PARENT()
#*
sub RELEASE_PARENT {
    my $self = shift;
    unkeep($self);
}

#** @method SetStyleIgnored($IgnoreState)
# Object method.
# Set the ignore status of style information when fetching features.
# @since 1.9.0
#*
sub SetStyleIgnored {
}

#** @method Geo::OGR::FeatureDefn new(%schema)
# Class method.
# Creates a new layer or feature definition. The new definition is
# either initialized to the given schema or it will contain no
# non-spatial fields and one spatial field, whose Name is '' and
# GeometryType is 'Unknown' or the value of the named parameter
# GeometryType.
# @param schema [optional] The schema for the new feature definition,
# as in Geo::OGR::FeatureDefn::Schema().
# @return a Geo::OGR::FeatureDefn object
# 
# Example usage:
# \code
# $fd = Geo::OGR::FeatureDefn->new(
#     Name => "name",
#     Fields => [{ Name => 'field1', Type => 'String' },
#                { Name => 'geom', GeometryType => 'Point' }] );
# \endcode
#*
sub new {
    my $pkg = shift;
    my %schema;
    if (@_ == 1 and ref($_[0]) eq 'HASH') {
        %schema = %{$_[0]};
    } elsif (@_ and @_ % 2 == 0) {
        %schema = @_;
    }
    my $fields = $schema{Fields};
    error("The 'Fields' argument must be an array reference.") if $fields and ref($fields) ne 'ARRAY';
    $schema{Name} //= '';
    my $self = Geo::OGRc::new_FeatureDefn($schema{Name});
    bless $self, $pkg;
    my $gt = $schema{GeometryType};
    if ($gt) {
        $self->GeometryType($gt);
    } elsif ($fields) {
        $self->DeleteGeomFieldDefn(0);
    }
    $self->StyleIgnored($schema{StyleIgnored}) if exists $schema{StyleIgnored};
    for my $fd (@{$fields}) {
        my $d = $fd;
        if (ref($fd) eq 'HASH') {
            # if Name and Type are missing, assume Name => Type
            if (!(exists $fd->{Name} && exists $fd->{Type})) {
                for my $key (sort keys %$fd) {
                    if (s_exists(field_type => $fd->{$key}) ||
                        s_exists(geometry_type => $fd->{$key}))
                    {
                        $fd->{Name} = $key;
                        $fd->{Type} = $fd->{$key};
                        delete $fd->{$key};
                        last;
                    }
                }
            }
            if ($fd->{GeometryType} or ($fd->{Type} && s_exists(geometry_type => $fd->{Type}))) {
                $d = Geo::OGR::GeomFieldDefn->new(%$fd);
            } else {
                $d = Geo::OGR::FieldDefn->new(%$fd);
            }
        }
        if (blessed($d) and $d->isa('Geo::OGR::FieldDefn')) {
            AddFieldDefn($self, $d);
        } elsif (blessed($d) and $d->isa('Geo::OGR::GeomFieldDefn')) {
            error("Do not mix GeometryType and geometry fields in Fields.") if $gt;
            AddGeomFieldDefn($self, $d);
        } else {
            error("Item in field list does not define a field.");
        }
    }
    return $self;
}

#** @class Geo::OGR::FieldDefn
# @brief A definition of a non-spatial attribute.
# @details
#*
package Geo::OGR::FieldDefn;

use base qw(Geo::OGR)

#** @method scalar Default($value)
# Object method.
# Get or set the default value for this field.
# @note a.k.a. GetDefault and SetDefault
# @param value [optional]
# @return the default value of this field in non-void context.
#*
sub Default {
    my $self = shift;
    SetDefault($self, $_[0]) if @_;
    GetDefault($self) if defined wantarray;
}

#** @method GetSchema()
#*
sub GetSchema {
}

#** @method scalar Ignored($ignore)
# Object method.
# Get and/or set the ignore status (whether this field should be
# omitted when fetching features) of this field.
# @note a.k.a. IsIgnored, SetIgnored
# @param ignore [optional]
# @return the ignore status of this field in non-void context.
# @since 1.9.0
#*
sub Ignored {
    my $self = shift;
    SetIgnored($self, $_[0]) if @_;
    IsIgnored($self) if defined wantarray;
}

#** @method IsDefaultDriverSpecific()
#*
sub IsDefaultDriverSpecific {
}

#** @method scalar Justify($justify)
# Object method.
# Get and/or set the justification of this field.
# @note a.k.a. GetJustify, SetJustify
# @param justify [optional] One of field justify types (Geo::OGR::FieldDefn::JustifyValues).
# @return the justify value of this field in non-void context.
#*
sub Justify {
    my($self, $justify) = @_;
    if (defined $justify) {
        $justify = s2i(justify => $justify);
        SetJustify($self, $justify);
    }
    return i2s(justify => GetJustify($self)) if defined wantarray;
}

#** @method list JustifyValues()
# Package subroutine.
# Justify values supported by GDAL. Current list is
# Left, Right, and Undefined.
#*
sub JustifyValues {
    return @JUSTIFY;
}

#** @method scalar Name($name)
# Object method.
# Get and/or set the name of the field.
# @note a.k.a. GetName, GetNameRef, SetName
# @param name [optional]
# @return the name in non-void context
#*
sub Name {
    my $self = shift;
    SetName($self, $_[0]) if @_;
    GetName($self) if defined wantarray;
}

#** @method scalar Nullable($nullable)
# Object method.
# Get or set the nullable constraint for this field.
# @note a.k.a. IsNullable and SetNullable
# @param nullable [optional]
# @return the nullable value of this field in non-void context.
#*
sub Nullable {
    my $self = shift;
    SetNullable($self, $_[0]) if @_;
    IsNullable($self) if defined wantarray;
}

#** @method scalar Precision($precision)
# Object method.
# Get and/or set the precision of this field.
# @note a.k.a. GetPrecision, SetPrecision
# @param precision [optional]
# @return the precision of this field in non-void context.
#*
sub Precision {
    my $self = shift;
    SetPrecision($self, $_[0]) if @_;
    GetPrecision($self) if defined wantarray;
}

#** @method hash reference Schema(%params)
# Object method.
# Get the schema or set parts of the schema
# @param params [optional] as those in Geo::OGR::FieldDefn::new.
# @return a reference to a hash whose keys are as those in Geo::OGR::FieldDefn::new.
#*
sub Schema {
    my $self = shift;
    if (@_) {
        my $params = @_ % 2 == 0 ? {@_} : shift;
        for my $key (keys %SCHEMA_KEYS) {
            next unless exists $params->{$key};
            eval "\$self->$key(\$params->{$key})";
            confess(last_error()) if $@;
        }
    }
    return unless defined wantarray;
    my %schema = ();
    for my $key (keys %SCHEMA_KEYS) {
        $schema{$key} = eval '$self->'.$key;
    }
    return wantarray ? %schema : \%schema;
}

#** @method SetSchema()
#*
sub SetSchema {
}

#** @method scalar SubType($SubType)
# Object method.
# @note a.k.a. GetSubType, SetSubType
# @param SubType [optional] One of field sub types (Geo::OGR::FieldDefn::SubTypes).
# @return the sub type of this field in non-void context.
#*
sub SubType {
    my($self, $subtype) = @_;
    if (defined $subtype) {
        $subtype = s2i(field_subtype => $subtype);
        SetSubType($self, $subtype);
    }
    return i2s(field_subtype => GetSubType($self)) if defined wantarray;
}

#** @method SubTypes()
#*
sub SubTypes {
    return @SUBTYPES;
}

#** @method scalar Type($type)
# Object method.
# Get and/or set the type of the field.
# @note a.k.a. GetFieldTypeName, GetTypeName, GetType, SetType
# @param type [optional] One of field types (Geo::OGR::FieldDefn::Types).
# @return one of field types in non-void context.
#*
sub Type {
    my($self, $type) = @_;
    if (defined $type) {
        $type = s2i(field_type => $type);
        SetType($self, $type);
    }
    return i2s(field_type => GetType($self)) if defined wantarray;
}

#** @method list Types()
# Package subroutine.
# Field types supported by GDAL. Current list is
# Binary, Date, DateTime, Integer, Integer64, Integer64List, IntegerList, Real, RealList, String, StringList, Time, WideString, and WideStringList.
# (However, WideString is not supported.)
#*
sub Types {
    return @TYPES;
}

#** @method scalar Width($width)
# Object method.
# Get and/or set the field width.
# @note a.k.a. GetWidth, SetWidth
# @param width [optional]
# @return the width of this field in non-void context.
#*
sub Width {
    my $self = shift;
    SetWidth($self, $_[0]) if @_;
    GetWidth($self) if defined wantarray;
}

#** @method Geo::OGR::FieldDefn new(%params)
# Class method.
# @brief Create a new field definition.
# 
# @param Named parameters:
# - \a Name Field name (default is 'unnamed').
# - \a Type Field type, one of Geo::OGR::FieldDefn::Types (default is 'String').
# - \a SubType Field sub type, one of Geo::OGR::FieldDefn::SubTypes.
# - \a Justify Justify value, one of Geo::OGR::FieldDefn::JustifyValues
# - \a Width
# - \a Precision
# - \a Nullable (default is true)
# - \a Default
# - \a Ignored (default is false)
# 
# @note Simplified parameters <name> => <type> is also supported.
# 
# @return a new Geo::OGR::FieldDefn object
#*
sub new {
    my $pkg = shift;
    my $params = {Name => 'unnamed', Type => 'String'};
    if (@_ == 0) {
    } elsif (@_ == 1 and not ref $_[0]) {
        $params->{Name} = shift;
    } elsif (@_ == 2 and not $Geo::OGR::FieldDefn::SCHEMA_KEYS{$_[0]}) {
        $params->{Name} = shift;
        $params->{Type} = shift;
    } else {
        my $tmp = @_ % 2 == 0 ? {@_} : shift;
        for my $key (keys %$tmp) {
            if ($Geo::OGR::FieldDefn::SCHEMA_KEYS{$key}) {
                $params->{$key} = $tmp->{$key};
            } else {
                carp "Unknown parameter: '$key'." if $key ne 'Index';
            }
        }
    }
    $params->{Type} = s2i(field_type => $params->{Type});
    my $self = Geo::OGRc::new_FieldDefn($params->{Name}, $params->{Type});
    bless $self, $pkg;
    delete $params->{Name};
    delete $params->{Type};
    $self->Schema($params);
    return $self;
}

#** @class Geo::OGR::GeomFieldDefn
# @brief A definition of a spatial attribute.
# @details
#*
package Geo::OGR::GeomFieldDefn;

use base qw(Geo::OGR)

#** @method scalar GeometryType($type)
# Object method.
# @note a.k.a. GetType, SetType
# @return the geometry type of the field.
#*
sub GeometryType {
}

#** @method GetSchema()
#*
sub GetSchema {
}

#** @method scalar Ignored($ignore)
# Object method.
# @note a.k.a. IsIgnored, SetIgnored
# @return the ignore status of the field.
#*
sub Ignored {
    my $self = shift;
    SetIgnored($self, $_[0]) if @_;
    IsIgnored($self) if defined wantarray;
}

#** @method scalar Name($name)
# Object method.
# @note a.k.a. GetName, GetNameRef, SetName
# @return the name of the field.
#*
sub Name {
    my $self = shift;
    SetName($self, $_[0]) if @_;
    GetName($self) if defined wantarray;
}

#** @method scalar Nullable($nullable)
# Object method.
# @note a.k.a. IsNullable, SetNullable
# @return the nullable status of the field.
#*
sub Nullable {
    my $self = shift;
    SetNullable($self, $_[0]) if @_;
    IsNullable($self) if defined wantarray;
}

#** @method hash reference Schema(%params)
# Object method.
# Get the schema or set parts of the schema.
# @param params [optional] as those in Geo::OGR::GeomFieldDefn::new.
# @return a reference to a hash whose keys are as those in Geo::OGR::GeomFieldDefn::new.
#*
sub Schema {
    my $self = shift;
    if (@_) {
        my $params = @_ % 2 == 0 ? {@_} : shift;
        for my $key (keys %SCHEMA_KEYS) {
            next unless exists $params->{$key};
            eval "\$self->$key(\$params->{$key})";
            confess last_error() if $@;
        }
    }
    return unless defined wantarray;
    my %schema = ();
    for my $key (keys %SCHEMA_KEYS) {
        $schema{$key} = eval '$self->'.$key;
    }
    return wantarray ? %schema : \%schema;
}

#** @method SetSchema()
#*
sub SetSchema {
}

#** @method scalar SpatialReference($sr)
# Object method.
# @note a.k.a. GetSpatialRef, SetSpatialRef
# @return the spatial reference of the field as a Geo::OSR::SpatialReference object.
#*
sub SpatialReference {
    my $self = shift;
    SetSpatialRef($self, $_[0]) if @_;
    GetSpatialRef($self) if defined wantarray;
}

#** @method Type()
# Object method.
# @return the type of this geometry field. One of Geo::OGR::GeomFieldDefn::Types
#*
sub Type {
    my($self, $type) = @_;
    if (defined $type) {
        $type = s2i(geometry_type => $type);
        SetType($self, $type);
    }
    i2s(geometry_type => GetType($self)) if defined wantarray;
}

#** @method Types()
# Package subroutine.
# @return a list of all geometry types, currently:
# CircularString, CircularStringM, CircularStringZ, CircularStringZM, CompoundCurve, CompoundCurveM, CompoundCurveZ, CompoundCurveZM, Curve, CurveM, CurvePolygon, CurvePolygonM, CurvePolygonZ, CurvePolygonZM, CurveZ, CurveZM, GeometryCollection, GeometryCollection25D, GeometryCollectionM, GeometryCollectionZM, LineString, LineString25D, LineStringM, LineStringZM, LinearRing, MultiCurve, MultiCurveM, MultiCurveZ, MultiCurveZM, MultiLineString, MultiLineString25D, MultiLineStringM, MultiLineStringZM, MultiPoint, MultiPoint25D, MultiPointM, MultiPointZM, MultiPolygon, MultiPolygon25D, MultiPolygonM, MultiPolygonZM, MultiSurface, MultiSurfaceM, MultiSurfaceZ, MultiSurfaceZM, None, Point, Point25D, PointM, PointZM, Polygon, Polygon25D, PolygonM, PolygonZM, PolyhedralSurface, PolyhedralSurfaceM, PolyhedralSurfaceZ, PolyhedralSurfaceZM, Surface, SurfaceM, SurfaceZ, SurfaceZM, TIN, TINM, TINZ, TINZM, Triangle, TriangleM, TriangleZ, TriangleZM, and Unknown.
#*
sub Types {
    return Geo::OGR::Geometry::GeometryTypes();
}

#** @method Geo::OGR::GeomFieldDefn new(%params)
# Class method.
# @brief Create a new spatial field definition.
# 
# @param params one or more of:
# - \a Name name for the field (default is 'geom').
# - \a GeometryType type for the field type, one of Geo::OGR::GeomFieldDefn::Types (default is 'Unknown').
# - \a SpatialReference a Geo::OSR::SpatialReference object.
# - \a Nullable (default is true)
# - \a Ignored (default is false)
# 
# @note Simplified parameters <name> => <type> is also supported.
# 
# @return a new Geo::OGR::GeomFieldDefn object
#*
sub new {
    my $pkg = shift;
    my $params = {Name => 'geom', Type => 'Unknown'};
    if (@_ == 0) {
    } elsif (@_ == 1) {
        $params->{Name} = shift;
    } elsif (@_ == 2 and not $Geo::OGR::GeomFieldDefn::SCHEMA_KEYS{$_[0]}) {
        $params->{Name} = shift;
        $params->{Type} = shift;
    } else {
        my $tmp = @_ % 2 == 0 ? {@_} : shift;
        for my $key (keys %$tmp) {
            if ($Geo::OGR::GeomFieldDefn::SCHEMA_KEYS{$key}) {
                $params->{$key} = $tmp->{$key};
            } else {
                carp "Unknown parameter: '$key'." if $key ne 'Index' && $key ne 'GeometryType';
            }
        }
        $params->{Type} //= $tmp->{GeometryType};
    }
    $params->{Type} = s2i(geometry_type => $params->{Type});
    my $self = Geo::OGRc::new_GeomFieldDefn($params->{Name}, $params->{Type});
    bless $self, $pkg;
    delete $params->{Name};
    delete $params->{Type};
    $self->Schema($params);
    return $self;
}

#** @class Geo::OGR::Geometry
# @brief Spatial data.
# @details A geometry is spatial data (coordinate values, and a reference to a
# spatial reference system) organized into one of the geometry
# types. Geometries can be created from several type of data including
# a Perl data structure. There are several methods, which modify,
# compare, test, or compute values from geometries.
# @note Most spatial analysis methods require <a
# href="http://geos.osgeo.org/doxygen/">GEOS</a> to work rigorously.
#*
package Geo::OGR::Geometry;

use base qw(Geo::OGR)

#** @method AddGeometry($other)
# Object method.
# Add a copy of another geometry to a geometry collection
# @param other a Geo::OGR::Geometry object
#*
sub AddGeometry {
}

#** @method AddGeometryDirectly($other)
# Object method.
# @param other a Geo::OGR::Geometry object
#*
sub AddGeometryDirectly {
}

#** @method AddPoint($x, $y, $z)
# Object method.
# Set the data of a point or add a point to a line string. Consider
# using Geo::OGR::Geometry::Points.  Note that the coordinate
# dimension is automatically upgraded to 25D (3) if z is given.
# @param x
# @param y
# @param z [optional]
# Calls internally the 2D or 3D version depending on the number of parameters.
#*
sub AddPoint {
    my $self = shift;
    my $t = $self->GetGeometryType;
    my $has_z = HasZ($t);
    my $has_m = HasM($t);
    if (!$has_z && !$has_m) {
        $self->AddPoint_2D(@_[0..1]);
    } elsif ($has_z && !$has_m) {
        $self->AddPoint_3D(@_[0..2]);
    } elsif (!$has_z && $has_m) {
        $self->AddPointM(@_[0..2]);
    } else {
        $self->AddPointZM(@_[0..3]);
    }
}

#** @method AddPointM()
#*
sub AddPointM {
}

#** @method AddPointZM()
#*
sub AddPointZM {
}

#** @method AddPoint_2D($x, $y)
# Object method.
# Set the data of a point or add a point to a line string. Consider
# using Geo::OGR::Geometry::Points.
# @param x
# @param y
#*
sub AddPoint_2D {
}

#** @method AddPoint_3D($x, $y, $z)
# Object method.
# Set the data of a point or add a point to a line string. Note that
# the coordinate dimension is automatically upgraded to 25D (3). Consider
# using Geo::OGR::Geometry::Points.
# @param x
# @param y
# @param z
#*
sub AddPoint_3D {
}

#** @method Geo::OGR::Geometry ApproximateArcAngles(%params)
# Package subroutine.
# Create a line string, which approximates an arc.
# @note All angles are in degrees.
# 
# @param %params Named parameters:
# - \a Center center point (default is [0, 0, 0])
# - \a PrimaryRadius default is 1.
# - \a SecondaryAxis default is 1.
# - \a Rotation default is 0.
# - \a StartAngle default is 0.
# - \a EndAngle default is 360.
# - \a MaxAngleStepSizeDegrees default is 4.
# @return a new Geo::OGR::Geometry object.
#*
sub ApproximateArcAngles {
    my %p = @_;
    my %default = ( Center => [0,0,0],
                    PrimaryRadius => 1,
                    SecondaryAxis => 1,
                    Rotation => 0,
                    StartAngle => 0,
                    EndAngle => 360,
                    MaxAngleStepSizeDegrees => 4
        );
    for my $p (keys %p) {
        if (exists $default{$p}) {
            $p{$p} //= $default{$p};
        } else {
            carp "Unknown parameter: '$p'.";
        }
    }
    for my $p (keys %default) {
        $p{$p} //= $default{$p};
    }
    error("Usage: Center => [x,y,z].") unless ref($p{Center}) eq 'ARRAY';
    for my $i (0..2) {
        $p{Center}->[$i] //= 0;
    }
    return Geo::OGR::ApproximateArcAngles($p{Center}->[0], $p{Center}->[1], $p{Center}->[2], $p{PrimaryRadius}, $p{SecondaryAxis}, $p{Rotation}, $p{StartAngle}, $p{EndAngle}, $p{MaxAngleStepSizeDegrees});
}

#** @method scalar Area()
# Object method.
# @note a.k.a. GetArea
# @return the area of the polygon or multipolygon
#*
sub Area {
}

#** @method scalar As(%params)
# Object method.
# Export the geometry into a known format.
# 
# @param params Named parameters:
# - \a Format One of
#     - \a WKT Well Known Text.
#     - <em>ISO WKT</em>
#     - \a Text Same as WKT.
#     - \a WKB Well Known Binary.
#     - <em>ISO WKB</em>
#     - \a Binary Same as WKB.
#     - \a HEXWKB
#     - \a HEXEWKB
#     - \a GML
#     - \a GeoJSON
# - \a ByteOrder Byte order for binary formats. Default is 'XDR'.
# - \a SRID Spatial reference id for HEXEWKB.
# - \a Options GML generation options.
# - \a AltitudeMode For KML.
# 
# @return the geometry in a given format.
#*
sub As {
    my $self = shift;
    my $p = named_parameters(\@_, Format => undef, ByteOrder => 'XDR', SRID => undef, Options => undef, AltitudeMode => undef);
    my $f = $p->{format};
    if ($f =~ /text/i) {
        return $self->AsText;
    } elsif ($f =~ /wkt/i) {
        if ($f =~ /iso/i) {
            return $self->ExportToIsoWkt;
        } else {
            return $self->AsText;
        }
    } elsif ($f =~ /binary/i) {
        return $self->ExportToWkb($p->{byteorder});
    } elsif ($f =~ /wkb/i) {
        if ($f =~ /iso/i) {
            $p->{byteorder} = s2i(byte_order => $p->{byteorder});
            return $self->ExportToIsoWkb($p->{byteorder});
        } elsif ($f =~ /ewkb/i) {
            return $self->AsHEXEWKB($p->{srid});
        } elsif ($f =~ /hex/i) {
            return $self->AsHEXWKB;
        } else {
            return $self->ExportToWkb($p->{byteorder});
        }
    } elsif ($f =~ /gml/i) {
        return $self->ExportToGML($p->{options});
    } elsif ($f =~ /kml/i) {
        return $self->ExportToKML($p->{altitudemode});
    } elsif ($f =~ /json/i) {
        return $self->AsJSON;
    } else {
        error(1, $f, map {$_=>1} qw/Text WKT ISO_WKT ISO_WKB HEX_WKB HEX_EWKB Binary GML KML JSON/);
    }
}

#** @method AssignSpatialReference($srs)
# Object method.
# @param srs a Geo::OSR::SpatialReference object
#*
sub AssignSpatialReference {
}

#** @method Geo::OGR::Geometry Boundary()
# Object method.
# @note a.k.a. GetBoundary
# @return the boundary of this geometry as a geometry
# @since 1.8.0
#*
sub Boundary {
}

#** @method Geo::OGR::Geometry Buffer($distance, $quadsecs = 30)
# Object method.
# @param distance
# @param quadsecs
# @return a new Geo::OGR::Geometry object
#*
sub Buffer {
}

#** @method Geo::OGR::Geometry BuildPolygonFromEdges($BestEffort = 0, $AutoClose = 0, $Tolerance = 0)
# Object method.
# Attempt to create a polygon from a collection of lines or from a multilinestring.
# @param BestEffort For future
# @param AutoClose Assure the first and last points of rings are same.
# @param Tolerance Snap distance.
# @exception Several possibilities, some are reported, some are general errors.
# @return a new Geo::OGR::Geometry object (Polygon)
#*
sub BuildPolygonFromEdges {
}

#** @method list ByteOrders()
# Package subroutine.
# Same as Geo::OGR::ByteOrders
#*
sub ByteOrders {
    return @BYTE_ORDER_TYPES;
}

#** @method Geo::OGR::Geometry Centroid()
# Object method.
# @return a new Geo::OGR::Geometry object
# @since 1.8.0
#*
sub Centroid {
}

#** @method Geo::OGR::Geometry Clone()
# Object method.
# @return a new Geo::OGR::Geometry object
#*
sub Clone {
}

#** @method CloseRings()
# Object method.
#*
sub CloseRings {
}

#** @method Geo::OGR::Geometry Collect(@geometries)
# Object method.
# Create a geometrycollection from this and possibly other geometries.
# @param geometries [optional] More geometries to add to the collection.
# @return a new Geo::OGR::Geometry object of type geometrycollection.
#*
sub Collect {
}

#** @method scalar Contains($other)
# Object method.
# @param other a Geo::OGR::Geometry object
# @return true if this geometry contains the other geometry, false otherwise
#*
sub Contains {
}

#** @method Geo::OGR::Geometry ConvexHull()
# Object method.
# @return a new Geo::OGR::Geometry object
#*
sub ConvexHull {
}

#** @method scalar CoordinateDimension($dimension)
# Object method.
# @param dimension [optional]
# @return 2 or 3
#*
sub CoordinateDimension {
    my $self = shift;
    SetCoordinateDimension($self, $_[0]) if @_;
    GetCoordinateDimension($self) if defined wantarray;
}

#** @method scalar Crosses($other)
# Object method.
# @param other a Geo::OGR::Geometry object
# @return true if this geometry crosses the other geometry, false otherwise
#*
sub Crosses {
}

#** @method DelaunayTriangulation()
#*
sub DelaunayTriangulation {
}

#** @method Geo::OGR::Geometry Difference($other)
# Object method.
# @param other a Geo::OGR::Geometry object
# @return a new Geo::OGR::Geometry object
#*
sub Difference {
}

#** @method scalar Disjoint($other)
# Object method.
# @param other a Geo::OGR::Geometry object
# @return true if this geometry is disjoint from the other geometry, false otherwise
#*
sub Disjoint {
}

#** @method list Dissolve()
# Object method.
# Dissolve a geometrycollection into separate geometries.
# @return a list of new Geo::OGR::Geometry objects cloned from the collection.
#*
sub Dissolve {
    my $self = shift;
    my @c;
    my $n = $self->GetGeometryCount;
    if ($n > 0) {
        for my $i (0..$n-1) {
            push @c, $self->GetGeometryRef($i)->Clone;
        }
    } else {
        push @c, $self;
    }
    return @c;
}

#** @method scalar Distance($other)
# Object method.
# @param other a Geo::OGR::Geometry object
# @return the distance to the other geometry
#*
sub Distance {
}

#** @method Distance3D()
#*
sub Distance3D {
}

#** @method Empty()
# Object method.
# Clear geometry data, i.e., remove all points, or, for a point, set
# the coordinate dimension as zero.
#*
sub Empty {
}

#** @method scalar Equals($other)
# Object method.
# @note a.k.a. Equal (deprecated)
# @param other a Geo::OGR::Geometry object
# @return true if this geometry is equivalent to the other geometry, false otherwise
#*
sub Equals {
}

#** @method Extent()
#*
sub Extent {
    my $self = shift;
    return Geo::GDAL::Extent->new($self->GetEnvelope);
}

#** @method Feature()
#*
sub Feature {
    my $self = shift;
    parent($self);
}

#** @method FlattenTo2D()
# Object method.
#*
sub FlattenTo2D {
}

#** @method Geo::OGR::Geometry ForceTo($type, ref options)
# Object method.
# Attempt to make a geometry of type 'type' out of this geometry.
# @param type target geometry type. One of Geo::OGR::GeometryTypes.
# @param options not used currently.
# @return a new Geo::OGR::Geometry object.
#*
sub ForceTo {
    my $self = shift;
    my $type = shift;
    $type = s2i(geometry_type => $type);
    eval {
        $self = Geo::OGR::ForceTo($self, $type, @_);
    };
    confess last_error() if $@;
    return $self;
}

#** @method Geo::OGR::Geometry ForceToCollection(@geometries)
# Object method.
# Create a geometrycollection from the geometry.
# @param geometries [optional] More geometries to add to the collection.
# @return a new Geo::OGR::Geometry object of type geometrycollection.
#*
sub ForceToCollection {
    my $self = Geo::OGR::Geometry->new(GeometryType => 'GeometryCollection');
    for my $g (@_) {
        $self->AddGeometry($g);
    }
    return $self;
}

#** @method Geo::OGR::Geometry ForceToLineString()
# Object method.
# Attempt to create a line string from this geometry.
# @return a new Geo::OGR::Geometry object.
#*
sub ForceToLineString {
    my $self = shift;
    return Geo::OGR::ForceToLineString($self);
}

#** @method Geo::OGR::Geometry ForceToMultiLineString(@linestrings)
# Object method.
# Attempt to create a multilinestring from the geometry, which must be a linestring.
# @param linestrings [optional] More linestrings to add to the collection.
# @return a new Geo::OGR::Geometry object of type multilinestring.
#*
sub ForceToMultiLineString {
    my $self = shift;
    $self = Geo::OGR::ForceToMultiLineString($self);
    for my $g (@_) {
        $self->AddGeometry($g);
    }
    return $self;
}

#** @method Geo::OGR::Geometry ForceToMultiPoint(@points)
# Object method.
# Attempt to create a multipoint from the geometry, which must be a point.
# @param points [optional] More points to add to the collection.
# @return a new Geo::OGR::Geometry object of type multipoint.
#*
sub ForceToMultiPoint {
    my $self = shift;
    $self = Geo::OGR::ForceToMultiPoint($self);
    for my $g (@_) {
        $self->AddGeometry($g);
    }
    return $self;
}

#** @method Geo::OGR::Geometry ForceToMultiPolygon(@polygons)
# Object method.
# Attempt to create a multipolygon from the geometry, which must be a polygon.
# @param polygons [optional] More polygons to add to the collection.
# @return a new Geo::OGR::Geometry object of type multipolygon.
#*
sub ForceToMultiPolygon {
    my $self = shift;
    $self = Geo::OGR::ForceToMultiPolygon($self);
    for my $g (@_) {
        $self->AddGeometry($g);
    }
    return $self;
}

#** @method Geo::OGR::Geometry ForceToPolygon()
# Object method.
# Attempt to create a polygon from this geometry.
# @exception None reported. If this method fails, just a copy is returned.
# @return a new Geo::OGR::Geometry object.
#*
sub ForceToPolygon {
}

#** @method scalar GeometryType()
# Object method.
# @return the geometry type of this geometry (one of Geo::OGR::GeometryTypes).
#*
sub GeometryType {
    my $self = shift;
    return i2s(geometry_type => $self->GetGeometryType);
}

#** @method list GeometryTypes()
# Package subroutine.
# Same as Geo::OGR::GeometryTypes
#*
sub GeometryTypes {
    return @GEOMETRY_TYPES;
}

#** @method scalar GetCoordinateDimension()
# Object method.
# @return an integer
#*
sub GetCoordinateDimension {
}

#** @method GetCurveGeometry()
#*
sub GetCurveGeometry {
}

#** @method scalar GetDimension()
# Object method.
# @return 0, 1, or 2
#*
sub GetDimension {
}

#** @method list GetEnvelope()
# Object method.
# @note In scalar context returns a reference to an anonymous array
# containing the envelope.
# @return the envelope ($minx, $maxx, $miny, $maxy)
#*
sub GetEnvelope {
}

#** @method list GetEnvelope3D()
# Object method.
# @note In scalar context returns a reference to an anonymous array
# containing the envelope.
# @return the 3-D envelope ($minx, $maxx, $miny, $maxy, $minz, $maxz)
# @since 1.9.0
#*
sub GetEnvelope3D {
}

#** @method scalar GetGeometryCount()
# Object method.
# @return an integer
#*
sub GetGeometryCount {
}

#** @method scalar GetGeometryName()
# Object method.
# @deprecated use Geo::OGR::Geometry::GeometryType.
# 
# @return a string
#*
sub GetGeometryName {
}

#** @method scalar GetGeometryRef($index)
# Object method.
# @param index index to the geometry, which is a part of this geometry
# @return a new Geo::OGR::Geometry object whose data is a part of the
# parent geometry
#*
sub GetGeometryRef {
}

#** @method scalar GetGeometryType()
# Object method.
# @deprecated use Geo::OGR::Geometry::GeometryType, which returns the
# type as a string.
# 
# @return type as an integer
#*
sub GetGeometryType {
}

#** @method GetLinearGeometry()
#*
sub GetLinearGeometry {
}

#** @method GetM()
#*
sub GetM {
}

#** @method list GetPoint($index = 0)
# Object method.
# @param index
# @return (x,y) or a list with more coordinates
#*
sub GetPoint {
    my($self, $i) = @_;
    $i //= 0;
    my $t = $self->GetGeometryType;
    my $has_z = HasZ($t);
    my $has_m = HasM($t);
    my $point;
    if (!$has_z && !$has_m) {
        $point = $self->GetPoint_2D($i);
    } elsif ($has_z && !$has_m) {
        $point = $self->GetPoint_3D($i);
    } elsif (!$has_z && $has_m) {
        $point = $self->GetPointZM($i);
        @$point = ($point->[0], $point->[1], $point->[3]);
    } else {
        $point = $self->GetPointZM($i);
    }
    return wantarray ? @$point : $point;
}

#** @method scalar GetPointCount()
# Object method.
# @return an integer
#*
sub GetPointCount {
}

#** @method GetPointZM()
#*
sub GetPointZM {
}

#** @method scalar GetPoint_2D($index = 0)
# Object method.
# @param index
# @return (x,y) or a list with more coordinates
#*
sub GetPoint_2D {
}

#** @method scalar GetPoint_3D($index = 0)
# Object method.
# @param index
# @return (x,y) or a list with more coordinates
#*
sub GetPoint_3D {
}

#** @method Geo::OSR::SpatialReference GetSpatialReference()
# Object method.
# @return a new Geo::OSR::SpatialReference object
#*
sub GetSpatialReference {
}

#** @method scalar GetX($index = 0)
# Object method.
# @param index
# @return a number
#*
sub GetX {
}

#** @method scalar GetY($index = 0)
# Object method.
# @param index
# @return a number
#*
sub GetY {
}

#** @method scalar GetZ($index = 0)
# Object method.
# @param index
# @return a number
#*
sub GetZ {
}

#** @method HasCurveGeometry()
#*
sub HasCurveGeometry {
}

#** @method Geo::OGR::Geometry Intersection($other)
# Object method.
# @param other a Geo::OGR::Geometry object
# @return a new Geo::OGR::Geometry object
#*
sub Intersection {
}

#** @method scalar Intersects($other)
# Object method.
# @note a.k.a. Intersect (deprecated)
# @param other a Geo::OGR::Geometry object
# @return true if this geometry intersects with the other geometry, false otherwise
#*
sub Intersects {
}

#** @method Is3D()
#*
sub Is3D {
}

#** @method scalar IsEmpty()
# Object method.
# Test whether the geometry is empty (has no points, or, for a point,
# has coordinate dimension of zero).
# @return boolean
#*
sub IsEmpty {
}

#** @method IsMeasured()
#*
sub IsMeasured {
}

#** @method scalar IsRing()
# Object method.
# Test if the geometry is a ring. Requires GEOS in GDAL.
# @return boolean
#*
sub IsRing {
}

#** @method scalar IsSimple()
# Object method.
# Test the simplicity of the geometry (OGC sense). Requires GEOS in GDAL.
# @return boolean
#*
sub IsSimple {
}

#** @method scalar IsValid()
# Object method.
# Test the validity of the geometry (OGC sense). Requires GEOS in GDAL.
# @return boolean
#*
sub IsValid {
}

#** @method scalar Length()
# Object method.
# @return the length of the linestring
#*
sub Length {
}

#** @method Move($dx, $dy, $dz)
# Object method.
# Move every point of the object as defined by the parameters.
# @param dx
# @param dy
# @param dz [optional]
#*
sub Move {
}

#** @method scalar Overlaps($other)
# Object method.
# @param other a Geo::OGR::Geometry object
# @return true if this geometry overlaps the other geometry, false otherwise
#*
sub Overlaps {
}

#** @method list Point($index, $x, $y, $z)
# Object method.
# Get or set the point
# @param index The index of the point. Optional (ignored if given) for
# Point and Point25D geometries.
# @param x [optional]
# @param y [optional]
# @param z [optional]
# @return
#*
sub Point {
    my $self = shift;
    my $i;
    if (@_) {
        my $t = $self->GetGeometryType;
        my $i;
        if (Flatten($t) == $Geo::OGR::wkbPoint) {
            my $has_z = HasZ($t);
            my $has_m = HasM($t);
            if (!$has_z && !$has_m) {
                shift if @_ > 2;
                $i = 0;
            } elsif ($has_z || $has_m) {
                shift if @_ > 3;
                $i = 0;
            } else {
                shift if @_ > 4;
                $i = 0;
            }
        }
        $i = shift unless defined $i;
        $self->SetPoint($i, @_);
    }
    return unless defined wantarray;
    my $point = $self->GetPoint;
    return wantarray ? @$point : $point;
}

#** @method PointOnSurface()
#*
sub PointOnSurface {
}

#** @method array reference Points(arrayref points)
# Object method.
# Get or set the points of the geometry. The points (vertices) are
# stored in obvious lists of lists. When setting, the geometry is
# first emptied. The method uses internally either AddPoint_2D or
# AddPoint_3D depending on the coordinate dimension of the input data.
# 
# @note The same structure may represent different geometries
# depending on the actual geometry type of the object.
# 
# @param points [optional] A reference to an array. A point is a reference to an
# array of numbers, a linestring or a ring is a reference to an array of points,
# a polygon is a reference to an array of rings, etc.
# 
# @return A reference to an array.
#*
sub Points {
    my $self = shift;
    my $t = $self->GetGeometryType;
    my $has_z = HasZ($t);
    my $has_m = HasM($t);
    my $postfix = '';
    $postfix .= 'Z' if HasZ($t);
    $postfix .= 'M' if HasM($t);
    $t = i2s(geometry_type => Flatten($t));
    my $points = shift;
    if ($points) {
        Empty($self);
        if ($t eq 'Unknown' or $t eq 'None' or $t eq 'GeometryCollection') {
            error("Can't set points of a geometry of type '$t'.");
        } elsif ($t eq 'Point') {
            # support both "Point" as a list of one point and one point
            if (ref($points->[0])) {
                $self->AddPoint(@{$points->[0]});
            } else {
                $self->AddPoint(@$points);
            }
        } elsif ($t eq 'LineString' or $t eq 'LinearRing' or $t eq 'CircularString') {
            for my $p (@$points) {
                $self->AddPoint(@$p);
            }
        } elsif ($t eq 'Polygon') {
            for my $r (@$points) {
                my $ring = Geo::OGR::Geometry->new('LinearRing');
                $ring->Set3D(1) if $has_z;
                $ring->SetMeasured(1) if $has_m;
                $ring->Points($r);
                $self->AddGeometryDirectly($ring);
            }
        } elsif ($t eq 'MultiPoint') {
            for my $p (@$points) {
                my $point = Geo::OGR::Geometry->new('Point'.$postfix);
                $point->Points($p);
                $self->AddGeometryDirectly($point);
            }
        } elsif ($t eq 'MultiLineString') {
            for my $l (@$points) {
                my $linestring = Geo::OGR::Geometry->new('LineString'.$postfix);
                $linestring->Points($l);
                $self->AddGeometryDirectly($linestring);
            }
        } elsif ($t eq 'MultiPolygon') {
            for my $p (@$points) {
                my $polygon = Geo::OGR::Geometry->new('Polygon'.$postfix);
                $polygon->Points($p);
                $self->AddGeometryDirectly($polygon);
            }
        }
    }
    return unless defined wantarray;
    $self->_GetPoints();
}

#** @method RELEASE_PARENT()
#*
sub RELEASE_PARENT {
    my $self = shift;
    unkeep($self);
}

#** @method Segmentize($MaxLength)
# Object method.
# Modify the geometry such it has no segment longer than the given length.
# @param MaxLength the given length
#*
sub Segmentize {
}

#** @method Set3D()
#*
sub Set3D {
}

#** @method SetCoordinateDimension($dimension)
# Object method.
# @param dimension
#*
sub SetCoordinateDimension {
}

#** @method SetMeasured()
#*
sub SetMeasured {
}

#** @method SetPoint($index, $x, $y, $z)
# Object method.
# Set the data of a point or a line string. Note that the coordinate
# dimension is automatically upgraded to 25D (3) if z is given.
# @param index
# @param x
# @param y
# @param z [optional]
#*
sub SetPoint {
    my $self = shift;
    my $t = $self->GetGeometryType;
    my $has_z = HasZ($t);
    my $has_m = HasM($t);
    if (!$has_z && !$has_m) {
        $self->SetPoint_2D(@_[0..2]);
    } elsif ($has_z && !$has_m) {
        $self->SetPoint_3D(@_[0..3]);
    } elsif (!$has_z && $has_m) {
        $self->SetPointM(@_[0..3]);
    } else {
        $self->SetPointZM(@_[0..4]);
    }
}

#** @method SetPointM()
#*
sub SetPointM {
}

#** @method SetPointZM()
#*
sub SetPointZM {
}

#** @method SetPoint_2D($index, $x, $y)
# Object method.
# @param index
# @param x
# @param y
#*
sub SetPoint_2D {
}

#** @method SetPoint_3D($index, $x, $y, $z)
# Object method.
# Set the data of a point or a line string. Note that the coordinate
# dimension is automatically upgraded to 25D (3).
# @param index
# @param x
# @param y
# @param z
#*
sub SetPoint_3D {
}

#** @method Geo::OGR::Geometry Simplify($Tolerance)
# Object method.
# Simplify the geometry.
# @param Tolerance the length tolerance for the simplification
# @since 1.8.0
# @return a new Geo::OSR::Geometry object
#*
sub Simplify {
}

#** @method SimplifyPreserveTopology()
#*
sub SimplifyPreserveTopology {
}

#** @method Geo::OGR::Geometry SymDifference($other)
# Object method.
# Compute symmetric difference.
# @note a.k.a. SymmetricDifference
# @param other a Geo::OGR::Geometry object
# @return a new Geo::OGR::Geometry object
# @since 1.8.0
#*
sub SymDifference {
}

#** @method scalar Touches($other)
# Object method.
# @param other a Geo::OGR::Geometry object
# @return true if this geometry touches the other geometry, false otherwise
#*
sub Touches {
}

#** @method Transform($trans)
# Object method.
# @param trans a Geo::OSR::CoordinateTransformation object
#*
sub Transform {
}

#** @method TransformTo($srs)
# Object method.
# @param srs a Geo::OSR::SpatialReference object
#*
sub TransformTo {
}

#** @method Geo::OGR::Geometry Union($other)
# Object method.
# @param other a Geo::OGR::Geometry object
# @return a new Geo::OGR::Geometry object
#*
sub Union {
}

#** @method Geo::OGR::Geometry UnionCascaded()
# Object method.
# @return a new Geo::OGR::Geometry object
# @since 1.8.0
#*
sub UnionCascaded {
}

#** @method Value()
#*
sub Value {
}

#** @method scalar Within($other)
# Object method.
# @param other a Geo::OGR::Geometry object
# @return true if this geometry is within the other geometry, false otherwise
#*
sub Within {
}

#** @method scalar WkbSize()
# Object method.
# @return an integer
#*
sub WkbSize {
}

#** @method Geo::OGR::Geometry new(%params)
# Class method.
# @param %params A named parameter, one of:
# - \a GeometryType one the supported geometry types, see Geo::OGR::GeometryTypes.
# - \a WKT a well known text string, which defines a geometry.
# - \a WKB a well known binary string, which defines a geometry.
# - \a HEXWKB WKB in hexadecimal.
# - \a HEXEWKB PostGIS extended WKB.
# - \a GML geometry written in Geographic Markup Language.
# - \a GeoJSON geometry written in GeoJSON (JavaScript Object Notation for Geographic data).
# - \a arc a reference to a list of values defining an arc: [CenterX,
#    CenterY, CenterZ, PrimaryRadius, SecondaryRadius, Rotation,
#    StartAngle, EndAngle, MaxAngleStepSizeDegrees] (see also Geo::OGR::Geometry::ApproximateArcAngles)
# - \a Points An anonymous array as in method
#      Geo::OGR::Geometry::Points; Note: requires also GeometryType
#      parameter
# 
# @return a new Geo::OGR::Geometry object.
#*
sub new {
    my $pkg = shift;
    my %param;
    if (@_ == 1 and ref($_[0]) eq 'HASH') {
        %param = %{$_[0]};
    } elsif (@_ % 2 == 0) {
        %param = @_;
    } else {
        ($param{GeometryType}) = @_;
    }
    my $type = $param{GeometryType} // $param{Type} // $param{type};
    my $srs = $param{SRS} // $param{srs};
    my $wkt = $param{WKT} // $param{wkt};
    my $wkb = $param{WKB} // $param{wkb};
    my $hex = $param{HEXEWKB} // $param{HEX_EWKB} // $param{hexewkb} // $param{hex_ewkb};
    my $srid;
    if ($hex) {
        # EWKB contains SRID
        $srid = substr($hex, 10, 8);
        substr($hex, 10, 8) = '';
    } else {
        $hex = $param{HEXWKB} // $param{HEX_WKB} // $param{hexwkb} // $param{hex_wkb};
    }
    if ($hex) {
        $wkb = '';
        for (my $i = 0; $i < length($hex); $i+=2) {
            $wkb .= chr(hex(substr($hex,$i,2)));
        }
    }
    my $gml = $param{GML} // $param{gml};
    my $json = $param{GeoJSON} // $param{geojson} // $param{JSON} // $param{json};
    my $points = $param{Points} // $param{points};
    my $arc = $param{Arc} // $param{arc};
    my $self;
    if (defined $wkt) {
        $self = Geo::OGRc::CreateGeometryFromWkt($wkt, $srs);
    } elsif (defined $wkb) {
        $self = Geo::OGRc::CreateGeometryFromWkb($wkb, $srs);
    } elsif (defined $gml) {
        $self = Geo::OGRc::CreateGeometryFromGML($gml);
    } elsif (defined $json) {
        $self = Geo::OGRc::CreateGeometryFromJson($json);
    } elsif (defined $type) {
        $type = s2i(geometry_type => $type);
        $self = Geo::OGRc::new_Geometry($type); # flattens the type
        $self->Set3D(1) if HasZ($type);
        $self->SetMeasured(1) if HasM($type);
    } elsif (defined $arc) {
        $self = Geo::OGRc::ApproximateArcAngles(@$arc);
    } else {
        error(1, undef, map {$_=>1} qw/GeometryType WKT WKB HEXEWKB HEXWKB GML GeoJSON Arc/);
    }
    bless $self, $pkg if defined $self;
    $self->Points($points) if $points;
    return $self;
}

#** @class Geo::OGR::Layer
# @brief A collection of similar features.
# @details A layer object is typically obtained with a data source object. A
# layer has a data model (a schema), which is maintained in a
# definition object, and a set of features, which contain data
# according to the data model. The schema is typically set when the
# layer is created or opened, but it may be altered somewhat with
# methods Geo::OGR::Layer::CreateField,
# Geo::OGR::Layer::AlterFieldDefn, and
# Geo::OGR::Layer::DeleteField. Features and/or their data can be
# read, inserted and deleted. Reading can be filtered. Layers can be
# compared to each other with methods Clip, Erase, Identity,
# Intersection, SymDifference, Union, and Update.
# A layer may have metadata OLMD_FID64 => 'YES' if it holds features
# with 64 bit FIDs. The metadata of a layer can be obtained with
# GetMetadata method.
#*
package Geo::OGR::Layer;

use base qw(Geo::GDAL::MajorObject Geo::OGR)

#** @method AlterFieldDefn($name, %params)
# Object method.
# @param field the name of the field to be altered.
# @param params as in Geo::OGR::FieldDefn::new. Width and
# Precision should be both or neither.
# @note Only non-spatial fields can be altered.
# @note Also the deprecated form AlterFieldDefn($field,
# Geo::OGR::FieldDefn $Defn, $Flags) works.
#*
sub AlterFieldDefn {
    my $self = shift;
    my $index = $self->GetLayerDefn->GetFieldIndex(shift // 0);
    my $param = @_ % 2 == 0 ? {@_} : shift;
    if (blessed($param) and $param->isa('Geo::OGR::FieldDefn')) {
        _AlterFieldDefn($self, $index, @_);
    } else {
        my $definition = Geo::OGR::FieldDefn->new($param);
        my $flags = 0;
        $flags |= 1 if exists $param->{Name};
        $flags |= 2 if exists $param->{Type};
        $flags |= 4 if exists $param->{Width} or exists $param->{Precision};
        $flags |= 8 if exists $param->{Nullable};
        $flags |= 16 if exists $param->{Default};
        _AlterFieldDefn($self, $index, $definition, $flags);
    }
}

#** @method list Capabilities()
# Object method.
# Both a package subroutine and an object method.
# @return a list of capabilities. The object method returns a list of
# the capabilities the layer has. The package subroutine returns a list of
# all potential capabilities a layer may have. These are currently:
# AlterFieldDefn, CreateField, CreateGeomField, CurveGeometries, DeleteFeature, DeleteField, FastFeatureCount, FastGetExtent, FastSetNextByIndex, FastSpatialFilter, IgnoreFields, MeasuredGeometries, RandomRead, RandomWrite, ReorderFields, SequentialWrite, StringsAsUTF8, and Transactions.
# 
# Examples:
# \code
# @cap = Geo::OGR::Layer::Capabilities(); # the package subroutine
# @cap = $layer->Capabilities(); # the object method
# \endcode
#*
sub Capabilities {
    return @CAPABILITIES if @_ == 0;
    my $self = shift;
    my @cap;
    for my $cap (@CAPABILITIES) {
        push @cap, $cap if _TestCapability($self, $CAPABILITIES{$cap});
    }
    return @cap;
}

#** @method Clip(Geo::OGR::Layer method, Geo::OGR::Layer result, hashref options, coderef callback, $callback_data)
# Object method.
# Clip off areas that are not covered by the method layer. The schema
# of the result layer can be set before calling this method, or is
# initialized to to contain all fields from
# this and method layer.
# @param method method layer.
# @param result result layer.
# @param options a reference to an options hash.
# @param callback [optional] a reference to a subroutine, which will
# be called with parameters (number progress, string msg, callback_data)
# @param callback_data [optional]
#*
sub Clip {
}

#** @method CommitTransaction()
# Object method.
#*
sub CommitTransaction {
}

#** @method CreateFeature()
#*
sub CreateFeature {
}

#** @method CreateField(%params)
# Object method.
# Create a field.
# @param params as in Geo::OGR::FieldDefn::new or
# Geo::OGR::GeomFieldDefn::new, plus ApproxOK (whose default is true).
#*
sub CreateField {
    my $self = shift;
    my %defaults = ( ApproxOK => 1,
                     Type => '' );
    my %params;
    if (@_ == 0) {
    } elsif (ref($_[0]) eq 'HASH') {
        %params = %{$_[0]};
    } elsif (@_ % 2 == 0) {
        %params = @_;
    } else {
        ($params{Defn}) = @_;
    }
    for my $k (keys %defaults) {
        $params{$k} //= $defaults{$k};
    }
    if (blessed($params{Defn}) and $params{Defn}->isa('Geo::OGR::FieldDefn')) {
        $self->_CreateField($params{Defn}, $params{ApproxOK});
    } elsif (blessed($_[0]) and $params{Defn}->isa('Geo::OGR::GeomFieldDefn')) {
        $self->CreateGeomField($params{Defn}, $params{ApproxOK});
    } else {
        # if Name and Type are missing, assume Name => Type
        if (!(exists $params{Name} && exists $params{Type})) {
            for my $key (sort keys %params) {
                if (s_exists(field_type => $params{$key}) ||
                    s_exists(geometry_type => $params{$key}))
                {
                    $params{Name} = $key;
                    $params{Type} = $params{$key};
                    delete $params{$key};
                    last;
                }
            }
        }
        my $a = $params{ApproxOK};
        delete $params{ApproxOK};
        if (exists $params{GeometryType}) {
            $params{Type} = $params{GeometryType};
            delete $params{GeometryType};
        }
        if (s_exists(field_type => $params{Type})) {
            my $fd = Geo::OGR::FieldDefn->new(%params);
            _CreateField($self, $fd, $a);
        } elsif (s_exists(geometry_type => $params{Type})) {
            my $fd = Geo::OGR::GeomFieldDefn->new(%params);
            CreateGeomField($self, $fd, $a);
        } elsif ($params{Type} ) {
            error("Invalid field type: $params{Type}.")
        } elsif ($params{Name} ) {
            error("Missing type for field: $params{Name}.")
        } else {
            error("Missing name and type for a field.")
        }
    }
}

#** @method DataSource()
#*
sub DataSource {
}

#** @method Dataset()
#*
sub Dataset {
    my $self = shift;
    parent($self);
}

#** @method DeleteFeature($fid)
# Object method.
# @param fid feature id
#*
sub DeleteFeature {
}

#** @method DeleteField($field)
# Object method.
# Delete an existing field from a layer.
# @param field name (or index) of the field which is deleted
# @note Only non-spatial fields can be deleted.
#*
sub DeleteField {
    my ($self, $field) = @_;
    my $index = $self->GetLayerDefn->GetFieldIndex($field // 0);
    _DeleteField($self, $index);
}

#** @method Erase(Geo::OGR::Layer method, Geo::OGR::Layer result, hashref options, coderef callback, $callback_data)
# Object method.
# The result layer contains features whose geometries represent areas
# that are in the input layer but not in the method layer. The
# features in the result layer have attributes from the input
# layer. The schema of the result layer can be set by the user or, if
# it is empty, is initialized to contain all fields in the input
# layer.
# @param method method layer.
# @param result result layer.
# @param options a reference to an options hash.
# @param callback [optional] a reference to a subroutine, which will
# be called with parameters (number progress, string msg, callback_data)
# @param callback_data [optional]
#*
sub Erase {
}

#** @method Geo::OGR::Feature Feature($f)
# Object method.
# 
# @param f [optional] feature id, a feature, a row, or a tuple 
# 
# @note If the argument feature has a null FID (FID not set) the
# feature is inserted into the layer as a new feature. If the FID is
# non null, then the feature replaces the feature in the layer with
# that FID.
# 
# @return a new Geo::OGR::Feature object that represents the feature
# in the layer.
#*
sub Feature {
    my $self = shift;
    my $x = shift;
    return $self->GetFeature($x) unless $x && ref $x;
    # Insert or Set depending on the FID
    my $fid;
    if (ref $x eq 'ARRAY') {
        # FID is the first item in the array
        $fid = $x->[0];
    } elsif (ref $x eq 'HASH') {
        # FID is FID
        $fid = $x->{FID};
    } else {
        $fid = $x->FID;
    }
    # OGRNullFID is -1
    if (!defined $fid || $fid < 0) {
        $self->InsertFeature($x);
    } else {
        $self->SetFeature($x);
    }
}

#** @method scalar FeatureCount($force = 1)
# Object method.
# A.k.a GetFeatureCount
# @param force
# @return integer
#*
sub FeatureCount {
}

#** @method ForFeatures($code, $in_place)
# Object method.
# @note experimental, the syntax may change
# 
# Call code for all features. This is a simple wrapper for
# ResetReading and while(GetNextFeature).
# 
# Example usage:
# \code
# $layer->ForFeatures(sub {my $f = shift; $self->DeleteFeature($f->FID)}); # empties the layer
# \endcode
# 
# @param code a reference to a subroutine, which is called with each
# feature as an argument
# @param in_place if set to true, the feature is stored back to the
# layer
#*
sub ForFeatures {
    my $self = shift;
    my $code = shift;
    my $in_place = shift;
    $self->ResetReading;
    while (my $f = $self->GetNextFeature) {
        keep($f, $self);
        $code->($f);
        $self->SetFeature($f) if $in_place;
    };
}

#** @method ForGeometries($code, $in_place)
# Object method.
# @note experimental, the syntax may change
# 
# Call code for all geometries. This is a simple wrapper for
# ResetReading and while(GetNextFeature).
# 
# Example usage:
# \code
# my $area = 0;
# $layer->ForGeometries(sub {my $g = shift; $area += $g->Area}); # computes the total area
# \endcode
# 
# @param code a reference to a subroutine, which is called with each
# geometry as an argument
# @param in_place if set to true, the geometry is stored back to the
# layer
#*
sub ForGeometries {
    my $self = shift;
    my $code = shift;
    my $in_place = shift;
    $self->ResetReading;
    while (my $f = $self->GetNextFeature) {
        my $g = $f->Geometry();
        $code->($g);
        if ($in_place) {
            $f->Geometry($g);
            $self->SetFeature($f);
        }
    }
}

#** @method scalar GeometryType($field)
# Object method.
# @param field the name or index of the spatial field.
# @return the geometry type of the spatial field.
#*
sub GeometryType {
    my $self = shift;
    my $d = $self->GetDefn;
    my $field = $d->GetGeomFieldIndex(shift // 0);
    my $fd = $d->_GetGeomFieldDefn($field);
    return $fd->Type if $fd;
}

#** @method Geo::OGR::DataSource GetDataSource()
# Object method.
# @return the data source object to which this layer object belongs to.
#*
sub GetDataSource {
    my $self = shift;
    parent($self);
}

#** @method Geo::OGR::FeatureDefn GetDefn()
# Object method.
# A.k.a GetLayerDefn.
# @return a Geo::OGR::FeatureDefn object.
#*
sub GetDefn {
    my $self = shift;
    my $defn = $self->GetLayerDefn;
    keep($defn, $self);
}

#** @method list GetExtent($force = 1)
# Object method.
# @param force compute the extent even if it is expensive
# @note In scalar context returns a reference to an anonymous array
# containing the extent.
# @return the extent ($minx, $maxx, $miny, $maxy)
# @param force
# @return the extent = ($minx, $maxx, $miny, $maxy) as a listref
#*
sub GetExtent {
}

#** @method scalar GetFIDColumn()
# Object method.
# @return the name of the underlying database column being used as the
# FID column, or "" if not supported.
#*
sub GetFIDColumn {
}

#** @method Geo::OGR::Feature GetFeature($fid)
# Object method.
# @param fid feature id
# @return a new Geo::OGR::Feature object that represents the feature in the layer.
#*
sub GetFeature {
    my ($self, $fid) = @_;
    $fid //= 0;
    my $f = $self->_GetFeature($fid);
    error(2, "FID=$fid", '"Feature') unless ref $f eq 'Geo::OGR::Feature';
    keep($f, $self);
}

#** @method GetFeatureCount()
#*
sub GetFeatureCount {
}

#** @method scalar GetFeaturesRead()
# Object method.
# @return integer
#*
sub GetFeaturesRead {
}

#** @method scalar GetFieldDefn($name)
# Object method.
# Get the definition of a field.
# @param name the name of the field.
# @return a Geo::OGR::FieldDefn object.
#*
sub GetFieldDefn {
    my $self = shift;
    my $d = $self->GetDefn;
    my $field = $d->GetFieldIndex(shift // 0);
    return $d->_GetFieldDefn($field);
}

#** @method list GetFieldNames()
# Object method.
# @return a list of the names of the fields in this layer. The
# non-geometry field names are first in the list and then the geometry
# fields.
#*
sub GetFieldNames {
    my $self = shift;
    my $d = $self->GetDefn;
    my @ret;
    for (my $i = 0; $i < $d->GetFieldCount; $i++) {
        push @ret, $d->GetFieldDefn($i)->Name();
    }
    for (my $i = 0; $i < $d->GetGeomFieldCount; $i++) {
        push @ret, $d->GetGeomFieldDefn($i)->Name();
    }
    return @ret;
}

#** @method scalar GetGeomFieldDefn($name)
# Object method.
# Get the definition of a spatial field.
# @param name the name of the spatial field.
# @return a Geo::OGR::GeomFieldDefn object.
#*
sub GetGeomFieldDefn {
    my $self = shift;
    my $d = $self->GetDefn;
    my $field = $d->GetGeomFieldIndex(shift // 0);
    return $d->_GetGeomFieldDefn($field);
}

#** @method scalar GetName()
# Object method.
# @return the name of the layer.
#*
sub GetName {
}

#** @method Geo::OGR::Feature GetNextFeature()
# Object method.
# @return iteratively Geo::OGR::Feature objects from the layer. The
# iteration obeys the spatial and the attribute filter.
#*
sub GetNextFeature {
}

#** @method hash reference GetSchema()
# Object method.
# @brief Get the schema of this layer.
# @note The schema of a layer cannot be set with this method.  If you
# have a Geo::OGR::FeatureDefn object before creating the layer, use
# its schema in the Geo::OGR::CreateLayer method.
# @return the schema of this layer, as in Geo::OGR::FeatureDefn::Schema.
#*
sub GetSchema {
    my $self = shift;
    carp "Schema of a layer should not be set directly." if @_;
    if (@_ and @_ % 2 == 0) {
        my %schema = @_;
        if ($schema{Fields}) {
            for my $field (@{$schema{Fields}}) {
                $self->CreateField($field);
            }
        }
    }
    return $self->GetDefn->Schema;
}

#** @method Geo::OGR::Geometry GetSpatialFilter()
# Object method.
# @return a new Geo::OGR::Geometry object
#*
sub GetSpatialFilter {
}

#** @method GetStyleTable()
#*
sub GetStyleTable {
}

#** @method Identity(Geo::OGR::Layer method, Geo::OGR::Layer result, hashref options, coderef callback, $callback_data)
# Object method.
# The result layer contains features whose geometries represent areas
# that are in the input layer. The features in the result layer have
# attributes from both input and method layers. The schema of the
# result layer can be set by the user or, if it is empty, is
# initialized to contain all fields in input and method layers.
# @param method method layer.
# @param result result layer.
# @param options a reference to an options hash.
# @param callback [optional] a reference to a subroutine, which will
# be called with parameters (number progress, string msg, callback_data)
# @param callback_data [optional]
#*
sub Identity {
}

#** @method InsertFeature($feature)
# Object method.
# Creates a new feature which has the schema of the layer and
# initializes it with data from the argument. Then inserts the feature
# into the layer (using CreateFeature). Uses Geo::OGR::Feature::Row or
# Geo::OGR::Feature::Tuple.
# @param feature a Geo::OGR::Feature object or reference to feature
# data in a hash (as in Geo::OGR::Feature::Row) or in an array (as in
# Geo::OGR::Feature::Tuple)
# @return the new feature.
#*
sub InsertFeature {
    my $self = shift;
    my $feature = shift;
    error("Usage: \$feature->InsertFeature(reference to a hash or array).") unless ref($feature);
    my $new = Geo::OGR::Feature->new(Schema => $self, Values => $feature);
    $self->CreateFeature($new);
    return unless defined wantarray;
    keep($new, $self);
}

#** @method Intersection(Geo::OGR::Layer method, Geo::OGR::Layer result, hashref options, coderef callback, $callback_data)
# Object method.
# The result layer contains features whose geometries represent areas
# that are common between features in the input layer and in the
# method layer. The schema of the result layer can be set before
# calling this method, or is initialized to contain all fields from
# this and method layer.
# @param method method layer.
# @param result result layer.
# @param options a reference to an options hash.
# @param callback [optional] a reference to a subroutine, which will
# be called with parameters (number progress, string msg, callback_data)
# @param callback_data [optional]
#*
sub Intersection {
}

#** @method RELEASE_PARENT()
#*
sub RELEASE_PARENT {
    my $self = shift;
    unkeep($self);
}

#** @method ReorderField()
#*
sub ReorderField {
}

#** @method ReorderFields()
#*
sub ReorderFields {
}

#** @method ResetReading()
# Object method.
# Initialize the layer object for iterative reading.
#*
sub ResetReading {
}

#** @method RollbackTransaction()
# Object method.
#*
sub RollbackTransaction {
}

#** @method hash reference Row(%row)
# Object method.
# Get and/or set the data of a feature that has the supplied feature
# id (the next feature obtained with GetNextFeature is used if feature
# id is not given). Calls Geo::OGR::Feature::Row.
# @param row [optional] feature data
# @return a reference to feature data in a hash
#*
sub Row {
    my $self = shift;
    my $update = @_ > 0;
    my %row = @_;
    my $feature = defined $row{FID} ? $self->GetFeature($row{FID}) : $self->GetNextFeature;
    return unless $feature;
    my $ret;
    if (defined wantarray) {
        $ret = $feature->Row(@_);
    } else {
        $feature->Row(@_);
    }
    $self->SetFeature($feature) if $update;
    return unless defined wantarray;
    return $ret;
}

#** @method SetAttributeFilter($filter_string)
# Object method.
# Set or clear the attribute filter.
# @param filter_string a SQL WHERE clause or undef to clear the
# filter.
#*
sub SetAttributeFilter {
}

#** @method SetFeature($feature)
# Object method.
# @note The feature should have the same schema as the layer.
# 
# Replaces a feature in the layer based on the given feature's
# id. Requires RandomWrite capability.
# @param feature a Geo::OGR::Feature object
#*
sub SetFeature {
}

#** @method SetIgnoredFields(@fields)
# Object method.
# @param fields a list of field names
#*
sub SetIgnoredFields {
}

#** @method SetNextByIndex($new_index)
# Object method.
# @param new_index the index to which set the read cursor in the
# current iteration
#*
sub SetNextByIndex {
}

#** @method SetSpatialFilter($filter)
# Object method.
# @param filter [optional] a Geo::OGR::Geometry object. If not given,
# removes the filter if there is one.
#*
sub SetSpatialFilter {
}

#** @method SetSpatialFilterRect($minx, $miny, $maxx, $maxy)
# Object method.
# @param minx
# @param miny
# @param maxx
# @param maxy
#*
sub SetSpatialFilterRect {
}

#** @method SetStyleTable()
#*
sub SetStyleTable {
}

#** @method Geo::OGR::Geometry SpatialFilter(@filter)
# Object method.
# @param filter [optional] a Geo::OGR::Geometry object or a string. An
# undefined value removes the filter if there is one.
# @return a new Geo::OGR::Geometry object
# @param filter [optional] a rectangle ($minx, $miny, $maxx, $maxy).
# @return a new Geo::OGR::Geometry object
#*
sub SpatialFilter {
    my $self = shift;
    $self->SetSpatialFilter($_[0]) if @_ == 1;
    $self->SetSpatialFilterRect(@_) if @_ == 4;
    return unless defined wantarray;
    $self->GetSpatialFilter;
}

#** @method Geo::OSR::SpatialReference SpatialReference($name, Geo::OSR::SpatialReference sr)
# Object method.
# @note A.k.a GetSpatialRef.
# Get or set the projection of a spatial field of this layer. Gets or
# sets the projection of the first field if no field name is given.
# @param name [optional] a name of a spatial field in this layer.
# @param sr [optional] a Geo::OSR::SpatialReference object,
# which replaces the existing projection.
# @return a Geo::OSR::SpatialReference object, which represents the
# projection in the given spatial field.
#*
sub SpatialReference {
    my $self = shift;
    my $d = $self->GetDefn;
    my $field = @_ == 2 ? $d->GetGeomFieldIndex(shift // 0) : 0;
    my $sr = shift;
    my $d2 = $d->_GetGeomFieldDefn($field);
    $d2->SpatialReference($sr) if defined $sr;
    return $d2->SpatialReference() if defined wantarray;
}

#** @method StartTransaction()
# Object method.
#*
sub StartTransaction {
}

#** @method SymDifference(Geo::OGR::Layer method, Geo::OGR::Layer result, hashref options, coderef callback, $callback_data)
# Object method.
# The result layer contains features whose geometries represent areas
# that are in either in the input layer or in the method layer but not
# in both. The features in the result layer have attributes from both
# input and method layers. For features which represent areas that are
# only in the input or in the method layer the respective attributes
# have undefined values. The schema of the result layer can be set by
# the user or, if it is empty, is initialized to contain all fields in
# the input and method layers.
# @param method method layer.
# @param result result layer.
# @param options a reference to an options hash.
# @param callback [optional] a reference to a subroutine, which will
# be called with parameters (number progress, string msg, callback_data)
# @param callback_data [optional]
#*
sub SymDifference {
}

#** @method SyncToDisk()
# Object method.
#*
sub SyncToDisk {
}

#** @method scalar TestCapability($cap)
# Object method.
# @param cap A capability string.
# @return a boolean value indicating whether the layer has the
# specified capability.
#*
sub TestCapability {
    my($self, $cap) = @_;
    return _TestCapability($self, $CAPABILITIES{$cap});
}

#** @method list Tuple(@tuple)
# Object method.
# Get and/set the data of a feature that has the supplied feature id
# (the next feature obtained with GetNextFeature is used if feature id
# is not given). The expected data in the tuple is: ([feature id,]
# non-spatial fields, spatial fields). Calls Geo::OGR::Feature::Tuple.
# @param tuple [optional] feature data
# @note The schema of the tuple needs to be the same as that of the
# layer.
# @return a reference to feature data in an array
#*
sub Tuple {
    my $self = shift;
    my $FID = shift;
    my $feature = defined $FID ? $self->GetFeature($FID) : $self->GetNextFeature;
    return unless $feature;
    my $set = @_ > 0;
    unshift @_, $feature->GetFID if $set;
    my @ret;
    if (defined wantarray) {
        @ret = $feature->Tuple(@_);
    } else {
        $feature->Tuple(@_);
    }
    $self->SetFeature($feature) if $set;
    return unless defined wantarray;
    return @ret;
}

#** @method Union(Geo::OGR::Layer method, Geo::OGR::Layer result, hashref options, coderef callback, $callback_data)
# Object method.
# The result layer contains features whose geometries represent areas
# that are in either in the input layer or in the method layer. The
# schema of the result layer can be set before calling this method, or
# is initialized to contain all fields from this and method layer.
# @param method method layer.
# @param result result layer.
# @param options a reference to an options hash.
# @param callback [optional] a reference to a subroutine, which will
# be called with parameters (number progress, string msg, callback_data)
# @param callback_data [optional]
#*
sub Union {
}

#** @method Update(Geo::OGR::Layer method, Geo::OGR::Layer result, hashref options, coderef callback, $callback_data)
# Object method.
# The result layer contains features whose geometries represent areas
# that are either in the input layer or in the method layer. The
# features in the result layer have areas of the features of the
# method layer or those ares of the features of the input layer that
# are not covered by the method layer. The features of the result
# layer get their attributes from the input layer. The schema of the
# result layer can be set by the user or, if it is empty, is
# initialized to contain all fields in the input layer.
# @param method method layer.
# @param result result layer.
# @param options a reference to an options hash.
# @param callback [optional] a reference to a subroutine, which will
# be called with parameters (number progress, string msg, callback_data)
# @param callback_data [optional]
#*
sub Update {
}

#** @class Geo::OGR::StyleTable
#*
package Geo::OGR::StyleTable;

use base qw(Geo::OGR)

#** @method AddStyle()
#*
sub AddStyle {
}

#** @method Find()
#*
sub Find {
}

#** @method GetLastStyleName()
#*
sub GetLastStyleName {
}

#** @method GetNextStyle()
#*
sub GetNextStyle {
}

#** @method LoadStyleTable()
#*
sub LoadStyleTable {
}

#** @method ResetStyleStringReading()
#*
sub ResetStyleStringReading {
}

#** @method SaveStyleTable()
#*
sub SaveStyleTable {
}

#** @method new()
#*
sub new {
    my $pkg = shift;
    my $self = Geo::OGRc::new_StyleTable(@_);
    bless $self, $pkg if defined($self);
}

#** @class Geo::OSR
# @brief Base class for projection related classes.
# @details
#*
package Geo::OSR;

#** @method list AngularUnits()
# Package subroutine.
# @return list of known angular units.
#*
sub AngularUnits {
    return keys %ANGULAR_UNITS;
}

#** @method CreateCoordinateTransformation()
#*
sub CreateCoordinateTransformation {
}

#** @method list Datums()
# Package subroutine.
# @return list of known datums.
#*
sub Datums {
    return keys %DATUMS;
}

#** @method list GetProjectionMethodParamInfo($projection, $parameter)
# Package subroutine.
# @param projection one of Geo::OSR::Projections
# @param parameter one of Geo::OSR::Parameters
# @return a list ($user_friendly_name, $type, $default_value).
#*
sub GetProjectionMethodParamInfo {
}

#** @method list GetProjectionMethodParameterList($projection)
# Package subroutine.
# @param projection one of Geo::OSR::Projections
# @return a list (arrayref parameters, $projection_name).
#*
sub GetProjectionMethodParameterList {
}

#** @method array reference GetProjectionMethods()
# Package subroutine.
# @deprecated Use Geo::OSR::Projections.
# 
# @return reference to an array of possible projection methods.
#*
sub GetProjectionMethods {
}

#** @method scalar GetUserInputAsWKT($name)
# Package subroutine.
# @param name the user input
# @return a WKT string.
#*
sub GetUserInputAsWKT {
}

#** @method scalar GetWellKnownGeogCSAsWKT($name)
# Package subroutine.
# @brief Get well known geographic coordinate system as WKT
# @param name a well known name
# @return a WKT string.
#*
sub GetWellKnownGeogCSAsWKT {
}

#** @method list LinearUnits()
# Package subroutine.
# @return list of known linear units.
#*
sub LinearUnits {
    return keys %LINEAR_UNITS;
}

#** @method OAO_Down()
#*
sub OAO_Down {
}

#** @method OAO_East()
#*
sub OAO_East {
}

#** @method OAO_North()
#*
sub OAO_North {
}

#** @method OAO_Other()
#*
sub OAO_Other {
}

#** @method OAO_South()
#*
sub OAO_South {
}

#** @method OAO_Up()
#*
sub OAO_Up {
}

#** @method OAO_West()
#*
sub OAO_West {
}

#** @method list Parameters()
# Package subroutine.
# @return list of known projection parameters.
#*
sub Parameters {
    return keys %PARAMETERS;
}

#** @method list Projections()
# Package subroutine.
# @return list of known projections.
#*
sub Projections {
    return keys %PROJECTIONS;
}

#** @method RELEASE_PARENT()
#*
sub RELEASE_PARENT {
}

#** @method SRS_PM_GREENWICH()
#*
sub SRS_PM_GREENWICH {
}

#** @method SRS_WGS84_INVFLATTENING()
#*
sub SRS_WGS84_INVFLATTENING {
}

#** @method SRS_WGS84_SEMIMAJOR()
#*
sub SRS_WGS84_SEMIMAJOR {
}

#** @method SRS_WKT_WGS84()
#*
sub SRS_WKT_WGS84 {
}

#** @class Geo::OSR::CoordinateTransformation
# @brief An object for transforming from one projection to another.
# @details
#*
package Geo::OSR::CoordinateTransformation;

use base qw(Geo::OSR)

#** @method array reference TransformPoint($x, $y, $z)
# Object method.
# @param x
# @param y
# @param z [optional]
# @return arrayref = [$x, $y, $z]
#*
sub TransformPoint {
}

#** @method TransformPoints(arrayref points)
# Object method.
# @param points [in/out] a reference to a list of points (line string
# or ring) that is modified in-place. A list of points is: ([x, y, z],
# [x, y, z], ...), where z is optional. Supports also lists of line
# strings and polygons.
#*
sub TransformPoints {
    my($self, $points) = @_;
    _TransformPoints($self, $points), return unless ref($points->[0]->[0]);
    for my $p (@$points) {
        TransformPoints($self, $p);
    }
}
1;
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.7
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
}

#** @method Geo::OSR::CoordinateTransformation new($src, $dst)
# Class method.
# @param src a Geo::OSR::SpatialReference object
# @param dst a Geo::OSR::SpatialReference object
# @return a new Geo::OSR::CoordinateTransformation object
#*
sub new {
    my $pkg = shift;
    my $self = Geo::OSRc::new_CoordinateTransformation(@_);
    bless $self, $pkg if defined($self);
}

#** @class Geo::OSR::SpatialReference
# @brief A spatial reference system.
# @details <a href="http://www.gdal.org/classOGRSpatialReference.html">Documentation
# of the underlying C++ class at www.gdal.org</a>
#*
package Geo::OSR::SpatialReference;

use base qw(Geo::OSR)

#** @method As()
#*
sub As {
}

#** @method AutoIdentifyEPSG()
# Object method.
# Set EPSG authority info if possible.
#*
sub AutoIdentifyEPSG {
}

#** @method Geo::OSR::SpatialReference Clone()
# Object method.
# Make a duplicate of this SpatialReference object.
# @return a new Geo::OSR::SpatialReference object
#*
sub Clone {
}

#** @method Geo::OSR::SpatialReference CloneGeogCS()
# Object method.
# Make a duplicate of the GEOGCS node of this SpatialReference object.
# @return a new Geo::OSR::SpatialReference object
#*
sub CloneGeogCS {
}

#** @method CopyGeogCSFrom($rhs)
# Object method.
# @param rhs Geo::OSR::SpatialReference
#*
sub CopyGeogCSFrom {
}

#** @method EPSGTreatsAsLatLong()
# Object method.
# Returns TRUE if EPSG feels this geographic coordinate system should be treated as having lat/long coordinate ordering.
#*
sub EPSGTreatsAsLatLong {
}

#** @method EPSGTreatsAsNorthingEasting()
#*
sub EPSGTreatsAsNorthingEasting {
}

#** @method Export($format)
# Object method.
# Export the spatial reference to a selected format.
# @note a.k.a. As
# 
# @param format One of the following. The return value is explained
# after the format. Other arguments are explained in parenthesis.
# - WKT (Text): Well Known Text string
# - PrettyWKT: Well Known Text string nicely formatted (simplify)
# - Proj4: PROJ.4 string
# - PCI: a list: ($proj_string, $units, [$parms1, ...])
# - USGS: a list: ($code, $zone, [$parms1, ...], $datum)
# - GML (XML): GML based string (dialect)
# - MapInfoCS (MICoordSys): MapInfo style co-ordinate system definition
# 
# @note The named parameter syntax also works and is needed is those
# cases when other arguments need or may be given. The format should
# be given using key as, 'to' or 'format'.
# 
# @note ExportTo* and AsText methods also exist but are not documented here.
# 
# @return a scalar or a list depending on the export format
#*
sub Export {
    my $self = shift;
    my $format;
    $format = pop if @_ == 1;
    my %params = @_;
    $format //= $params{to} //= $params{format} //= $params{as} //= '';
    my $simplify = $params{simplify} // 0;
    my $dialect = $params{dialect} // '';
    my %converters = (
        WKT => sub { return ExportToWkt($self) },
        Text => sub { return ExportToWkt($self) },
        PrettyWKT => sub { return ExportToPrettyWkt($self, $simplify) },
        Proj4 => sub { return ExportToProj4($self) },
        PCI => sub { return ExportToPCI($self) },
        USGS => sub { return ExportToUSGS($self) },
        GML => sub { return ExportToXML($self, $dialect) },
        XML => sub { return ExportToXML($self, $dialect) },
        MICoordSys => sub { return ExportToMICoordSys() },
        MapInfoCS => sub { return ExportToMICoordSys() },
        );
    error(1, $format, \%converters) unless $converters{$format};
    return $converters{$format}->();
}

#** @method Fixup()
# Object method.
#*
sub Fixup {
}

#** @method FixupOrdering()
# Object method.
#*
sub FixupOrdering {
}

#** @method scalar GetAngularUnits()
# Object method.
# @return a number
#*
sub GetAngularUnits {
}

#** @method GetAngularUnitsName()
#*
sub GetAngularUnitsName {
}

#** @method scalar GetAttrValue($name, $child = 0)
# Object method.
# @param name
# @param child
# @return string
#*
sub GetAttrValue {
}

#** @method scalar GetAuthorityCode($target_key)
# Object method.
# @param target_key
# @return string
#*
sub GetAuthorityCode {
}

#** @method scalar GetAuthorityName($target_key)
# Object method.
# @param target_key
# @return string
#*
sub GetAuthorityName {
}

#** @method GetAxisName()
#*
sub GetAxisName {
}

#** @method GetAxisOrientation()
#*
sub GetAxisOrientation {
}

#** @method GetInvFlattening()
# Object method.
#*
sub GetInvFlattening {
}

#** @method scalar GetLinearUnits()
# Object method.
# @return a number
#*
sub GetLinearUnits {
}

#** @method scalar GetLinearUnitsName()
# Object method.
# @return string
#*
sub GetLinearUnitsName {
}

#** @method scalar GetNormProjParm($name, $default_val = 0.0)
# Object method.
# @param name
# @param default_val
# @return a number
#*
sub GetNormProjParm {
}

#** @method scalar GetProjParm($name, $default_val = 0.0)
# Object method.
# @param name
# @param default_val
# @return a number
#*
sub GetProjParm {
}

#** @method GetSemiMajor()
# Object method.
#*
sub GetSemiMajor {
}

#** @method GetSemiMinor()
# Object method.
#*
sub GetSemiMinor {
}

#** @method GetTOWGS84()
# Object method.
# @return array = ($p1, $p2, $p3, $p4, $p5, $p6, $p7)
#*
sub GetTOWGS84 {
}

#** @method GetTargetLinearUnits()
#*
sub GetTargetLinearUnits {
}

#** @method GetUTMZone()
# Object method.
# Get UTM zone information.
# @return The UTM zone (integer). In scalar context the returned value
# is negative for southern hemisphere zones. In list context returns
# two values ($zone, $north), where $zone is always non-negative and
# $north is true or false.
#*
sub GetUTMZone {
    my $self = shift;
    my $zone = _GetUTMZone($self);
    if (wantarray) {
        my $north = 1;
        if ($zone < 0) {
            $zone *= -1;
            $north = 0;
        }
        return ($zone, $north);
    } else {
        return $zone;
    }
}

#** @method ImportFromOzi()
#*
sub ImportFromOzi {
}

#** @method scalar IsCompound()
# Object method.
# @return boolean
#*
sub IsCompound {
}

#** @method scalar IsGeocentric()
# Object method.
# @return boolean
#*
sub IsGeocentric {
}

#** @method scalar IsGeographic()
# Object method.
# @return boolean
#*
sub IsGeographic {
}

#** @method scalar IsLocal()
# Object method.
# @return boolean
#*
sub IsLocal {
}

#** @method scalar IsProjected()
# Object method.
# @return boolean
#*
sub IsProjected {
}

#** @method scalar IsSame($rs)
# Object method.
# @param rs a Geo::OSR::SpatialReference object
# @return boolean
#*
sub IsSame {
}

#** @method scalar IsSameGeogCS($rs)
# Object method.
# @param rs a Geo::OSR::SpatialReference object
# @return boolean
#*
sub IsSameGeogCS {
}

#** @method scalar IsSameVertCS($rs)
# Object method.
# @param rs a Geo::OSR::SpatialReference object
# @return boolean
#*
sub IsSameVertCS {
}

#** @method scalar IsVertical()
# Object method.
# @return boolean
#*
sub IsVertical {
}

#** @method MorphFromESRI()
# Object method.
#*
sub MorphFromESRI {
}

#** @method MorphToESRI()
# Object method.
#*
sub MorphToESRI {
}

#** @method Set(%params)
# Object method.
# Set a parameter or parameters in the spatial reference object.
# @param params Named parameters. Recognized keys and respective
# values are the following.
# - Authority: authority name (give also TargetKey, Node and Code)
# - TargetKey:
# - Node: partial or complete path to the target node (Node and Value together sets an attribute value)
# - Code: code for value with an authority
# - Value: value to be assigned to a node, a projection parameter or an object
# - AngularUnits: angular units for the geographic coordinate system (give also Value) (one of Geo::OSR::LinearUnits)
# - LinearUnits: linear units for the target node or the object (give also Value and optionally Node) (one of Geo::OSR::LinearUnits)
# - Parameter: projection parameter to set (give also Value and Normalized) (one of Geo::OSR::Parameters)
# - Normalized: set to true to indicate that the Value argument is in "normalized" form
# - Name: a well known name of a geographic coordinate system (e.g. WGS84)
# - GuessFrom: arbitrary text that specifies a projection ("user input")
# - LOCAL_CS: name of a local coordinate system
# - GeocentricCS: name of a geocentric coordinate system
# - VerticalCS: name of a vertical coordinate system (give also Datum and optionally VertDatumType [default is 2005])
# - Datum: a known (OGC or EPSG) name (or(?) one of Geo::OSR::Datums)
# - CoordinateSystem: 'WGS', 'UTM', 'State Plane', or a user visible name (give optionally also Parameters, Zone, North, NAD83, UnitName, UnitConversionFactor, Datum, Spheroid, HorizontalCS, and/or VerticalCS
# - Parameters: a reference to a list containing the coordinate system or projection parameters
# - Zone: zone for setting up UTM or State Plane coordinate systems (State Plane zone in USGS numbering scheme)
# - North: set false for southern hemisphere
# - NAD83: set false if the NAD27 zone definition should be used instead of NAD83
# - UnitName: to override the legal definition for a zone
# - UnitConversionFactor: to override the legal definition for a zone
# - Spheroid: user visible name
# - HorizontalCS: Horizontal coordinate system name
# - Projection: name of a projection, one of Geo::OSR::Projections (give also optionally Parameters and Variant)
# 
# @note Numerous Set* methods also exist but are not documented here.
#*
sub Set {
    my($self, %params) = @_;
    if (exists $params{Authority} and exists $params{TargetKey} and exists $params{Node} and exists $params{Code}) {
        SetAuthority($self, $params{TargetKey}, $params{Authority}, $params{Code});
    } elsif (exists $params{Node} and exists $params{Value}) {
        SetAttrValue($self, $params{Node}, $params{Value});
    } elsif (exists $params{AngularUnits} and exists $params{Value}) {
        SetAngularUnits($self, $params{AngularUnits}, $params{Value});
    } elsif (exists $params{LinearUnits} and exists $params{Node} and exists $params{Value}) {
        SetTargetLinearUnits($self, $params{Node}, $params{LinearUnits}, $params{Value});
    } elsif (exists $params{LinearUnits} and exists $params{Value}) {
        SetLinearUnitsAndUpdateParameters($self, $params{LinearUnits}, $params{Value});
    } elsif ($params{Parameter} and exists $params{Value}) {
        error(1, $params{Parameter}, \%Geo::OSR::PARAMETERS) unless exists $Geo::OSR::PARAMETERS{$params{Parameter}};
        $params{Normalized} ?
            SetNormProjParm($self, $params{Parameter}, $params{Value}) :
            SetProjParm($self, $params{Parameter}, $params{Value});
    } elsif (exists $params{Name}) {
        SetWellKnownGeogCS($self, $params{Name});
    } elsif (exists $params{GuessFrom}) {
        SetFromUserInput($self, $params{GuessFrom});
    } elsif (exists $params{LOCAL_CS}) {
        SetLocalCS($self, $params{LOCAL_CS});
    } elsif (exists $params{GeocentricCS}) {
        SetGeocCS($self, $params{GeocentricCS});
    } elsif (exists $params{VerticalCS} and $params{Datum}) {
        my $type = $params{VertDatumType} || 2005;
        SetVertCS($self, $params{VerticalCS}, $params{Datum}, $type);
    } elsif (exists $params{CoordinateSystem}) {
        my @parameters = ();
        @parameters = @{$params{Parameters}} if ref($params{Parameters});
        if ($params{CoordinateSystem} eq 'State Plane' and exists $params{Zone}) {
            my $NAD83 = exists $params{NAD83} ? $params{NAD83} : 1;
            my $name = exists $params{UnitName} ? $params{UnitName} : undef;
            my $c = exists $params{UnitConversionFactor} ? $params{UnitConversionFactor} : 0.0;
            SetStatePlane($self, $params{Zone}, $NAD83, $name, $c);
        } elsif ($params{CoordinateSystem} eq 'UTM' and exists $params{Zone} and exists $params{North}) {
            my $north = exists $params{North} ? $params{North} : 1;
            SetUTM($self, $params{Zone}, $north);
        } elsif ($params{CoordinateSystem} eq 'WGS') {
            SetTOWGS84($self, @parameters);
        } elsif ($params{CoordinateSystem} and $params{Datum} and $params{Spheroid}) {
            SetGeogCS($self, $params{CoordinateSystem}, $params{Datum}, $params{Spheroid}, @parameters);
        } elsif ($params{CoordinateSystem} and $params{HorizontalCS} and $params{VerticalCS}) {
            SetCompoundCS($self, $params{CoordinateSystem}, $params{HorizontalCS}, $params{VerticalCS});
        } else {
            SetProjCS($self, $params{CoordinateSystem});
        }
    } elsif (exists $params{Projection}) {
        error(1, $params{Projection}, \%Geo::OSR::PROJECTIONS) unless exists $Geo::OSR::PROJECTIONS{$params{Projection}};
        my @parameters = ();
        @parameters = @{$params{Parameters}} if ref($params{Parameters});
        if ($params{Projection} eq 'Albers_Conic_Equal_Area') {
            SetACEA($self, @parameters);
        } elsif ($params{Projection} eq 'Azimuthal_Equidistant') {
            SetAE($self, @parameters);
        } elsif ($params{Projection} eq 'Bonne') {
            SetBonne($self, @parameters);
        } elsif ($params{Projection} eq 'Cylindrical_Equal_Area') {
            SetCEA($self, @parameters);
        } elsif ($params{Projection} eq 'Cassini_Soldner') {
            SetCS($self, @parameters);
        } elsif ($params{Projection} eq 'Equidistant_Conic') {
            SetEC($self, @parameters);
            # Eckert_I, Eckert_II, Eckert_III, Eckert_V ?
        } elsif ($params{Projection} eq 'Eckert_IV') {
            SetEckertIV($self, @parameters);
        } elsif ($params{Projection} eq 'Eckert_VI') {
            SetEckertVI($self, @parameters);
        } elsif ($params{Projection} eq 'Equirectangular') {
            @parameters == 4 ?
                SetEquirectangular($self, @parameters) :
                SetEquirectangular2($self, @parameters);
        } elsif ($params{Projection} eq 'Gauss_Schreiber_Transverse_Mercator') {
            SetGaussSchreiberTMercator($self, @parameters);
        } elsif ($params{Projection} eq 'Gall_Stereographic') {
            SetGS($self, @parameters);
        } elsif ($params{Projection} eq 'Goode_Homolosine') {
            SetGH($self, @parameters);
        } elsif ($params{Projection} eq 'Interrupted_Goode_Homolosine') {
            SetIGH($self);
        } elsif ($params{Projection} eq 'Geostationary_Satellite') {
            SetGEOS($self, @parameters);
        } elsif ($params{Projection} eq 'Gnomonic') {
            SetGnomonic($self, @parameters);
        } elsif ($params{Projection} eq 'Hotine_Oblique_Mercator') {
            # Hotine_Oblique_Mercator_Azimuth_Center ?
            SetHOM($self, @parameters);
        } elsif ($params{Projection} eq 'Hotine_Oblique_Mercator_Two_Point_Natural_Origin') {
            SetHOM2PNO($self, @parameters);
        } elsif ($params{Projection} eq 'Krovak') {
            SetKrovak($self, @parameters);
        } elsif ($params{Projection} eq 'Lambert_Azimuthal_Equal_Area') {
            SetLAEA($self, @parameters);
        } elsif ($params{Projection} eq 'Lambert_Conformal_Conic_2SP') {
            SetLCC($self, @parameters);
        } elsif ($params{Projection} eq 'Lambert_Conformal_Conic_1SP') {
            SetLCC1SP($self, @parameters);
        } elsif ($params{Projection} eq 'Lambert_Conformal_Conic_2SP_Belgium') {
            SetLCCB($self, @parameters);
        } elsif ($params{Projection} eq 'miller_cylindrical') {
            SetMC($self, @parameters);
        } elsif ($params{Projection} =~ /^Mercator/) {
            # Mercator_1SP, Mercator_2SP, Mercator_Auxiliary_Sphere ?
            # variant is in Variant (or Name)
            SetMercator($self, @parameters);
        } elsif ($params{Projection} eq 'Mollweide') {
            SetMollweide($self, @parameters);
        } elsif ($params{Projection} eq 'New_Zealand_Map_Grid') {
            SetNZMG($self, @parameters);
        } elsif ($params{Projection} eq 'Oblique_Stereographic') {
            SetOS($self, @parameters);
        } elsif ($params{Projection} eq 'Orthographic') {
            SetOrthographic($self, @parameters);
        } elsif ($params{Projection} eq 'Polyconic') {
            SetPolyconic($self, @parameters);
        } elsif ($params{Projection} eq 'Polar_Stereographic') {
            SetPS($self, @parameters);
        } elsif ($params{Projection} eq 'Robinson') {
            SetRobinson($self, @parameters);
        } elsif ($params{Projection} eq 'Sinusoidal') {
            SetSinusoidal($self, @parameters);
        } elsif ($params{Projection} eq 'Stereographic') {
            SetStereographic($self, @parameters);
        } elsif ($params{Projection} eq 'Swiss_Oblique_Cylindrical') {
            SetSOC($self, @parameters);
        } elsif ($params{Projection} eq 'Transverse_Mercator_South_Orientated') {
            SetTMSO($self, @parameters);
        } elsif ($params{Projection} =~ /^Transverse_Mercator/) {
            my($variant) = $params{Projection} =~ /^Transverse_Mercator_(\w+)/;
            $variant //= $params{Variant} //= $params{Name};
            $variant ?
                SetTMVariant($self, $variant, @parameters) :
                SetTM($self, @parameters);
        } elsif ($params{Projection} eq 'Tunisia_Mining_Grid') {
            SetTMG($self, @parameters);
        } elsif ($params{Projection} eq 'VanDerGrinten') {
            SetVDG($self, @parameters);
        } else {
            # Aitoff, Craster_Parabolic, International_Map_of_the_World_Polyconic, Laborde_Oblique_Mercator
            # Loximuthal, Miller_Cylindrical, Quadrilateralized_Spherical_Cube, Quartic_Authalic, Two_Point_Equidistant
            # Wagner_I, Wagner_II, Wagner_III, Wagner_IV, Wagner_V, Wagner_VI, Wagner_VII
            # Winkel_I, Winkel_II, Winkel_Tripel
            # ?
            SetProjection($self, $params{Projection});
        }
    } else {
        error("Not enough information to create a spatial reference object.");
    }
}

#** @method StripCTParms()
# Object method.
#*
sub StripCTParms {
}

#** @method Validate()
# Object method.
#*
sub Validate {
}

#** @method Geo::OSR::SpatialReference new(%params)
# Class method.
# Create a new spatial reference object using a named parameter. This
# constructor recognizes the following key words (alternative in
# parenthesis): WKT (Text), Proj4, ESRI, EPSG, EPSGA, PCI, USGS, GML
# (XML), URL, ERMapper (ERM), MapInfoCS (MICoordSys). The value
# depends on the key.
# - WKT: Well Known Text string
# - Proj4: PROJ.4 string
# - ESRI: reference to a list of strings (contents of ESRI .prj file)
# - EPSG: EPSG code number
# - EPSGA: EPSG code number (the resulting CS will have EPSG preferred axis ordering)
# - PCI: listref: [PCI_projection_string, Grid_units_code, [17 cs parameters]]
# - USGS: listref: [Projection_system_code, Zone, [15 cs parameters], Datum_code, Format_flag]
# - GML: GML string
# - URL: URL for downloading the spatial reference from
# - ERMapper: listref: [Projection, Datum, Units]
# - MapInfoCS: MapInfo style co-ordinate system definition
# 
# For more information, consult the import methods in <a href="http://www.gdal.org/classOGRSpatialReference.html">OGR documentation</a>.
# 
# @note ImportFrom* methods also exist but are not documented here.
# 
# Usage:
# \code
# $sr = Geo::OSR::SpatialReference->new( key => value );
# \endcode
# @return a new Geo::OSR::SpatialReference object
#*
sub new {
    my $pkg = shift;
    my %param = @_;
    my $self = Geo::OSRc::new_SpatialReference();
    if (exists $param{WKT}) {
        ImportFromWkt($self, $param{WKT});
    } elsif (exists $param{Text}) {
        ImportFromWkt($self, $param{Text});
    } elsif (exists $param{Proj4}) {
        ImportFromProj4($self, $param{Proj4});
    } elsif (exists $param{ESRI}) {
        ImportFromESRI($self, @{$param{ESRI}});
    } elsif (exists $param{EPSG}) {
        ImportFromEPSG($self, $param{EPSG});
    } elsif (exists $param{EPSGA}) {
        ImportFromEPSGA($self, $param{EPSGA});
    } elsif (exists $param{PCI}) {
        ImportFromPCI($self, @{$param{PCI}});
    } elsif (exists $param{USGS}) {
        ImportFromUSGS($self, @{$param{USGS}});
    } elsif (exists $param{XML}) {
        ImportFromXML($self, $param{XML});
    } elsif (exists $param{GML}) {
        ImportFromGML($self, $param{GML});
    } elsif (exists $param{URL}) {
        ImportFromUrl($self, $param{URL});
    } elsif (exists $param{ERMapper}) {
        ImportFromERM($self, @{$param{ERMapper}});
    } elsif (exists $param{ERM}) {
        ImportFromERM($self, @{$param{ERM}});
    } elsif (exists $param{MICoordSys}) {
        ImportFromMICoordSys($self, $param{MICoordSys});
    } elsif (exists $param{MapInfoCS}) {
        ImportFromMICoordSys($self, $param{MapInfoCS});
    } elsif (exists $param{WGS}) {
        eval {
            SetWellKnownGeogCS($self, 'WGS'.$param{WGS});
        };
        confess last_error() if $@;
    } else {
        error("Unrecognized/missing parameters: @_.");
    }
    bless $self, $pkg if defined $self;
}