all.pm

Go to the documentation of this file.

#** @class Geo::GDAL
# @brief GDAL utility functions and a root class for raster classes.
# 
# Geo::GDAL wraps many GDAL utility functions and acts as a root class
# for all GDAL raster classes. A "raster" is a dataset, whose core is
# a rectagular grid or grids of pixels, called a "band" in GDAL. Each
# pixel contains a numeric value of a specific data type
#*
package Geo::GDAL;

use base qw()

#** @method list AccessTypes()
# Class method.
# @return a list of GDAL data set open modes. These are currently:
# ReadOnly, and Update.
#*
sub AccessTypes {
    return @ACCESS_TYPES;
}

#** @method Geo::GDAL::Dataset AutoCreateWarpedVRT(Geo::GDAL::Dataset src, Geo::OSR::SpatialReference src_srs=undef, Geo::OSR::SpatialReference dst_srs=undef, $ResampleAlg='NearestNeighbour', $maxerror=0.0)
# Class method.
# @param src
# @param src_srs source projection.
# @param dst_srs destination projection.
# @param ResampleAlg one of Geo::GDAL::ResamplingTypes().
# @param maxerror
# @return a new Geo::GDAL::Dataset object
# 
# <a href="http://www.gdal.org/gdalwarper_8h.html">Documentation for GDAL warper</a>
#*
sub AutoCreateWarpedVRT {
    my @p = @_;
    for my $i (1..2) {
        if (defined $p[$i] and ref($p[$i])) {
            $p[$i] = $p[$i]->ExportToWkt;
        }
    }
    if (defined $p[3]) {
        confess "Unknown data type: '$p[3]'." unless exists $Geo::GDAL::RESAMPLING_STRING2INT{$p[3]};
        $p[3] = $Geo::GDAL::RESAMPLING_STRING2INT{$p[3]};
    }
    return _AutoCreateWarpedVRT(@p);
}

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

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

#** @method list Child($node, $i)
# Class method.
# @param node
# @param i 0 .. number of children - 1
# @return
#*
sub Child {
    my($node, $child) = @_;
    return $node->[2+$child];
}

#** @method list Children($node)
# Class method.
# @param node
# @return
#*
sub Children {
    my $node = shift;
    return @$node[2..$#$node];
}

#** @method ComputeMedianCutPCT(Geo::GDAL::Band red, Geo::GDAL::Band green, Geo::GDAL::Band blue, $num_colors, $colors, subref progress, $progress_data)
# Class method.
# Compute an "optimal" color table for a three band image.
# @param red a Geo::GDAL::Band object
# @param green a Geo::GDAL::Band object
# @param blue a Geo::GDAL::Band object
# @param num_colors the desired number of colors 
# @param colors an empty Geo::GDAL::ColorTable object
# @param progress [optional] a reference to a subroutine, which will
# be called with parameters (number progress, string msg, progress_data)
# @param progress_data [optional]
# 
# <a href="http://www.gdal.org/gdal__alg_8h.html">Documentation for GDAL algorithms</a>
#*
sub ComputeMedianCutPCT {
    my @p = @_;
    $p[6] = 1 if $p[5] and not defined $p[6];
    _ComputeMedianCutPCT(@p);
}

#** @method ComputeProximity(Geo::GDAL::Band src, Geo::GDAL::Band proximity, hashref options, subref progress, $progress_data)
# Class method.
# @param src The raster from which the proximities are computed from.
# @param proximity The raster to which the proximities are computed to.
# @param options Options. Supported key, value pairs are 
# - VALUES => n[,n]* A list of target pixel values to measure the
# distance from.  If this option is not provided proximity will be
# computed from non-zero pixel values.  Currently pixel values are
# internally processed as integers.
# - DISTUNITS => PIXEL|GEO Indicates whether distances will be
# computed in pixel units or in georeferenced units.  The default is
# pixel units.  This also determines the interpretation of MAXDIST.
# - MAXDIST => n The maximum distance to search.  Proximity distances
# greater than this value will not be computed.  Instead output pixels
# will be set to a nodata value.
# - NODATA => n The NODATA value to use on the output band for pixels
# that are beyond MAXDIST.  If not provided, the hProximityBand will
# be queried for a nodata value.  If one is not found, 65535 will be
# used.
# - FIXED_BUF_VAL => n If this option is set, all pixels within the
# MAXDIST threadhold are set to this fixed value instead of to a
# proximity distance.
# @param progress [optional] a reference to a subroutine, which will
# be called with parameters (number progress, string msg, progress_data)
# @param progress_data [optional]
# 
# <a href="http://www.gdal.org/gdal__alg_8h.html">Documentation for GDAL algorithms</a>
#*
sub ComputeProximity {
    my @p = @_;
    $p[4] = 1 if $p[3] and not defined $p[4];
    _ComputeProximity(@p);
}

#** @method scalar DataTypeIsComplex($DataType)
# Class method.
# @param DataType A GDAL pixel data type (one of those listed by Geo::GDAL::DataTypes).
# @return true if the data type is a complex number.
#*
sub DataTypeIsComplex {
    my $t = shift;
    my $t2 = $t;
    $t2 = $TYPE_STRING2INT{$t} if exists $TYPE_STRING2INT{$t};
    confess "Unknown data type: '$t'." unless exists $TYPE_INT2STRING{$t2};
    return _DataTypeIsComplex($t2);
}

#** @method list DataTypeValueRange($DataType)
# Class method.
# @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;
    confess "Unknown data type: '$t'." unless exists $TYPE_STRING2INT{$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()
# Class method.
# @return a list of GDAL pixel data types. These are currently:
# Byte, CFloat32, CFloat64, CInt16, CInt32, Float32, Float64, Int16, Int32, UInt16, UInt32, and Unknown.
#*
sub DataTypes {
    return @DATA_TYPES;
}

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

#** @method scalar DecToDMS($angle, $axis, $precision=2)
# Class method.
# 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)
# Class method.
# @param dec Decimal degrees
# @return packed DMS, i.e., a number DDDMMMSSS.SS
#*
sub DecToPackedDMS {
}

#** @method DitherRGB2PCT($red, $green, $blue, $target, $colors, subref progress, $progress_data)
# Class method.
# Dither a three band image into one band using a color table.
# @param red a Geo::GDAL::Band object
# @param green a Geo::GDAL::Band object
# @param blue a Geo::GDAL::Band object
# @param target a Geo::GDAL::Band object
# @param colors a Geo::GDAL::ColorTable object
# @param progress [optional] a reference to a subroutine, which will
# be called with parameters (number progress, string msg, progress_data)
# @param progress_data [optional]
# 
# <a href="http://www.gdal.org/gdal__alg_8h.html">Documentation for GDAL algorithms</a>
#*
sub DitherRGB2PCT {
    my @p = @_;
    $p[6] = 1 if $p[5] and not defined $p[6];
    _DitherRGB2PCT(@p);
}

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

#** @method scalar FindFile($class, $basename)
# Class method.
# Search for GDAL support files.
# 
# An example:
# \code
# use Geo::GDAL;
# $a = Geo::GDAL::FindFile('gdal', 'pcs.csv');
# print STDERR "$a\n";
# \endcode
# Prints (for example):
# \code
# c:\msys\1.0\local\share\gdal\pcs.csv
# \endcode
# 
# @param class The class of files to search for. For example 'gdal'.
# @param basename The basename of the file to search for. For example
# 'pcs.csv'.
# @return the path to the searched file or undef.
#*
sub FindFile {
}

#** @method FinderClean()
# Class method.
# 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()
# Class method.
# @return maximum amount of memory (as bytes) for caching within GDAL.
#*
sub GetCacheMax {
}

#** @method scalar GetCacheUsed()
# Class method.
# @return the amount of memory currently used for caching within GDAL.
#*
sub GetCacheUsed {
}

#** @method scalar GetConfigOption($key, $default)
# Class method.
# @param key A GDAL config option.
# @param default A default value for the option.
# @return the value of the GDAL config option or the value of the
# default parameter.
#*
sub GetConfigOption {
}

#** @method scalar GetDataTypeSize($DataType)
# Class method.
# @param DataType A GDAL pixel data type (one of those listed by Geo::GDAL::DataTypes).
# @return the size as the number of bits.
#*
sub GetDataTypeSize {
    my $t = shift;
    my $t2 = $t;
    $t2 = $TYPE_STRING2INT{$t} if exists $TYPE_STRING2INT{$t};
    confess "Unknown data type: '$t'." unless exists $TYPE_INT2STRING{$t2};
    return _GetDataTypeSize($t2);
}

#** @method Geo::GDAL::Driver GetDriver($name)
# Class method.
# Create a driver object for the internal GDAL driver.
# @param name the (short) name of the driver.
# @return a Geo::GDAL::Driver object, which represents the internal driver.
#*
sub GetDriver {
    my($name) = @_;
    $name = 0 unless defined $name;
    my $driver;
    $driver = _GetDriver($name) if $name =~ /^\d+$/; # is the name an index to driver list?
    $driver = GetDriverByName("$name") unless $driver;
    if ($driver) {
        my $md = $driver->GetMetadata;
        confess "Driver exists but does not have raster capabilities." 
            unless $md->{DCAP_RASTER} and $md->{DCAP_RASTER} eq 'YES';
        return $driver;
    }
    confess "Driver not found: '$name'. Maybe support for it was not built in?";
}

#** @method list GetDriverNames()
# Class method.
# @return a list of the named of all (available and registered) GDAL
# raster drivers.
#*
sub GetDriverNames {
    my @names;
    for my $i (0..GetDriverCount()-1) {
        my $driver = _GetDriver($i);
        my $md = $driver->GetMetadata;
        next unless $md->{DCAP_RASTER} and $md->{DCAP_RASTER} eq 'YES';
        push @names, _GetDriver($i)->Name;
    }
    return @names;
}

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

#** @method Geo::GDAL::Driver IdentifyDriver($path, $siblings)
# Class method.
# @param path a dataset path.
# @param siblings [optional] A list of names of files in the directory
# specified by the path.
# @return a Geo::GDAL::Driver object, which represents an internal driver.
#*
sub IdentifyDriver {
}

#** @method list NodeData($node)
# Class method.
# @param node
# @return ($NodeType, $value)
#*
sub NodeData {
    my $node = shift;
    return (Geo::GDAL::NodeType($node->[0]), $node->[1]);
}

#** @method scalar NodeType($type)
# Class method.
# Convert between integer and string expressions of CPLXMLNodeTypes
# @param type (as integer)
# @return type (as string)
#*
sub NodeType {
    my $type = shift;
    return $NODE_TYPE_INT2STRING{$type} if $type =~ /^\d/;
    return $NODE_TYPE_STRING2INT{$type};
}

#** @method list NodeTypes()
# Class method.
# @return a list of GDAL XML parser node types. These are currently:
# Attribute, Comment, Element, Literal, and Text.
#*
sub NodeTypes {
    return @NODE_TYPES;
}

#** @method Geo::GDAL::Dataset Open($name, $access = 'ReadOnly')
# Class method.
# An example
# \code
# use Geo::GDAL;
# $ds = Geo::GDAL::Open('existing.tiff', 'Update');
# \endcode
# @param name
# @param access Access type (one of those listed by Geo::GDAL::AccessTypes).
# @return a new Geo::GDAL::Dataset object.
#*
sub Open {
    my @p = @_;
    if (defined $p[1]) {
        confess "Unknown access type: '$p[1]'." unless exists $Geo::GDAL::ACCESS_STRING2INT{$p[1]};
        $p[1] = $Geo::GDAL::ACCESS_STRING2INT{$p[1]};
    }
    return _Open(@p);
}

#** @method Geo::GDAL::Dataset OpenEx($name, $open_flags = 0, array reference allowed_drivers = undef, array reference open_options = undef, array reference sibling_files = undef);
# Class method.
# @return a new Geo::GDAL::Dataset object.
#*
sub OpenEx {
}

#** @method Geo::GDAL::Dataset OpenShared($name, $access = 'ReadOnly')
# Class method.
# @param name
# @param access Access type (one of those listed by Geo::GDAL::AccessTypes).
# @return a new Geo::GDAL::Dataset object.
#*
sub OpenShared {
    my @p = @_;
    if (defined $p[1]) {
        confess "Unknown access type: '$p[1]'." unless exists $Geo::GDAL::ACCESS_STRING2INT{$p[1]};
        $p[1] = $Geo::GDAL::ACCESS_STRING2INT{$p[1]};
    }
    return _OpenShared(@p);
}

#** @method scalar PackCharacter($DataType)
# Class method.
# 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 pixel 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 = $TYPE_INT2STRING{$t} if exists $TYPE_INT2STRING{$t};
    confess "Unknown data type: '$t'." unless exists $TYPE_STRING2INT{$t};
    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)
# Class method.
# @param packed DMS as a number DDDMMMSSS.SS
# @return decimal degrees
#*
sub PackedDMSToDec {
}

#** @method array reference ParseXMLString($XML)
# Class method.
# Parses a given XML into an array of arrays and returns a reference
# to that. An array in the structure is: (CPLXMLNodeType, value,
# child, child, ...). CPLXMLNodeType is an integer.
# @param XML
# @return an XMLTree.
# 
# Example:
# \code
# open FILE, "data.xml" or die "Couldn't open file: $!"; 
# my $xml = join("", <FILE>); 
# close FILE;
# my $tree = Geo::GDAL::ParseXMLString($xml);
# traverse($tree);
# print Geo::GDAL::SerializeXMLTree($tree),"\n";
# 
# sub traverse {
# .    my $node = shift;
# .    my $type = shift @$node;
# .    my $data = shift @$node;
# .    $type = Geo::GDAL::NodeType($type); 
# .    print "$type, $data\n";
# .    for my $child (@$node) {
# .        traverse($child);
# .    }
# }
# \endcode
#*
sub ParseXMLString {
}

#** @method Polygonize(Geo::GDAL::Band src, Geo::GDAL::Band mask, Geo::OGR::Layer out, $PixValField, hashref options, subref progress, $progress_data)
# Class method.
# @param src
# @param mask All pixels in the mask band with a value other than zero
# will be considered suitable for collection as polygons. Must be
# undef if not used.
# @param out
# @param PixValField The index (or name) of the field in output layer
# into which the pixel value of the polygon should be written.
# @param options Not used.
# @param progress [optional] a reference to a subroutine, which will
# be called with parameters (number progress, string msg, progress_data)
# @param progress_data [optional]
# 
# <a href="http://www.gdal.org/gdal__alg_8h.html">Documentation for GDAL algorithms</a>
#*
sub Polygonize {
    my @params = @_;
    $params[6] = 1 if $params[5] and not defined $params[6];
    $params[3] = $params[2]->GetLayerDefn->GetFieldIndex($params[3]) unless $params[3] =~ /^\d/;
    _Polygonize(@params);
}

#** @method PopFinderLocation()
# Class method.
# Remove the latest addition from the set of support file search
# paths.
#*
sub PopFinderLocation {
}

#** @method PushFinderLocation($path)
# Class method.
# Add a path to the set of paths from where GDAL support files are
# sought.
#*
sub PushFinderLocation {
}

#** @method list RIOResamplingTypes()
# Class method.
# @return a list of GDAL raster IO resampling methods.
#*
sub RIOResamplingTypes {
    return @RIO_RESAMPLING_TYPES;
}

#** @method RasterizeLayer(Geo::GDAL::Dataset ds, arrayref bands, Geo::OGR::Layer layer, $transformer, $arg, arrayref burn_values, hashref options, subref progress, $progress_data)
# Class method.
# @param ds
# @param bands A reference to a list of bands to be updated.
# @param layer
# @param transformer Not supported, must be undef.
# @param arg Transformer argument, must be undef.
# @param burn_values Values to be used for burning the geometries. One for each layer.
# @param options Not used.
# @param progress [optional] a reference to a subroutine, which will
# be called with parameters (number progress, string msg, progress_data)
# @param progress_data [optional]
# 
# <a href="http://www.gdal.org/gdal__alg_8h.html">Documentation for GDAL algorithms</a>
#*
sub RasterizeLayer {
    my @p = @_;
    $p[8] = 1 if $p[7] and not defined $p[8];
    _RasterizeLayer(@p);
}

#** @method ReprojectImage($src_ds, $dst_ds, $src_wkt=undef, $dst_wkt=undef, $ResampleAlg='NearestNeighbour', $WarpMemoryLimit=0, $maxerror=0.0, subref progress, $progress_data)
# Class method.
# @param src_ds Source dataset.
# @param dst_ds Destination dataset.
# @param src_wkt Source projection as a WKT.
# @param dst_wkt Destination projection as a WKT.
# @param ResampleAlg One of NearestNeighbour Bilinear Cubic or CubicSpline.
# @param WarpMemoryLimit The amount of memory allowed for caching. Default is 0, i.e., no limit.
# @param maxerror Maximum error measured in input pixels that is
# allowed in approximating the transformation. Default is 0.0, i.e.,
# exact calculations.
# @param progress [optional] a reference to a subroutine, which will
# be called with parameters (number progress, string msg, progress_data).
# Reprojection is terminated if the progress function returns 0.
# @param progress_data [optional]
# 
# <a href="http://www.gdal.org/gdalwarper_8h.html">Documentation for GDAL warper</a>
#*
sub ReprojectImage {
    my @p = @_;
    $p[8] = 1 if $p[7] and not defined $p[8];
    if (defined $p[4]) {
        confess "Unknown data type: '$p[4]'." unless exists $Geo::GDAL::RESAMPLING_STRING2INT{$p[4]};
        $p[4] = $Geo::GDAL::RESAMPLING_STRING2INT{$p[4]};
    }
    return _ReprojectImage(@p);
}

#** @method list ResamplingTypes()
# Class method.
# @return a list of GDAL resampling methods.
#*
sub ResamplingTypes {
    return @RESAMPLING_TYPES;
}

#** @method scalar SerializeXMLTree(arrayref XMLTree)
# Class method.
# @param XMLTree
# @return XML
#*
sub SerializeXMLTree {
}

#** @method SetCacheMax($Bytes)
# Class method.
# @param Bytes New maximum amount of memory for caching within GDAL.
# 
#*
sub SetCacheMax {
}

#** @method SetConfigOption($key, $value)
# Class method.
# @param key A GDAL config option. Possible values include
# 'GDAL_FORCE_CACHING', 'USE_RRD', GDAL_DATA', 'GDAL_SKIP',
# 'GDAL_DRIVER_PATH', 'GDAL_IGNORE_AXIS_ORIENTATION',
# 'GMLJP2OVERRIDE', 'GDAL_DISABLE_READDIR_ON_OPEN',
# 'GDAL_PAM_ENABLED', 'GDAL_PAM_MODE', 'GDAL_PAM_PROXY_DIR',
# 'GDAL_MAX_DATASET_POOL_SIZE', 'GDAL_FORCE_CACHING', 'GDAL_CACHEMAX',
# 'GDAL_SWATH_SIZE', 'PROJSO', 'CENTER_LONG',
# 'OGR_DEBUG_ORGANIZE_POLYGONS', 'OGR_ORGANIZE_POLYGONS',
# and 'GDAL_JP2K_ALT_OFFSETVECTOR_ORDER'.
# Consult the GDAL main documentation for the semantics of config options.
# @param value A value for the option, typically 'YES', 'NO',
# undef, a path, or a filename.
#*
sub SetConfigOption {
}

#** @method SieveFilter(Geo::GDAL::Band src, Geo::GDAL::Band mask, Geo::GDAL::Band dst, $threshold, $connectedness, hashref options, subref progress, $progress_data)
# Class method.
# Removes small raster polygons.
# @param src
# @param mask
# @param dst
# @param threshold An integer.
# @param connectedness 4 or 8
# @param options Not used.
# @param progress [optional] a reference to a subroutine, which will
# be called with parameters (number progress, string msg, progress_data)
# @param progress_data [optional]
# 
# <a href="http://www.gdal.org/gdal__alg_8h.html">Documentation for GDAL algorithms</a>
#*
sub SieveFilter {
    my @p = @_;
    $p[7] = 1 if $p[6] and not defined $p[7];
    _SieveFilter(@p);
}

#** @method scalar VersionInfo($request = 'VERSION_NUM')
# Class method.
# @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 {
}

#** @class Geo::GDAL::AsyncReader
# @brief Enable asynchronous requests.
# @todo Test and document.
# 
# This class is not yet documented nor tested in the GDAL Perl wrappers
#*
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.
#*
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)
# @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);
    $Geo::GDAL::RasterAttributeTable::BANDS{$r} = $self if $r;
    return $r;
}

#** @method list CategoryNames(@names)
# @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)
# 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 scalar ColorInterpretation($color_interpretation)
# @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 color interpretation, one of Geo::GDAL::Band::ColorInterpretations.
#*
sub ColorInterpretation {
    my($self, $ci) = @_;
    if (defined $ci) {
        my $ci2 = $ci;
        $ci2 = $COLOR_INTERPRETATION_STRING2INT{$ci} if exists $COLOR_INTERPRETATION_STRING2INT{$ci};
        confess "Unknown color interpretation: '$ci'." unless exists $COLOR_INTERPRETATION_INT2STRING{$ci2};
        SetRasterColorInterpretation($self, $ci2);
        return $ci;
    } else {
        return $COLOR_INTERPRETATION_INT2STRING{GetRasterColorInterpretation($self)};
    }
}

#** @method ColorInterpretations()
#*
sub ColorInterpretations {
    return @COLOR_INTERPRETATIONS;
}

#** @method Geo::GDAL::ColorTable ColorTable($ColorTable)
# Get or set the color table of this band.
# @param ColorTable [optional] a Geo::GDAL::ColorTable object
# @return a new Geo::GDAL::ColorTable object in a non-void context.
#*
sub ColorTable {
    my $self = shift;
    SetRasterColorTable($self, $_[0]) if @_ and defined $_[0];
    return unless defined wantarray;
    GetRasterColorTable($self);
}

#** @method ComputeBandStats($samplestep = 1)
# @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)
# @return arrayref MinMax = [min, max]
#*
sub ComputeRasterMinMax {
}

#** @method list ComputeStatistics($approx_ok, $progress = undef, $progress_data = undef)
# @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, subref Progress, $ProgressData)
# 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 %defaults = (DataSource => undef,
                    LayerConstructor => {Name => 'contours'},
                    ContourInterval => 100,
                    ContourBase => 0,
                    FixedLevels => [],
                    NoDataValue => undef,
                    IDField => -1,
                    ElevField => -1,
                    Progress => undef,
                    ProgressData => undef);
    my %params;
    if (!defined($_[0]) or (blessed($_[0]) and $_[0]->isa('Geo::OGR::DataSource'))) {
        ($params{DataSource}, $params{LayerConstructor},
         $params{ContourInterval}, $params{ContourBase},
         $params{FixedLevels}, $params{NoDataValue},
         $params{IDField}, $params{ElevField},
         $params{Progress}, $params{ProgressData}) = @_;
    } else {
        %params = @_;
        if (exists $params{progress}) {
            $params{Progress} = $params{progress};
            delete $params{progress};
        }
        if (exists $params{progress_data}) {
            $params{ProgressData} = $params{progress_data};
            delete $params{progress_data};
        }
    }
    for (keys %params) {
        carp "unknown parameter $_ in Geo::GDAL::Band::Contours" unless exists $defaults{$_};
    }
    for (keys %defaults) {
        $params{$_} = $defaults{$_} unless defined $params{$_};
    }
    $params{DataSource} = Geo::OGR::GetDriver('Memory')->CreateDataSource('ds')
        unless defined $params{DataSource};
    $params{LayerConstructor}->{Schema} = {} unless $params{LayerConstructor}->{Schema};
    $params{LayerConstructor}->{Schema}{Fields} = [] unless $params{LayerConstructor}->{Schema}{Fields};
    my %fields;
    unless ($params{IDField} =~ /^[+-]?\d+$/ or $fields{$params{IDField}}) {
        push @{$params{LayerConstructor}->{Schema}{Fields}}, {Name => $params{IDField}, Type => 'Integer'};
    }
    unless ($params{ElevField} =~ /^[+-]?\d+$/ or $fields{$params{ElevField}}) {
        my $type = $self->DataType() =~ /Float/ ? 'Real' : 'Integer';
        push @{$params{LayerConstructor}->{Schema}{Fields}}, {Name => $params{ElevField}, Type => $type};
    }
    my $layer = $params{DataSource}->CreateLayer($params{LayerConstructor});
    my $schema = $layer->GetLayerDefn;
    for ('IDField', 'ElevField') {
        $params{$_} = $schema->GetFieldIndex($params{$_}) unless $params{$_} =~ /^[+-]?\d+$/;
    }
    $params{ProgressData} = 1 if $params{Progress} and not defined $params{ProgressData};
    ContourGenerate($self, $params{ContourInterval}, $params{ContourBase}, $params{FixedLevels},
                    $params{NoDataValue}, $layer, $params{IDField}, $params{ElevField},
                    $params{Progress}, $params{ProgressData});
    return $layer;
}

#** @method CreateMaskBand(@flags)
# @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);
}
# GetMaskBand should be redefined and the result should be put into 
# %Geo::GDAL::Dataset::BANDS
# GetOverview should be redefined and the result should be put into 
# %Geo::GDAL::Dataset::BANDS
}

#** @method scalar DataType()
# @return the data type of this band (as string, one of Geo::GDAL::DataTypes).
#*
sub DataType {
    my $self = shift;
    return $Geo::GDAL::TYPE_INT2STRING{$self->{DataType}};
}

#** @method Domains()
#*
sub Domains {
    return @DOMAINS;
}

#** @method Fill($real_part, $imag_part = 0.0)
# 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, subref progress, $progress_data)
# Interpolate values for pixels in this raster. The pixels to fill
# should be marked in the mask band with zero.
# @note This is a wrapper for Geo::GDAL::FillNodata.
# 
# @param mask [optional] a mask band indicating pixels to be interpolated (zero valued) (default is to get it with Geo::GDAL::Band::GetMaskBand).
# @param max_search_dist [optional] the maximum number of pixels 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 {
    my $self = shift;
    my $mask = shift;
    $mask = $self->GetMaskBand unless $mask;
    my @p = @_;
    $p[0] = 10 unless defined $p[0];
    $p[1] = 0 unless defined $p[1];
    $p[2] = undef unless defined $p[2];
    $p[3] = undef unless defined $p[3];
    $p[4] = undef unless defined $p[1];
    Geo::GDAL::FillNodata($self, $mask, @p);
}

#** @method FlushCache()
# Write cached data to disk. There is usually no need to call this
# method.
#*
sub FlushCache {
}

#** @method scalar GetBandNumber()
# @note a.k.a. GetBand
# @return the number of this band.
#*
sub GetBandNumber {
}

#** @method list GetBlockSize()
# @return the size of a preferred i/o raster blocks as a list (width,
# height).
#*
sub GetBlockSize {
}

#** @method Geo::GDAL::ColorTable GetColorTable()
# @note a.k.a. GetRasterColorTable, see also ColorTable
# @return a color table object.
#*
sub GetColorTable {
}

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

#** @method list GetDefaultHistogram($force = 1, subref progress = undef, $progress_data = undef)
# @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]
# @return a list: ($min, $max, arrayref histogram).
#*
sub GetDefaultHistogram {
}

#** @method list GetHistogram(%parameters)
# 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
# @return a list which contains the count of values in each bucket
#*
sub GetHistogram {
    my $self = shift;
    my %defaults = (Min => -0.5,
                    Max => 255.5,
                    Buckets => 256,
                    IncludeOutOfRange => 0,
                    ApproxOK => 0,
                    Progress => undef,
                    ProgressData => undef);
    my %params = @_;
    for (keys %params) {
        carp "unknown parameter $_ in Geo::GDAL::Band::GetHistogram" unless exists $defaults{$_};
    }
    for (keys %defaults) {
        $params{$_} = $defaults{$_} unless defined $params{$_};
    }
    $params{ProgressData} = 1 if $params{Progress} and not defined $params{ProgressData};
    _GetHistogram($self, $params{Min}, $params{Max}, $params{Buckets},
                  $params{IncludeOutOfRange}, $params{ApproxOK},
                  $params{Progress}, $params{ProgressData});
}

#** @method Geo::GDAL::Band GetMaskBand()
# @return the mask band associated with this
# band.
#*
sub GetMaskBand {
}

#** @method list GetMaskFlags()
# @return th mask flags of the mask band associated with this
# band. The flags are 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()
# @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()
# @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)
# @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 {
}

#** @method scalar GetOverviewCount()
# @return the number of overviews available of the band.
#*
sub GetOverviewCount {
}

#** @method list GetStatistics($approx_ok, $force)
# @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()
# @return true or false.
#*
sub HasArbitraryOverviews {
}

#** @method list MaskFlags()
# Class method.
# @return the list of mask flags. These are
# - \a AllValid: There are no invalid pixels, 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)
# @note a.k.a. GetNoDataValue (get only), SetNoDataValue (set only)
# @param NoDataValue [optional]
# Get or set the "no data" value.
# @note $band->NoDataValue(undef) sets the "no data" value to the Posix
# floating point maximum.
# @return the "no data" value in scalar context. In list context
# returns the no data value or an out of range value and a boolean
# value, which indicates which is the case (true is first, false is
# second).
#*
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()
# @return the character to use in Perl pack and unpack for the DataType of this band.
#*
sub PackCharacter {
    my $self = shift;
    return Geo::GDAL::PackCharacter($self->DataType);
}

#** @method scalar ReadRaster(%params)
# Read data from the band.
# 
# @param params named parameters. These are
# - \a XOff x offset (pixel coordinates) (default is 0)
# - \a YOff y offset (pixel 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)
# 
# If the parameters are given as a list the order is as above.
# <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 %d = (
        XOFF => 0,
        YOFF => 0,
        XSIZE => $width,
        YSIZE => $height,
        BUFXSIZE => undef,
        BUFYSIZE => undef,
        BUFTYPE => $type,
        BUFPIXELSPACE => 0,
        BUFLINESPACE => 0,
        RESAMPLEALG => 'NearestNeighbour',
        PROGRESS => undef,
        PROGRESSDATA => undef
        );
    my %p;
    my $t;
    if (defined $_[0]) {
        $t = uc($_[0]); 
        $t =~ s/_//g;
    }
    if (@_ == 0) {
    } elsif (ref($_[0]) eq 'HASH') {
        %p = %{$_[0]};
    } elsif (@_ % 2 == 0 and (defined $t and exists $d{$t})) {
        %p = @_;
    } else {
        ($p{xoff},$p{yoff},$p{xsize},$p{ysize},$p{buf_xsize},$p{buf_ysize},$p{buf_type},$p{buf_pixel_space},$p{buf_line_space},$p{resample_alg},$p{progress},$p{progress_data}) = @_;
    }
    for (keys %p) {
        my $u = uc($_);
        $u =~ s/_//g;
        carp "Unknown named parameter '$_'." unless exists $d{$u};
        $p{$u} = $p{$_};
    }
    for (keys %d) {
        $p{$_} = $d{$_} unless defined $p{$_};
    }
    confess "Unknown resampling algorithm: '$p{RESAMPLEALG}'." 
        unless exists $Geo::GDAL::RIO_RESAMPLING_STRING2INT{$p{RESAMPLEALG}};
    $p{RESAMPLEALG} = $Geo::GDAL::RIO_RESAMPLING_STRING2INT{$p{RESAMPLEALG}};
    unless ($Geo::GDAL::TYPE_INT2STRING{$p{BUFTYPE}}) {
        confess "Unknown data type: '$p{BUFTYPE}'." 
            unless exists $Geo::GDAL::TYPE_STRING2INT{$p{BUFTYPE}};
        $p{BUFTYPE} = $Geo::GDAL::TYPE_STRING2INT{$p{BUFTYPE}};
    }
    $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>)
# 
# 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(1)->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
# @param yoff
# @param xsize
# @param ysize
# @return a two-dimensional Perl array, organizes as data->[y][x], y =
# 0..height-1, x = 0..width-1.
#*
sub ReadTile {
    my($self, $xoff, $yoff, $xsize, $ysize) = @_;
    $xoff = 0 unless defined $xoff;
    $yoff = 0 unless defined $yoff;
    $xsize = $self->{XSize} - $xoff unless defined $xsize;
    $ysize = $self->{YSize} - $yoff unless defined $ysize;
    my $buf = $self->ReadRaster($xoff, $yoff, $xsize, $ysize);
    my $pc = Geo::GDAL::PackCharacter($self->{DataType});
    my $w = $xsize * Geo::GDAL::GetDataTypeSize($self->{DataType})/8;
    my $offset = 0;
    my @data;
    for (0..$ysize-1) {
        my $sub = substr($buf, $offset, $w);
        my @d = unpack($pc."[$xsize]", $sub);
        push @data, \@d;
        $offset += $w;
    }
    return \@data;
}

#** @method RegenerateOverview(Geo::GDAL::Band overview, $resampling, subref progress, $progress_data)
# @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, subref progress, $progress_data)
# @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)
# Scale and offset are used to transform raw pixel 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 SetColorTable($ColorTable)
# @note a.k.a. SetRasterColorTable, see also ColorTable
# @param ColorTable A color table object.
# 
#*
sub SetColorTable {
}

#** @method list SetDefaultHistogram($min, $max, $histogram)
# @param min
# @param max
# @param histogram reference to an array containing the histogram
# 
#*
sub SetDefaultHistogram {
}

#** @method SetStatistics($min, $max, $mean, $stddev)
# 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 list Size()
# @return the size of the band as a list (width, height).
#*
sub Size {
    my $self = shift;
    return ($self->{XSize}, $self->{YSize});
}

#** @method Unit($type)
# @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 = '' unless defined $unit;
        SetUnitType($self, $unit);
    }
    return unless defined wantarray;
    GetUnitType($self);
}

#** @method WriteRaster(%params)
# Write data into the band.
# 
# @param params named parameters. These are
# - \a XOff x offset (pixel coordinates) (default is 0)
# - \a YOff y offset (pixel 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 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)
# 
# If the parameters are given as a list the order is as above.
# <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 %d = (
        XOFF => 0,
        YOFF => 0,
        XSIZE => $width,
        YSIZE => $height,
        BUF => undef,
        BUFXSIZE => undef,
        BUFYSIZE => undef,
        BUFTYPE => $type,
        BUFPIXELSPACE => 0,
        BUFLINESPACE => 0
        );
    my %p;
    my $t;
    if (defined $_[0]) {
        $t = uc($_[0]); 
        $t =~ s/_//g;
    }
    if (@_ == 0) {
    } elsif (ref($_[0]) eq 'HASH') {
        %p = %{$_[0]};
    } elsif (@_ % 2 == 0 and (defined $t and exists $d{$t})) {
        %p = @_;
    } else {
        ($p{xoff},$p{yoff},$p{xsize},$p{ysize},$p{buf},$p{buf_xsize},$p{buf_ysize},$p{buf_type},$p{buf_pixel_space},$p{buf_line_space}) = @_;
    }
    for (keys %p) {
        my $u = uc($_);
        $u =~ s/_//g;
        carp "Unknown named parameter '$_'." unless exists $d{$u};
        $p{$u} = $p{$_};
    }
    for (keys %d) {
        $p{$_} = $d{$_} unless defined $p{$_};
    }
    unless ($Geo::GDAL::TYPE_INT2STRING{$p{BUFTYPE}}) {
        confess "Unknown data type: '$p{BUFTYPE}'." 
            unless exists $Geo::GDAL::TYPE_STRING2INT{$p{BUFTYPE}};
        $p{BUFTYPE} = $Geo::GDAL::TYPE_STRING2INT{$p{BUFTYPE}};
    }
    $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)
# @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 unless defined $xoff;
    $yoff = 0 unless defined $yoff;
    my $xsize = @{$data->[0]};
    $xsize = $self->{XSize} - $xoff if $xsize > $self->{XSize} - $xoff;
    my $ysize = @{$data};
    $ysize = $self->{YSize} - $yoff if $ysize > $self->{YSize} - $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 in a raster band.
#*
package Geo::GDAL::ColorTable;

use base qw(Geo::GDAL)

#** @method Geo::GDAL::ColorTable Clone()
# @return a new Geo::GDAL::ColorTable object
#*
sub Clone {
}

#** @method list ColorEntries(@color_entries)
# Get or set the table of color entries.
# @deprecated use Geo::GDAL::ColorTable::ColorTable
# 
# @param color_entries [optional]
# @return a table of color entries (a list of lists) in a non void context
#*
sub ColorEntries {
}

#** @method list ColorEntry($i, @color)
# Get or set a color entry.
# @param i
# @param color [optional]
# @return a color entry
#*
sub ColorEntry {
    my $self = shift;
    my $index = shift;
    SetColorEntry($self, $index, @_) if @_ > 0;
    GetColorEntry($self, $index) if defined wantarray;
}

#** @method list ColorTable(@colortable)
# Get or set the table of color entries.
# @param colortable [optional]
# @return a table of color entries (a list of lists) in a non void context
#*
sub ColorTable {
    my $self = shift;
    my @table;
    if (@_) {
        my $index = 0;
        for my $color (@_) {
            push @table, [ColorEntry($self, $index, @$color)];
            $index++;
        }
    } else {
        for (my $index = 0; $index < GetCount($self); $index++) {
            push @table, [ColorEntry($self, $index)];
        }
    }
    return @table;
}

#** @method CreateColorRamp($start_index, arrayref start_color, $end_index, arrayref end_color)
# @param start_index
# @param start_color
# @param end_index
# @param end_color
# 
#*
sub CreateColorRamp {
}

#** @method list GetColorEntry($i)
# @param i
# @return array ColorEntry = ($c1, $c2, $c3, $c4)
#*
sub GetColorEntry {
}

#** @method list GetColorEntryAsRGB($i)
# @param i
# @return array ColorEntry = ($r, $g, $b, $alpha)
#*
sub GetColorEntryAsRGB {
}

#** @method scalar GetCount()
# @return scalar (count of color entries as int)
#*
sub GetCount {
}

#** @method scalar GetPaletteInterpretation()
# @return paletter interpretation (string)
#*
sub GetPaletteInterpretation {
    my $self = shift;
    return $PALETTE_INTERPRETATION_INT2STRING{GetPaletteInterpretation($self)};
}

#** @method SetColorEntry($index, @ColorEntry)
# @param index
# @param ColorEntry a list or a reference to an array
# 
#*
sub SetColorEntry {
    my $self = shift;
    my $index = shift;
    my $color;
    if (ref($_[0]) eq 'ARRAY') {
        $color = shift;
    } else {
        $color = [@_];
    }
    eval {
        $self->_SetColorEntry($index, $color);
    };
    confess $@ if $@;
}

#** @method Geo::GDAL::ColorTable new($GDALPaletteInterp = 'RGB')
# Class method.
# 
# Usage:
# \code
# $ct = Geo::GDAL::ColorTable->new(...arguments...);
# \endcode
# @return a new Geo::GDAL::ColorTable object
#*
sub new {
    my($pkg, $pi) = @_;
    $pi = $PALETTE_INTERPRETATION_STRING2INT{$pi} if defined $pi and exists $PALETTE_INTERPRETATION_STRING2INT{$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.
#*
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 = 0)
# Add a new band to the dataset. The driver must support the action.
# @param datatype GDAL pixel data type (one of those listed by Geo::GDAL::DataTypes).
# @param options reference to a hash of format specific key=>value options.
#*
sub AddBand {
    my @p = @_;
    if (defined $p[1]) {
        confess "Unknown data type: '$p[1]'." unless exists $Geo::GDAL::TYPE_STRING2INT{$p[1]};
        $p[1] = $Geo::GDAL::TYPE_STRING2INT{$p[1]};
    }
    return _AddBand(@p);
}

#** @method Geo::GDAL::Band Band($index)
# Create a band object for the band within the dataset.
# @note a.k.a. GetRasterBand
# @param index 1...RasterCount
# @return a new Geo::GDAL::Band object
#*
sub Band {
}

#** @method list Bands()
# @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, subref progress, $progress_data)
# @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 $@ if $@;
}

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

#** @method Domains()
#*
sub Domains {
    return @DOMAINS;
}

#** @method list GCPs(@GCPs, Geo::OSR::SpatialReference sr)
# 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)
# Transformation from pixel 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 $@ if $@;
    return unless defined wantarray;
    my $t = GetGeoTransform($self);
    if (wantarray) {
        return @$t;
    } else {
        return Geo::GDAL::GeoTransform->new($t);
    }
}

#** @method Geo::GDAL::Driver GetDriver()
# @return a new Geo::GDAL::Driver object
#*
sub GetDriver {
}

#** @method list GetFileList()
# @return list of files GDAL believes to be part of this dataset.
#*
sub GetFileList {
}

#** @method scalar GetGCPProjection()
# @return projection string.
#*
sub GetGCPProjection {
}

#** @method Geo::GDAL::Dataset Open($name, $access='ReadOnly')
# Class method.
# An example:
# \code
# use Geo::GDAL;
# $ds = Geo::GDAL::Dataset::Open('/data/dem.tiff', 'Update');
# \endcode
# @param name
# @param access Access type (one of those listed by Geo::GDAL::AccessTypes).
# @return a new Geo::GDAL::Dataset object.
#*
sub Open {
    return Geo::GDAL::Open(@_);
}

#** @method Geo::GDAL::Dataset OpenShared($name, $access='ReadOnly')
# Class method.
# @param name
# @param access Access type (one of those listed by Geo::GDAL::AccessTypes).
# @return a new Geo::GDAL::Dataset object.
#*
sub OpenShared {
    return Geo::GDAL::OpenShared(@_);
}

#** @method scalar ReadRaster(%params)
# Read data from the dataset.
# 
# @param params named parameters. These are
# - \a XOff x offset (pixel coordinates) (default is 0)
# - \a YOff y offset (pixel 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 indeces (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)
# 
# If the parameters are given as a list the order is as above.
# <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 %d = (
        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
        );
    my %p;
    my $t;
    if (defined $_[0]) {
        $t = uc($_[0]); 
        $t =~ s/_//g;
    }
    if (@_ == 0) {
    } elsif (ref($_[0]) eq 'HASH') {
        %p = %{$_[0]};
    } elsif (@_ % 2 == 0 and (defined $t and exists $d{$t})) {
        %p = @_;
    } else {
        ($p{xoff},$p{yoff},$p{xsize},$p{ysize},$p{buf_xsize},$p{buf_ysize},$p{buf_type},$p{band_list},$p{buf_pixel_space},$p{buf_line_space},$p{buf_band_space},$p{resample_alg},$p{progress},$p{progress_data}) = @_;
    }
    for (keys %p) {
        my $u = uc($_);
        $u =~ s/_//g;
        carp "Unknown named parameter '$_'." unless exists $d{$u};
        $p{$u} = $p{$_};
    }
    for (keys %d) {
        $p{$_} = $d{$_} unless defined $p{$_};
    }
    confess "Unknown resampling algorithm: '$p{RESAMPLEALG}'." 
        unless exists $Geo::GDAL::RIO_RESAMPLING_STRING2INT{$p{RESAMPLEALG}};
    $p{RESAMPLEALG} = $Geo::GDAL::RIO_RESAMPLING_STRING2INT{$p{RESAMPLEALG}};
    unless ($Geo::GDAL::TYPE_INT2STRING{$p{BUFTYPE}}) {
        confess "Unknown data type: '$p{BUFTYPE}'." 
            unless exists $Geo::GDAL::TYPE_STRING2INT{$p{BUFTYPE}};
        $p{BUFTYPE} = $Geo::GDAL::TYPE_STRING2INT{$p{BUFTYPE}};
    }
    $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 RollbackTransaction()
#*
sub RollbackTransaction {
}

#** @method list Size()
# @return (width, height)
#*
sub Size {
    my $self = shift;
    return ($self->{RasterXSize}, $self->{RasterYSize});
}

#** @method Geo::OSR::SpatialReference SpatialReference(Geo::OSR::SpatialReference sr)
# 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;
    return Geo::OSR::SpatialReference->new(GetProjection($self)) if defined wantarray;
}

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

#** @method WriteRaster(%params)
# Write data into the dataset. 
# 
# @param params named parameters. These are
# - \a XOff x offset (pixel coordinates) (default is 0)
# - \a YOff y offset (pixel 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 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 indeces (default is [1])
# - \a BufPixelSpace (default is 0)
# - \a BufLineSpace (default is 0)
# - \a BufBandSpace (default is 0)
# 
# If the parameters are given as a list the order is as above.
# <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 %d = (
        XOFF => 0,
        YOFF => 0,
        XSIZE => $width,
        YSIZE => $height,
        BUF => undef,
        BUFXSIZE => undef,
        BUFYSIZE => undef,
        BUFTYPE => $type,
        BANDLIST => [1],
        BUFPIXELSPACE => 0,
        BUFLINESPACE => 0,
        BUFBANDSPACE => 0
        );
    my %p;
    my $t;
    if (defined $_[0]) {
        $t = uc($_[0]); 
        $t =~ s/_//g;
    }
    if (@_ == 0) {
    } elsif (ref($_[0]) eq 'HASH') {
        %p = %{$_[0]};
    } elsif (@_ % 2 == 0 and (defined $t and exists $d{$t})) {
        %p = @_;
    } else {
        ($p{xoff},$p{yoff},$p{xsize},$p{ysize},$p{buf},$p{buf_xsize},$p{buf_ysize},$p{buf_type},$p{band_list},$p{buf_pixel_space},$p{buf_line_space},$p{buf_band_space}) = @_;
    }
    for (keys %p) {
        my $u = uc($_);
        $u =~ s/_//g;
        carp "Unknown named parameter '$_'." unless exists $d{$u};
        $p{$u} = $p{$_};
    }
    for (keys %d) {
        $p{$_} = $d{$_} unless defined $p{$_};
    }
    unless ($Geo::GDAL::TYPE_INT2STRING{$p{BUFTYPE}}) {
        confess "Unknown data type: '$p{BUFTYPE}'." 
            unless exists $Geo::GDAL::TYPE_STRING2INT{$p{BUFTYPE}};
        $p{BUFTYPE} = $Geo::GDAL::TYPE_STRING2INT{$p{BUFTYPE}};
    }
    $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});
}

#** @class Geo::GDAL::Driver
# @brief A raster format driver.
#*
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()
# @return A list of capabilities. When executed as a class method
# 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($name, $src, $strict = 1, hashref options = undef)
# Copy the files of a dataset.
# @param NewName String.
# @param OldName String.
# Create a new Geo::GDAL::Dataset as a copy of an existing dataset.
# @note a.k.a. CreateCopy 
# @param name
# @param src A Geo::GDAL::Dataset object.
# @param strict
# @param options An anonymous hash of driver specific parameters.
# @return a new Geo::GDAL::Dataset object.
#*
sub Copy {
}

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

#** @method Geo::GDAL::Dataset Create(%params)
# Create a GDAL dataset using this driver.
# @note a.k.a. CreateDataset
# 
# @note As a list the parameters are: Name, Width, Height, NumberOfBands, PixelDataType, Options
# 
# Create a new Geo::GDAL::Dataset
# @param params named parameters:
# - \a Name the name of the dataset (default is 'unnamed').
# - \a Width the width of the dataset (default is 256).
# - \a Height the height of the dataset (default is 256).
# - \a Bands number of bands in the dataset (default is 1).
# - \a Type the data type of the pixels the dataset (default is 'Byte'). One of Geo::OGR::Driver::CreationDataTypes.
# - \a Options creation options as a reference to a hash (default is {}).
# 
# @return a new Geo::GDAL::Dataset object.
#*
sub Create {
    my $self = shift;
    my %defaults = ( Name => 'unnamed',
                     Width => 256,
                     Height => 256,
                     Bands => 1,
                     Type => 'Byte',
                     Options => {} );
    my %params;
    if (@_ == 0) {
    } elsif (ref($_[0]) eq 'HASH') {
        %params = %{$_[0]};
    } elsif (exists $defaults{$_[0]} and @_ % 2 == 0) {
        %params = @_;
    } else {
        ($params{Name}, $params{Width}, $params{Height}, $params{Bands}, $params{Type}, $params{Options}) = @_;
    }
    for my $k (keys %params) {
        carp "Create: unrecognized named parameter '$k'." unless exists $defaults{$k};
    }
    for my $k (keys %defaults) {
        $params{$k} = $defaults{$k} unless defined $params{$k};
    }
    my $type;
    confess "Unknown data type: '$params{Type}'." unless exists $Geo::GDAL::TYPE_STRING2INT{$params{Type}};
    $type = $Geo::GDAL::TYPE_STRING2INT{$params{Type}};
    return $self->_Create($params{Name}, $params{Width}, $params{Height}, $params{Bands}, $type, $params{Options});
}

#** @method list CreationDataTypes()
# @return a list of data types that can be used for new datasets.
#*
sub CreationDataTypes {
    my $self = shift;
    my $h = $self->GetMetadata;
    return split /\s+/, $h->{DMD_CREATIONDATATYPES} if $h->{DMD_CREATIONDATATYPES};
}

#** @method list CreationOptionList()
# @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 = Geo::GDAL::ParseXMLString($h);
        my($type, $value) = Geo::GDAL::NodeData($h);
        if ($value eq 'CreationOptionList') {
            for my $o (Geo::GDAL::Children($h)) {
                my %option;
                for my $a (Geo::GDAL::Children($o)) {
                    my(undef, $key) = Geo::GDAL::NodeData($a);
                    my(undef, $value) = Geo::GDAL::NodeData(Geo::GDAL::Child($a, 0));
                    if ($key eq 'Value') {
                        push @{$option{$key}}, $value;
                    } else {
                        $option{$key} = $value;
                    }
                }
                push @options, \%option;
            }
        }
    }
    return @options;
}

#** @method Delete($name)
# @param name
#*
sub Delete {
}

#** @method Domains()
#*
sub Domains {
    return @DOMAINS;
}

#** @method scalar Extension()
# @return a suggested extension or extensions (e.g., ext1/ext2) for
# datasets.
#*
sub Extension {
    my $self = shift;
    my $h = $self->GetMetadata;
    return $h->{DMD_EXTENSION};
}

#** @method scalar MIMEType()
# @return a suggested MIME type for datasets.
#*
sub MIMEType {
    my $self = shift;
    my $h = $self->GetMetadata;
    return $h->{DMD_MIMETYPE};
}

#** @method scalar Name()
# @return The short name of the driver.
#*
sub Name {
    my $self = shift;
    return $self->{ShortName};
}

#** @method Rename($NewName, $OldName)
# Rename (move) a GDAL dataset.
# @param NewName String.
# @param OldName String.
#*
sub Rename {
}

#** @method scalar TestCapability($cap)
# 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;
}

#** @class Geo::GDAL::GCP
# @brief A ground control point for georeferencing images.
#*
package Geo::GDAL::GCP;

use base qw(Geo::GDAL)

#** @attr $Column 
# pixel x coordinate (access as $gcp->{Column})
# @note Pixel is deprecated.
# 
#*

#** @attr $Id 
# unique identifier (string) (access as $gcp->{Id})
#*

#** @attr $Info 
# informational message (access as $gcp->{Info})
#*

#** @attr $Row 
# pixel y coordinate (access as $gcp->{Row})
# @note Line is deprecated.
# 
#*

#** @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 pixel x coordinate
# @param row pixel 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.
# 
# The geo transformation has the form
# \code
# x = a + column * b + row * c
# y = d + column * e + row * f
# \endcode
# where<br/>
# (column,row) is the location in pixel coordinates<br/>
# (x,y) is the location in projection coordinates<br/>
# or vice versa.
# A Geo::GDAL::GeoTransform object is a reference to an anonymous array.
#*
package Geo::GDAL::GeoTransform;

use base qw()

#** @method Apply(array reference x, array reference y)
# @return a list (x, y), where x and y are references to arrays of
# transformed coordinates.
#*
sub Apply {
    my ($self, $columns, $rows) = @_;
    my (@x, @y);
    for my $i (0..$#$columns) {
        ($x[$i], $y[$i]) = 
            Geo::GDAL::ApplyGeoTransform($self, $columns->[$i], $rows->[$i]);
    }
    return (\@x, \@y);
}

#** @method FromGCPs(@GCPs, $ApproxOK)
# Compute transformation coefficients from a list of Geo::GDAL::GCP
# objects
# @param GCPs A list of Geo::GDAL::GCP objects.
# @param ApproxOK [optional] Minimize the error in the coefficient (integer, default is true).
# @return a new Geo::GDAL::GeoTransform object.
#*
sub FromGCPs {
    my @GCPs;
    my $ApproxOK = 1;
    if (ref($_[0]) eq 'ARRAY') {
        @GCPs = @{$_[0]};
        $ApproxOK = $_[1] if defined $_[1];
    } else {
        @GCPs = @_;
        $ApproxOK = pop @GCPs if !ref($GCPs[$#GCPs]);
    }
    my $self = Geo::GDAL::GCPsToGeoTransform(\@GCPs, $ApproxOK);
    bless $self, 'Geo::GDAL::GetTransform';
    return $self;
}

#** @method Inv()
# @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);
    unless (defined wantarray) {
        @$self = @inv;
    } else {
        return new(@inv);
    }
}
1;
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.5
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
}

#** @method new(@coeffs)
# Class method.
# @return a new Geo::GDAL::GeoTransform object.
#*
sub new {
    my $class = shift;
    my $self;
    if (@_ == 0) {
        $self = [0,1,0,0,0,1];
    } elsif (@_ == 1) {
        $self = $_[0];
    } else {
        my @a = @_;
        $self = \@a;
    }
    bless $self, $class;
    return $self;
}

#** @class Geo::GDAL::MajorObject
# @brief An object, which holds meta data.
#*
package Geo::GDAL::MajorObject;

use base qw(Geo::GDAL)

#** @method scalar Description($description)
# @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()
# Class method.
# @return the class specific DOMAINS list
#*
sub Domains {
    return @DOMAINS;
}

#** @method scalar GetDescription()
# @return
#*
sub GetDescription {
}

#** @method hash reference GetMetadata($domain = "")
# @note see Metadata
# @param domain
# @return
#*
sub GetMetadata {
}

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

#** @method hash reference Metadata(hashref metadata = undef, $domain = '')
# @param metadata
# @param domain
# @return the metadata in a non-void context.
#*
sub Metadata {
    my $self = shift;
    my $metadata;
    $metadata = shift if ref $_[0];
    my $domain = shift;
    $domain = '' unless defined $domain;
    SetMetadata($self, $metadata, $domain) if defined $metadata;
    GetMetadata($self, $domain) if defined wantarray;
}

#** @method SetDescription($NewDesc)
# @param NewDesc
# 
#*
sub SetDescription {
}

#** @method SetMetadata(hashref metadata, $domain = "")
# @note see Metadata
# @param metadata
# @param domain
# 
#*
sub SetMetadata {
}

#** @class Geo::GDAL::RasterAttributeTable
# @brief An attribute table in a raster band.
#*
package Geo::GDAL::RasterAttributeTable;

use base qw(Geo::GDAL)

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

#** @method Geo::GDAL::RasterAttributeTable Clone()
# @return a new Geo::GDAL::RasterAttributeTable object
#*
sub Clone {
}

#** @method hash Columns(%columns)
# 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)
# @param name
# @param type one of FieldTypes
# @param usage one of FieldUsages
#*
sub CreateColumn {
    my($self, $name, $type, $usage) = @_;
    confess "Unknown RAT column type: '$type'." unless exists $FIELD_TYPE_STRING2INT{$type};
    confess "Unknown RAT column usage: '$usage'." unless exists $FIELD_USAGE_STRING2INT{$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 = $FIELD_TYPE_STRING2INT{$type};
    $usage = $FIELD_USAGE_STRING2INT{$usage};
    _CreateColumn($self, $name, $type, $usage);
}

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

#** @method list FieldTypes()
# Class method.
# @return
#*
sub FieldTypes {
    return @FIELD_TYPES;
}

#** @method list FieldUsages()
# Class method.
# @return
#*
sub FieldUsages {
    return @FIELD_USAGES;
}

#** @method scalar GetColOfUsage($usage)
# @param usage
# @return
#*
sub GetColOfUsage {
    my($self, $usage) = @_;
    _GetColOfUsage($self, $FIELD_USAGE_STRING2INT{$usage});
}

#** @method scalar GetColumnCount()
# @return
#*
sub GetColumnCount {
}

#** @method scalar GetNameOfCol($column)
# @param column
# @return
#*
sub GetNameOfCol {
}

#** @method scalar GetRowCount()
#*
sub GetRowCount {
}

#** @method scalar GetRowOfValue($value)
# @param value a pixel value
# @return row index or -1
#*
sub GetRowOfValue {
}

#** @method scalar GetTypeOfCol($column)
# @param column
# @return
#*
sub GetTypeOfCol {
    my($self, $col) = @_;
    $FIELD_TYPE_INT2STRING{_GetTypeOfCol($self, $col)};
}

#** @method scalar GetUsageOfCol($column)
# @param column
# @return
#*
sub GetUsageOfCol {
    my($self, $col) = @_;
    $FIELD_USAGE_INT2STRING{_GetUsageOfCol($self, $col)};
}

#** @method scalar GetValueAsDouble($row, $column)
# @param row
# @param column
# @return
#*
sub GetValueAsDouble {
}

#** @method scalar GetValueAsInt($row, $column)
# @param row
# @param column
# @return
#*
sub GetValueAsInt {
}

#** @method scalar GetValueAsString($row, $column)
# @param row
# @param column
# @return
#*
sub GetValueAsString {
}

#** @method LinearBinning($Row0MinIn, $BinSizeIn)
# @param Row0MinIn [optional] the lower bound (pixel value) of the first category.
# @param BinSizeIn [optional] the width of each category (in pixel value units).
# @return ($Row0MinIn, $BinSizeIn) or an empty list if LinearBinning is not set.
#*
sub LinearBinning {
    my $self = shift;
    SetLinearBinning($self, @_) if @_ > 0;
    return unless defined wantarray;
    my @a = GetLinearBinning($self);
    return $a[0] ? ($a[1], $a[2]) : ();
}

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

#** @method SetValueAsDouble($row, $column, $value)
# @param row
# @param column
# @param value
# 
#*
sub SetValueAsDouble {
}

#** @method SetValueAsInt($row, $column, $value)
# @param row
# @param column
# @param value
# 
#*
sub SetValueAsInt {
}

#** @method SetValueAsString($row, $column, $value)
# @param row
# @param column
# @param value
# 
#*
sub SetValueAsString {
}

#** @method scalar Value($row, $column, $value)
# @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
# 
# 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.
#*
package Geo::GDAL::VSIF;

use base qw()

#** @method Close()
#*
sub Close {
    my ($self, $data) = @_;
    eval {
        Geo::GDAL::VSIFCloseL($self);
    };
    if ($@) {
        confess "Cannot close file: $@.";
    }
}

#** @method MkDir()
#*
sub MkDir {
    my ($path) = @_;
    my $mode = 0; # unused in CPL
    eval {
        Geo::GDAL::Mkdir($path, $mode);
    };
    if ($@) {
        confess "Cannot make directory \"$path\": $@.";
    }
}

#** @method Geo::GDAL::VSIF Open($filename, $mode)
# Class method.
# @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)
# @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)
# Class method.
# @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)
# Class method.
# @return Contents of a directory tree in an anonymous array.
#*
sub ReadDirRecursive {
    my ($path) = @_;
    Geo::GDAL::ReadDirRecursive($path);
}

#** @method Rename($old, $new)
# Class method.
# Rename a file.
# @note The name of this method is VSIRename in GDAL.
# 
#*
sub Rename {
    my ($old, $new) = @_;
    eval {
        Geo::GDAL::Rename($old, $new);
    };
    if ($@) {
        confess "Cannot rename file \"$old\": $@.";
    }
}

#** @method RmDir()
#*
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' : '';
        confess "Cannot remove directory \"$dirname\"$r: $@.";
    }
}

#** @method Rmdir($path)
# Class method.
# Remove a directory.
# @note The name of this method is VSIRmdir in GDAL.
# 
#*
sub Rmdir {
}

#** @method Seek($offset, $whence)
#*
sub Seek {
    my ($self, $offset, $whence) = @_;
    Geo::GDAL::VSIFSeekL($self, $offset, $whence);
}

#** @method list Stat($filename)
# Class method.
# @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) = @_;
    eval {
        Geo::GDAL::Stat($path);
    };
    if ($@) {
        confess "Cannot stat file \"$path\": $@.";
    }
}

#** @method scalar Tell()
#*
sub Tell {
    my ($self) = @_;
    Geo::GDAL::VSIFTellL($self);
}

#** @method Truncate($new_size)
#*
sub Truncate {
    my ($self, $new_size) = @_;
    eval {
        Geo::GDAL::VSIFTruncateL($self, $new_size);
    };
    if ($@) {
        confess "Cannot truncate file: $@.";
    }
}

#** @method Unlink($filename)
# Class method.
# @param filename The file to delete.
# @return 0 on success and -1 on an error.
#*
sub Unlink {
    my ($filename) = @_;
    eval {
        Geo::GDAL::Unlink($filename);
    };
    if ($@) {
        confess "Cannot unlink file \"$filename\": $@.";
    }
}

#** @method Write($scalar)
# @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::OGR
# @brief OGR utility functions.
# 
# A wrapper for many OGR utility functions and a root class for all
# OGR classes.
#*
package Geo::OGR;

use base qw()

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

#** @method scalar GeometryTypeModify($type, $modifier)
# @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) = @_;
    confess "Unknown geometry type: '$type'." unless exists $Geo::OGR::Geometry::TYPE_STRING2INT{$type};
    $type = $Geo::OGR::Geometry::TYPE_STRING2INT{$type};
    return $Geo::OGR::Geometry::TYPE_INT2STRING{GT_Flatten($type)} if $modifier =~ /flat/i;
    return $Geo::OGR::Geometry::TYPE_INT2STRING{GT_SetZ($type)} if $modifier =~ /z/i;
    return $Geo::OGR::Geometry::TYPE_INT2STRING{GT_GetCollection($type)} if $modifier =~ /collection/i;
    return $Geo::OGR::Geometry::TYPE_INT2STRING{GT_GetCurve($type)} if $modifier =~ /curve/i;
    return $Geo::OGR::Geometry::TYPE_INT2STRING{GT_GetLinear($type)} if $modifier =~ /linear/i;
    confess "Unknown geometry type modifier: '$modifier'.";
}

#** @method scalar GeometryTypeTest($type, $test, $type2)
# @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) = @_;
    confess "Unknown geometry type: '$type'." unless exists $Geo::OGR::Geometry::TYPE_STRING2INT{$type};
    $type = $Geo::OGR::Geometry::TYPE_STRING2INT{$type};
    if (defined $type2) {
        confess "Unknown geometry type: '$type2'." unless exists $Geo::OGR::Geometry::TYPE_STRING2INT{$type2};
        $type2 = $Geo::OGR::Geometry::TYPE_STRING2INT{$type2};
    } else {
        confess "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;
    confess "Unknown geometry type test: '$test'.";
}

#** @method list GeometryTypes()
# Class method.
# @return a list of all geometry types, currently:
# CircularString, CircularStringZ, CompoundCurve, CompoundCurveZ, CurvePolygon, CurvePolygonZ, GeometryCollection, GeometryCollection25D, LineString, LineString25D, LinearRing, MultiCurve, MultiCurveZ, MultiLineString, MultiLineString25D, MultiPoint, MultiPoint25D, MultiPolygon, MultiPolygon25D, MultiSurface, MultiSurfaceZ, None, Point, Point25D, Polygon, Polygon25D, and Unknown.
#*
sub GeometryTypes {
}

#** @method Geo::OGR::Driver GetDriver($name)
# @param name a driver name. One of Geo::OGR::GetDriverNames.
# @return a Geo::OGR::Driver object that represents the internal driver.
#*
sub GetDriver {
    my($name) = @_;
    $name = 0 unless defined $name;
    my $driver;
    $driver = _GetDriver($name) if $name =~ /^\d+$/; # is the name an index to driver list?
    $driver = GetDriverByName("$name") unless $driver;
    return $driver if $driver;
    confess "Driver not found: '$name'. Maybe support for it was not built in?";
}

#** @method list GetDriverNames()
# @return a list of the names of available Geo::OGR::Drivers.
#*
sub GetDriverNames {
    my @names;
    for my $i (0..GetDriverCount()-1) {
        push @names, _GetDriver($i)->Name;
    }
    return @names;
}

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

#** @method Geo::OGR::DataSource GetOpenDS($number)
# @param number The number of the requested data source.
# @return a new Geo::OGR::DataSource object.
#*
sub GetOpenDS {
}

#** @method scalar GetOpenDSCount()
# @return the number of all open data sources.
#*
sub GetOpenDSCount {
}

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

#** @method Geo::OGR::DataSource Open($name, $update = 0)
# @param name The data source string (directory, filename, etc.).
# @param update Whether to open the data source in update mode.
# @return a new Geo::OGR::DataSource object.
#*
sub Open {
}

#** @method Geo::OGR::DataSource OpenShared($name, $update = 0)
# @param name The data source string (directory, filename, etc.).
# @param update Whether to open the data source in update mode.
# @return a new Geo::OGR::DataSource object.
#*
sub OpenShared {
}

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

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

#** @class Geo::OGR::DataSource
# @brief A source and/or storage of vector data layers.
# 
# A data source object may, depending on its capabilities, create,
# open (as such or using GDAL SQL), copy, and delete layers.
#*
package Geo::OGR::DataSource;

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

#** @method list Capabilities()
# Both a class and an object method.
# @return a list of capabilities. The object method returns a list of
# all capabilities the data source has. The class method returns a
# list of all potential capabilities a data source may have. These are
# currently:
# CreateGeomFieldAfterCreateLayer, CreateLayer, CurveGeometries, DeleteLayer, EmulatedTransactions, and Transactions.
#*
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 CommitTransaction()
#*
sub CommitTransaction {
}

#** @method Geo::OGR::Layer CopyLayer($layer, $name, hashref options = undef)
# @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)
# @brief Create a new layer into this data source.
# 
# @param %params A list of named parameters:
# - \a Name (scalar) name for the new layer.
# - \a Fields (array reference) a list of 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) may contain keys Name, Fields, GeomFields, GeometryType.
# - \a SRS (scalar, deprecated) the spatial reference for the default geometry field.
# - \a GeometryType (scalar) the type of the default geometry field (if only one geometry field).
# 
# @note If Fields or Schema|Fields is not given, a default geometry
# field (Name => '', GeometryType => 'Unknown') is created. 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
# @return a new Geo::OGR::Layer object.
#*
sub CreateLayer {
    my $self = shift;
    my %defaults = ( Name => 'unnamed',
                     SRS => undef,
                     Options => {},
                     GeometryType => 'Unknown',
                     Schema => undef,
                     Fields => undef,
                     ApproxOK => 1);
    my %params;
    if (@_ == 0) {
    } elsif (ref($_[0]) eq 'HASH') {
        %params = %{$_[0]};
    } elsif (@_ % 2 == 0 and (defined $_[0] and exists $defaults{$_[0]})) {
        %params = @_;
    } else {
        ($params{Name}, $params{SRS}, $params{GeometryType}, $params{Options}, $params{Schema}) = @_;
    }
    for (keys %params) {
        carp "CreateLayer: unknown named parameter '$_'." unless exists $defaults{$_};
    }
    if (exists $params{Schema}) {
        my $s = $params{Schema};
        $params{GeometryType} = $s->{GeometryType} if exists $s->{GeometryType};
        $params{Fields} = $s->{Fields} if exists $s->{Fields};
        $params{Name} = $s->{Name} if exists $s->{Name};
    }
    $defaults{GeometryType} = 'None' if $params{Fields};
    for (keys %defaults) {
        $params{$_} = $defaults{$_} unless defined $params{$_};
    }
    confess "Unknown geometry type: '$params{GeometryType}'."
        unless exists $Geo::OGR::Geometry::TYPE_STRING2INT{$params{GeometryType}};
    my $gt = $Geo::OGR::Geometry::TYPE_STRING2INT{$params{GeometryType}};
    my $layer = _CreateLayer($self, $params{Name}, $params{SRS}, $gt, $params{Options});
    $LAYERS{tied(%$layer)} = $self;
    my $f = $params{Fields};
    if ($f) {
        confess "Named parameter 'Fields' must be a reference to an array." unless ref($f) eq 'ARRAY';
        for my $field (@$f) {
            $layer->CreateField($field);
        }
    }
    return $layer;
}

#** @method DeleteLayer($name)
# 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;
    }
    confess "No such layer: '$name'." unless defined $index;
    _DeleteLayer($self, $index);
}

#** @method Geo::OGR::Layer ExecuteSQL($statement, $geom = undef, $dialect = "")
# @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(@_);
    $LAYERS{tied(%$layer)} = $self;
    $RESULT_SET{tied(%$layer)} = 1;
    return $layer;
}

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

#** @method Geo::OGR::Driver GetDriver()
# @return a Geo::OGR::Driver object for this data source.
#*
sub GetDriver {
}

#** @method Geo::OGR::Layer GetLayer($name)
# @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 = '' unless defined $name;
    confess "No such layer: '$name'." unless $layer;
    $LAYERS{tied(%$layer)} = $self;
    return $layer;
}

#** @method list GetLayerNames()
# @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 scalar GetName()
# @return the name of this data source.
#*
sub GetName {
}

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

#** @method Geo::OGR::DataSource Open($name, $update = 0)
# Class method.
# An example:
# \code
# use Geo::GDAL;
# $ds = Geo::OGR::DataSource::Open('/data/roads.shp');
# \endcode
# @param name The data source name (directory, filename, etc.).
# @param update Whether to open the data source in update mode.
# @return a new Geo::OGR::DataSource object.
#*
sub Open {
    return Geo::OGR::Open(@_);
}

#** @method Geo::OGR::DataSource OpenShared($name, $update = 0)
# Class method.
# @param name The data source name (directory, filename, etc.).
# @param update Whether to open the data source in update mode.
# @return a new Geo::OGR::DataSource object.
#*
sub OpenShared {
    return Geo::OGR::OpenShared(@_);
}

#** @method ReleaseResultSet($layer)
# @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 RollbackTransaction()
#*
sub RollbackTransaction {
}

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

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

#** @method scalar TestCapability($cap)
# @param cap A capability string.
# @return a boolean value indicating whether the data source has the
# specified capability.
#*
sub TestCapability {
    my($self, $cap) = @_;
    confess "No such capability defined for class DataSource: '$cap'." unless defined $CAPABILITIES{$cap};
    return _TestCapability($self, $CAPABILITIES{$cap});
}

#** @method new()
#*
sub new {
    my $pkg = shift;
    return Geo::OGR::Open(@_);
}

#** @class Geo::OGR::Driver
# @brief A vector format driver.
# 
# A driver may, depending on its capabilities, create, open, copy, and
# delete data sources.
#*
package Geo::OGR::Driver;

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

#** @method list Capabilities()
# Both a class and an object method.
# @return a list of capabilities. The object method returns a list of
# the capabilities the driver has. The class method returns a list of
# all potential capabilities a driver may have. These are currently:
# CreateDataSource, and DeleteDataSource.
# 
# Examples:
# \code
# @all_capabilities = Geo::OGR::Driver::Capabilities;
# @capabilities_of_a_driver = Geo::OGR::Driver('KML')->Capabilities;
# \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 Geo::OGR::DataSource Copy(Geo::OGR::DataSource source, $name, arrayref options = undef)
# Copy an OGR data source object.
# @note a.k.a. CopyDataSource
# @param source the Geo::OGR::DataSource object to be copied.
# @param name the name for the new data source.
# @param options driver specific options.
# @return a new Geo::OGR::DataSource object.
#*
sub Copy {
}

#** @method Geo::OGR::DataSource Create($name, hashref options = undef )
# Create an OGR data source object.
# @note a.k.a. CreateDataSource
# @param name The data source name.
# @param options Driver specific options.
# 
# Usage:
# \code
# $ds = Geo::OGR::Driver('driver name')->Create('data source name', {});
# \endcode
# @return a new Geo::OGR::DataSource object.
#*
sub Create {
}

#** @method Delete($name)
# Delete an OGR data source.
# @note a.k.a. DeleteDataSource
# @param name The name of data source.
#*
sub Delete {
}

#** @method scalar Name()
# @note a.k.a. GetName
# @return the name of the driver.
#*
sub Name {
}

#** @method Geo::OGR::DataSource Open($name, $update = 0)
# Open an OGR data source object. Alternative name: OpenDataSource.
# @note a.k.a. GetDataSource
# @param name the name of data source.
# @param update whether to open the data source in update mode.
# @return a new Geo::OGR::DataSource object
#*
sub Open {
}

#** @method scalar TestCapability($cap)
# @param cap A capability string.
# @return boolean value.
#*
sub TestCapability {
    my($self, $cap) = @_;
    confess "No such capability defined for class Driver: '$cap'." unless defined $CAPABILITIES{$cap};
    return _TestCapability($self, $CAPABILITIES{$cap});
}

#** @class Geo::OGR::Feature
# @brief A collection of non-spatial and spatial attributes.
# 
# 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()
# @return a new Geo::OGR::Feature object
#*
sub Clone {
}

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

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

#** @method scalar FID($id)
# @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)
# @brief Get or set the field.
# @param name the name of the field.
# @param Value a scalar or list depending on the field type.
# @return the value of the field, which may be a scalar or a list,
# depending on the field type.
#*
sub Field {
    my $self = shift;
    my $field = shift;
    $self->SetField($field, @_) if @_;
    $self->GetField($field);
}

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

#** @method scalar Geometry($name, $geometry)
# @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. The ownership of
# the geometry is given (if the parameter is an object) or kept to the
# feature and thus the geometry will keep the feature alive as long as
# the geometry is alive.
# @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 spatial field.
# @param geometry [optional] a Geo::OGR::Geometry object or a hash
# array from which such can be created (using
# Geo::OGR::Geometry::new)
# @return in a non-void context the geometry in the feature
# as a Geo::OGR::Geometry object.
#*
sub Geometry {
    my $self = shift;
    my $field = (ref($_[0]) eq '' or (@_ > 2 and @_ % 2 == 1)) ? shift : undef;
    $field = $self->_GetGeomFieldIndex($field);
    if (@_) {
        my $type = $self->GetDefn->GetGeomFieldDefn($field)->Type;
        my $geometry;
        if (@_ == 1) {
            $geometry = $_[0];
        } elsif (@_ and @_ % 2 == 0) {
            %$geometry = @_;
        }
        if (blessed($geometry) and $geometry->isa('Geo::OGR::Geometry')) {
            confess "The type of the inserted geometry ('".$geometry->GeometryType."') is not the field type ('$type')."
                if $type ne 'Unknown' and $type ne $geometry->GeometryType;
            eval {
                $self->SetGeomFieldDirectly($field, $geometry);
            };
            confess "$@" if $@;
            $GEOMETRIES{tied(%{$geometry})} = $self;
        } elsif (ref($geometry) eq 'HASH') {
            $geometry->{GeometryType} = $type unless exists $geometry->{GeometryType};
            eval {
                $geometry = Geo::OGR::Geometry->new($geometry);
            };
            confess "The type of the inserted geometry ('".$geometry->GeometryType."') is not the field type ('$type')."
                if $type ne 'Unknown' and $type ne $geometry->GeometryType;
            eval {
                $self->SetGeomFieldDirectly($field, $geometry);
            };
            confess "$@" if $@;
        } else {
            confess "'@_' does not define a geometry.";
        }
    }
    return unless defined wantarray;
    my $geometry = $self->GetGeomFieldRef($field);
    return unless $geometry;
    $GEOMETRIES{tied(%{$geometry})} = $self;
    return $geometry;
}

#** @method Geo::OGR::FeatureDefn GetDefn()
# @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;
    $DEFNS{$defn} = $self;
    return $defn;
}

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

#** @method list GetField($name)
# @note A number of GetFieldAs* methods exist but they are not
# documented. Syntax $feature->{field} can be used to access the
# field (v1.9.0)
# @param name the name of the field
# @return the value of the field, which may be a scalar or a list,
# depending on the field type.
#*
sub GetField {
    my($self, $field) = @_;
    $field = $self->_GetFieldIndex($field);
    return unless IsFieldSet($self, $field);
    my $type = GetFieldType($self, $field);
    if ($type == $Geo::OGR::OFTInteger) {
        return GetFieldAsInteger($self, $field);
    }
    if ($type == $Geo::OGR::OFTInteger64) {
        return GetFieldAsInteger64($self, $field);
    }
    if ($type == $Geo::OGR::OFTReal) {
        return GetFieldAsDouble($self, $field);
    }
    if ($type == $Geo::OGR::OFTString) {
        return GetFieldAsString($self, $field);
    }
    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 GetFieldAsString($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) {
        return GetFieldAsDateTime($self, $field);
    }
    confess "Perl bindings do not support field type '$Geo::OGR::FieldDefn::TYPE_INT2STRING{$type}'.";
}

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

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

#** @method Geo::OGR::FieldDefn GetFieldDefn($name)
# @note A.k.a GetFieldDefnRef
# @param name the name of the field.
# @return a new Geo::OGR::FieldDefn object that represents the field
# in question.
#*
sub GetFieldDefn {
}

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

#** @method hash reference GetSchema()
# @brief Get the schema of this feature. 
# @return the schema of this layer, as in Geo::OGR::FeatureDefn::Schema.
#*
sub GetSchema {
    my $self = shift;
    confess "Schema of a feature cannot be set directly." if @_;
    return $self->GetDefnRef->Schema;
}

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

#** @method scalar IsFieldSet($field)
# @param field the name (or index) of the field
# @return boolean
#*
sub IsFieldSet {
}

#** @method hash reference Row(%row)
# @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 geometry respectively. The
# geometry is set and get using the Geo::OGR::Feature::Geometry
# method. Field values are set using the Geo::OGR::Feature::SetField
# 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 {
            confess '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->SetGeometry(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->SetGeometry($i, $row{$name});
                    $f = 1;
                    last;
                }
            }
            next if $f;
            carp "Feature->Row: 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;
        $name = 'Geometry' if $name eq '';
        $row{$name} = $self->GetGeometry($i);
    }
    $row{FID} = $self->GetFID;
    #$row{Geometry} = $self->Geometry;
    return \%row;
}

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

#** @method SetField($name, @Value)
# @note Syntax $feature->{field} can be used to access the
# field (v1.9.0)
# @param name the name of the field.
# @param Value a string, integer, double, a list (year, month,
# day), a list (hour, minute, second, tzflag), a list (year, month,
# day, hour, minute, second, tzflag), or a list of integers, doubles,
# or strings.
# @note If value is not given or is undefined this method unsets the field.
#*
sub SetField {
    my $self = shift;
    my $field = shift;
    $field = $self->_GetFieldIndex($field);
    if (@_ == 0 or !defined($_[0])) {
        _UnsetField($self, $field);
        return;
    }
    my $list = ref($_[0]) ? $_[0] : [@_];
    my $type = GetFieldType($self, $field);
    if ($type == $Geo::OGR::OFTInteger or
        $type == $Geo::OGR::OFTInteger64 or
        $type == $Geo::OGR::OFTReal or
        $type == $Geo::OGR::OFTString or
        $type == $Geo::OGR::OFTBinary)
    {
        _SetField($self, $field, $_[0]);
    }
    elsif ($type == $Geo::OGR::OFTIntegerList) {
        SetFieldIntegerList($self, $field, $list);
    }
    elsif ($type == $Geo::OGR::OFTInteger64List) {
        SetFieldInteger64List($self, $field, $list);
    }
    elsif ($type == $Geo::OGR::OFTRealList) {
        SetFieldDoubleList($self, $field, $list);
    }
    elsif ($type == $Geo::OGR::OFTStringList) {
        SetFieldStringList($self, $field, $list);
    }
    elsif ($type == $Geo::OGR::OFTDate) {
        # year, month, day, hour, minute, second, timezone
        for my $i (0..6) {
            $list->[$i] = 0 unless defined $list->[$i];
        }
        _SetField($self, $field, @$list[0..6]);
    }
    elsif ($type == $Geo::OGR::OFTTime) {
        $list->[3] = 0 unless defined $list->[3];
        _SetField($self, $field, 0, 0, 0, @$list[0..3]);
    }
    elsif ($type == $Geo::OGR::OFTDateTime) {
        $list->[6] = 0 unless defined $list->[6];
        _SetField($self, $field, @$list[0..6]);
    }
    else {
        confess "Perl bindings do not support field type '$Geo::OGR::FieldDefn::TYPE_INT2STRING{$type}'.";
    }
}

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

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

#** @method SetFrom($other, $forgiving = 1, hashref map)
# @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 SetStyleString($string)
# @param string
#*
sub SetStyleString {
}

#** @method list Tuple(@tuple)
# @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 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 $FID;
        $FID = shift if @_ == $nf + $ngf + 1;
        $self->SetFID($FID) if defined $FID;
        my $values = \@_;
        if (@$values != $nf + $ngf) {
            my $n = $nf + $ngf;
            confess "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->SetGeometry($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 UnsetField($field)
# @note Field value can be unset by calling SetField without
# parameters or with an undefined argument.
# @param field the name (or index) of the field
#*
sub UnsetField {
    my($self, $field) = @_;
    $field = $self->_GetFieldIndex($field);
    _UnsetField($self, $field);
}

#** @method scalar Validate(list flags)
# @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.
# @param schema as in Schema
# @return a new Geo::OGR::Feature object
#*
sub new {
    my $pkg = shift;
    my $self = Geo::OGRc::new_Feature(@_);
    bless $self, $pkg if defined($self);
}

#** @class Geo::OGR::FeatureDefn
# @brief A definition of the attributes of a feature class or a layer.
# 
# A definition object is a collection of field definition objects. A
# read-only definition object is obtained from a layer or a feature.
#*
package Geo::OGR::FeatureDefn;

use base qw(Geo::OGR)

#** @method AddField(%params)
# @param params named parameters to create a new Geo::OGR::FieldDefn
# or Geo::OGR::GeomFieldDefn object.
#*
sub AddField {
    my $self = shift;
    confess "Read-only definition." if $Geo::OGR::Feature::DEFNS{$self} or $Geo::OGR::Layer::DEFNS{$self};
    my %params;
    if (@_ == 0) {
    } elsif (ref($_[0]) eq 'HASH') {
        %params = %{$_[0]};
    } elsif (@_ % 2 == 0) {
        %params = @_;
    }
    $params{Type} = '' unless defined $params{Type};
    if (exists $Geo::OGR::FieldDefn::TYPE_STRING2INT{$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)
# @note Currently only geometry fields can be deleted.
# @param index the index of the geometry field to be deleted.
#*
sub DeleteField {
    my ($self, $name) = @_;
    confess "Read-only definition." if $Geo::OGR::Feature::DEFNS{$self} or $Geo::OGR::Layer::DEFNS{$self};
    for my $i (0..$self->GetFieldCount-1) {
        confess "Non-geometry 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;
    }
    confess "No such field: '$name'.";
}

#** @method object GetFieldDefn($name)
# @param name the name of the field.
# @return either a Geo::OGR::FieldDefn or Geo::OGR::GeomFieldDefn
# object that represents the field in question.
#*
sub GetFieldDefn {
    my ($self, $name) = @_;
    for my $i (0..$self->GetFieldCount-1) {
        my $fd = $self->GetFieldDefn($i);
        return $fd if $fd->Name eq $name;
    }
    for my $i (0..$self->GetGeomFieldCount-1) {
        my $fd = $self->GetGeomFieldDefn($i);
        return $fd if $fd->Name eq $name;
    }
    confess "No such field: '$name'.";
}

#** @method list GetFieldNames()
# 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 GetName()
# @return the name of this layer or feature definition.
#*
sub GetName {
}

#** @method hash reference GetSchema()
# @brief Get the schema of this feature or layer definition. 
# 
# The schema is 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.
# @return the schema of this feature or layer definition.
#*
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)
# @return true if this definition is similar to the other definition,
# false otherwise.
#*
sub IsSame {
}

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

#** @method SetStyleIgnored($IgnoreState)
# 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};
    confess "The Fields argument is not a reference to an array." if $fields and ref($fields) ne 'ARRAY';
    $schema{Name} = '' unless exists $schema{Name};
    my $self = Geo::OGRc::new_FeatureDefn($schema{Name});
    bless $self, $pkg;
    my $gt = $schema{GeometryType};
    if ($fields) {
        $self->DeleteGeomFieldDefn(0); # either default behavior or argument specified
    } else {
        $self->GeometryType($schema{GeometryType}) if exists $schema{GeometryType};
    }
    $self->StyleIgnored($schema{StyleIgnored}) if exists $schema{StyleIgnored};
    for my $fd (@{$fields}) {
        my $d = $fd;
        if (ref($fd) eq 'HASH') {
            if ($fd->{GeometryType} or exists $Geo::OGR::Geometry::TYPE_STRING2INT{$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')) {
            AddGeomFieldDefn($self, $d);
        } else {
            confess "Item in field list does not define a field.";
        }
    }
    return $self;
}

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

use base qw(Geo::OGR)

#** @method scalar Default($value)
# 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)
# 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)
# 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) {
        confess "Unknown justify value: '$justify'." unless exists $JUSTIFY_STRING2INT{$justify};
        $justify = $JUSTIFY_STRING2INT{$justify} if exists $JUSTIFY_STRING2INT{$justify};
        SetJustify($self, $justify);
    }
    return $JUSTIFY_INT2STRING{GetJustify($self)} if defined wantarray;
}

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

#** @method scalar Name($name)
# 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)
# 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)
# 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)
# 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 %args = @_;
        for my $key (keys %SCHEMA_KEYS) {
            eval '$self->'.$key.'($args{'.$key.'}) if exists $args{'.$key.'}';
            croak $@ 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)
# @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, $sub_type) = @_;
    if (defined $sub_type) {
        confess "Unknown field sub type: '$sub_type'." unless exists $SUB_TYPE_STRING2INT{$sub_type};
        $sub_type = $SUB_TYPE_STRING2INT{$sub_type};
        SetSubType($self, $sub_type);
    }
    return $SUB_TYPE_INT2STRING{GetSubType($self)} if defined wantarray;
}

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

#** @method scalar Type($type)
# @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) {
        confess "Unknown field type: '$type'." unless exists $TYPE_STRING2INT{$type};
        $type = $TYPE_STRING2INT{$type};
        SetType($self, $type);
    }
    return $TYPE_INT2STRING{GetType($self)} if defined wantarray;
}

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

#** @method scalar Width($width)
# 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.
# 
# This method supports both an argument list and named arguments.
# 
# @param name Field name (please do not try to name the field as Name or Type etc.).
# @param type One of supported field types
# (see Geo::OGR::FieldDefn::Types). Optional. Default is String.
# 
# or
# 
# @param params one or more of:
# - \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)
# @return a new Geo::OGR::FieldDefn object
#*
sub new {
    my $pkg = shift;
    my ($name, $type) = ('unnamed', 'String');
    my %args;
    if (@_ == 0) {
    } elsif (@_ == 1) {
        $name = shift;
    } elsif (@_ == 2 and not $Geo::OGR::FieldDefn::SCHEMA_KEYS{$_[0]}) {
        $name = shift;
        $type = shift;
    } else {
        my %named = @_;
        for my $key (keys %named) {
            if ($Geo::OGR::FieldDefn::SCHEMA_KEYS{$key}) {
                $args{$key} = $named{$key};
            } else {
                carp "Unrecognized argument: '$key'.";
            }
        }
        $name = $args{Name} if exists $args{Name};
        delete $args{Name};
        $type = $args{Type} if exists $args{Type};
        delete $args{Type};
    }
    confess "Unknown field type: '$type'." unless exists $Geo::OGR::FieldDefn::TYPE_STRING2INT{$type};
    $type = $Geo::OGR::FieldDefn::TYPE_STRING2INT{$type};
    my $self = Geo::OGRc::new_FieldDefn($name, $type);
    if (defined($self)) {
        bless $self, $pkg;
        $self->Schema(%args);
    }
    return $self;
}

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

use base qw(Geo::OGR)

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

#** @method scalar Ignored($ignore)
# @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)
# @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)
# @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)
# 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 %args = @_;
        for my $key (keys %SCHEMA_KEYS) {
            eval '$self->'.$key.'($args{'.$key.'}) if exists $args{'.$key.'}';
            croak $@ 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)
# @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()
# @return the type of this geometry field. One of Geo::OGR::GeomFieldDefn::Types
#*
sub Type {
    my($self, $type) = @_;
    if (defined $type) {
        confess "Unknown geometry type: '$type'." unless exists $Geo::OGR::Geometry::TYPE_STRING2INT{$type};
        $type = $Geo::OGR::Geometry::TYPE_STRING2INT{$type};
        SetType($self, $type);
    }
    $Geo::OGR::Geometry::TYPE_INT2STRING{GetType($self)} if defined wantarray;
}

#** @method Types()
# Class method.
# @return a list of all geometry types, currently:
# CircularString, CircularStringZ, CompoundCurve, CompoundCurveZ, CurvePolygon, CurvePolygonZ, GeometryCollection, GeometryCollection25D, LineString, LineString25D, LinearRing, MultiCurve, MultiCurveZ, MultiLineString, MultiLineString25D, MultiPoint, MultiPoint25D, MultiPolygon, MultiPolygon25D, MultiSurface, MultiSurfaceZ, None, Point, Point25D, Polygon, Polygon25D, and Unknown.
#*
sub Types {
     return @Geo::OGR::Geometry::GEOMETRY_TYPES;
}

#** @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)
# @return a new Geo::OGR::GeomFieldDefn object
#*
sub new {
    my $pkg = shift;
    my ($name, $type) = ('geom', 'Unknown');
    my %args;
    if (@_ == 0) {
    } elsif (@_ == 1) {
        $name = shift;
    } elsif (@_ == 2 and not $Geo::OGR::GeomFieldDefn::SCHEMA_KEYS{$_[0]}) {
        $name = shift;
        $type = shift;
    } else {
        my %named = @_;
        for my $key (keys %named) {
            if ($Geo::OGR::GeomFieldDefn::SCHEMA_KEYS{$key}) {
                $args{$key} = $named{$key};
            } else {
                carp "Unrecognized argument: '$key'.";
            }
        }
        $name = $args{Name} if exists $args{Name};
        delete $args{Name};
        $type = $args{Type} if $args{Type};
        delete $args{Type};
        $type = $args{GeometryType} if $args{GeometryType};
        delete $args{GeometryType};
    }
    confess "Unknown geometry type: '$type'." unless exists $Geo::OGR::Geometry::TYPE_STRING2INT{$type};
    $type = $Geo::OGR::Geometry::TYPE_STRING2INT{$type};
    my $self = Geo::OGRc::new_GeomFieldDefn($name, $type);
    if (defined($self)) {
        bless $self, $pkg;
        $self->Schema(%args);
    }
    return $self;
}

#** @class Geo::OGR::Geometry
# @brief Spatial data.
# 
# 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)
# Add a copy of another geometry to a geometry collection
# @param other a Geo::OGR::Geometry object
#*
sub AddGeometry {
}

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

#** @method AddPoint($x, $y, $z)
# 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 {
    @_ == 4 ? AddPoint_3D(@_) : AddPoint_2D(@_);
}

#** @method AddPoint_2D($x, $y)
# 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)
# 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)
# Class method.
# Create a line string, which approximates an arc. 
# @note All angles are in degrees.
# 
# @param %params named parameters, these are:
# - \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} unless defined $p{$p};
        } else {
            carp "Unknown named parameter: '$p'.";
        }
    }
    for my $p (keys %default) {
        $p{$p} = $default{$p} unless exists $p{$p};
    }
    confess "Usage: Center => [x,y,z]." unless ref($p{Center}) eq 'ARRAY';
    for my $i (0..2) {
        $p{Center}->[$i] = 0 unless defined $p{Center}->[$i];
    }
    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()
# @note a.k.a. GetArea
# @return the area of the polygon or multipolygon
#*
sub Area {
}

#** @method scalar As(%params)
# Export the geometry into a known format.
# @param params named parameters, either: Text (a.k.a WKT), WKB
# (a.k.a. Binary) (ByteOrder can also be defined, default is 'XDR'),
# ISO WKT and WKB, HEXWKB, HEXEWKB (srid can also be given), GML,
# GeoJSON, Binary.
# @note Uses As\<format\>/ExportTo\<format\> methods.
# @return the geometry in a given format.
#*
sub As {
    my $self = shift;
    my %param;
    if (@_ == 1 and ref($_[0]) eq 'HASH') {
        %param = %{$_[0]};
    } elsif (@_ % 2 == 0) {
        %param = @_;
    } else {
        ($param{Format}, $param{x}) = @_;
    }
    $param{ByteOrder} = 'XDR' unless $param{ByteOrder};
    my $f = $param{Format};
    my $x = $param{x};
    $x = $param{ByteOrder} unless defined $x;
    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->AsBinary($x);        
    } elsif ($f =~ /wkb/i) {
        if ($f =~ /iso/i) {
            return $self->ExportToIsoWkb;
        } elsif ($f =~ /hexe/i) {
            $param{srid} = 'XDR' unless $param{srid};
            $x = $param{srid} unless defined $x;
            return $self->AsHEXEWKB($x);
        } elsif ($f =~ /hex/i) {
            return $self->AsHEXWKB;
        } else {
            return $self->AsBinary($x);
        }
    } elsif ($f =~ /gml/i) {
        return $self->AsGML;
    } elsif ($f =~ /kml/i) {
        return $self->AsKML;
    } elsif ($f =~ /json/i) {
        return $self->AsJSON;
    } else {
        confess "Unsupported format: $f.";
    }
}

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

#** @method Geo::OGR::Geometry Boundary()
# @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)
# @param distance
# @param quadsecs
# @return a new Geo::OGR::Geometry object
#*
sub Buffer {
}

#** @method Geo::OGR::Geometry BuildPolygonFromEdges($BestEffort = 0, $AutoClose = 0, $Tolerance = 0)
# 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()
# Class method.
# Same as Geo::OGR::ByteOrders
#*
sub ByteOrders {
    return @BYTE_ORDER_TYPES;
}

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

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

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

#** @method Geo::OGR::Geometry Collect(@geometries)
# 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)
# @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()
# @return a new Geo::OGR::Geometry object
#*
sub ConvexHull {
}

#** @method scalar CoordinateDimension($dimension)
# @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)
# @param other a Geo::OGR::Geometry object
# @return true if this geometry crosses the other geometry, false otherwise
#*
sub Crosses {
}

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

#** @method scalar Disjoint($other)
# @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()
# 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)
# @param other a Geo::OGR::Geometry object
# @return the distance to the other geometry
#*
sub Distance {
}

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

#** @method scalar Equals($other)
# @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 FlattenTo2D()
#*
sub FlattenTo2D {
}

#** @method Geo::OGR::Geometry ForceTo($type, ref options)
# 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;
    confess "Unknown geometry type: '$type'." unless exists $TYPE_STRING2INT{$type};
    $type = $TYPE_STRING2INT{$type};
    eval {
        $self = Geo::OGR::ForceTo($self, $type, @_);
    };
    confess $@ if $@;
    return $self;
}

#** @method Geo::OGR::Geometry ForceToCollection(@geometries)
# 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()
# Attempt to create a line string from this geometry.
# @return a new Geo::OGR::Geometry object.
#*
sub ForceToLineString {
    my $self = shift;
    $self = Geo::OGR::ForceToLineString($self);
    return $self;
}

#** @method Geo::OGR::Geometry ForceToMultiLineString(@linestrings)
# 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)
# 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)
# 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()
# 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()
# @return the geometry type of this geometry (one of Geo::OGR::GeometryTypes).
#*
sub GeometryType {
    my $self = shift;
    return $TYPE_INT2STRING{$self->GetGeometryType};
}

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

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

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

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

#** @method list GetEnvelope()
# @note In scalar context returns a reference to an anonymous array
# containing the envelope.
# @note The order of values is different from those returned by
# Geo::OGR::Layer::GetExtent.
# @return the envelope ($minx, $maxx, $miny, $maxy)
#*
sub GetEnvelope {
}

#** @method list GetEnvelope3D()
# @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()
# @return an integer
#*
sub GetGeometryCount {
}

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

#** @method scalar GetGeometryRef($index)
# @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()
# @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 list GetPoint($index = 0)
# @param index
# @return (x,y) or a list with more coordinates
#*
sub GetPoint {
    my($self, $i) = @_;
    $i = 0 unless defined $i;
    my $point = ($self->GetGeometryType & 0x80000000) == 0 ? GetPoint_2D($self, $i) : GetPoint_3D($self, $i);
    return @$point;
}

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

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

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

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

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

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

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

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

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

#** @method scalar Intersects($other)
# @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 scalar IsEmpty()
# Test whether the geometry is empty (has no points, or, for a point,
# has coordinate dimension of zero).
# @return boolean
#*
sub IsEmpty {
}

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

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

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

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

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

#** @method scalar Overlaps($other)
# @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)
# 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;
        if ($t == $Geo::OGR::wkbPoint) {
            shift if @_ > 2;
            $i = 0;
        } elsif ($t == $Geo::OGR::wkbPoint25D) {
            shift if @_ > 3;
            $i = 0;
        } else {
            my $i = shift;
        }
        SetPoint($self, $i, @_);
    }
    return GetPoint($self, $i) if defined wantarray;
}

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

#** @method array reference Points(arrayref points)
# 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 $flat = not Geo::OGR::GT_HasZ($t);
    $t = Geo::OGR::GT_Flatten($t);
    $t = $TYPE_INT2STRING{$t};
    my $points = shift;
    if ($points) {
        Empty($self);
        if ($t eq 'Unknown' or $t eq 'None' or $t eq 'GeometryCollection') {
            confess "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])) {
                $flat ?
                    AddPoint_2D($self, @{$points->[0]}[0..1]) :
                    AddPoint_3D($self, @{$points->[0]}[0..2]);
            } else {
                $flat ?
                    AddPoint_2D($self, @$points[0..1]) :
                    AddPoint_3D($self, @$points[0..2]);
            }
        } elsif ($t eq 'LineString' or $t eq 'LinearRing') {
            if ($flat) {
                for my $p (@$points) {
                    AddPoint_2D($self, @$p[0..1]);
                }
            } else{
                for my $p (@$points) {
                    AddPoint_3D($self, @$p[0..2]);
                }
            }
        } elsif ($t eq 'Polygon') {
            for my $r (@$points) {
                my $ring = Geo::OGR::Geometry->new('LinearRing');
                $ring->SetCoordinateDimension(3) unless $flat;
                $ring->Points($r);
                $self->AddGeometryDirectly($ring);
            }
        } elsif ($t eq 'MultiPoint') {
            for my $p (@$points) {
                my $point = Geo::OGR::Geometry->new($flat ? 'Point' : 'Point25D');
                $point->Points($p);
                $self->AddGeometryDirectly($point);
            }
        } elsif ($t eq 'MultiLineString') {
            for my $l (@$points) {
                my $linestring = Geo::OGR::Geometry->new($flat ? 'LineString' : 'LineString25D');
                $linestring->Points($l);
                $self->AddGeometryDirectly($linestring);
            }
        } elsif ($t eq 'MultiPolygon') {
            for my $p (@$points) {
                my $polygon = Geo::OGR::Geometry->new($flat ? 'Polygon' : 'Polygon25D');
                $polygon->Points($p);
                $self->AddGeometryDirectly($polygon);
            }
        }
    }
    return unless defined wantarray;
    $self->_GetPoints($flat);
}

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

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

#** @method SetPoint($index, $x, $y, $z)
# 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 {
    @_ == 5 ? SetPoint_3D(@_) : SetPoint_2D(@_);
}

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

#** @method SetPoint_3D($index, $x, $y, $z)
# 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)
# 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)
# 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)
# @param other a Geo::OGR::Geometry object
# @return true if this geometry touches the other geometry, false otherwise
#*
sub Touches {
}

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

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

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

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

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

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

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

#** @method Geo::OGR::Geometry new(%params)
# Class method.
# @param %params A named parameter, one of: WKT, WKB, HEXWKB,
# HEXEWKB, GML, GeoJSON, arc, or GeometryType and optionally Points.
# - \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
# 
# @note uses CreateGeometryFrom* functions from Geo::OGR
# 
# @return a new Geo::OGR::Geometry object.
# Usage:
# \code
# $g = Geo::OGR::Geometry->new(...arguments...);
# \endcode
#*
sub new {
    my $pkg = shift;
    my ($type, $wkt, $wkb, $gml, $json, $srs, $points, $arc);
    my %param;
    if (@_ == 1 and ref($_[0]) eq 'HASH') {
        %param = %{$_[0]};
    } elsif (@_ % 2 == 0) {
        %param = @_;
    } else {
        ($param{GeometryType}) = @_;
    }
    $type = ($param{type} or $param{Type} or $param{GeometryType});
    $srs = ($param{srs} or $param{SRS});
    $wkt = ($param{wkt} or $param{WKT});
    $wkb = ($param{wkb} or $param{WKB});
    my $hex = ($param{hexewkb} or $param{HEXEWKB}); # PostGIS HEX EWKB
    my $srid;
    if ($hex) {
        # get and remove SRID
        $srid = substr($hex, 10, 8);
        substr($hex, 10, 8) = '';
    } else {
        $hex = ($param{hexwkb} or $param{HEXWKB});
    }
    if ($hex) {
        $wkb = '';
        for (my $i = 0; $i < length($hex); $i+=2) {
            $wkb .= chr(hex(substr($hex,$i,2)));
        }
    }
    $gml = ($param{gml} or $param{GML});
    $json = ($param{geojson} or $param{GeoJSON});
    $points = $param{Points};
    $arc = ($param{arc} or $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) {
        confess "Unknown geometry type: '$type'." unless exists $Geo::OGR::Geometry::TYPE_STRING2INT{$type};
        $type = $Geo::OGR::Geometry::TYPE_STRING2INT{$type};
        $self = Geo::OGRc::new_Geometry($type); # flattens the type
        SetCoordinateDimension($self, 3) if Geo::OGR::GT_HasZ($type);
    } elsif (defined $arc) {
        $self = Geo::OGRc::ApproximateArcAngles(@$arc);
    } else {
        confess "Missing a parameter when creating a Geo::OGR::Geometry object.";
    }
    bless $self, $pkg if defined $self;
    $self->Points($points) if $points;
    return $self;
}

#** @class Geo::OGR::Layer
# @brief A collection of similar features.
# 
# 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.
#*
package Geo::OGR::Layer;

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

#** @method AlterFieldDefn($name, %params)
# @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 $field = shift;
    my $index;
    eval {
        $index = $self->GetFieldIndex($field);
    };
    confess "Only non-spatial fields can be altered.\n$@" if $@;
    if (blessed($_[0]) and $_[0]->isa('Geo::OGR::FieldDefn')) {
        _AlterFieldDefn($self, $index, @_);
    } elsif (@_ % 2 == 0) {
        my %params = @_;
        my $definition = Geo::OGR::FieldDefn->new(%params);
        my $flags = 0;
        $flags |= 1 if exists $params{Name};
        $flags |= 2 if exists $params{Type};
        $flags |= 4 if exists $params{Width} or exists $params{Precision};
        $flags |= 8 if exists $params{Nullable};
        $flags |= 16 if exists $params{Default};
        _AlterFieldDefn($self, $index, $definition, $flags);
    } else {
        croak "Usage: AlterFieldDefn(\$Name, \%NamedParameters)";
    }
}

#** @method list Capabilities()
# Both a class and an object method.
# @return a list of capabilities. The object method returns a list of
# the capabilities the layer has. The class method 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, RandomRead, RandomWrite, ReorderFields, SequentialWrite, StringsAsUTF8, and Transactions.
# 
# Examples:
# \code
# @cap = Geo::OGR::Layer::Capabilities(); # the class method
# @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, subref callback, $callback_data)
# 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()
#*
sub CommitTransaction {
}

#** @method CreateFeature($feature)
# @deprecated use Geo::OGR::Layer::InsertFeature which accepts Perl
# data and checks for geometry type and attribute data
# 
# @note The feature should have the same schema as the layer.
# 
# Inserts a feature into the layer. The given feature's id may change.
# @param feature a Geo::OGR::Feature object
#*
sub CreateFeature {
}

#** @method CreateField(%params)
# 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 (keys %defaults) {
        $params{$_} = $defaults{$_} unless defined $params{$_};
    }
    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 {
        my $a = $params{ApproxOK};
        delete $params{ApproxOK};
        if (exists $params{GeometryType}) {
            $params{Type} = $params{GeometryType};
            delete $params{GeometryType};
        }
        if (exists $Geo::OGR::FieldDefn::TYPE_STRING2INT{$params{Type}}) {
            my $fd = Geo::OGR::FieldDefn->new(%params);
            _CreateField($self, $fd, $a);
        } else {
            my $fd = Geo::OGR::GeomFieldDefn->new(%params);
            CreateGeomField($self, $fd, $a);
        }
    }
}

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

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

#** @method DeleteField($field)
# 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, $fn) = @_;
    my $d = $self->GetDefn;
    my $index = $d->GetFieldIndex($fn);
    $index = $fn if $index < 0;
    eval {
        _DeleteField($self, $index);
    };
    confess "Field not found: '$fn'. Only non-spatial fields can be deleted." if $@;
}

#** @method Erase(Geo::OGR::Layer method, Geo::OGR::Layer result, hashref options, subref callback, $callback_data)
# 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 ForFeatures($code, $in_place)
# @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) {
        $code->($f);
        $self->SetFeature($f) if $in_place;
    };
}

#** @method ForGeometries($code, $in_place)
# @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 GeometryType()
#*
sub GeometryType {
    my $self = shift;
    my $d = $self->GetDefn;
    my $fd = $d->GetGeomFieldDefn(0);
    return $fd->Type if $fd;
}

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

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

#** @method list GetExtent($force = 1)
# @param force compute the extent even if it is expensive
# @note In scalar context returns a reference to an anonymous array
# containing the extent.
# @note The order of values is different from those returned by
# Geo::OGR::Geometry::GetEnvelope.
# @return the extent ($minx, $miny, $maxx, $maxy)
# @param force
# @return the extent = ($minx, $miny, $maxx, $maxy) as a listref
#*
sub GetExtent {
}

#** @method scalar GetFIDColumn()
# @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)
# @param fid feature id
# @return a new Geo::OGR::Feature object that represents the feature in the layer.
#*
sub GetFeature {
}

#** @method scalar GetFeatureCount($force = 1)
# @param force
# @return integer
#*
sub GetFeatureCount {
}

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

#** @method hash GetFieldDefn($name)
# Get the definition of a field.
# @param name the name of the field.
# @return the field definition object, either Geo::OGR::FieldDefn or
# Geo::OGR::GeomFieldDefn.
#*
sub GetFieldDefn {
    my ($self, $name) = @_;
    my $d = $self->GetDefn;
    for (my $i = 0; $i < $d->GetFieldCount; $i++) {
        my $fd = $d->GetFieldDefn($i);
        return $fd if $fd->Name eq $name;
    }
    for (my $i = 0; $i < $d->GetGeomFieldCount; $i++) {
        my $fd = $d->GetGeomFieldDefn($i);
        return $fd if $fd->Name eq $name;
    }
    confess "No such field: '$name'.";
}

#** @method list GetFieldNames()
# @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 GetName()
# @return the name of the layer.
#*
sub GetName {
}

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

#** @method hash reference GetSchema()
# @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()
# @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, subref callback, $callback_data)
# 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)
# 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)
#*
sub InsertFeature {
    my $self = shift;
    my $feature = shift;
    confess "Usage: \$feature->InsertFeature(reference to a hash or array)." unless ref($feature);
    my $new = Geo::OGR::Feature->new($self->GetDefn);
    if (ref($feature) eq 'HASH') {
        $new->Row(%$feature);
    } elsif (ref($feature) eq 'ARRAY') {
        $new->Tuple(@$feature);
    } elsif (blessed($feature) and $feature->isa('Geo::OGR::Feature')) {
        $new->Row($feature->Row);
    }
    $self->CreateFeature($new);
}

#** @method Intersection(Geo::OGR::Layer method, Geo::OGR::Layer result, hashref options, subref callback, $callback_data)
# 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 ReorderField()
#*
sub ReorderField {
}

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

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

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

#** @method hash reference Row(%row)
# 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)
# Set or clear the attribute filter.
# @param filter_string a SQL WHERE clause or undef to clear the
# filter.
#*
sub SetAttributeFilter {
}

#** @method SetFeature($feature)
# @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)
# @param fields a list of field names
#*
sub SetIgnoredFields {
}

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

#** @method SetSpatialFilter($filter)
# @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)
# @param minx
# @param miny
# @param maxx
# @param maxy
#*
sub SetSpatialFilterRect {
}

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

#** @method Geo::OGR::Geometry SpatialFilter(@filter)
# @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)
# @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, $field, $sr) = @_;
    my $d = $self->GetDefn;
    my $i;
    if (not defined $field or (blessed($field) and $field->isa('Geo::OSR::SpatialReference'))) {
        $i = 0;
    } else {
        $i = $d->GetGeomFieldIndex($field);
    }
    my $d2 = $d->GetGeomFieldDefn($i);
    $d2->SpatialReference($sr) if defined $sr;
    return $d2->SpatialReference() if defined wantarray;
}

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

#** @method SymDifference(Geo::OGR::Layer method, Geo::OGR::Layer result, hashref options, subref callback, $callback_data)
# 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()
#*
sub SyncToDisk {
}

#** @method scalar TestCapability($cap)
# @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)
# 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, subref callback, $callback_data)
# 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, subref callback, $callback_data)
# 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.
#*
package Geo::OSR;

use base qw()

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

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

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

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

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

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

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

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

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

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

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

#** @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.
#*
package Geo::OSR::CoordinateTransformation;

use base qw(Geo::OSR)

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

#** @method TransformPoints(arrayref points)
# @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 3.0.5
#
# 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.
# 
# <a href="http://www.gdal.org/ogr/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()
# Set EPSG authority info if possible.
#*
sub AutoIdentifyEPSG {
}

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

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

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

#** @method EPSGTreatsAsLatLong()
# 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)
# 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} unless $format;
    $format = $params{format} unless $format;
    $format = $params{as} unless $format;
    if ($format eq 'WKT' or $format eq 'Text') {
        return ExportToWkt($self);
    } elsif ($format eq 'PrettyWKT') {
        my $simplify = exists $params{simplify} ? $params{simplify} : 0;
        return ExportToPrettyWkt($self, $simplify);
    } elsif ($format eq 'Proj4') {
        return ExportToProj4($self);
    } elsif ($format eq 'PCI') {            
        return ExportToPCI($self);
    } elsif ($format eq 'USGS') {
        return ExportToUSGS($self);
    } elsif ($format eq 'GML' or $format eq 'XML') {
        my $dialect = exists $params{dialect} ? $params{dialect} : '';
        return ExportToXML($self, $dialect);
    } elsif ($format eq 'MICoordSys' or $format eq 'MapInfoCS') {
        return ExportToMICoordSys();
    } else {
        confess "Unrecognized export format.";
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#** @method GetUTMZone()
# 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()
# @return boolean
#*
sub IsCompound {
}

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

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

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

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

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

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

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

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

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

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

#** @method Set(%params)
# 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}) {
        croak "Unknown projection parameter '$params{Parameter}'." unless exists $Geo::OSR::PARAMETERS{$params{Parameter}};
        $params{Normalized} ?
            SetNormProjParm($self, $params{Parameter}, $params{Value}) :
            SetProjParm($self, $params{Parameter}, $params{Value});
    } elsif ($params{Name}) {
        SetWellKnownGeogCS($self, $params{Name});
    } elsif ($params{GuessFrom}) {
        SetFromUserInput($self, $params{GuessFrom});
    } elsif ($params{LOCAL_CS}) {
        SetLocalCS($self, $params{LOCAL_CS});
    } elsif ($params{GeocentricCS}) {
        SetGeocCS($self, $params{GeocentricCS});
    } elsif ($params{VerticalCS} and $params{Datum}) {
        my $type = $params{VertDatumType} || 2005;
        SetVertCS($self, $params{VerticalCS}, $params{Datum}, $type);
    } elsif ($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 ($params{Projection}) {
        confess "Unknown projection." 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} unless $variant;
            $variant = $params{Name} unless $variant;
            $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 {
        confess "Not enough information for a spatial reference object.";
    }
}

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

#** @method Validate()
#*
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/ogr/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 ($param{WKT}) {
        ImportFromWkt($self, $param{WKT});
    } elsif ($param{Text}) {
        ImportFromWkt($self, $param{Text});
    } elsif ($param{Proj4}) {
        ImportFromProj4($self, $param{Proj4});
    } elsif ($param{ESRI}) {
        ImportFromESRI($self, @{$param{ESRI}});
    } elsif ($param{EPSG}) {
        ImportFromEPSG($self, $param{EPSG});
    } elsif ($param{EPSGA}) {
        ImportFromEPSGA($self, $param{EPSGA});
    } elsif ($param{PCI}) {
        ImportFromPCI($self, @{$param{PCI}});
    } elsif ($param{USGS}) {
        ImportFromUSGS($self, @{$param{USGS}});
    } elsif ($param{XML}) {
        ImportFromXML($self, $param{XML});
    } elsif ($param{GML}) {
        ImportFromGML($self, $param{GML});
    } elsif ($param{URL}) {
        ImportFromUrl($self, $param{URL});
    } elsif ($param{ERMapper}) {
        ImportFromERM($self, @{$param{ERMapper}});
    } elsif ($param{ERM}) {
        ImportFromERM($self, @{$param{ERM}});
    } elsif ($param{MICoordSys}) {
        ImportFromMICoordSys($self, $param{MICoordSys});
    } elsif ($param{MapInfoCS}) {
        ImportFromMICoordSys($self, $param{MapInfoCS});
    } elsif ($param{WGS}) {
        eval {
            SetWellKnownGeogCS($self, 'WGS'.$param{WGS});
        };
        confess "$@" if $@;
    } else {
        confess "Unrecognized/missing parameters: @_.";
    }
    bless $self, $pkg if defined $self;
}