void object::test<4>()
{
OGRErr err = OGRERR_NONE;
const int size = 5;
const int expect[size] = { 168, 169, 166, 158, 165 };
std::string source(data_tmp_);
source += SEP;
source += "tpoly.shp";
OGRDataSourceH ds = OGR_Dr_Open(drv_, source.c_str(), false);
ensure("Can't open layer", NULL != ds);
OGRLayerH lyr = OGR_DS_GetLayer(ds, 0);
ensure("Can't get source layer", NULL != lyr);
err = OGR_L_SetAttributeFilter(lyr, "eas_id < 170");
ensure_equals("Can't set attribute filter", OGRERR_NONE, err);
// Prepare tester collection
std::vector<int> list;
std::copy(expect, expect + size, std::back_inserter(list));
ensure_equal_attributes(lyr, "eas_id", list);
OGR_DS_Destroy(ds);
}
QgsShapeFile::QgsShapeFile( QString name, QString encoding )
{
fileName = name;
features = 0;
QgsApplication::registerOgrDrivers();
QSettings settings;
CPLSetConfigOption( "SHAPE_ENCODING", settings.value( "/qgis/ignoreShapeEncoding", true ).toBool() ? "" : 0 );
ogrDataSource = OGROpen( TO8F( fileName ), false, NULL );
if ( ogrDataSource != NULL )
{
valid = true;
ogrLayer = OGR_DS_GetLayer( ogrDataSource, 0 );
features = OGR_L_GetFeatureCount( ogrLayer, true );
}
else
valid = false;
setDefaultTable();
// init the geometry types
geometries << "NULL" << "POINT" << "LINESTRING" << "POLYGON" << "MULTIPOINT"
<< "MULTILINESTRING" << "MULTIPOLYGON" << "GEOMETRYCOLLECTION";
codec = QTextCodec::codecForName( encoding.toLocal8Bit().constData() );
if ( !codec )
codec = QTextCodec::codecForLocale();
Q_ASSERT( codec );
}
void object::test<7>()
{
OGRErr err = OGRERR_NONE;
// Read feature without geometry
std::string tmp(data_tmp_);
tmp += SEP;
tmp += "tpoly.shp";
OGRDataSourceH ds = OGR_Dr_Open(drv_, tmp.c_str(), false);
ensure("Can't open layer", NULL != ds);
OGRLayerH lyr = OGR_DS_GetLayer(ds, 0);
ensure("Can't get layer", NULL != lyr);
err = OGR_L_SetAttributeFilter(lyr, "PRFEDEA = 'nulled'");
ensure_equals("Can't set attribute filter", OGRERR_NONE, err);
// Fetch feature without geometry
OGRFeatureH featNonSpatial = OGR_L_GetNextFeature(lyr);
ensure("Didnt get feature with null geometry back", NULL != featNonSpatial);
// Null geometry is expected
OGRGeometryH nonGeom = OGR_F_GetGeometryRef(featNonSpatial);
ensure("Didnt get null geometry as expected", NULL == nonGeom);
OGR_F_Destroy(featNonSpatial);
OGR_DS_Destroy(ds);
}
void object::test<6>()
{
// Create feature without geometry
std::string tmp(data_tmp_);
tmp += SEP;
tmp += "tpoly.shp";
OGRDataSourceH ds = OGR_Dr_Open(drv_, tmp.c_str(), true);
ensure("Can't open layer", NULL != ds);
OGRLayerH lyr = OGR_DS_GetLayer(ds, 0);
ensure("Can't get layer", NULL != lyr);
OGRFeatureDefnH featDefn = OGR_L_GetLayerDefn(lyr);
ensure("Layer schema is NULL", NULL != featDefn);
OGRFeatureH featNonSpatial = OGR_F_Create(featDefn);
ensure("Can't create non-spatial feature", NULL != featNonSpatial);
int fldIndex = OGR_FD_GetFieldIndex(featDefn, "PRFEDEA");
ensure("Can't find field 'PRFEDEA'", fldIndex >= 0);
OGR_F_SetFieldString(featNonSpatial, fldIndex, "nulled");
OGRErr err = OGR_L_CreateFeature(lyr, featNonSpatial);
ensure_equals("Can't write non-spatial feature to layer", OGRERR_NONE, err);
OGR_F_Destroy(featNonSpatial);
OGR_DS_Destroy(ds);
}
QgsOgrFeatureIterator::QgsOgrFeatureIterator( QgsOgrFeatureSource* source, bool ownSource, const QgsFeatureRequest& request )
: QgsAbstractFeatureIteratorFromSource<QgsOgrFeatureSource>( source, ownSource, request )
, ogrDataSource( 0 )
, ogrLayer( 0 )
, mSubsetStringSet( false )
, mGeometrySimplifier( NULL )
{
mFeatureFetched = false;
ogrDataSource = OGROpen( TO8F( mSource->mFilePath ), false, NULL );
if ( mSource->mLayerName.isNull() )
{
ogrLayer = OGR_DS_GetLayer( ogrDataSource, mSource->mLayerIndex );
}
else
{
ogrLayer = OGR_DS_GetLayerByName( ogrDataSource, TO8( mSource->mLayerName ) );
}
if ( !mSource->mSubsetString.isEmpty() )
{
ogrLayer = QgsOgrUtils::setSubsetString( ogrLayer, ogrDataSource, mSource->mEncoding, mSource->mSubsetString );
mSubsetStringSet = true;
}
mFetchGeometry = ( mRequest.filterType() == QgsFeatureRequest::FilterRect ) || !( mRequest.flags() & QgsFeatureRequest::NoGeometry );
QgsAttributeList attrs = ( mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes ) ? mRequest.subsetOfAttributes() : mSource->mFields.allAttributesList();
// make sure we fetch just relevant fields
// unless it's a VRT data source filtered by geometry as we don't know which
// attributes make up the geometry and OGR won't fetch them to evaluate the
// filter if we choose to ignore them (fixes #11223)
if (( mSource->mDriverName != "VRT" && mSource->mDriverName != "OGR_VRT" ) || mRequest.filterType() != QgsFeatureRequest::FilterRect )
{
QgsOgrUtils::setRelevantFields( ogrLayer, mSource->mFields.count(), mFetchGeometry, attrs );
}
// spatial query to select features
if ( mRequest.filterType() == QgsFeatureRequest::FilterRect )
{
OGRGeometryH filter = 0;
QString wktExtent = QString( "POLYGON((%1))" ).arg( mRequest.filterRect().asPolygon() );
QByteArray ba = wktExtent.toAscii();
const char *wktText = ba;
OGR_G_CreateFromWkt(( char ** )&wktText, NULL, &filter );
QgsDebugMsg( "Setting spatial filter using " + wktExtent );
OGR_L_SetSpatialFilter( ogrLayer, filter );
OGR_G_DestroyGeometry( filter );
}
else
{
OGR_L_SetSpatialFilter( ogrLayer, 0 );
}
//start with first feature
rewind();
}
void object::test<5>()
{
// Original shapefile
std::string orig(data_);
orig += SEP;
orig += "poly.shp";
OGRDataSourceH dsOrig = OGR_Dr_Open(drv_, orig.c_str(), false);
ensure("Can't open layer", NULL != dsOrig);
OGRLayerH lyrOrig = OGR_DS_GetLayer(dsOrig, 0);
ensure("Can't get layer", NULL != lyrOrig);
// Copied shapefile
std::string tmp(data_tmp_);
tmp += SEP;
tmp += "tpoly.shp";
OGRDataSourceH dsTmp = OGR_Dr_Open(drv_, tmp.c_str(), false);
ensure("Can't open layer", NULL != dsTmp);
OGRLayerH lyrTmp = OGR_DS_GetLayer(dsTmp, 0);
ensure("Can't get layer", NULL != lyrTmp);
// Iterate through features and compare geometries
OGRFeatureH featOrig = OGR_L_GetNextFeature(lyrOrig);
OGRFeatureH featTmp = OGR_L_GetNextFeature(lyrTmp);
while (NULL != featOrig && NULL != featTmp)
{
OGRGeometryH lhs = OGR_F_GetGeometryRef(featOrig);
OGRGeometryH rhs = OGR_F_GetGeometryRef(featTmp);
ensure_equal_geometries(lhs, rhs, 0.000000001);
// TODO: add ensure_equal_attributes()
OGR_F_Destroy(featOrig);
OGR_F_Destroy(featTmp);
// Move to next feature
featOrig = OGR_L_GetNextFeature(lyrOrig);
featTmp = OGR_L_GetNextFeature(lyrTmp);
}
OGR_DS_Destroy(dsOrig);
OGR_DS_Destroy(dsTmp);
}
static QgsOgrLayerItem* dataItemForLayer( QgsDataItem* parentItem, QString name, QString path, OGRDataSourceH hDataSource, int layerId )
{
OGRLayerH hLayer = OGR_DS_GetLayer( hDataSource, layerId );
OGRFeatureDefnH hDef = OGR_L_GetLayerDefn( hLayer );
QgsLayerItem::LayerType layerType = QgsLayerItem::Vector;
OGRwkbGeometryType ogrType = QgsOgrProvider::getOgrGeomType( hLayer );
switch ( ogrType )
{
case wkbUnknown:
case wkbGeometryCollection:
break;
case wkbNone:
layerType = QgsLayerItem::TableLayer;
break;
case wkbPoint:
case wkbMultiPoint:
case wkbPoint25D:
case wkbMultiPoint25D:
layerType = QgsLayerItem::Point;
break;
case wkbLineString:
case wkbMultiLineString:
case wkbLineString25D:
case wkbMultiLineString25D:
layerType = QgsLayerItem::Line;
break;
case wkbPolygon:
case wkbMultiPolygon:
case wkbPolygon25D:
case wkbMultiPolygon25D:
layerType = QgsLayerItem::Polygon;
break;
default:
break;
}
QgsDebugMsgLevel( QString( "ogrType = %1 layertype = %2" ).arg( ogrType ).arg( layerType ), 2 );
QString layerUri = path;
if ( name.isEmpty() )
{
// we are in a collection
name = FROM8( OGR_FD_GetName( hDef ) );
QgsDebugMsg( "OGR layer name : " + name );
layerUri += "|layerid=" + QString::number( layerId );
path += "/" + name;
}
QgsDebugMsgLevel( "OGR layer uri : " + layerUri, 2 );
return new QgsOgrLayerItem( parentItem, name, path, layerUri, layerType );
}
/**
* \brief Convenience function to check if a geometry is contained in a OGR
* datasource for a given layer.
*
* The passed geometry is a wkt representation of a geometry of type GeomType.
* pszFile is opened, and the passed geometry is queried against all
* geometries in pszLayer. If the passed geometry is contained in *any* of the
* geomtries in the layer, TRUE is returned. FALSE is returned otherwise,
* including errors. The SRS of all geometries is assumed to be the same.
*
* \param pszWkt Well-known text representation of a geometry.
* \param pszFile File to open
* \param pszLayer Layer to extract geometry from, if NULL, use layer 0.
* \return TRUE if pszWkt is contained in any geometry in pszLayer, FALSE
* otherwise, include errors
*/
int NinjaOGRContain(const char *pszWkt, const char *pszFile,
const char *pszLayer)
{
int bContains = FALSE;
if( pszWkt == NULL || pszFile == NULL )
{
return FALSE;
}
CPLDebug( "WINDNINJA", "Checking for containment of %s in %s:%s",
pszWkt, pszFile, pszLayer ? pszLayer : "" );
OGRGeometryH hTestGeometry = NULL;
int err = OGR_G_CreateFromWkt( (char**)&pszWkt, NULL, &hTestGeometry );
if( hTestGeometry == NULL || err != CE_None )
{
return FALSE;
}
OGRDataSourceH hDS = OGROpen( pszFile, 0, NULL );
if( hDS == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to open datasource: %s", pszFile );
OGR_G_DestroyGeometry( hTestGeometry );
bContains = FALSE;
return bContains;
}
OGRLayerH hLayer;
if( pszLayer == NULL )
{
hLayer = OGR_DS_GetLayer( hDS, 0 );
}
else
{
hLayer = OGR_DS_GetLayerByName( hDS, pszLayer );
}
OGRFeatureH hFeature;
if( hLayer != NULL )
{
OGRGeometryH hGeometry;
OGR_L_ResetReading( hLayer );
while( ( hFeature = OGR_L_GetNextFeature( hLayer ) ) != NULL )
{
hGeometry = OGR_F_GetGeometryRef( hFeature );
if( OGR_G_Contains( hGeometry, hTestGeometry ) )
{
bContains = TRUE;
OGR_F_Destroy( hFeature );
break;
}
OGR_F_Destroy( hFeature );
}
}
OGR_G_DestroyGeometry( hTestGeometry );
OGR_DS_Destroy( hDS );
return bContains;
}
QgsOgrFeatureIterator::QgsOgrFeatureIterator( QgsOgrFeatureSource* source, bool ownSource, const QgsFeatureRequest& request )
: QgsAbstractFeatureIteratorFromSource<QgsOgrFeatureSource>( source, ownSource, request )
, mFeatureFetched( false )
, mConn( nullptr )
, ogrLayer( nullptr )
, mSubsetStringSet( false )
, mFetchGeometry( false )
, mExpressionCompiled( false )
, mFilterFids( mRequest.filterFids() )
, mFilterFidsIt( mFilterFids.constBegin() )
{
mConn = QgsOgrConnPool::instance()->acquireConnection( mSource->mProvider->dataSourceUri() );
if ( !mConn->ds )
{
return;
}
if ( mSource->mLayerName.isNull() )
{
ogrLayer = OGR_DS_GetLayer( mConn->ds, mSource->mLayerIndex );
}
else
{
ogrLayer = OGR_DS_GetLayerByName( mConn->ds, TO8( mSource->mLayerName ) );
}
if ( !ogrLayer )
{
return;
}
if ( !mSource->mSubsetString.isEmpty() )
{
ogrLayer = QgsOgrProviderUtils::setSubsetString( ogrLayer, mConn->ds, mSource->mEncoding, mSource->mSubsetString );
if ( !ogrLayer )
{
return;
}
mSubsetStringSet = true;
}
mFetchGeometry = ( !mRequest.filterRect().isNull() ) || !( mRequest.flags() & QgsFeatureRequest::NoGeometry );
QgsAttributeList attrs = ( mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes ) ? mRequest.subsetOfAttributes() : mSource->mFields.allAttributesList();
// ensure that all attributes required for expression filter are being fetched
if ( mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes && request.filterType() == QgsFeatureRequest::FilterExpression )
{
Q_FOREACH ( const QString& field, request.filterExpression()->referencedColumns() )
{
int attrIdx = mSource->mFields.fieldNameIndex( field );
if ( !attrs.contains( attrIdx ) )
attrs << attrIdx;
}
mRequest.setSubsetOfAttributes( attrs );
}
int wxStation::GetFirstStationLine(const char *xFilename)
{
OGRDataSourceH hDS;
OGRLayer *poLayer;
OGRFeature *poFeature;
OGRLayerH hLayer;
GIntBig iBig = 1;
hDS = OGROpen( xFilename, FALSE, NULL );
if(hDS == NULL)
{
return -1; //very bad!
}
poLayer = (OGRLayer*)OGR_DS_GetLayer( hDS, 0 );
hLayer=OGR_DS_GetLayer(hDS,0);
OGR_L_ResetReading(hLayer);
poLayer->ResetReading();
poFeature = poLayer->GetFeature(iBig);
if (poFeature==NULL)
{
return -1; //If there are no stations in the csv!
}
std::string start_datetime(poFeature->GetFieldAsString(15));
if(start_datetime.empty()==true)
{
return 1;
}
if(start_datetime.empty()==false)
{
return 2;
}
}
int QGisImporter::getGeometryType(QString const & path) {
int ret = -1;
// Well, this code is legacy, but fsck it :-P
// Should not be compatible GDAL >= 2.0
// TODO: Anyway, Mapserver code should provide similar mechanisms,
// I'm probably re-inventing the wheel here.
OGRDataSourceH hDS;
hDS = OGROpen(path.toStdString().c_str(), 0, NULL);
if(hDS == NULL)
{
return -1;
}
int layerCount = OGR_DS_GetLayerCount(hDS);
if (layerCount <= 0) {
OGRReleaseDataSource( hDS );
return -1;
}
OGRLayerH layer = OGR_DS_GetLayer (hDS, 0);
OGRwkbGeometryType geomType = OGR_L_GetGeomType(layer);
// TODO: Might be a little naïve ...
switch(geomType) {
case wkbUnknown:
ret = -1;
break;
case wkbPoint:
case wkbMultiPoint:
ret = MS_LAYER_POINT;
break;
case wkbLineString:
case wkbMultiLineString:
ret = MS_LAYER_LINE;
break;
case wkbPolygon:
case wkbMultiPolygon:
case wkbGeometryCollection:
ret = MS_LAYER_POLYGON;
break;
default:
ret = -1;
}
OGRReleaseDataSource(hDS);
return ret;
}
QgsOgrFeatureIterator::QgsOgrFeatureIterator( QgsOgrProvider* p, const QgsFeatureRequest& request )
: QgsAbstractFeatureIterator( request )
, P( p )
, ogrDataSource( 0 )
, ogrLayer( 0 )
, mSubsetStringSet( false )
, mGeometrySimplifier( NULL )
{
mFeatureFetched = false;
ogrDataSource = OGROpen( TO8F( P->filePath() ), false, NULL );
if ( P->layerName().isNull() )
{
ogrLayer = OGR_DS_GetLayer( ogrDataSource, P->layerIndex() );
}
else
{
ogrLayer = OGR_DS_GetLayerByName( ogrDataSource, TO8( p->layerName() ) );
}
if ( !P->subsetString().isEmpty() )
{
ogrLayer = P->setSubsetString( ogrLayer, ogrDataSource );
mSubsetStringSet = true;
}
ensureRelevantFields();
// spatial query to select features
if ( mRequest.filterType() == QgsFeatureRequest::FilterRect )
{
OGRGeometryH filter = 0;
QString wktExtent = QString( "POLYGON((%1))" ).arg( mRequest.filterRect().asPolygon() );
QByteArray ba = wktExtent.toAscii();
const char *wktText = ba;
OGR_G_CreateFromWkt(( char ** )&wktText, NULL, &filter );
QgsDebugMsg( "Setting spatial filter using " + wktExtent );
OGR_L_SetSpatialFilter( ogrLayer, filter );
OGR_G_DestroyGeometry( filter );
}
else
{
OGR_L_SetSpatialFilter( ogrLayer, 0 );
}
//start with first feature
rewind();
}
static int _ogrLoadCell(const char *filename, S52_loadLayer_cb loadLayer_cb, S52_loadObject_cb loadObject_cb)
{
OGRDataSourceH hDS = NULL;;
OGRSFDriverH hDriver = NULL;
PRINTF("DEBUG: starting to load cell (%s)\n", filename);
hDS = OGROpen(filename, FALSE, &hDriver);
if (NULL == hDS) {
PRINTF("WARNING: file loading failed (%s)\n", filename);
return FALSE;
}
if (NULL == loadLayer_cb) {
PRINTF("ERROR: should be using default S52_loadLayer() callback\n");
g_assert(0);
return FALSE;
}
if (NULL == loadObject_cb) {
PRINTF("ERROR: should be using default S52_loadObject_cb() callback\n");
g_assert(0);
return FALSE;
}
//_loadAux(hDS);
int nLayer = OGR_DS_GetLayerCount(hDS);
for (int iLayer=0; iLayer<nLayer; ++iLayer) {
OGRLayerH ogrlayer = OGR_DS_GetLayer(hDS, iLayer);
OGRFeatureDefnH defn = OGR_L_GetLayerDefn(ogrlayer);
const char *layername = OGR_FD_GetName(defn);
#ifdef _MINGW
// on Windows 32 the callback is broken
S52_loadLayer(layername, ogrlayer, NULL);
#else
//loadLayer_cb(layername, ogrlayer, NULL);
loadLayer_cb(layername, ogrlayer, loadObject_cb);
#endif
}
//OGR_DS_Destroy(hDS);
OGRReleaseDataSource(hDS);
return TRUE;
}
QgsFeatureList QgsOgrUtils::stringToFeatureList( const QString& string, const QgsFields& fields, QTextCodec* encoding )
{
QgsFeatureList features;
if ( string.isEmpty() )
return features;
QString randomFileName = QString( "/vsimem/%1" ).arg( QUuid::createUuid().toString() );
// create memory file system object from string buffer
QByteArray ba = string.toUtf8();
VSIFCloseL( VSIFileFromMemBuffer( TO8( randomFileName ), reinterpret_cast< GByte* >( ba.data() ),
static_cast< vsi_l_offset >( ba.size() ), FALSE ) );
OGRDataSourceH hDS = OGROpen( TO8( randomFileName ), false, nullptr );
if ( !hDS )
{
VSIUnlink( TO8( randomFileName ) );
return features;
}
OGRLayerH ogrLayer = OGR_DS_GetLayer( hDS, 0 );
if ( !ogrLayer )
{
OGR_DS_Destroy( hDS );
VSIUnlink( TO8( randomFileName ) );
return features;
}
OGRFeatureH oFeat;
while (( oFeat = OGR_L_GetNextFeature( ogrLayer ) ) )
{
QgsFeature feat = readOgrFeature( oFeat, fields, encoding );
if ( feat.isValid() )
features << feat;
OGR_F_Destroy( oFeat );
}
OGR_DS_Destroy( hDS );
VSIUnlink( TO8( randomFileName ) );
return features;
}
GDALWConnection * GDALWConnect(char * source) {
GDALWConnection * conn = NULL;
OGRFeatureDefnH featureDefn;
int fieldCount, i;
OGRRegisterAll();
conn = malloc(sizeof(GDALWConnection));
if (conn == NULL) {
fprintf(stderr, "Could not allocate memory\n");
return NULL;
}
conn->handler = OGROpen(source, 0 , &(conn->driver));
if (conn->handler == NULL) {
free(conn);
return NULL;
}
conn->layer = OGR_DS_GetLayer(conn->handler, 0);
if (conn->layer == NULL) {
OGRReleaseDataSource(conn->handler);
free(conn);
return NULL;
}
conn->layername = (const char *) OGR_L_GetName(conn->layer);
featureDefn = OGR_L_GetLayerDefn(conn->layer);
fieldCount = OGR_FD_GetFieldCount(featureDefn);
conn->numFieldDefinitions = fieldCount;
conn->fieldDefinitions = malloc(fieldCount * sizeof(OGRFieldDefnH));
if (conn->fieldDefinitions == NULL) {
OGRReleaseDataSource(conn->handler);
free(conn);
fprintf(stderr, "Could not allocate memory\n");
return NULL;
}
for (i=0 ; i<fieldCount ; i++) {
conn->fieldDefinitions[i] = OGR_FD_GetFieldDefn(featureDefn, i);
}
return conn;
}
/* OGRLayerH CPL_DLL OGR_DS_GetLayer( OGRDataSourceH, int );
{ok, DataSource} = lgeo_ogr:open("test/polygon.shp"),
lgeo_ogr:ds_get_layer(DataSource, 0).
*/
static ERL_NIF_TERM
ds_get_layer(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
OGRDataSourceH *datasource;
int index;
ERL_NIF_TERM eterm;
if (argc != 2) {
return enif_make_badarg(env);
}
if(!enif_get_resource(env, argv[0], OGR_DS_RESOURCE, (void**)&datasource)) {
return enif_make_badarg(env);
}
if (!enif_get_int(env, argv[1], &index)) {
return enif_make_badarg(env);
}
OGRLayerH lyr = OGR_DS_GetLayer(*datasource, index);
if(lyr == NULL) {
return enif_make_atom(env, "undefined");
}
EnvLayer_t **layer = \
enif_alloc_resource(OGR_L_RESOURCE, sizeof(EnvLayer_t*));
ErlNifEnv *layer_env = enif_alloc_env();
*layer = (EnvLayer_t*) enif_alloc(sizeof(EnvLayer_t));
(**layer).env = layer_env;
(**layer).obj = lyr;
// Save copy of datasource so is not garbage collected
enif_make_copy(layer_env, argv[0]);
eterm = enif_make_resource(env, layer);
enif_release_resource(layer);
return enif_make_tuple2(env, enif_make_atom(env, "ok"), eterm);
}
QgsFeatureList QgsOgrUtils::stringToFeatureList( const QString &string, const QgsFields &fields, QTextCodec *encoding )
{
QgsFeatureList features;
if ( string.isEmpty() )
return features;
QString randomFileName = QStringLiteral( "/vsimem/%1" ).arg( QUuid::createUuid().toString() );
// create memory file system object from string buffer
QByteArray ba = string.toUtf8();
VSIFCloseL( VSIFileFromMemBuffer( randomFileName.toUtf8().constData(), reinterpret_cast< GByte * >( ba.data() ),
static_cast< vsi_l_offset >( ba.size() ), FALSE ) );
gdal::ogr_datasource_unique_ptr hDS( OGROpen( randomFileName.toUtf8().constData(), false, nullptr ) );
if ( !hDS )
{
VSIUnlink( randomFileName.toUtf8().constData() );
return features;
}
OGRLayerH ogrLayer = OGR_DS_GetLayer( hDS.get(), 0 );
if ( !ogrLayer )
{
hDS.reset();
VSIUnlink( randomFileName.toUtf8().constData() );
return features;
}
gdal::ogr_feature_unique_ptr oFeat;
while ( oFeat.reset( OGR_L_GetNextFeature( ogrLayer ) ), oFeat )
{
QgsFeature feat = readOgrFeature( oFeat.get(), fields, encoding );
if ( feat.isValid() )
features << feat;
}
hDS.reset();
VSIUnlink( randomFileName.toUtf8().constData() );
return features;
}
bool CUtils::insideInPolygons(OGRDataSourceH poDS, double x, double y)
{
bool res = false;
OGRGeometryH pt = OGR_G_CreateGeometry(wkbPoint);
OGR_G_AddPoint_2D(pt, x, y);
for(int iLayer = 0; iLayer < OGR_DS_GetLayerCount(poDS); iLayer++)
{
OGRLayerH poLayer = OGR_DS_GetLayer(poDS, iLayer);
if(poLayer!=NULL)
{
OGREnvelope layerBounds;
OGR_L_GetExtent(poLayer, &layerBounds, 1);
if( (layerBounds.MinX <= x) && (layerBounds.MinY <= y) &&
(layerBounds.MaxX >= x) && (layerBounds.MaxY >= y) )
{
OGR_L_ResetReading(poLayer);
if(OGR_FD_GetGeomType( OGR_L_GetLayerDefn(poLayer) ) == wkbPolygon)
{
OGRFeatureH poFeat;
while((poFeat = OGR_L_GetNextFeature(poLayer))!= NULL)
{
OGRGeometryH hGeom = OGR_F_GetGeometryRef(poFeat);
if(OGR_G_Within(pt, hGeom))
{
res = true;
break;
}
}
if(res) { OGR_L_ResetReading(poLayer); break; }
}
}
}
}
OGR_G_DestroyGeometry(pt);
return res;
}
QgsShapeFile::QgsShapeFile( QString name, QString encoding )
{
fileName = name;
features = 0;
QgsApplication::registerOgrDrivers();
ogrDataSource = OGROpen( QFile::encodeName( fileName ).constData(), FALSE, NULL );
if ( ogrDataSource != NULL )
{
valid = true;
ogrLayer = OGR_DS_GetLayer( ogrDataSource, 0 );
features = OGR_L_GetFeatureCount( ogrLayer, TRUE );
}
else
valid = false;
setDefaultTable();
// init the geometry types
geometries << "NULL" << "POINT" << "LINESTRING" << "POLYGON" << "MULTIPOINT"
<< "MULTILINESTRING" << "MULTIPOLYGON" << "GEOMETRYCOLLECTION";
codec = QTextCodec::codecForName( encoding.toLocal8Bit().data() );
if ( !codec )
codec = QTextCodec::codecForLocale();
}
Shapefile::Shapefile (string const filename, GeometryType layer_type, bool append)
{
name = filename.substr(0, filename.find_last_of('.'));
geom_type = layer_type;
layer = NULL;
OGRRegisterAll();
driver = OGRGetDriverByName(driver_name.c_str());
if( driver == NULL ) {
throw runtime_error( driver_name + " driver not available." );
}
ds = OGR_Dr_Open(driver, filename.c_str(), NULL);
if (ds != NULL && !append) {
OGR_DS_Destroy(ds);
unlink(filename.c_str());
}
if (ds == NULL || !append) {
ds = OGR_Dr_CreateDataSource(driver, filename.c_str(), NULL);
if( ds == NULL ) {
throw runtime_error(filename + " datasource creation failed.");
}
}
layer = OGR_DS_GetLayer(ds, 0);
if (layer != NULL && !append) {
if (OGR_DS_DeleteLayer(ds, 0) != OGRERR_NONE) {
throw runtime_error(filename + " existing layer can't be deleted.");
}
}
if (layer == NULL) {
layer = OGR_DS_CreateLayer(ds, name.c_str(), NULL, layer_type, NULL);
if( layer == NULL ) {
throw runtime_error(filename + " layer creation failed.");
}
}
}
bool OGRPointToLatLon(double &x, double &y, OGRDataSourceH hDS,
const char *datum) {
char *pszPrj = NULL;
OGRSpatialReference *poSrcSRS;
OGRSpatialReference oSourceSRS, oTargetSRS;
OGRCoordinateTransformation *poCT;
if (hDS == NULL) {
return false;
}
OGRLayer *poLayer;
poLayer = (OGRLayer *)OGR_DS_GetLayer(hDS, 0);
poLayer->ResetReading();
poSrcSRS = poLayer->GetSpatialRef();
if (poSrcSRS == NULL) {
return false;
}
oTargetSRS.SetWellKnownGeogCS(datum);
poCT = OGRCreateCoordinateTransformation(poSrcSRS, &oTargetSRS);
if (poCT == NULL) {
return false;
}
if (!poCT->Transform(1, &x, &y)) {
OGRCoordinateTransformation::DestroyCT(poCT);
return false;
}
OGRCoordinateTransformation::DestroyCT(poCT);
return true;
}
void object::test<10>()
{
OGRErr err = OGRERR_NONE;
// Read feature without geometry
std::string tmp(data_tmp_);
tmp += SEP;
tmp += "tpoly.shp";
OGRDataSourceH ds = OGR_Dr_Open(drv_, tmp.c_str(), false);
ensure("Can't open layer", NULL != ds);
OGRLayerH lyr = OGR_DS_GetLayer(ds, 0);
ensure("Can't get layer", NULL != lyr);
// Set empty filter for attributes
err = OGR_L_SetAttributeFilter(lyr, NULL);
ensure_equals("Can't set attribute filter", OGRERR_NONE, err);
// Set spatial filter
const char* wkt = "LINESTRING(479505 4763195,480526 4762819)";
OGRGeometryH filterGeom = NULL;
err = OGR_G_CreateFromWkt((char**) &wkt, NULL, &filterGeom);
ensure_equals("Can't create geometry from WKT", OGRERR_NONE, err);
OGR_L_SetSpatialFilter(lyr, filterGeom);
// Prepare tester collection
std::vector<int> list;
list.push_back(158);
list.push_back(0);
// Test attributes
ensure_equal_attributes(lyr, "eas_id", list);
OGR_G_DestroyGeometry(filterGeom);
OGR_DS_Destroy(ds);
}
int db__driver_describe_table(dbString * table_name, dbTable ** table)
{
int i, nlayers;
OGRLayerH hLayer = NULL;
OGRFeatureDefnH hFeatureDefn;
/* Find data source */
nlayers = OGR_DS_GetLayerCount(hDs);
for (i = 0; i < nlayers; i++) {
hLayer = OGR_DS_GetLayer(hDs, i);
hFeatureDefn = OGR_L_GetLayerDefn(hLayer);
if (G_strcasecmp
((char *)OGR_FD_GetName(hFeatureDefn),
db_get_string(table_name)) == 0) {
break;
}
hLayer = NULL;
}
if (hLayer == NULL) {
append_error("Table '%s' does not exist\n",
db_get_string(table_name));
report_error();
return DB_FAILED;
}
G_debug(3, "->>");
if (describe_table(hLayer, table, NULL) == DB_FAILED) {
append_error("Cannot describe table\n");
report_error();
return DB_FAILED;
}
return DB_OK;
}
QgsOgrFeatureIterator::QgsOgrFeatureIterator( QgsOgrFeatureSource* source, bool ownSource, const QgsFeatureRequest& request )
: QgsAbstractFeatureIteratorFromSource<QgsOgrFeatureSource>( source, ownSource, request )
, mFeatureFetched( false )
, mConn( nullptr )
, ogrLayer( nullptr )
, mSubsetStringSet( false )
, mFetchGeometry( false )
, mExpressionCompiled( false )
, mFilterFids( mRequest.filterFids() )
, mFilterFidsIt( mFilterFids.constBegin() )
{
mConn = QgsOgrConnPool::instance()->acquireConnection( mSource->mProvider->dataSourceUri() );
if ( !mConn->ds )
{
return;
}
if ( mSource->mLayerName.isNull() )
{
ogrLayer = OGR_DS_GetLayer( mConn->ds, mSource->mLayerIndex );
}
else
{
ogrLayer = OGR_DS_GetLayerByName( mConn->ds, TO8( mSource->mLayerName ) );
}
if ( !ogrLayer )
{
return;
}
if ( !mSource->mSubsetString.isEmpty() )
{
ogrLayer = QgsOgrProviderUtils::setSubsetString( ogrLayer, mConn->ds, mSource->mEncoding, mSource->mSubsetString );
if ( !ogrLayer )
{
return;
}
mSubsetStringSet = true;
}
mFetchGeometry = ( !mRequest.filterRect().isNull() ) || !( mRequest.flags() & QgsFeatureRequest::NoGeometry );
QgsAttributeList attrs = ( mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes ) ? mRequest.subsetOfAttributes() : mSource->mFields.allAttributesList();
// ensure that all attributes required for expression filter are being fetched
if ( mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes && request.filterType() == QgsFeatureRequest::FilterExpression )
{
//ensure that all fields required for filter expressions are prepared
QSet<int> attributeIndexes = request.filterExpression()->referencedAttributeIndexes( mSource->mFields );
attributeIndexes += attrs.toSet();
attrs = attributeIndexes.toList();
mRequest.setSubsetOfAttributes( attrs );
}
if ( request.filterType() == QgsFeatureRequest::FilterExpression && request.filterExpression()->needsGeometry() )
{
mFetchGeometry = true;
}
// make sure we fetch just relevant fields
// unless it's a VRT data source filtered by geometry as we don't know which
// attributes make up the geometry and OGR won't fetch them to evaluate the
// filter if we choose to ignore them (fixes #11223)
if (( mSource->mDriverName != "VRT" && mSource->mDriverName != "OGR_VRT" ) || mRequest.filterRect().isNull() )
{
QgsOgrProviderUtils::setRelevantFields( ogrLayer, mSource->mFields.count(), mFetchGeometry, attrs, mSource->mFirstFieldIsFid );
}
// spatial query to select features
if ( !mRequest.filterRect().isNull() )
{
const QgsRectangle& rect = mRequest.filterRect();
OGR_L_SetSpatialFilterRect( ogrLayer, rect.xMinimum(), rect.yMinimum(), rect.xMaximum(), rect.yMaximum() );
}
else
{
OGR_L_SetSpatialFilter( ogrLayer, nullptr );
}
if ( request.filterType() == QgsFeatureRequest::FilterExpression
&& QSettings().value( "/qgis/compileExpressions", true ).toBool() )
{
QgsSqlExpressionCompiler* compiler;
if ( source->mDriverName == "SQLite" || source->mDriverName == "GPKG" )
{
compiler = new QgsSQLiteExpressionCompiler( source->mFields );
}
else
{
compiler = new QgsOgrExpressionCompiler( source );
}
QgsSqlExpressionCompiler::Result result = compiler->compile( request.filterExpression() );
if ( result == QgsSqlExpressionCompiler::Complete || result == QgsSqlExpressionCompiler::Partial )
{
QString whereClause = compiler->result();
if ( OGR_L_SetAttributeFilter( ogrLayer, mSource->mEncoding->fromUnicode( whereClause ).constData() ) == OGRERR_NONE )
{
//if only partial success when compiling expression, we need to double-check results using QGIS' expressions
mExpressionCompiled = ( result == QgsSqlExpressionCompiler::Complete );
mCompileStatus = ( mExpressionCompiled ? Compiled : PartiallyCompiled );
}
}
else
{
OGR_L_SetAttributeFilter( ogrLayer, nullptr );
}
delete compiler;
}
else
{
OGR_L_SetAttributeFilter( ogrLayer, nullptr );
}
//start with first feature
rewind();
}
int readoutlets(char *outletsds,char *lyrname, int uselayername,int outletslyr,OGRSpatialReferenceH hSRSRaster,int *noutlets, double*& x, double*& y,int*& id)
{
// initializing datasoruce,layer,feature, geomtery, spatial reference
OGRSFDriverH driver;
OGRDataSourceH hDS1;
OGRLayerH hLayer1;
OGRFeatureDefnH hFDefn1;
OGRFieldDefnH hFieldDefn1;
OGRFeatureH hFeature1;
OGRGeometryH geometry, line;
OGRSpatialReferenceH hRSOutlet;
// register all ogr driver related to OGR
OGRRegisterAll();
// open data source
hDS1 = OGROpen(outletsds, FALSE, NULL );
if( hDS1 == NULL )
{
printf( "Error Opening OGR Data Source .\n" );
return 1;
}
//get layer from layer name
if(uselayername==1) { hLayer1 = OGR_DS_GetLayerByName(hDS1,lyrname);}
//get layerinfo from layer number
else { hLayer1 = OGR_DS_GetLayer(hDS1,outletslyr);} // get layerinfo from layername
if(hLayer1 == NULL)getlayerfail(hDS1,outletsds,outletslyr);
OGRwkbGeometryType gtype;
gtype=OGR_L_GetGeomType(hLayer1);
// Test that the type is a point
if(gtype != wkbPoint)getlayerfail(hDS1,outletsds,outletslyr);
const char* RasterProjectionName;
const char* sprs;
const char* sprso;
const char* OutletProjectionName;
int pj_raster,pj_outlet;
// Spatial reference of outlet
hRSOutlet = OGR_L_GetSpatialRef(hLayer1);
if(hSRSRaster!=NULL){
pj_raster=OSRIsProjected(hSRSRaster); // find if projected or not
if(pj_raster==0) {sprs="GEOGCS";} else { sprs="PROJCS"; }
RasterProjectionName = OSRGetAttrValue(hSRSRaster,sprs,0); // get projection name
}
if(hRSOutlet!=NULL){
pj_outlet=OSRIsProjected(hRSOutlet);
if(pj_outlet==0) {sprso="GEOGCS";} else { sprso="PROJCS"; }
OutletProjectionName = OSRGetAttrValue(hRSOutlet,sprso,0);
}
//Write warnings where projections may not match
if(hRSOutlet!=NULL && hSRSRaster!=NULL){
if (pj_raster==pj_outlet){
int rc= strcmp(RasterProjectionName,OutletProjectionName); // compare string
if(rc!=0){
printf( "Warning: Projection of Outlet feature and Raster data may be different.\n" );
printf("Projection of Raster datasource %s.\n",RasterProjectionName);
printf("Projection of Outlet feature %s.\n",OutletProjectionName);
}
}
else {
printf( "Warning: Spatial References of Outlet feature and Raster data are different.\n" );
printf("Projection of Raster datasource %s.\n",RasterProjectionName);
printf("Projection of Outlet feature %s.\n",OutletProjectionName);
}
}
else if(hSRSRaster==NULL && hRSOutlet!=NULL) {
printf( "Warning: Spatial Reference of Raster is missing.\n" );
printf("Projection of Outlet feature %s.\n",OutletProjectionName);
}
else if(hSRSRaster!=NULL && hRSOutlet==NULL) {
printf( "Warning: Spatial Reference of Outlet feature is missing.\n" );
printf("Projection of Raster datasource %s.\n",RasterProjectionName);
}
else {
printf( "Warning: Spatial References of Outlet feature and Raster data are missing.\n" );
}
long countPts=0;
// count number of feature
countPts=OGR_L_GetFeatureCount(hLayer1,0);
// get schema i.e geometry, properties (e.g. ID)
hFDefn1 = OGR_L_GetLayerDefn(hLayer1);
x = new double[countPts];
y = new double[countPts];
int iField;
int nxy=0;
id = new int[countPts];
// loop through each feature and get lat,lon and id information
OGR_L_ResetReading(hLayer1);
while( (hFeature1 = OGR_L_GetNextFeature(hLayer1)) != NULL ) {
//hFeature1=OGR_L_GetFeature(hLayer1,j); // get feature info
geometry = OGR_F_GetGeometryRef(hFeature1); // get geometry
x[nxy] = OGR_G_GetX(geometry, 0);
y[nxy] = OGR_G_GetY(geometry, 0);
int idfld =OGR_F_GetFieldIndex(hFeature1,"id");
if (idfld >= 0)
{
hFieldDefn1 = OGR_FD_GetFieldDefn( hFDefn1,idfld); // get field definiton based on index
if( OGR_Fld_GetType(hFieldDefn1) == OFTInteger ) {
id[nxy] =OGR_F_GetFieldAsInteger( hFeature1, idfld );} // get id value
}
else {
id[nxy]=1;// if there is no id field
}
nxy++; // count number of outlets point
OGR_F_Destroy( hFeature1 ); // destroy feature
}
*noutlets=nxy;
OGR_DS_Destroy( hDS1); // destroy data source
return 0;
}
void OgrFileImport::import(bool load_symbols_only)
{
auto file = qobject_cast<QFile*>(stream);
if (!file)
{
throw FileFormatException("Internal error"); /// \todo Review design and/or message
}
auto filename = file->fileName();
// GDAL 2.0: ... = GDALOpenEx(template_path.toLatin1(), GDAL_OF_VECTOR, nullptr, nullptr, nullptr);
auto data_source = ogr::unique_datasource(OGROpen(filename.toLatin1(), 0, nullptr));
if (data_source == nullptr)
{
throw FileFormatException(Importer::tr("Could not read '%1'")
.arg(filename));
}
empty_geometries = 0;
no_transformation = 0;
failed_transformation = 0;
unsupported_geometry_type = 0;
too_few_coordinates = 0;
importStyles(data_source.get());
if (!load_symbols_only)
{
auto num_layers = OGR_DS_GetLayerCount(data_source.get());
for (int i = 0; i < num_layers; ++i)
{
auto layer = OGR_DS_GetLayer(data_source.get(), i);
if (!layer)
{
addWarning(tr("Unable to load layer %1.").arg(i));
continue;
}
auto part = map->getCurrentPart();
if (option(QLatin1String("Separate layers")).toBool())
{
if (num_layers > 0)
{
if (part->getNumObjects() == 0)
{
part->setName(OGR_L_GetName(layer));
}
else
{
part = new MapPart(OGR_L_GetName(layer), map);
auto index = map->getNumParts();
map->addPart(part, index);
map->setCurrentPartIndex(index);
}
}
}
importLayer(part, layer);
}
}
if (empty_geometries)
{
addWarning(tr("Unable to load %n objects, reason: %1", nullptr, empty_geometries)
.arg(tr("Empty geometry.")));
}
if (no_transformation)
{
addWarning(tr("Unable to load %n objects, reason: %1", nullptr, no_transformation)
.arg(tr("Can't determine the coordinate transformation: %1").arg(CPLGetLastErrorMsg())));
}
if (failed_transformation)
{
addWarning(tr("Unable to load %n objects, reason: %1", nullptr, failed_transformation)
.arg(tr("Failed to transform the coordinates.")));
}
if (unsupported_geometry_type)
{
addWarning(tr("Unable to load %n objects, reason: %1", nullptr, unsupported_geometry_type)
.arg(tr("Unknown or unsupported geometry type.")));
}
if (too_few_coordinates)
{
addWarning(tr("Unable to load %n objects, reason: %1", nullptr, too_few_coordinates)
.arg(tr("Not enough coordinates.")));
}
}
QgsOgrFeatureIterator::QgsOgrFeatureIterator( QgsOgrFeatureSource* source, bool ownSource, const QgsFeatureRequest& request )
: QgsAbstractFeatureIteratorFromSource<QgsOgrFeatureSource>( source, ownSource, request )
, ogrLayer( 0 )
, mSubsetStringSet( false )
, mGeometrySimplifier( NULL )
, mExpressionCompiled( false )
{
mFeatureFetched = false;
mConn = QgsOgrConnPool::instance()->acquireConnection( mSource->mFilePath );
if ( mSource->mLayerName.isNull() )
{
ogrLayer = OGR_DS_GetLayer( mConn->ds, mSource->mLayerIndex );
}
else
{
ogrLayer = OGR_DS_GetLayerByName( mConn->ds, TO8( mSource->mLayerName ) );
}
if ( !mSource->mSubsetString.isEmpty() )
{
ogrLayer = QgsOgrUtils::setSubsetString( ogrLayer, mConn->ds, mSource->mEncoding, mSource->mSubsetString );
mSubsetStringSet = true;
}
mFetchGeometry = ( !mRequest.filterRect().isNull() ) || !( mRequest.flags() & QgsFeatureRequest::NoGeometry );
QgsAttributeList attrs = ( mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes ) ? mRequest.subsetOfAttributes() : mSource->mFields.allAttributesList();
// make sure we fetch just relevant fields
// unless it's a VRT data source filtered by geometry as we don't know which
// attributes make up the geometry and OGR won't fetch them to evaluate the
// filter if we choose to ignore them (fixes #11223)
if (( mSource->mDriverName != "VRT" && mSource->mDriverName != "OGR_VRT" ) || mRequest.filterRect().isNull() )
{
QgsOgrUtils::setRelevantFields( ogrLayer, mSource->mFields.count(), mFetchGeometry, attrs );
}
// spatial query to select features
if ( !mRequest.filterRect().isNull() )
{
const QgsRectangle& rect = mRequest.filterRect();
OGR_L_SetSpatialFilterRect( ogrLayer, rect.xMinimum(), rect.yMinimum(), rect.xMaximum(), rect.yMaximum() );
}
else
{
OGR_L_SetSpatialFilter( ogrLayer, 0 );
}
if ( request.filterType() == QgsFeatureRequest::FilterExpression
&& QSettings().value( "/qgis/compileExpressions", true ).toBool() )
{
QgsOgrExpressionCompiler compiler = QgsOgrExpressionCompiler( source );
QgsSqlExpressionCompiler::Result result = compiler.compile( request.filterExpression() );
if ( result == QgsSqlExpressionCompiler::Complete || result == QgsSqlExpressionCompiler::Partial )
{
QString whereClause = compiler.result();
if ( OGR_L_SetAttributeFilter( ogrLayer, whereClause.toLocal8Bit().data() ) == OGRERR_NONE )
{
//if only partial success when compiling expression, we need to double-check results using QGIS' expressions
mExpressionCompiled = ( result == QgsSqlExpressionCompiler::Complete );
}
}
else
{
OGR_L_SetAttributeFilter( ogrLayer, 0 );
}
}
else
{
OGR_L_SetAttributeFilter( ogrLayer, 0 );
}
//start with first feature
rewind();
}
int OGRCDump(const char *pszFname)
{
OGRDataSourceH datasource;
int i, numLayers;
/* Register all OGR drivers */
OGRRegisterAll();
/* Open data source */
datasource = OGROpen(pszFname, 0 /* bUpdate */, NULL);
if (datasource == NULL)
{
printf("Unable to open %s\n", pszFname);
return -1;
}
/* Loop through layers and dump their contents */
numLayers = OGR_DS_GetLayerCount(datasource);
for(i=0; i<numLayers; i++)
{
OGRLayerH layer;
int j, numFields;
OGRFeatureH feature;
OGRFeatureDefnH layerDefn;
layer = OGR_DS_GetLayer( datasource, i );
/* Dump info about this layer */
layerDefn = OGR_L_GetLayerDefn( layer );
numFields = OGR_FD_GetFieldCount( layerDefn );
printf("\n===================\n");
printf("Layer %d: '%s'\n\n", i, OGR_FD_GetName(layerDefn));
for(j=0; j<numFields; j++)
{
OGRFieldDefnH fieldDefn;
fieldDefn = OGR_FD_GetFieldDefn( layerDefn, j );
printf(" Field %d: %s (%s)\n",
j, OGR_Fld_GetNameRef(fieldDefn),
OGR_GetFieldTypeName(OGR_Fld_GetType(fieldDefn)) );
}
printf("\n");
/* And dump each feature individually */
while( (feature = OGR_L_GetNextFeature( layer )) != NULL )
{
OGR_F_DumpReadable( feature, stdout );
OGR_F_Destroy( feature );
}
/* No need to free layer handle, it belongs to the datasource */
}
/* Close data source */
OGR_DS_Destroy( datasource );
return 0;
}
int OGRCCreate(const char *pszFname)
{
OGRSFDriverH driver;
int i, numDrivers;
OGRDataSourceH datasource;
OGRLayerH layer;
OGRFeatureDefnH layerDefn;
OGRFieldDefnH fieldDefn;
OGRFeatureH feature;
OGRGeometryH geometry, ring;
/* Register all OGR drivers */
OGRRegisterAll();
/* Fetch MITAB driver - we want to create a TAB file */
numDrivers = OGRGetDriverCount();
for(i=0; i<numDrivers; i++)
{
driver = OGRGetDriver(i);
if (EQUAL("MapInfo File", OGR_Dr_GetName(driver)))
break; /* Found it! */
driver = NULL;
}
if (!driver)
{
printf("Driver not found!\n");
return -1;
}
/* Create new file using this driver */
datasource = OGR_Dr_CreateDataSource(driver, pszFname, NULL);
if (datasource == NULL)
{
printf("Unable to create %s\n", pszFname);
return -1;
}
/* MapInfo data sources are created with one empty layer.
Fetch the layer handle */
layer = OGR_DS_GetLayer(datasource, 0);
if (layer == NULL)
{
printf("Unable to create new layer in %s\n", pszFname);
return -1;
}
/* Add a few fields to the layer defn */
fieldDefn = OGR_Fld_Create( "id", OFTInteger );
OGR_L_CreateField(layer, fieldDefn, 0);
fieldDefn = OGR_Fld_Create( "area", OFTReal );
OGR_L_CreateField(layer, fieldDefn, 0);
fieldDefn = OGR_Fld_Create( "name", OFTString );
OGR_L_CreateField(layer, fieldDefn, 0);
/* We'll need the layerDefn handle to create new features in this layer */
layerDefn = OGR_L_GetLayerDefn( layer );
/* Create a new point */
feature = OGR_F_Create( layerDefn );
OGR_F_SetFieldInteger( feature, 0, 1);
OGR_F_SetFieldDouble( feature, 1, 123.45);
OGR_F_SetFieldString( feature, 2, "Feature #1");
geometry = OGR_G_CreateGeometry( wkbPoint );
OGR_G_SetPoint(geometry, 0, 123.45, 456.78, 0);
OGR_F_SetGeometryDirectly(feature, geometry);
OGR_L_CreateFeature( layer, feature );
/* Create a new line */
feature = OGR_F_Create( layerDefn );
OGR_F_SetFieldInteger( feature, 0, 2);
OGR_F_SetFieldDouble( feature, 1, 42.45);
OGR_F_SetFieldString( feature, 2, "Feature #2");
geometry = OGR_G_CreateGeometry( wkbLineString );
OGR_G_AddPoint(geometry, 123.45, 456.78, 0);
OGR_G_AddPoint(geometry, 12.34, 45.67, 0);
OGR_F_SetGeometryDirectly(feature, geometry);
OGR_L_CreateFeature( layer, feature );
/* Create a new polygon (square) */
feature = OGR_F_Create( layerDefn );
OGR_F_SetFieldInteger( feature, 0, 3);
OGR_F_SetFieldDouble( feature, 1, 49.71);
OGR_F_SetFieldString( feature, 2, "Feature #3");
geometry = OGR_G_CreateGeometry( wkbPolygon );
ring = OGR_G_CreateGeometry( wkbLinearRing );
OGR_G_AddPoint(ring, 123.45, 456.78, 0);
OGR_G_AddPoint(ring, 12.34, 456.78, 0);
OGR_G_AddPoint(ring, 12.34, 45.67, 0);
OGR_G_AddPoint(ring, 123.45, 45.67, 0);
OGR_G_AddPoint(ring, 123.45, 456.78, 0);
OGR_G_AddGeometryDirectly(geometry, ring);
OGR_F_SetGeometryDirectly(feature, geometry);
OGR_L_CreateFeature( layer, feature );
/* Close data source */
OGR_DS_Destroy( datasource );
return 0;
}
void object::test<3>()
{
OGRErr err = OGRERR_NONE;
OGRDataSourceH ds = NULL;
ds = OGR_Dr_CreateDataSource(drv_, data_tmp_.c_str(), NULL);
ensure("Can't open or create data source", NULL != ds);
// Create memory Layer
OGRLayerH lyr = NULL;
lyr = OGR_DS_CreateLayer(ds, "tpoly", NULL, wkbPolygon, NULL);
ensure("Can't create layer", NULL != lyr);
// Create schema
OGRFieldDefnH fld = NULL;
fld = OGR_Fld_Create("AREA", OFTReal);
err = OGR_L_CreateField(lyr, fld, true);
OGR_Fld_Destroy(fld);
ensure_equals("Can't create field", OGRERR_NONE, err);
fld = OGR_Fld_Create("EAS_ID", OFTInteger);
err = OGR_L_CreateField(lyr, fld, true);
OGR_Fld_Destroy(fld);
ensure_equals("Can't create field", OGRERR_NONE, err);
fld = OGR_Fld_Create("PRFEDEA", OFTString);
err = OGR_L_CreateField(lyr, fld, true);
OGR_Fld_Destroy(fld);
ensure_equals("Can't create field", OGRERR_NONE, err);
// Check schema
OGRFeatureDefnH featDefn = OGR_L_GetLayerDefn(lyr);
ensure("Layer schema is NULL", NULL != featDefn);
ensure_equals("Fields creation failed", 3, OGR_FD_GetFieldCount(featDefn));
// Copy ogr/poly.shp to temporary layer
OGRFeatureH featDst = OGR_F_Create(featDefn);
ensure("Can't create empty feature", NULL != featDst);
std::string source(data_);
source += SEP;
source += "poly.shp";
OGRDataSourceH dsSrc = OGR_Dr_Open(drv_, source.c_str(), false);
ensure("Can't open source layer", NULL != dsSrc);
OGRLayerH lyrSrc = OGR_DS_GetLayer(dsSrc, 0);
ensure("Can't get source layer", NULL != lyrSrc);
OGRFeatureH featSrc = NULL;
while (NULL != (featSrc = OGR_L_GetNextFeature(lyrSrc)))
{
err = OGR_F_SetFrom(featDst, featSrc, true);
ensure_equals("Can't set festure from source", OGRERR_NONE, err);
err = OGR_L_CreateFeature(lyr, featDst);
ensure_equals("Can't write feature to layer", OGRERR_NONE, err);
OGR_F_Destroy(featSrc);
}
// Release and close resources
OGR_F_Destroy(featDst);
OGR_DS_Destroy(dsSrc);
OGR_DS_Destroy(ds);
}
