GDAL
OGR API Tutorial

This document is intended to document using the OGR C++ classes to read and write data from a file. It is strongly advised that the read first review the OGR Architecture document describing the key classes and their roles in OGR.

It also includes code snippets for the corresponding functions in C and Python.

Reading From OGR

For purposes of demonstrating reading with OGR, we will construct a small utility for dumping point layers from an OGR data source to stdout in comma-delimited format.

Initially it is necessary to register all the format drivers that are desired. This is normally accomplished by calling GDALAllRegister() which registers all format drivers built into GDAL/OGR.

In C++ :

#include "ogrsf_frmts.h"
int main()
{

In C :

#include "gdal.h"
int main()
{

Next we need to open the input OGR datasource. Datasources can be files, RDBMSes, directories full of files, or even remote web services depending on the driver being used. However, the datasource name is always a single string. In this case we are hardcoded to open a particular shapefile. The second argument (GDAL_OF_VECTOR) tells the OGROpen() method that we want a vector driver to be use and that don't require update access. On failure NULL is returned, and we report an error.

In C++ :

poDS = (GDALDataset*) GDALOpenEx( "point.shp", GDAL_OF_VECTOR, NULL, NULL, NULL );
if( poDS == NULL )
{
printf( "Open failed.\n" );
exit( 1 );
}

In C :

hDS = GDALOpenEx( "point.shp", GDAL_OF_VECTOR, NULL, NULL, NULL );
if( hDS == NULL )
{
printf( "Open failed.\n" );
exit( 1 );
}

A GDALDataset can potentially have many layers associated with it. The number of layers available can be queried with GDALDataset::GetLayerCount() and individual layers fetched by index using GDALDataset::GetLayer(). However, we will just fetch the layer by name.

In C++ :

OGRLayer *poLayer;
poLayer = poDS->GetLayerByName( "point" );

In C :

OGRLayerH hLayer;
hLayer = GDALDatasetGetLayerByName( hDS, "point" );

Now we want to start reading features from the layer. Before we start we could assign an attribute or spatial filter to the layer to restrict the set of feature we get back, but for now we are interested in getting all features.

With GDAL 2.3 and C++11:

for( auto& poFeature: poLayer )
{

With GDAL 2.3 and C:

OGR_FOR_EACH_FEATURE_BEGIN(hFeature, hLayer)
{

If using older GDAL versions, while it isn't strictly necessary in this circumstance since we are starting fresh with the layer, it is often wise to call OGRLayer::ResetReading() to ensure we are starting at the beginning of the layer. We iterate through all the features in the layer using OGRLayer::GetNextFeature(). It will return NULL when we run out of features.

With GDAL < 2.3 and C++ :

OGRFeature *poFeature;
poLayer->ResetReading();
while( (poFeature = poLayer->GetNextFeature()) != NULL )
{

With GDAL < 2.3 and C :

OGRFeatureH hFeature;
while( (hFeature = OGR_L_GetNextFeature(hLayer)) != NULL )
{

In order to dump all the attribute fields of the feature, it is helpful to get the OGRFeatureDefn. This is an object, associated with the layer, containing the definitions of all the fields. We loop over all the fields, and fetch and report the attributes based on their type.

With GDAL 2.3 and C++11:

for( auto&& oField: *poFeature )
{
switch( oField.GetType() )
{
case OFTInteger:
printf( "%d,", oField.GetInteger() );
break;
printf( CPL_FRMT_GIB ",", oField.GetInteger64() );
break;
case OFTReal:
printf( "%.3f,", oField.GetDouble() );
break;
case OFTString:
printf( "%s,", oField.GetString() );
break;
default:
printf( "%s,", oField.GetAsString() );
break;
}
}

With GDAL < 2.3 and C++ :

OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
for( int iField = 0; iField < poFDefn->GetFieldCount(); iField++ )
{
OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn( iField );
switch( poFieldDefn->GetType() )
{
case OFTInteger:
printf( "%d,", poFeature->GetFieldAsInteger( iField ) );
break;
printf( CPL_FRMT_GIB ",", poFeature->GetFieldAsInteger64( iField ) );
break;
case OFTReal:
printf( "%.3f,", poFeature->GetFieldAsDouble(iField) );
break;
case OFTString:
printf( "%s,", poFeature->GetFieldAsString(iField) );
break;
default:
printf( "%s,", poFeature->GetFieldAsString(iField) );
break;
}
}

In C :

int iField;
for( iField = 0; iField < OGR_FD_GetFieldCount(hFDefn); iField++ )
{
OGRFieldDefnH hFieldDefn = OGR_FD_GetFieldDefn( hFDefn, iField );
switch( OGR_Fld_GetType(hFieldDefn) )
{
case OFTInteger:
printf( "%d,", OGR_F_GetFieldAsInteger( hFeature, iField ) );
break;
printf( CPL_FRMT_GIB ",", OGR_F_GetFieldAsInteger64( hFeature, iField ) );
break;
case OFTReal:
printf( "%.3f,", OGR_F_GetFieldAsDouble( hFeature, iField) );
break;
case OFTString:
printf( "%s,", OGR_F_GetFieldAsString( hFeature, iField) );
break;
default:
printf( "%s,", OGR_F_GetFieldAsString( hFeature, iField) );
break;
}
}

There are a few more field types than those explicitly handled above, but a reasonable representation of them can be fetched with the OGRFeature::GetFieldAsString() method. In fact we could shorten the above by using OGRFeature::GetFieldAsString() for all the types.

Next we want to extract the geometry from the feature, and write out the point geometry x and y. Geometries are returned as a generic OGRGeometry pointer. We then determine the specific geometry type, and if it is a point, we cast it to point and operate on it. If it is something else we write placeholders.

In C++ :

OGRGeometry *poGeometry;
poGeometry = poFeature->GetGeometryRef();
if( poGeometry != NULL
&& wkbFlatten(poGeometry->getGeometryType()) == wkbPoint )
{
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(2,3,0)
OGRPoint *poPoint = poGeometry->toPoint();
#else
OGRPoint *poPoint = (OGRPoint *) poGeometry;
#endif
printf( "%.3f,%3.f\n", poPoint->getX(), poPoint->getY() );
}
else
{
printf( "no point geometry\n" );
}

In C :

OGRGeometryH hGeometry;
hGeometry = OGR_F_GetGeometryRef(hFeature);
if( hGeometry != NULL
{
printf( "%.3f,%3.f\n", OGR_G_GetX(hGeometry, 0), OGR_G_GetY(hGeometry, 0) );
}
else
{
printf( "no point geometry\n" );
}

The wkbFlatten() macro is used above to convert the type for a wkbPoint25D (a point with a z coordinate) into the base 2D geometry type code (wkbPoint). For each 2D geometry type there is a corresponding 2.5D type code. The 2D and 2.5D geometry cases are handled by the same C++ class, so our code will handle 2D or 3D cases properly.

Starting with OGR 1.11, several geometry fields can be associated to a feature.

In C++ :

OGRGeometry *poGeometry;
int iGeomField;
int nGeomFieldCount;
nGeomFieldCount = poFeature->GetGeomFieldCount();
for(iGeomField = 0; iGeomField < nGeomFieldCount; iGeomField ++ )
{
poGeometry = poFeature->GetGeomFieldRef(iGeomField);
if( poGeometry != NULL
&& wkbFlatten(poGeometry->getGeometryType()) == wkbPoint )
{
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(2,3,0)
OGRPoint *poPoint = poGeometry->toPoint();
#else
OGRPoint *poPoint = (OGRPoint *) poGeometry;
#endif
printf( "%.3f,%3.f\n", poPoint->getX(), poPoint->getY() );
}
else
{
printf( "no point geometry\n" );
}
}

In C :

OGRGeometryH hGeometry;
int iGeomField;
int nGeomFieldCount;
nGeomFieldCount = OGR_F_GetGeomFieldCount(hFeature);
for(iGeomField = 0; iGeomField < nGeomFieldCount; iGeomField ++ )
{
hGeometry = OGR_F_GetGeomFieldRef(hFeature, iGeomField);
if( hGeometry != NULL
{
printf( "%.3f,%3.f\n", OGR_G_GetX(hGeometry, 0),
OGR_G_GetY(hGeometry, 0) );
}
else
{
printf( "no point geometry\n" );
}
}

In Python:

nGeomFieldCount = feat.GetGeomFieldCount()
for iGeomField in range(nGeomFieldCount):
geom = feat.GetGeomFieldRef(iGeomField)
if geom is not None and geom.GetGeometryType() == ogr.wkbPoint:
print "%.3f, %.3f" % ( geom.GetX(), geom.GetY() )
else:
print "no point geometry\n"

Note that OGRFeature::GetGeometryRef() and OGRFeature::GetGeomFieldRef() return a pointer to the internal geometry owned by the OGRFeature. There we don't actually deleted the return geometry.

With GDAL 2.3 and C++11, the looping over features is simply terminated by a closing curly bracket.

}

With GDAL 2.3 and C, the looping over features is simply terminated by the following.

For GDAL < 2.3, as the OGRLayer::GetNextFeature() method returns a copy of the feature that is now owned by us. So at the end of use we must free the feature. We could just "delete" it, but this can cause problems in windows builds where the GDAL DLL has a different "heap" from the main program. To be on the safe side we use a GDAL function to delete the feature.

In C++ :

}

In C :

OGR_F_Destroy( hFeature );
}

The OGRLayer returned by GDALDataset::GetLayerByName() is also a reference to an internal layer owned by the GDALDataset so we don't need to delete it. But we do need to delete the datasource in order to close the input file. Once again we do this with a custom delete method to avoid special win32 heap issues.

In C/C++ :

GDALClose( poDS );
}

All together our program looks like this.

With GDAL 2.3 and C++11 :

#include "ogrsf_frmts.h"
int main()
{
if( poDS == nullptr )
{
printf( "Open failed.\n" );
exit( 1 );
}
for( const OGRLayer* poLayer: poDS->GetLayers() )
{
for( const auto& poFeature: *poLayer )
{
for( const auto& oField: *poFeature )
{
switch( oField.GetType() )
{
case OFTInteger:
printf( "%d,", oField.GetInteger() );
break;
printf( CPL_FRMT_GIB ",", oField.GetInteger64() );
break;
case OFTReal:
printf( "%.3f,", oField.GetDouble() );
break;
case OFTString:
printf( "%s,", oField.GetString() );
break;
default:
printf( "%s,", oField.GetAsString() );
break;
}
}
const OGRGeometry *poGeometry = poFeature->GetGeometryRef();
if( poGeometry != nullptr
&& wkbFlatten(poGeometry->getGeometryType()) == wkbPoint )
{
const OGRPoint *poPoint = poGeometry->toPoint();
printf( "%.3f,%3.f\n", poPoint->getX(), poPoint->getY() );
}
else
{
printf( "no point geometry\n" );
}
}
}
return 0;
}

In C++ :

#include "ogrsf_frmts.h"
int main()
{
GDALDataset *poDS = static_cast<GDALDataset*>(
GDALOpenEx( "point.shp", GDAL_OF_VECTOR, NULL, NULL, NULL ));
if( poDS == NULL )
{
printf( "Open failed.\n" );
exit( 1 );
}
OGRLayer *poLayer = poDS->GetLayerByName( "point" );
OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
poLayer->ResetReading();
OGRFeature *poFeature;
while( (poFeature = poLayer->GetNextFeature()) != NULL )
{
for( int iField = 0; iField < poFDefn->GetFieldCount(); iField++ )
{
OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn( iField );
switch( poFieldDefn->GetType() )
{
case OFTInteger:
printf( "%d,", poFeature->GetFieldAsInteger( iField ) );
break;
printf( CPL_FRMT_GIB ",", poFeature->GetFieldAsInteger64( iField ) );
break;
case OFTReal:
printf( "%.3f,", poFeature->GetFieldAsDouble(iField) );
break;
case OFTString:
printf( "%s,", poFeature->GetFieldAsString(iField) );
break;
default:
printf( "%s,", poFeature->GetFieldAsString(iField) );
break;
}
}
OGRGeometry *poGeometry = poFeature->GetGeometryRef();
if( poGeometry != NULL
&& wkbFlatten(poGeometry->getGeometryType()) == wkbPoint )
{
OGRPoint *poPoint = (OGRPoint *) poGeometry;
printf( "%.3f,%3.f\n", poPoint->getX(), poPoint->getY() );
}
else
{
printf( "no point geometry\n" );
}
}
GDALClose( poDS );
}

In C :

#include "gdal.h"
int main()
{
OGRLayerH hLayer;
OGRFeatureH hFeature;
hDS = GDALOpenEx( "point.shp", GDAL_OF_VECTOR, NULL, NULL, NULL );
if( hDS == NULL )
{
printf( "Open failed.\n" );
exit( 1 );
}
hLayer = GDALDatasetGetLayerByName( hDS, "point" );
hFDefn = OGR_L_GetLayerDefn(hLayer);
while( (hFeature = OGR_L_GetNextFeature(hLayer)) != NULL )
{
int iField;
OGRGeometryH hGeometry;
for( iField = 0; iField < OGR_FD_GetFieldCount(hFDefn); iField++ )
{
OGRFieldDefnH hFieldDefn = OGR_FD_GetFieldDefn( hFDefn, iField );
switch( OGR_Fld_GetType(hFieldDefn) )
{
case OFTInteger:
printf( "%d,", OGR_F_GetFieldAsInteger( hFeature, iField ) );
break;
printf( CPL_FRMT_GIB ",", OGR_F_GetFieldAsInteger64( hFeature, iField ) );
break;
case OFTReal:
printf( "%.3f,", OGR_F_GetFieldAsDouble( hFeature, iField) );
break;
case OFTString:
printf( "%s,", OGR_F_GetFieldAsString( hFeature, iField) );
break;
default:
printf( "%s,", OGR_F_GetFieldAsString( hFeature, iField) );
break;
}
}
hGeometry = OGR_F_GetGeometryRef(hFeature);
if( hGeometry != NULL
{
printf( "%.3f,%3.f\n", OGR_G_GetX(hGeometry, 0), OGR_G_GetY(hGeometry, 0) );
}
else
{
printf( "no point geometry\n" );
}
OGR_F_Destroy( hFeature );
}
GDALClose( hDS );
}

In Python:

import sys
from osgeo import gdal
ds = gdal.OpenEx( "point.shp", gdal.OF_VECTOR )
if ds is None:
print "Open failed.\n"
sys.exit( 1 )
lyr = ds.GetLayerByName( "point" )
lyr.ResetReading()
for feat in lyr:
feat_defn = lyr.GetLayerDefn()
for i in range(feat_defn.GetFieldCount()):
field_defn = feat_defn.GetFieldDefn(i)
# Tests below can be simplified with just :
# print feat.GetField(i)
if field_defn.GetType() == ogr.OFTInteger or field_defn.GetType() == ogr.OFTInteger64:
print "%d" % feat.GetFieldAsInteger64(i)
elif field_defn.GetType() == ogr.OFTReal:
print "%.3f" % feat.GetFieldAsDouble(i)
elif field_defn.GetType() == ogr.OFTString:
print "%s" % feat.GetFieldAsString(i)
else:
print "%s" % feat.GetFieldAsString(i)
geom = feat.GetGeometryRef()
if geom is not None and geom.GetGeometryType() == ogr.wkbPoint:
print "%.3f, %.3f" % ( geom.GetX(), geom.GetY() )
else:
print "no point geometry\n"
ds = None

Writing To OGR

As an example of writing through OGR, we will do roughly the opposite of the above. A short program that reads comma separated values from input text will be written to a point shapefile via OGR.

As usual, we start by registering all the drivers, and then fetch the Shapefile driver as we will need it to create our output file.

In C++ :

#include "ogrsf_frmts.h"
int main()
{
const char *pszDriverName = "ESRI Shapefile";
GDALDriver *poDriver;
poDriver = GetGDALDriverManager()->GetDriverByName(pszDriverName );
if( poDriver == NULL )
{
printf( "%s driver not available.\n", pszDriverName );
exit( 1 );
}

In C :

#include "ogr_api.h"
int main()
{
const char *pszDriverName = "ESRI Shapefile";
GDALDriver *poDriver;
poDriver = (GDALDriver*) GDALGetDriverByName(pszDriverName );
if( poDriver == NULL )
{
printf( "%s driver not available.\n", pszDriverName );
exit( 1 );
}

Next we create the datasource. The ESRI Shapefile driver allows us to create a directory full of shapefiles, or a single shapefile as a datasource. In this case we will explicitly create a single file by including the extension in the name. Other drivers behave differently. The second, third, fourth and fifth argument are related to raster dimensions (in case the driver has raster capabilities). The last argument to the call is a list of option values, but we will just be using defaults in this case. Details of the options supported are also format specific.

In C ++ :

poDS = poDriver->Create( "point_out.shp", 0, 0, 0, GDT_Unknown, NULL );
if( poDS == NULL )
{
printf( "Creation of output file failed.\n" );
exit( 1 );
}

In C :

hDS = GDALCreate( hDriver, "point_out.shp", 0, 0, 0, GDT_Unknown, NULL );
if( hDS == NULL )
{
printf( "Creation of output file failed.\n" );
exit( 1 );
}

Now we create the output layer. In this case since the datasource is a single file, we can only have one layer. We pass wkbPoint to specify the type of geometry supported by this layer. In this case we aren't passing any coordinate system information or other special layer creation options.

In C++ :

OGRLayer *poLayer;
poLayer = poDS->CreateLayer( "point_out", NULL, wkbPoint, NULL );
if( poLayer == NULL )
{
printf( "Layer creation failed.\n" );
exit( 1 );
}

In C :

OGRLayerH hLayer;
hLayer = GDALDatasetCreateLayer( hDS, "point_out", NULL, wkbPoint, NULL );
if( hLayer == NULL )
{
printf( "Layer creation failed.\n" );
exit( 1 );
}

Now that the layer exists, we need to create any attribute fields that should appear on the layer. Fields must be added to the layer before any features are written. To create a field we initialize an OGRField object with the information about the field. In the case of Shapefiles, the field width and precision is significant in the creation of the output .dbf file, so we set it specifically, though generally the defaults are OK. For this example we will just have one attribute, a name string associated with the x,y point.

Note that the template OGRField we pass to CreateField() is copied internally. We retain ownership of the object.

In C++:

OGRFieldDefn oField( "Name", OFTString );
oField.SetWidth(32);
if( poLayer->CreateField( &oField ) != OGRERR_NONE )
{
printf( "Creating Name field failed.\n" );
exit( 1 );
}

In C:

OGRFieldDefnH hFieldDefn;
hFieldDefn = OGR_Fld_Create( "Name", OFTString );
OGR_Fld_SetWidth( hFieldDefn, 32);
if( OGR_L_CreateField( hLayer, hFieldDefn, TRUE ) != OGRERR_NONE )
{
printf( "Creating Name field failed.\n" );
exit( 1 );
}
OGR_Fld_Destroy(hFieldDefn);

The following snipping loops reading lines of the form "x,y,name" from stdin, and parsing them.

In C++ and in C :

double x, y;
char szName[33];
while( !feof(stdin)
&& fscanf( stdin, "%lf,%lf,%32s", &x, &y, szName ) == 3 )
{

To write a feature to disk, we must create a local OGRFeature, set attributes and attach geometry before trying to write it to the layer. It is imperative that this feature be instantiated from the OGRFeatureDefn associated with the layer it will be written to.

In C++ :

OGRFeature *poFeature;
poFeature = OGRFeature::CreateFeature( poLayer->GetLayerDefn() );
poFeature->SetField( "Name", szName );

In C :

OGRFeatureH hFeature;
hFeature = OGR_F_Create( OGR_L_GetLayerDefn( hLayer ) );
OGR_F_SetFieldString( hFeature, OGR_F_GetFieldIndex(hFeature, "Name"), szName );

We create a local geometry object, and assign its copy (indirectly) to the feature. The OGRFeature::SetGeometryDirectly() differs from OGRFeature::SetGeometry() in that the direct method gives ownership of the geometry to the feature. This is generally more efficient as it avoids an extra deep object copy of the geometry.

In C++ :

pt.setX( x );
pt.setY( y );
poFeature->SetGeometry( &pt );

In C :

Now we create a feature in the file. The OGRLayer::CreateFeature() does not take ownership of our feature so we clean it up when done with it.

In C++ :

if( poLayer->CreateFeature( poFeature ) != OGRERR_NONE )
{
printf( "Failed to create feature in shapefile.\n" );
exit( 1 );
}
}

In C :

if( OGR_L_CreateFeature( hLayer, hFeature ) != OGRERR_NONE )
{
printf( "Failed to create feature in shapefile.\n" );
exit( 1 );
}
OGR_F_Destroy( hFeature );
}

Finally we need to close down the datasource in order to ensure headers are written out in an orderly way and all resources are recovered.

In C/C++ :

GDALClose( poDS );
}

The same program all in one block looks like this:

In C++ :

#include "ogrsf_frmts.h"
int main()
{
const char *pszDriverName = "ESRI Shapefile";
GDALDriver *poDriver;
poDriver = GetGDALDriverManager()->GetDriverByName(pszDriverName );
if( poDriver == NULL )
{
printf( "%s driver not available.\n", pszDriverName );
exit( 1 );
}
GDALDataset *poDS;
poDS = poDriver->Create( "point_out.shp", 0, 0, 0, GDT_Unknown, NULL );
if( poDS == NULL )
{
printf( "Creation of output file failed.\n" );
exit( 1 );
}
OGRLayer *poLayer;
poLayer = poDS->CreateLayer( "point_out", NULL, wkbPoint, NULL );
if( poLayer == NULL )
{
printf( "Layer creation failed.\n" );
exit( 1 );
}
OGRFieldDefn oField( "Name", OFTString );
oField.SetWidth(32);
if( poLayer->CreateField( &oField ) != OGRERR_NONE )
{
printf( "Creating Name field failed.\n" );
exit( 1 );
}
double x, y;
char szName[33];
while( !feof(stdin)
&& fscanf( stdin, "%lf,%lf,%32s", &x, &y, szName ) == 3 )
{
OGRFeature *poFeature;
poFeature = OGRFeature::CreateFeature( poLayer->GetLayerDefn() );
poFeature->SetField( "Name", szName );
pt.setX( x );
pt.setY( y );
poFeature->SetGeometry( &pt );
if( poLayer->CreateFeature( poFeature ) != OGRERR_NONE )
{
printf( "Failed to create feature in shapefile.\n" );
exit( 1 );
}
}
GDALClose( poDS );
}

In C :

#include "gdal.h"
int main()
{
const char *pszDriverName = "ESRI Shapefile";
GDALDriverH hDriver;
OGRLayerH hLayer;
OGRFieldDefnH hFieldDefn;
double x, y;
char szName[33];
hDriver = GDALGetDriverByName( pszDriverName );
if( hDriver == NULL )
{
printf( "%s driver not available.\n", pszDriverName );
exit( 1 );
}
hDS = GDALCreate( hDriver, "point_out.shp", 0, 0, 0, GDT_Unknown, NULL );
if( hDS == NULL )
{
printf( "Creation of output file failed.\n" );
exit( 1 );
}
hLayer = GDALDatasetCreateLayer( hDS, "point_out", NULL, wkbPoint, NULL );
if( hLayer == NULL )
{
printf( "Layer creation failed.\n" );
exit( 1 );
}
hFieldDefn = OGR_Fld_Create( "Name", OFTString );
OGR_Fld_SetWidth( hFieldDefn, 32);
if( OGR_L_CreateField( hLayer, hFieldDefn, TRUE ) != OGRERR_NONE )
{
printf( "Creating Name field failed.\n" );
exit( 1 );
}
OGR_Fld_Destroy(hFieldDefn);
while( !feof(stdin)
&& fscanf( stdin, "%lf,%lf,%32s", &x, &y, szName ) == 3 )
{
OGRFeatureH hFeature;
hFeature = OGR_F_Create( OGR_L_GetLayerDefn( hLayer ) );
OGR_F_SetFieldString( hFeature, OGR_F_GetFieldIndex(hFeature, "Name"), szName );
OGR_G_SetPoint_2D(hPt, 0, x, y);
OGR_F_SetGeometry( hFeature, hPt );
if( OGR_L_CreateFeature( hLayer, hFeature ) != OGRERR_NONE )
{
printf( "Failed to create feature in shapefile.\n" );
exit( 1 );
}
OGR_F_Destroy( hFeature );
}
GDALClose( hDS );
}

In Python :

import sys
from osgeo import gdal
from osgeo import ogr
import string
driverName = "ESRI Shapefile"
drv = gdal.GetDriverByName( driverName )
if drv is None:
print "%s driver not available.\n" % driverName
sys.exit( 1 )
ds = drv.Create( "point_out.shp", 0, 0, 0, gdal.GDT_Unknown )
if ds is None:
print "Creation of output file failed.\n"
sys.exit( 1 )
lyr = ds.CreateLayer( "point_out", None, ogr.wkbPoint )
if lyr is None:
print "Layer creation failed.\n"
sys.exit( 1 )
field_defn = ogr.FieldDefn( "Name", ogr.OFTString )
field_defn.SetWidth( 32 )
if lyr.CreateField ( field_defn ) != 0:
print "Creating Name field failed.\n"
sys.exit( 1 )
# Expected format of user input: x y name
linestring = raw_input()
linelist = string.split(linestring)
while len(linelist) == 3:
x = float(linelist[0])
y = float(linelist[1])
name = linelist[2]
feat = ogr.Feature( lyr.GetLayerDefn())
feat.SetField( "Name", name )
pt = ogr.Geometry(ogr.wkbPoint)
pt.SetPoint_2D(0, x, y)
feat.SetGeometry(pt)
if lyr.CreateFeature(feat) != 0:
print "Failed to create feature in shapefile.\n"
sys.exit( 1 )
feat.Destroy()
linestring = raw_input()
linelist = string.split(linestring)
ds = None

Starting with OGR 1.11, several geometry fields can be associated to a feature. This capability is just available for a few file formats, such as PostGIS.

To create such datasources, geometry fields must be first created. Spatial reference system objects can be associated to each geometry field.

In C++ :

OGRGeomFieldDefn oPointField( "PointField", wkbPoint );
poSRS->importFromEPSG(4326);
oPointField.SetSpatialRef(poSRS);
poSRS->Release();
if( poLayer->CreateGeomField( &oPointField ) != OGRERR_NONE )
{
printf( "Creating field PointField failed.\n" );
exit( 1 );
}
OGRGeomFieldDefn oFieldPoint2( "PointField2", wkbPoint );
poSRS = new OGRSpatialReference();
poSRS->importFromEPSG(32631);
oPointField2.SetSpatialRef(poSRS);
poSRS->Release();
if( poLayer->CreateGeomField( &oPointField2 ) != OGRERR_NONE )
{
printf( "Creating field PointField2 failed.\n" );
exit( 1 );
}

In C :

OGRGeomFieldDefnH hPointField;
OGRGeomFieldDefnH hPointField2;
hPointField = OGR_GFld_Create( "PointField", wkbPoint );
hSRS = OSRNewSpatialReference( NULL );
OSRImportFromEPSG(hSRS, 4326);
OGR_GFld_SetSpatialRef(hPointField, hSRS);
OSRRelease(hSRS);
if( OGR_L_CreateGeomField( hLayer, hPointField ) != OGRERR_NONE )
{
printf( "Creating field PointField failed.\n" );
exit( 1 );
}
OGR_GFld_Destroy( hPointField );
hPointField2 = OGR_GFld_Create( "PointField2", wkbPoint );
OSRImportFromEPSG(hSRS, 32631);
OGR_GFld_SetSpatialRef(hPointField2, hSRS);
OSRRelease(hSRS);
if( OGR_L_CreateGeomField( hLayer, hPointField2 ) != OGRERR_NONE )
{
printf( "Creating field PointField2 failed.\n" );
exit( 1 );
}
OGR_GFld_Destroy( hPointField2 );

To write a feature to disk, we must create a local OGRFeature, set attributes and attach geometries before trying to write it to the layer. It is imperative that this feature be instantiated from the OGRFeatureDefn associated with the layer it will be written to.

In C++ :

OGRFeature *poFeature;
OGRGeometry *poGeometry;
char* pszWKT;
poFeature = OGRFeature::CreateFeature( poLayer->GetLayerDefn() );
pszWKT = (char*) "POINT (2 49)";
OGRGeometryFactory::createFromWkt( &pszWKT, NULL, &poGeometry );
poFeature->SetGeomFieldDirectly( "PointField", poGeometry );
pszWKT = (char*) "POINT (500000 4500000)";
OGRGeometryFactory::createFromWkt( &pszWKT, NULL, &poGeometry );
poFeature->SetGeomFieldDirectly( "PointField2", poGeometry );
if( poLayer->CreateFeature( poFeature ) != OGRERR_NONE )
{
printf( "Failed to create feature.\n" );
exit( 1 );
}

In C :

OGRFeatureH hFeature;
OGRGeometryH hGeometry;
char* pszWKT;
poFeature = OGR_F_Create( OGR_L_GetLayerDefn(hLayer) );
pszWKT = (char*) "POINT (2 49)";
OGR_G_CreateFromWkt( &pszWKT, NULL, &hGeometry );
OGR_F_GetGeomFieldIndex(hFeature, "PointField"), hGeometry );
pszWKT = (char*) "POINT (500000 4500000)";
OGR_G_CreateFromWkt( &pszWKT, NULL, &hGeometry );
OGR_F_GetGeomFieldIndex(hFeature, "PointField2"), hGeometry );
if( OGR_L_CreateFeature( hFeature ) != OGRERR_NONE )
{
printf( "Failed to create feature.\n" );
exit( 1 );
}
OGR_F_Destroy( hFeature );

In Python :

feat = ogr.Feature( lyr.GetLayerDefn() )
feat.SetGeomFieldDirectly( "PointField",
ogr.CreateGeometryFromWkt( "POINT (2 49)" ) )
feat.SetGeomFieldDirectly( "PointField2",
ogr.CreateGeometryFromWkt( "POINT (500000 4500000)" ) )
if lyr.CreateFeature( feat ) != 0 )
{
print( "Failed to create feature.\n" );
sys.exit( 1 );
}
OGR_F_GetGeomFieldRef
OGRGeometryH OGR_F_GetGeomFieldRef(OGRFeatureH hFeat, int iField)
Fetch an handle to feature geometry.
Definition: ogrfeature.cpp:754
OGRLayer::CreateField
virtual OGRErr CreateField(OGRFieldDefn *poField, int bApproxOK=TRUE)
Create a new field on a layer.
Definition: ogrlayer.cpp:664
GDALDataset::CreateLayer
virtual OGRLayer * CreateLayer(const char *pszName, OGRSpatialReference *poSpatialRef=nullptr, OGRwkbGeometryType eGType=wkbUnknown, char **papszOptions=nullptr)
This method attempts to create a new layer on the dataset with the indicated name,...
Definition: gdaldataset.cpp:4341
OGR_F_SetFieldString
void OGR_F_SetFieldString(OGRFeatureH, int, const char *)
Set field to string value.
Definition: ogrfeature.cpp:4130
OGR_Fld_GetType
OGRFieldType OGR_Fld_GetType(OGRFieldDefnH)
Fetch type of this field.
Definition: ogrfielddefn.cpp:250
gdal.h
OGR_L_CreateFeature
OGRErr OGR_L_CreateFeature(OGRLayerH, OGRFeatureH) CPL_WARN_UNUSED_RESULT
Create and write a new feature within a layer.
Definition: ogrlayer.cpp:646
OGR_Fld_SetWidth
void OGR_Fld_SetWidth(OGRFieldDefnH, int)
Set the formatting width for this field in characters.
Definition: ogrfielddefn.cpp:907
OGRFeature::SetGeometry
OGRErr SetGeometry(const OGRGeometry *)
Set feature geometry.
Definition: ogrfeature.cpp:436
OGRGeometry::getGeometryType
virtual OGRwkbGeometryType getGeometryType() const =0
Fetch geometry type.
OGRSpatialReference::Release
void Release()
Decrements the reference count by one, and destroy if zero.
Definition: ogrspatialreference.cpp:930
OGR_F_GetFieldAsInteger64
GIntBig OGR_F_GetFieldAsInteger64(OGRFeatureH, int)
Fetch field value as integer 64 bit.
Definition: ogrfeature.cpp:2076
wkbPoint
0-dimensional geometric object, standard WKB
Definition: ogr_core.h:320
OGRLayer::GetNextFeature
virtual OGRFeature * GetNextFeature() CPL_WARN_UNUSED_RESULT=0
Fetch the next available feature from this layer.
OGRLayer::ResetReading
virtual void ResetReading()=0
Reset feature reading to start on the first feature.
OGR_L_GetLayerDefn
OGRFeatureDefnH OGR_L_GetLayerDefn(OGRLayerH)
Fetch the schema information for this layer.
Definition: ogrlayer.cpp:992
GDT_Unknown
Definition: gdal.h:60
OGR_F_GetGeometryRef
OGRGeometryH OGR_F_GetGeometryRef(OGRFeatureH)
Fetch an handle to feature geometry.
Definition: ogrfeature.cpp:627
GDALDriver
Format specific driver.
Definition: gdal_priv.h:1422
OGRSpatialReference
This class represents an OpenGIS Spatial Reference System, and contains methods for converting betwee...
Definition: ogr_spatialref.h:155
GDALClose
void GDALClose(GDALDatasetH)
Close GDAL dataset.
Definition: gdaldataset.cpp:3588
OGRFeature::GetFieldAsString
const char * GetFieldAsString(int i) const
Fetch field value as a string.
Definition: ogrfeature.cpp:2296
OGRGeometry
Abstract base class for all geometry classes.
Definition: ogr_geometry.h:285
OGR_F_GetFieldAsString
const char * OGR_F_GetFieldAsString(OGRFeatureH, int)
Fetch field value as a string.
Definition: ogrfeature.cpp:2649
OGR_GFld_SetSpatialRef
void OGR_GFld_SetSpatialRef(OGRGeomFieldDefnH, OGRSpatialReferenceH hSRS)
Set the spatial reference of this field.
Definition: ogrgeomfielddefn.cpp:516
OGR_F_GetFieldAsInteger
int OGR_F_GetFieldAsInteger(OGRFeatureH, int)
Fetch field value as integer.
Definition: ogrfeature.cpp:1955
OGRLayer
This class represents a layer of simple features, with access methods.
Definition: ogrsf_frmts.h:69
OGRPoint
Point class.
Definition: ogr_geometry.h:809
OGR_F_SetGeomFieldDirectly
OGRErr OGR_F_SetGeomFieldDirectly(OGRFeatureH hFeat, int iField, OGRGeometryH hGeom)
Set feature geometry of a specified geometry field.
Definition: ogrfeature.cpp:844
OGRFeatureH
void * OGRFeatureH
Opaque type for a feature (OGRFeature)
Definition: ogr_api.h:301
CPL_FRMT_GIB
#define CPL_FRMT_GIB
Printf formatting for GIntBig.
Definition: cpl_port.h:315
OGRFeatureDefnH
void * OGRFeatureDefnH
Opaque type for a feature definition (OGRFeatureDefn)
Definition: ogr_api.h:299
OGRLayer::GetLayerDefn
virtual OGRFeatureDefn * GetLayerDefn()=0
Fetch the schema information for this layer.
OGRFeatureDefn::GetFieldDefn
virtual OGRFieldDefn * GetFieldDefn(int i)
Fetch field definition.
Definition: ogrfeaturedefn.cpp:329
GDALDataset
A set of associated raster bands, usually from one file.
Definition: gdal_priv.h:334
OGRPoint::setX
void setX(double xIn)
Set x.
Definition: ogr_geometry.h:865
OGR_F_GetFieldAsDouble
double OGR_F_GetFieldAsDouble(OGRFeatureH, int)
Fetch field value as a double.
Definition: ogrfeature.cpp:2189
OGR_Fld_Destroy
void OGR_Fld_Destroy(OGRFieldDefnH)
Destroy a field definition.
Definition: ogrfielddefn.cpp:138
GDALDriverManager::GetDriverByName
GDALDriver * GetDriverByName(const char *)
Fetch a driver based on the short name.
Definition: gdaldrivermanager.cpp:589
OGRGeomFieldDefnH
struct OGRGeomFieldDefnHS * OGRGeomFieldDefnH
Opaque type for a geometry field definition (OGRGeomFieldDefn)
Definition: ogr_api.h:306
wkbFlatten
#define wkbFlatten(x)
Return the 2D geometry type corresponding to the specified geometry type.
Definition: ogr_core.h:439
OGRFeature::SetField
void SetField(int i, int nValue)
Set field to integer value.
Definition: ogrfeature.cpp:3414
OGR_L_ResetReading
void OGR_L_ResetReading(OGRLayerH)
Reset feature reading to start on the first feature.
Definition: ogrlayer.cpp:1472
OGR_G_DestroyGeometry
void OGR_G_DestroyGeometry(OGRGeometryH)
Destroy geometry object.
Definition: ogrgeometryfactory.cpp:647
OGRSpatialReferenceH
void * OGRSpatialReferenceH
Opaque type for a spatial reference system.
Definition: ogr_api.h:73
OGR_F_GetGeomFieldCount
int OGR_F_GetGeomFieldCount(OGRFeatureH hFeat)
Fetch number of geometry fields on this feature This will always be the same as the geometry field co...
Definition: ogrfeature.cpp:1232
OGRFeature::GetGeometryRef
OGRGeometry * GetGeometryRef()
Fetch pointer to feature geometry.
Definition: ogrfeature.cpp:582
OGRFeatureDefn::GetFieldCount
virtual int GetFieldCount() const
Fetch number of fields on this feature.
Definition: ogrfeaturedefn.cpp:285
GDALDataset::Open
static GDALDataset * Open(const char *pszFilename, unsigned int nOpenFlags=0, const char *const *papszAllowedDrivers=nullptr, const char *const *papszOpenOptions=nullptr, const char *const *papszSiblingFiles=nullptr)
Definition: gdal_priv.h:612
OGRGeometry::toPoint
OGRPoint * toPoint()
Down-cast to OGRPoint*.
Definition: ogr_geometry.h:523
OGR_FOR_EACH_FEATURE_BEGIN
#define OGR_FOR_EACH_FEATURE_BEGIN(hFeat, hLayer)
Conveniency macro to iterate over features of a layer.
Definition: ogr_api.h:560
OGRLayer::CreateGeomField
virtual OGRErr CreateGeomField(OGRGeomFieldDefn *poField, int bApproxOK=TRUE)
Create a new geometry field on a layer.
Definition: ogrlayer.cpp:875
OFTString
String of ASCII chars.
Definition: ogr_core.h:599
OSRNewSpatialReference
OGRSpatialReferenceH OSRNewSpatialReference(const char *)
Constructor.
Definition: ogrspatialreference.cpp:688
OGR_FD_GetFieldCount
int OGR_FD_GetFieldCount(OGRFeatureDefnH)
Fetch number of fields on the passed feature definition.
Definition: ogrfeaturedefn.cpp:303
ogrsf_frmts.h
OGRLayer::CreateFeature
OGRErr CreateFeature(OGRFeature *poFeature) CPL_WARN_UNUSED_RESULT
Create and write a new feature within a layer.
Definition: ogrlayer.cpp:625
GDALOpenEx
GDALDatasetH GDALOpenEx(const char *pszFilename, unsigned int nOpenFlags, const char *const *papszAllowedDrivers, const char *const *papszOpenOptions, const char *const *papszSiblingFiles) CPL_WARN_UNUSED_RESULT
Open a raster or vector file as a GDALDataset.
Definition: gdaldataset.cpp:3206
OGR_L_CreateGeomField
OGRErr OGR_L_CreateGeomField(OGRLayerH hLayer, OGRGeomFieldDefnH hFieldDefn, int bForce)
Create a new geometry field on a layer.
Definition: ogrlayer.cpp:891
OGRFieldDefn
Definition of an attribute of an OGRFeatureDefn.
Definition: ogr_feature.h:91
OFTInteger
Simple 32bit integer.
Definition: ogr_core.h:595
OGRFeature::GetFieldAsDouble
double GetFieldAsDouble(int i) const
Fetch field value as a double.
Definition: ogrfeature.cpp:2115
OGR_L_GetNextFeature
OGRFeatureH OGR_L_GetNextFeature(OGRLayerH) CPL_WARN_UNUSED_RESULT
Fetch the next available feature from this layer.
Definition: ogrlayer.cpp:540
OGR_G_SetPoint_2D
void OGR_G_SetPoint_2D(OGRGeometryH, int iPoint, double, double)
Set the location of a vertex in a point or linestring geometry.
Definition: ogr_api.cpp:877
OGRFeature::CreateFeature
static OGRFeature * CreateFeature(OGRFeatureDefn *)
Feature factory.
Definition: ogrfeature.cpp:245
GDALDataset::GetLayers
Layers GetLayers()
Function that returns an iterable object over layers in the dataset.
Definition: gdaldataset.cpp:7693
GDALGetDriverByName
GDALDriverH GDALGetDriverByName(const char *)
Fetch a driver based on the short name.
Definition: gdaldrivermanager.cpp:611
GDALDataset::GetLayerByName
virtual OGRLayer * GetLayerByName(const char *)
Fetch a layer by name.
Definition: gdaldataset.cpp:5179
OGR_G_GetX
double OGR_G_GetX(OGRGeometryH, int)
Fetch the x coordinate of a point from a geometry.
Definition: ogr_api.cpp:186
OGRFeature::SetGeomFieldDirectly
OGRErr SetGeomFieldDirectly(int iField, OGRGeometry *)
Set feature geometry of a specified geometry field.
Definition: ogrfeature.cpp:801
OGR_FOR_EACH_FEATURE_END
#define OGR_FOR_EACH_FEATURE_END(hFeat)
End of iterator.
Definition: ogr_api.h:573
OGRSpatialReference::importFromEPSG
OGRErr importFromEPSG(int)
Initialize SRS based on EPSG geographic, projected or vertical CRS code.
Definition: ogrspatialreference.cpp:10219
GDALDriver::Create
GDALDataset * Create(const char *pszName, int nXSize, int nYSize, int nBands, GDALDataType eType, char **papszOptions) CPL_WARN_UNUSED_RESULT
Create a new dataset with this driver.
Definition: gdaldriver.cpp:161
OGRFieldDefnH
void * OGRFieldDefnH
Opaque type for a field definition (OGRFieldDefn)
Definition: ogr_api.h:297
OGRGeometryH
void * OGRGeometryH
Opaque type for a geometry.
Definition: ogr_api.h:59
OGRGeomFieldDefn
Definition of a geometry field of an OGRFeatureDefn.
Definition: ogr_feature.h:181
GDALAllRegister
void GDALAllRegister(void)
Register all known configured GDAL drivers.
Definition: gdalallregister.cpp:61
OGRFieldDefn::GetType
OGRFieldType GetType() const
Fetch type of this field.
Definition: ogr_feature.h:114
OGR_F_Destroy
void OGR_F_Destroy(OGRFeatureH)
Destroy feature.
Definition: ogrfeature.cpp:219
OGR_G_GetY
double OGR_G_GetY(OGRGeometryH, int)
Fetch the x coordinate of a point from a geometry.
Definition: ogr_api.cpp:209
OSRRelease
void OSRRelease(OGRSpatialReferenceH)
Decrements the reference count by one, and destroy if zero.
Definition: ogrspatialreference.cpp:946
OGR_G_GetGeometryType
OGRwkbGeometryType OGR_G_GetGeometryType(OGRGeometryH)
Fetch geometry type.
Definition: ogrgeometry.cpp:1839
OGRFeature
A simple feature, including geometry and attributes.
Definition: ogr_feature.h:353
OGRPoint::setY
void setY(double yIn)
Set y.
Definition: ogr_geometry.h:869
ogr_api.h
OGR_G_CreateFromWkt
OGRErr OGR_G_CreateFromWkt(char **, OGRSpatialReferenceH, OGRGeometryH *)
Create a geometry object of the appropriate type from its well known text representation.
Definition: ogrgeometryfactory.cpp:496
OGRPoint::getY
double getY() const
Return y.
Definition: ogr_geometry.h:854
GDALDatasetCreateLayer
OGRLayerH GDALDatasetCreateLayer(GDALDatasetH, const char *, OGRSpatialReferenceH, OGRwkbGeometryType, CSLConstList)
This function attempts to create a new layer on the dataset with the indicated name,...
Definition: gdaldataset.cpp:4428
GDALDatasetGetLayerByName
OGRLayerH GDALDatasetGetLayerByName(GDALDatasetH, const char *)
Fetch a layer by name.
Definition: gdaldataset.cpp:4240
OGR_G_CreateGeometry
OGRGeometryH OGR_G_CreateGeometry(OGRwkbGeometryType) CPL_WARN_UNUSED_RESULT
Create an empty geometry of desired type.
Definition: ogrgeometryfactory.cpp:604
OGR_FD_GetFieldDefn
OGRFieldDefnH OGR_FD_GetFieldDefn(OGRFeatureDefnH, int)
Fetch field definition of the passed feature definition.
Definition: ogrfeaturedefn.cpp:384
OGR_F_GetGeomFieldIndex
int OGR_F_GetGeomFieldIndex(OGRFeatureH hFeat, const char *pszName)
Fetch the geometry field index given geometry field name.
Definition: ogrfeature.cpp:1343
OFTInteger64
Single 64bit integer.
Definition: ogr_core.h:607
GDALCreate
GDALDatasetH GDALCreate(GDALDriverH hDriver, const char *, int, int, int, GDALDataType, CSLConstList) CPL_WARN_UNUSED_RESULT
Create a new dataset with this driver.
Definition: gdaldriver.cpp:305
OGRFeature::GetFieldAsInteger64
GIntBig GetFieldAsInteger64(int i) const
Fetch field value as integer 64 bit.
Definition: ogrfeature.cpp:1997
OGRFeature::GetFieldAsInteger
int GetFieldAsInteger(int i) const
Fetch field value as integer.
Definition: ogrfeature.cpp:1858
OGRERR_NONE
#define OGRERR_NONE
Success.
Definition: ogr_core.h:291
OGRFeatureDefn
Definition of a feature class or feature layer.
Definition: ogr_feature.h:258
OGR_GFld_Destroy
void OGR_GFld_Destroy(OGRGeomFieldDefnH)
Destroy a geometry field definition.
Definition: ogrgeomfielddefn.cpp:154
OGR_F_SetGeometry
OGRErr OGR_F_SetGeometry(OGRFeatureH, OGRGeometryH)
Set feature geometry.
Definition: ogrfeature.cpp:471
OGRFeature::DestroyFeature
static void DestroyFeature(OGRFeature *)
Destroy feature.
Definition: ogrfeature.cpp:281
GetGDALDriverManager
GDALDriverManager * GetGDALDriverManager(void)
Fetch the global GDAL driver manager.
Definition: gdaldrivermanager.cpp:96
OFTReal
Double Precision floating point.
Definition: ogr_core.h:597
GDAL_OF_VECTOR
#define GDAL_OF_VECTOR
Allow vector drivers to be used.
Definition: gdal.h:447
OGRLayerH
void * OGRLayerH
Opaque type for a layer (OGRLayer)
Definition: ogr_api.h:508
OGR_GFld_Create
OGRGeomFieldDefnH OGR_GFld_Create(const char *, OGRwkbGeometryType) CPL_WARN_UNUSED_RESULT
Create a new field geometry definition.
Definition: ogrgeomfielddefn.cpp:108
OGR_F_GetFieldIndex
int OGR_F_GetFieldIndex(OGRFeatureH, const char *)
Fetch the field index given field name.
Definition: ogrfeature.cpp:1189
GDALDatasetUniquePtr
std::unique_ptr< GDALDataset, GDALDatasetUniquePtrDeleter > GDALDatasetUniquePtr
Unique pointer type for GDALDataset.
Definition: gdal_priv.h:838
OGR_Fld_Create
OGRFieldDefnH OGR_Fld_Create(const char *, OGRFieldType) CPL_WARN_UNUSED_RESULT
Create a new field definition.
Definition: ogrfielddefn.cpp:112
GDALDatasetH
void * GDALDatasetH
Opaque type used for the C bindings of the C++ GDALDataset class.
Definition: gdal.h:254
OGRPoint::getX
double getX() const
Return x.
Definition: ogr_geometry.h:852
OGR_L_CreateField
OGRErr OGR_L_CreateField(OGRLayerH, OGRFieldDefnH, int)
Create a new field on a layer.
Definition: ogrlayer.cpp:680
OGR_F_Create
OGRFeatureH OGR_F_Create(OGRFeatureDefnH) CPL_WARN_UNUSED_RESULT
Feature factory.
Definition: ogrfeature.cpp:128
OGRGeometryFactory::createFromWkt
static OGRErr createFromWkt(const char *, OGRSpatialReference *, OGRGeometry **)
Create a geometry object of the appropriate type from its well known text representation.
Definition: ogrgeometryfactory.cpp:463
GDALDriverH
void * GDALDriverH
Opaque type used for the C bindings of the C++ GDALDriver class.
Definition: gdal.h:260
OSRImportFromEPSG
OGRErr OSRImportFromEPSG(OGRSpatialReferenceH, int)
Initialize SRS based on EPSG geographic, projected or vertical CRS code.
Definition: ogrspatialreference.cpp:10235

Generated for GDAL by doxygen 1.8.16.