/*!
\brief Open database (OGR datasource)
\param handle pointer to dbHandle (db name and schema)
\return DB_OK on success
\return DB_FAILED on failure
*/
int db__driver_open_database(dbHandle * handle)
{
const char *name;
dbConnection connection;
init_error();
db_get_connection(&connection);
name = db_get_handle_dbname(handle);
/* if name is empty use connection.databaseName */
if (strlen(name) == 0)
name = connection.databaseName;
G_debug(3, "db_driver_open_database() name = '%s'", name);
OGRRegisterAll();
hDs = OGROpen(name, TRUE, NULL);
if (hDs == NULL) {
append_error(_("Unable to open OGR data source"));
report_error();
return DB_FAILED;
}
G_debug(3, "Datasource opened");
return DB_OK;
}
void QgsNewOgrConnection::testConnection()
{
QString uri;
uri = createDatabaseURI( cmbDatabaseTypes->currentText(),
txtHost->text(),
txtDatabase->text(),
txtPort->text(),
mAuthSettingsDatabase->configId(),
mAuthSettingsDatabase->username(),
mAuthSettingsDatabase->password(),
true );
QgsDebugMsg( "Connecting using uri = " + uri );
OGRRegisterAll();
OGRDataSourceH poDS;
OGRSFDriverH pahDriver;
CPLErrorReset();
poDS = OGROpen( uri.toUtf8().constData(), false, &pahDriver );
if ( !poDS )
{
QMessageBox::information( this, tr( "Test Connection" ), tr( "Connection failed - Check settings and try again.\n\nExtended error information:\n%1" ).arg( QString::fromUtf8( CPLGetLastErrorMsg() ) ) );
}
else
{
QMessageBox::information( this, tr( "Test Connection" ), tr( "Connection to %1 was successful." ).arg( uri ) );
OGRReleaseDataSource( poDS );
}
}
void AttributeFilter::ready(PointContext ctx)
{
m_gdal_debug = std::shared_ptr<pdal::gdal::Debug>(
new pdal::gdal::Debug(isDebug(), log()));
for (auto& dim_par : m_dimensions)
{
Dimension::Id::Enum t = ctx.findDim(dim_par.first);
dim_par.second.dim = t;
if (dim_par.second.isogr)
{
OGRDSPtr ds = OGRDSPtr(OGROpen(dim_par.second.datasource.c_str(), 0, 0), OGRDataSourceDeleter());
if (!ds)
{
std::ostringstream oss;
oss << "Unable to open data source '" << dim_par.second.datasource <<"'";
throw pdal_error(oss.str());
}
dim_par.second.ds = ds;
}
}
}
bool QgsOgrLayerItem::setCrs( QgsCoordinateReferenceSystem crs )
{
QgsDebugMsg( "mPath = " + mPath );
OGRRegisterAll();
OGRSFDriverH hDriver;
OGRDataSourceH hDataSource = OGROpen( TO8F( mPath ), true, &hDriver );
if ( !hDataSource )
return false;
QString driverName = OGR_Dr_GetName( hDriver );
OGR_DS_Destroy( hDataSource );
// we are able to assign CRS only to shapefiles :-(
if ( driverName == "ESRI Shapefile" )
{
QString layerName = mPath.left( mPath.indexOf( ".shp", Qt::CaseInsensitive ) );
QString wkt = crs.toWkt();
// save ordinary .prj file
OGRSpatialReferenceH hSRS = OSRNewSpatialReference( wkt.toLocal8Bit().data() );
OSRMorphToESRI( hSRS ); // this is the important stuff for shapefile .prj
char* pszOutWkt = NULL;
OSRExportToWkt( hSRS, &pszOutWkt );
QFile prjFile( layerName + ".prj" );
if ( prjFile.open( QIODevice::WriteOnly ) )
{
QTextStream prjStream( &prjFile );
prjStream << pszOutWkt << endl;
prjFile.close();
}
else
{
QgsMessageLog::logMessage( tr( "Couldn't open file %1.prj" ).arg( layerName ), tr( "OGR" ) );
return false;
}
OSRDestroySpatialReference( hSRS );
CPLFree( pszOutWkt );
// save qgis-specific .qpj file (maybe because of better wkt compatibility?)
QFile qpjFile( layerName + ".qpj" );
if ( qpjFile.open( QIODevice::WriteOnly ) )
{
QTextStream qpjStream( &qpjFile );
qpjStream << wkt.toLocal8Bit().data() << endl;
qpjFile.close();
}
else
{
QgsMessageLog::logMessage( tr( "Couldn't open file %1.qpj" ).arg( layerName ), tr( "OGR" ) );
return false;
}
return true;
}
// It it is impossible to assign a crs to an existing layer
// No OGR_L_SetSpatialRef : http://trac.osgeo.org/gdal/ticket/4032
return false;
}
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 );
}
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();
}
/**
* \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;
}
/* OGRDataSourceH CPL_DLL OGROpen(const char *, int, OGRSFDriverH *)
CPL_WARN_UNUSED_RESULT;
{ok, DataSource} = lgeo_ogr:open("test/polygon.shp").
{ok, DataSource} = lgeo_ogr:open("test/polygon.shp", 1).
*/
static ERL_NIF_TERM
open(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
int update = 0; // read-only (default)
OGRDataSourceH datasource;
ERL_NIF_TERM eterm;
/*
OGRSFDriverH *pahDriver;
ERL_NIF_TERM eterm1, eterm2;
*/
unsigned len;
if (argc > 0 && !enif_get_list_length(env, argv[0], &len)) {
return enif_make_badarg(env);
}
char * filename = enif_alloc(sizeof(char)*(len+1));
if(!enif_get_string(env, argv[0], filename, len+1, ERL_NIF_LATIN1)) {
return enif_make_badarg(env);
}
if (argc == 2 && !enif_get_int(env, argv[1], &update)) {
return enif_make_badarg(env);
}
datasource = OGROpen(filename, update, NULL);
//datasource = OGROpen(filename, upadate, pahDriver);
enif_free(filename);
if(datasource == NULL) {
return enif_make_atom(env, "undefined");
}
OGRDataSourceH **hDS = \
enif_alloc_resource(OGR_DS_RESOURCE, sizeof(OGRDataSourceH*));
*hDS = datasource;
/*
OGRSFDriverH **hDriver = \
enif_alloc_resource(OGR_D_RESOURCE, sizeof(OGRSFDriverH*));
*hDriver = *pahDriver;
*/
eterm = enif_make_resource(env, hDS);
enif_release_resource(hDS);
return enif_make_tuple2(env, enif_make_atom(env, "ok"), eterm);
/*
eterm2 = enif_make_resource(env, hDriver);
enif_release_resource(hDriver);
return enif_make_tuple2(env, eterm1, eterm1);
*/
}
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();
}
void AttributeFilter::ready(PointTableRef table)
{
if (m_value != m_value)
{
m_ds = OGRDSPtr(OGROpen(m_datasource.c_str(), 0, 0),
OGRDataSourceDeleter());
if (!m_ds)
{
std::ostringstream oss;
oss << getName() << ": Unable to open data source '" <<
m_datasource << "'";
throw pdal_error(oss.str());
}
}
}
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;
}
QgsLayerItem::Capability QgsOgrLayerItem::capabilities()
{
QgsDebugMsg( "mPath = " + mPath );
OGRRegisterAll();
OGRSFDriverH hDriver;
OGRDataSourceH hDataSource = OGROpen( TO8F( mPath ), true, &hDriver );
if ( !hDataSource )
return NoCapabilities;
QString driverName = OGR_Dr_GetName( hDriver );
OGR_DS_Destroy( hDataSource );
if ( driverName == "ESRI Shapefile" )
return SetCrs;
return NoCapabilities;
}
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;
}
QVector<QgsDataItem*> QgsOgrDataCollectionItem::createChildren()
{
QVector<QgsDataItem*> children;
OGRSFDriverH hDriver;
OGRDataSourceH hDataSource = OGROpen( TO8F( mPath ), false, &hDriver );
if ( !hDataSource )
return children;
int numLayers = OGR_DS_GetLayerCount( hDataSource );
for ( int i = 0; i < numLayers; i++ )
{
QgsOgrLayerItem* item = dataItemForLayer( this, QString(), mPath, hDataSource, i );
children.append( item );
}
OGR_DS_Destroy( hDataSource );
return children;
}
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;
}
void AttributeFilter::ready(PointTableRef table)
{
for (auto& dim_par : m_dimensions)
{
Dimension::Id::Enum t = table.layout()->findDim(dim_par.first);
dim_par.second.dim = t;
if (dim_par.second.isogr)
{
OGRDSPtr ds = OGRDSPtr(OGROpen(dim_par.second.datasource.c_str(), 0, 0), OGRDataSourceDeleter());
if (!ds)
{
std::ostringstream oss;
oss << "Unable to open data source '" << dim_par.second.datasource <<"'";
throw pdal_error(oss.str());
}
dim_par.second.ds = ds;
}
}
}
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;
}
}
QgsOgrLayerItem::QgsOgrLayerItem( QgsDataItem* parent,
const QString& name, const QString& path, const QString& uri, LayerType layerType )
: QgsLayerItem( parent, name, path, uri, layerType, "ogr" )
{
mToolTip = uri;
setState( Populated ); // children are not expected
OGRRegisterAll();
OGRSFDriverH hDriver;
OGRDataSourceH hDataSource = OGROpen( TO8F( mPath ), true, &hDriver );
if ( hDataSource )
{
QString driverName = OGR_Dr_GetName( hDriver );
OGR_DS_Destroy( hDataSource );
if ( driverName == "ESRI Shapefile" )
mCapabilities |= SetCrs;
// It it is impossible to assign a crs to an existing layer
// No OGR_L_SetSpatialRef : http://trac.osgeo.org/gdal/ticket/4032
}
}
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();
}
/* What we need: specific condition, is walk in , tactic, distance elevation
* minsteps, maxsteps, waterdrops, pump/roll, fwa id.
*/
int main( int argc, char *argv[] )
{
GDALAllRegister();
OGRRegisterAll();
const char *pszInputfile = NULL;
const char *pszOutputfile = NULL;
const char *pszOutputFormat = "CSV";
char **papszCreateOptions = NULL;
const char *pszDataPath = NULL;
const char *pszFpuCode = NULL;
int nLimit = 0;
int bProgress = TRUE;
double dfMaxX, dfMinX, dfMaxY, dfMinY;
int bLimit = FALSE;
double dfBuffer = 0.0;
int i = 1;
while( i < argc )
{
if( EQUAL( argv[i], "-p" ) )
{
bProgress = TRUE;
}
else if( EQUAL( argv[i], "-d" ) )
{
pszDataPath = argv[++i];
}
else if( EQUAL( argv[i], "-of" ) )
{
pszOutputFormat = argv[++i];
}
else if( EQUAL( argv[i], "-co" ) )
{
papszCreateOptions = CSLAddString( papszCreateOptions, argv[++i] );
}
else if( EQUAL( argv[i], "-sl" ) )
{
dfMaxX = atof(argv[++i]);
dfMinX = atof(argv[++i]);
dfMaxY = atof(argv[++i]);
dfMinY = atof(argv[++i]);
bLimit = TRUE;
}
else if( EQUAL( argv[i], "-fpu" ) )
{
pszFpuCode = argv[++i];
}
else if( EQUAL( argv[i], "-b" ) )
{
dfBuffer = atof( argv[++i] );
}
else if( EQUAL( argv[i], "-l" ) )
{
nLimit = atoi( argv[++i] );
}
else if( EQUAL( argv[i], "-h" ) )
{
Usage();
}
else if( pszInputfile == NULL )
{
pszInputfile = argv[i];
}
else if( pszOutputfile == NULL )
{
pszOutputfile = argv[i];
}
else
{
Usage();
}
i++;
}
if( pszInputfile == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed, "No input file provided\n");
Usage();
}
if( pszOutputfile == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed, "Invalid output selected, "
"use database and table or output file\n" );
Usage();
}
pszDataPath = CPLGetConfigOption( "OMFFR_DATA", NULL );
OGRDataSourceH hInputDS = OGROpen( pszInputfile, FALSE, NULL );
if( hInputDS == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed, "Cannot open input file\n" );
Usage();
}
int year, num, day;
const char *dow, *disc_time;
int bi;
double ros;
int fuel;
const char *spec_cond;
int slope, walkin;
const char *tactic;
double dist;
int elev;
double ltow;
int minsteps = 250;
int maxsteps = 10000;
const char *sunrise, *sunset;
int waterdrops, pumproll;
char *abyFwa;
const char *fwaid;
double lon, lat;
OGRLayerH hInputLayer;
hInputLayer = OGR_DS_GetLayerByName( hInputDS, CPLGetBasename( pszInputfile ) );
OGRFeatureDefnH hInputFeatureDefn;
OGRFeatureH hInputFeature;
OGRGeometryH hGeometry;
hInputFeatureDefn = OGR_L_GetLayerDefn( hInputLayer );
const char *pszTmpFilename =CPLFormFilename( pszDataPath, "irs/FWA", ".dat" );
std::vector<CFWA>fwas = LoadFwas( pszTmpFilename );
int nFeatures = OGR_L_GetFeatureCount( hInputLayer, TRUE );
FILE *fout = fopen( pszOutputfile, "w" );
//CFWA *fwa;
Random random;
char pszDb[8192];
sprintf( pszDb, "%s/omffr.sqlite", pszDataPath );
IRSDataAccess *poDA = IRSDataAccess::Create( 0, pszDb );
int rc;
sqlite3 *db;
rc = sqlite3_open_v2( pszDb, &db, SQLITE_OPEN_READONLY, NULL );
rc = sqlite3_enable_load_extension( db, 1 );
rc = sqlite3_load_extension( db, "/usr/local/lib/libspatialite.so", 0, NULL );
sqlite3_stmt *stmt;
rc = sqlite3_prepare_v2( db, "SELECT * from fwa join fwa_bndry USING(fwa_gis_id) " \
"WHERE ST_Contains(fwa_bndry.geometry, MakePoint(?, ?, 4269))",
-1, &stmt, NULL );
if(rc)
{
CPLError( CE_Failure, CPLE_AppDefined, "Could not open DB");
}
GDALTermProgress( 0.0, NULL, NULL );
OGR_L_ResetReading( hInputLayer );
const char *pszFwaName;
int nDone = 0;
while( ( hInputFeature = OGR_L_GetNextFeature( hInputLayer ) ) != NULL )
{
/*
fwaid = OGR_F_GetFieldAsString( hInputFeature,
OGR_FD_GetFieldIndex( hInputFeatureDefn,
"fwa_name" ) );
abyFwa = CPLStrdup( fwaid );
LaunderFwaName( abyFwa );
fwa = FindFwa( fwas, abyFwa );
if( fwa == NULL )
{
CPLError( CE_Warning, CPLE_FileIO,
"Could not load fwa (%s)from file, missing\n", abyFwa );
continue;
}
*/
/* Get fwa by point */
hGeometry = OGR_F_GetGeometryRef( hInputFeature );
/* Try to handle non-geometry types (csv) */
if( hGeometry != NULL )
{
lat = OGR_G_GetY( hGeometry, 0 );
lon = OGR_G_GetX( hGeometry, 0 );
}
else
{
lat = OGR_F_GetFieldAsDouble( hInputFeature, OGR_FD_GetFieldIndex( hInputFeatureDefn,
"Y") );
lon = OGR_F_GetFieldAsDouble( hInputFeature, OGR_FD_GetFieldIndex( hInputFeatureDefn,
"X") );
}
std::string oFwaName = poDA->PointQuery( "fwa_bndry", "fwa_lndr_name",
lon, lat );
rc = sqlite3_bind_double( stmt, 1, lon );
rc = sqlite3_bind_double( stmt, 2, lat );
//sqlite3_bind_text( stmt, 1, oFwaName.c_str(), -1, SQLITE_TRANSIENT);
rc = sqlite3_step( stmt );
if( rc != SQLITE_ROW && rc != SQLITE_DONE )
{
CPLError( CE_Warning, CPLE_FileIO,
"Could not load fwa (%s)from file, missing\n", oFwaName.c_str() );
sqlite3_reset(stmt);
continue;
}
int nFwaWalkIn, nFwaHead, nFwaTail, nFwaPara, nFwaAttackD;
int nFwaWaterDrop, nFwaPumpRoll;
nFwaWalkIn = sqlite3_column_int( stmt, 4 );
nFwaHead = sqlite3_column_int( stmt, 6 );
nFwaTail = sqlite3_column_int( stmt, 7 );
nFwaPara = sqlite3_column_int( stmt, 8 );
nFwaAttackD = sqlite3_column_int( stmt, 9 );
nFwaWaterDrop = sqlite3_column_int( stmt, 10 );
nFwaPumpRoll = sqlite3_column_int( stmt, 5 );
year = OGR_F_GetFieldAsInteger( hInputFeature,
OGR_FD_GetFieldIndex( hInputFeatureDefn,
"year" ) );
num = OGR_F_GetFieldAsInteger( hInputFeature, OGR_FD_GetFieldIndex( hInputFeatureDefn,
"fire_num" ) );
day = OGR_F_GetFieldAsInteger( hInputFeature, OGR_FD_GetFieldIndex( hInputFeatureDefn,
"day" ) );
dow = OGR_F_GetFieldAsString( hInputFeature, OGR_FD_GetFieldIndex( hInputFeatureDefn,
"week_day" ) );
disc_time = OGR_F_GetFieldAsString( hInputFeature, OGR_FD_GetFieldIndex( hInputFeatureDefn,
"disc_time" ) );
bi = OGR_F_GetFieldAsInteger( hInputFeature, OGR_FD_GetFieldIndex( hInputFeatureDefn,
"bi" ) );
ros = OGR_F_GetFieldAsDouble( hInputFeature, OGR_FD_GetFieldIndex( hInputFeatureDefn,
"ros" ) );
fuel = OGR_F_GetFieldAsInteger( hInputFeature, OGR_FD_GetFieldIndex( hInputFeatureDefn,
"fuel" ) );
spec_cond = OGR_F_GetFieldAsString( hInputFeature, OGR_FD_GetFieldIndex( hInputFeatureDefn,
"spec_cond" ) );
slope = OGR_F_GetFieldAsInteger( hInputFeature, OGR_FD_GetFieldIndex( hInputFeatureDefn,
"slope_perc" ) );
//if( random.rand3() * 100 > fwa->GetWalkInPct() )
if( random.rand3() * 100 > nFwaWalkIn )
walkin = 0;
else
walkin = 1;
//if( fwa->GetHead() == 100 )
if( nFwaHead == 100 )
tactic = "HEAD\0";
//else if( fwa->GetTail() == 100 )
else if( nFwaTail == 100 )
tactic = "TAIL\0";
//else if( fwa->GetParallel() == 100 )
else if( nFwaTail == 100 )
tactic = "PARALLEL\0";
else
{
int r = (int)(random.rand3() * 100 );
int total = 0;
if( r < nFwaHead )
tactic = "HEAD\0";
else if( r < nFwaTail + nFwaTail )
tactic = "TAIL\0";
else
tactic = "PARALLEL\0";
}
//dist = fwa->GetAttackDist();
dist = nFwaAttackD;
elev = OGR_F_GetFieldAsInteger( hInputFeature, OGR_FD_GetFieldIndex( hInputFeatureDefn,
"elev" ) );
ltow = OGR_F_GetFieldAsDouble( hInputFeature, OGR_FD_GetFieldIndex( hInputFeatureDefn,
"ratio" ) );
sunrise = OGR_F_GetFieldAsString( hInputFeature, OGR_FD_GetFieldIndex( hInputFeatureDefn,
"sunrise" ) );
sunset = OGR_F_GetFieldAsString( hInputFeature, OGR_FD_GetFieldIndex( hInputFeatureDefn,
"sunset" ) );
//if( fwa->GetWaterDrops() )
if( nFwaWaterDrop )
waterdrops = TRUE;
else
waterdrops = FALSE;
//if( fwa->GetPumpnRoll() )
if( nFwaPumpRoll )
pumproll = TRUE;
else
pumproll = FALSE;
fprintf( fout, "%d %d %d %s %s "
"%d %lf %d %s %d "
"%d %s %lf %d %lf "
"%d %d %s %s %d "
"%d %s %lf %lf\n",
year, num, day, dow, disc_time,
bi, ros, fuel, spec_cond, slope,
walkin, tactic, dist, elev, ltow,
minsteps, maxsteps, sunrise, sunset, waterdrops,
pumproll, /* abyFwa */ oFwaName.c_str(), lat, lon );
sqlite3_reset(stmt);
nDone++;
GDALTermProgress( (float)nDone / (float)nFeatures, NULL, NULL );
}
GDALTermProgress( 1.0, NULL, NULL );
fclose( fout );
OGR_DS_Destroy( hInputDS );
return 0;
}
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 TIndexReader::initialize()
{
if (!m_bounds.empty())
m_wkt = m_bounds.toWKT();
m_out_ref.reset(new gdal::SpatialRef());
log()->get(LogLevel::Debug) << "Opening file " << m_filename <<
std::endl;
gdal::registerDrivers();
m_dataset = OGROpen(m_filename.c_str(), FALSE, NULL);
if (!m_dataset)
{
std::stringstream oss;
oss << "unable to datasource '" << m_filename << "'";
throw pdal::pdal_error(oss.str());
}
OGRGeometryH geometry(0);
if (m_sql.size())
{
m_layer = OGR_DS_ExecuteSQL(m_dataset, m_sql.c_str(), geometry,
m_dialect.c_str());
}
else
{
m_layer = OGR_DS_GetLayerByName(m_dataset, m_layerName.c_str());
}
if (!m_layer)
{
std::stringstream oss;
oss << getName() << ": Unable to open layer '" << m_layerName <<
"' from OGR datasource '" << m_filename << "'";
throw pdal::pdal_error(oss.str());
}
m_out_ref->setFromLayer(m_layer);
// Override the SRS if the user set one, otherwise, take it
// from the layer
if (m_tgtSrsString.size())
m_out_ref.reset(new gdal::SpatialRef(m_tgtSrsString));
else
m_out_ref.reset(new gdal::SpatialRef(m_out_ref->wkt()));
setSpatialReference(SpatialReference(m_out_ref->wkt()));
std::unique_ptr<gdal::Geometry> wkt_g;
// If the user set either explicit 'polygon' or 'boundary' options
// we will filter by that geometry. The user can set a 'filter_srs'
// option to override the SRS of the input geometry and we will
// reproject to the output projection as needed.
if (m_wkt.size())
{
// Reproject the given wkt to the output SRS so
// filtering/cropping works
gdal::SpatialRef assign(m_filterSRS);
gdal::Geometry before(m_wkt, assign);
before.transform(*m_out_ref);
wkt_g.reset (new gdal::Geometry(before.wkt(), *m_out_ref));
geometry = wkt_g->get();
m_wkt = wkt_g->wkt();
OGR_L_SetSpatialFilter(m_layer, geometry);
}
if (m_attributeFilter.size())
{
OGRErr err = OGR_L_SetAttributeFilter(m_layer,
m_attributeFilter.c_str());
if (err != OGRERR_NONE)
{
std::stringstream oss;
oss << getName() << ": Unable to set attribute filter '"
<< m_attributeFilter << "' for OGR datasource '"
<< m_filename << "'";
throw pdal::pdal_error(oss.str());
}
}
Options cropOptions;
if (m_wkt.size())
cropOptions.add("polygon", m_wkt);
for (auto f : getFiles())
{
log()->get(LogLevel::Debug) << "Adding file "
<< f.m_filename
<< " to merge filter" <<std::endl;
std::string driver = m_factory.inferReaderDriver(f.m_filename);
Stage *reader = m_factory.createStage(driver);
if (!reader)
{
std::stringstream out;
out << "Unable to create reader for file '"
<< f.m_filename << "'.";
throw pdal_error(out.str());
}
Options readerOptions;
readerOptions.add("filename", f.m_filename);
reader->setOptions(readerOptions);
Stage *premerge = reader;
if (m_tgtSrsString != f.m_srs &&
(m_tgtSrsString.size() && f.m_srs.size()))
{
Stage *repro = m_factory.createStage("filters.reprojection");
repro->setInput(*reader);
Options reproOptions;
reproOptions.add("out_srs", m_tgtSrsString);
reproOptions.add("in_srs", f.m_srs);
log()->get(LogLevel::Debug2) << "Repro = "
<< m_tgtSrsString << "/"
<< f.m_srs << "!\n";
repro->setOptions(reproOptions);
premerge = repro;
}
// WKT is set even if we're using a bounding box for filtering, so
// can be used as a test here.
if (!m_wkt.empty())
{
Stage *crop = m_factory.createStage("filters.crop");
crop->setOptions(cropOptions);
crop->setInput(*premerge);
log()->get(LogLevel::Debug3) << "Cropping data with wkt '"
<< m_wkt << "'" << std::endl;
premerge = crop;
}
m_merge.setInput(*premerge);
}
if (m_sql.size())
{
// We were created with OGR_DS_ExecuteSQL which needs to have
// its layer explicitly released
OGR_DS_ReleaseResultSet(m_dataset, m_layer);
}
else
{
OGR_DS_Destroy(m_dataset);
}
m_layer = 0;
m_dataset = 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.")));
}
}
int main( int nArgc, char ** papszArgv )
{
NITFFile *psFile;
int iSegment, iFile;
char szTemp[100];
int bDisplayTRE = FALSE;
int bExtractSHP = FALSE, bExtractSHPInMem = FALSE;
if( nArgc < 2 )
{
printf( "Usage: nitfdump [-tre] [-extractshp | -extractshpinmem] <nitf_filename>*\n" );
exit( 1 );
}
for( iFile = 1; iFile < nArgc; iFile++ )
{
if ( EQUAL(papszArgv[iFile], "-tre") )
bDisplayTRE = TRUE;
else if ( EQUAL(papszArgv[iFile], "-extractshp") )
bExtractSHP = TRUE;
else if ( EQUAL(papszArgv[iFile], "-extractshpinmem") )
{
bExtractSHP = TRUE;
bExtractSHPInMem = TRUE;
}
}
/* ==================================================================== */
/* Loop over all files. */
/* ==================================================================== */
for( iFile = 1; iFile < nArgc; iFile++ )
{
int bHasFoundLocationTable = FALSE;
if ( EQUAL(papszArgv[iFile], "-tre") )
continue;
if ( EQUAL(papszArgv[iFile], "-extractshp") )
continue;
if ( EQUAL(papszArgv[iFile], "-extractshpinmem") )
continue;
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
psFile = NITFOpen( papszArgv[iFile], FALSE );
if( psFile == NULL )
exit( 2 );
printf( "Dump for %s\n", papszArgv[iFile] );
/* -------------------------------------------------------------------- */
/* Dump first TRE list. */
/* -------------------------------------------------------------------- */
if( psFile->pachTRE != NULL )
{
int nTREBytes = psFile->nTREBytes;
const char *pszTREData = psFile->pachTRE;
printf( "File TREs:" );
while( nTREBytes > 10 )
{
int nThisTRESize = atoi(NITFGetField(szTemp, pszTREData, 6, 5 ));
if (nThisTRESize < 0 || nThisTRESize > nTREBytes - 11)
{
NITFGetField(szTemp, pszTREData, 0, 6 );
printf(" Invalid size (%d) for TRE %s", nThisTRESize, szTemp);
break;
}
printf( " %6.6s(%d)", pszTREData, nThisTRESize );
pszTREData += nThisTRESize + 11;
nTREBytes -= (nThisTRESize + 11);
}
printf( "\n" );
if (bDisplayTRE)
{
nTREBytes = psFile->nTREBytes;
pszTREData = psFile->pachTRE;
while( nTREBytes > 10 )
{
char *pszEscaped;
int nThisTRESize = atoi(NITFGetField(szTemp, pszTREData, 6, 5 ));
if (nThisTRESize < 0 || nThisTRESize > nTREBytes - 11)
{
break;
}
pszEscaped = CPLEscapeString( pszTREData + 11, nThisTRESize,
CPLES_BackslashQuotable );
printf( "TRE '%6.6s' : %s\n", pszTREData, pszEscaped);
CPLFree(pszEscaped);
pszTREData += nThisTRESize + 11;
nTREBytes -= (nThisTRESize + 11);
}
}
}
/* -------------------------------------------------------------------- */
/* Dump Metadata */
/* -------------------------------------------------------------------- */
DumpMetadata( "File Metadata:", " ", psFile->papszMetadata );
/* -------------------------------------------------------------------- */
/* Dump general info about segments. */
/* -------------------------------------------------------------------- */
NITFCollectAttachments( psFile );
NITFReconcileAttachments( psFile );
for( iSegment = 0; iSegment < psFile->nSegmentCount; iSegment++ )
{
NITFSegmentInfo *psSegInfo = psFile->pasSegmentInfo + iSegment;
printf( "Segment %d (Type=%s):\n",
iSegment + 1, psSegInfo->szSegmentType );
printf( " HeaderStart=" CPL_FRMT_GUIB ", HeaderSize=%u, DataStart=" CPL_FRMT_GUIB ", DataSize=" CPL_FRMT_GUIB "\n",
psSegInfo->nSegmentHeaderStart,
psSegInfo->nSegmentHeaderSize,
psSegInfo->nSegmentStart,
psSegInfo->nSegmentSize );
printf( " DLVL=%d, ALVL=%d, LOC=C%d,R%d, CCS=C%d,R%d\n",
psSegInfo->nDLVL,
psSegInfo->nALVL,
psSegInfo->nLOC_C,
psSegInfo->nLOC_R,
psSegInfo->nCCS_C,
psSegInfo->nCCS_R );
printf( "\n" );
}
/* -------------------------------------------------------------------- */
/* Report details of images. */
/* -------------------------------------------------------------------- */
for( iSegment = 0; iSegment < psFile->nSegmentCount; iSegment++ )
{
NITFSegmentInfo *psSegInfo = psFile->pasSegmentInfo + iSegment;
NITFImage *psImage;
NITFRPC00BInfo sRPCInfo;
int iBand;
char **papszMD;
if( !EQUAL(psSegInfo->szSegmentType,"IM") )
continue;
psImage = NITFImageAccess( psFile, iSegment );
if( psImage == NULL )
{
printf( "NITFAccessImage(%d) failed!\n", iSegment );
continue;
}
printf( "Image Segment %d, %dPx%dLx%dB x %dbits:\n",
iSegment + 1, psImage->nCols, psImage->nRows,
psImage->nBands, psImage->nBitsPerSample );
printf( " PVTYPE=%s, IREP=%s, ICAT=%s, IMODE=%c, IC=%s, COMRAT=%s, ICORDS=%c\n",
psImage->szPVType, psImage->szIREP, psImage->szICAT,
psImage->chIMODE, psImage->szIC, psImage->szCOMRAT,
psImage->chICORDS );
if( psImage->chICORDS != ' ' )
{
printf( " UL=(%.15g,%.15g), UR=(%.15g,%.15g) Center=%d\n LL=(%.15g,%.15g), LR=(%.15g,%.15g)\n",
psImage->dfULX, psImage->dfULY,
psImage->dfURX, psImage->dfURY,
psImage->bIsBoxCenterOfPixel,
psImage->dfLLX, psImage->dfLLY,
psImage->dfLRX, psImage->dfLRY );
}
printf( " IDLVL=%d, IALVL=%d, ILOC R=%d,C=%d, IMAG=%s\n",
psImage->nIDLVL, psImage->nIALVL,
psImage->nILOCRow, psImage->nILOCColumn,
psImage->szIMAG );
printf( " %d x %d blocks of size %d x %d\n",
psImage->nBlocksPerRow, psImage->nBlocksPerColumn,
psImage->nBlockWidth, psImage->nBlockHeight );
if( psImage->pachTRE != NULL )
{
int nTREBytes = psImage->nTREBytes;
const char *pszTREData = psImage->pachTRE;
printf( " Image TREs:" );
while( nTREBytes > 10 )
{
int nThisTRESize = atoi(NITFGetField(szTemp, pszTREData, 6, 5 ));
if (nThisTRESize < 0 || nThisTRESize > nTREBytes - 11)
{
NITFGetField(szTemp, pszTREData, 0, 6 );
printf(" Invalid size (%d) for TRE %s", nThisTRESize, szTemp);
break;
}
printf( " %6.6s(%d)", pszTREData, nThisTRESize );
pszTREData += nThisTRESize + 11;
nTREBytes -= (nThisTRESize + 11);
}
printf( "\n" );
if (bDisplayTRE)
{
nTREBytes = psImage->nTREBytes;
pszTREData = psImage->pachTRE;
while( nTREBytes > 10 )
{
char *pszEscaped;
int nThisTRESize = atoi(NITFGetField(szTemp, pszTREData, 6, 5 ));
if (nThisTRESize < 0 || nThisTRESize > nTREBytes - 11)
{
break;
}
pszEscaped = CPLEscapeString( pszTREData + 11, nThisTRESize,
CPLES_BackslashQuotable );
printf( " TRE '%6.6s' : %s\n", pszTREData, pszEscaped);
CPLFree(pszEscaped);
pszTREData += nThisTRESize + 11;
nTREBytes -= (nThisTRESize + 11);
}
}
}
/* Report info from location table, if found. */
if( psImage->nLocCount > 0 )
{
int i;
bHasFoundLocationTable = TRUE;
printf( " Location Table\n" );
for( i = 0; i < psImage->nLocCount; i++ )
{
printf( " LocName=%s, LocId=%d, Offset=%d, Size=%d\n",
GetLocationNameFromId(psImage->pasLocations[i].nLocId),
psImage->pasLocations[i].nLocId,
psImage->pasLocations[i].nLocOffset,
psImage->pasLocations[i].nLocSize );
}
printf( "\n" );
}
if( strlen(psImage->pszComments) > 0 )
printf( " Comments:\n%s\n", psImage->pszComments );
for( iBand = 0; iBand < psImage->nBands; iBand++ )
{
NITFBandInfo *psBandInfo = psImage->pasBandInfo + iBand;
printf( " Band %d: IREPBAND=%s, ISUBCAT=%s, %d LUT entries.\n",
iBand + 1, psBandInfo->szIREPBAND, psBandInfo->szISUBCAT,
psBandInfo->nSignificantLUTEntries );
}
if( NITFReadRPC00B( psImage, &sRPCInfo ) )
{
DumpRPC( psImage, &sRPCInfo );
}
papszMD = NITFReadUSE00A( psImage );
if( papszMD != NULL )
{
DumpMetadata( " USE00A TRE:", " ", papszMD );
CSLDestroy( papszMD );
}
papszMD = NITFReadBLOCKA( psImage );
if( papszMD != NULL )
{
DumpMetadata( " BLOCKA TRE:", " ", papszMD );
CSLDestroy( papszMD );
}
papszMD = NITFReadSTDIDC( psImage );
if( papszMD != NULL )
{
DumpMetadata( " STDIDC TRE:", " ", papszMD );
CSLDestroy( papszMD );
}
DumpMetadata( " Image Metadata:", " ", psImage->papszMetadata );
printf("\n");
}
/* ==================================================================== */
/* Report details of graphic segments. */
/* ==================================================================== */
for( iSegment = 0; iSegment < psFile->nSegmentCount; iSegment++ )
{
NITFSegmentInfo *psSegInfo = psFile->pasSegmentInfo + iSegment;
char achSubheader[298];
int nSTYPEOffset;
if( !EQUAL(psSegInfo->szSegmentType,"GR")
&& !EQUAL(psSegInfo->szSegmentType,"SY") )
continue;
/* -------------------------------------------------------------------- */
/* Load the graphic subheader. */
/* -------------------------------------------------------------------- */
if( VSIFSeekL( psFile->fp, psSegInfo->nSegmentHeaderStart,
SEEK_SET ) != 0
|| VSIFReadL( achSubheader, 1, sizeof(achSubheader),
psFile->fp ) < 258 )
{
CPLError( CE_Warning, CPLE_FileIO,
"Failed to read graphic subheader at " CPL_FRMT_GUIB ".",
psSegInfo->nSegmentHeaderStart );
continue;
}
// NITF 2.0. (also works for NITF 2.1)
nSTYPEOffset = 200;
if( STARTS_WITH_CI(achSubheader+193, "999998") )
nSTYPEOffset += 40;
/* -------------------------------------------------------------------- */
/* Report some standard info. */
/* -------------------------------------------------------------------- */
printf( "Graphic Segment %d, type=%2.2s, sfmt=%c, sid=%10.10s\n",
iSegment + 1,
achSubheader + 0,
achSubheader[nSTYPEOffset],
achSubheader + 2 );
printf( " sname=%20.20s\n", achSubheader + 12 );
printf("\n");
}
/* ==================================================================== */
/* Report details of text segments. */
/* ==================================================================== */
for( iSegment = 0; iSegment < psFile->nSegmentCount; iSegment++ )
{
char *pabyHeaderData;
char *pabyTextData;
NITFSegmentInfo *psSegment = psFile->pasSegmentInfo + iSegment;
if( !EQUAL(psSegment->szSegmentType,"TX") )
continue;
printf( "Text Segment %d\n", iSegment + 1);
/* -------------------------------------------------------------------- */
/* Load the text header */
/* -------------------------------------------------------------------- */
/* Allocate one extra byte for the NULL terminating character */
pabyHeaderData = (char *) CPLCalloc(1,
(size_t) psSegment->nSegmentHeaderSize + 1);
if (VSIFSeekL(psFile->fp, psSegment->nSegmentHeaderStart,
SEEK_SET) != 0 ||
VSIFReadL(pabyHeaderData, 1, (size_t) psSegment->nSegmentHeaderSize,
psFile->fp) != psSegment->nSegmentHeaderSize)
{
CPLError( CE_Warning, CPLE_FileIO,
"Failed to read %d bytes of text header data at " CPL_FRMT_GUIB ".",
psSegment->nSegmentHeaderSize,
psSegment->nSegmentHeaderStart);
CPLFree(pabyHeaderData);
continue;
}
printf(" Header : %s\n", pabyHeaderData);
CPLFree(pabyHeaderData);
/* -------------------------------------------------------------------- */
/* Load the raw TEXT data itself. */
/* -------------------------------------------------------------------- */
/* Allocate one extra byte for the NULL terminating character */
pabyTextData = (char *) CPLCalloc(1,(size_t)psSegment->nSegmentSize+1);
if( VSIFSeekL( psFile->fp, psSegment->nSegmentStart,
SEEK_SET ) != 0
|| VSIFReadL( pabyTextData, 1, (size_t)psSegment->nSegmentSize,
psFile->fp ) != psSegment->nSegmentSize )
{
CPLError( CE_Warning, CPLE_FileIO,
"Failed to read " CPL_FRMT_GUIB " bytes of text data at " CPL_FRMT_GUIB ".",
psSegment->nSegmentSize,
psSegment->nSegmentStart );
CPLFree( pabyTextData );
continue;
}
printf(" Data : %s\n", pabyTextData);
printf("\n");
CPLFree( pabyTextData );
}
/* -------------------------------------------------------------------- */
/* Report details of DES. */
/* -------------------------------------------------------------------- */
for( iSegment = 0; iSegment < psFile->nSegmentCount; iSegment++ )
{
NITFSegmentInfo *psSegInfo = psFile->pasSegmentInfo + iSegment;
NITFDES *psDES;
int nOffset = 0;
char szTREName[7];
int nThisTRESize;
int nRPFDESOffset = -1;
if( !EQUAL(psSegInfo->szSegmentType,"DE") )
continue;
psDES = NITFDESAccess( psFile, iSegment );
if( psDES == NULL )
{
printf( "NITFDESAccess(%d) failed!\n", iSegment );
continue;
}
printf( "DE Segment %d:\n", iSegment + 1 );
printf( " Segment TREs:" );
nOffset = 0;
while (NITFDESGetTRE( psDES, nOffset, szTREName, NULL, &nThisTRESize))
{
printf( " %6.6s(%d)", szTREName, nThisTRESize );
if (strcmp(szTREName, "RPFDES") == 0)
nRPFDESOffset = nOffset + 11;
nOffset += 11 + nThisTRESize;
}
printf( "\n" );
if (bDisplayTRE)
{
char* pabyTREData = NULL;
nOffset = 0;
while (NITFDESGetTRE( psDES, nOffset, szTREName, &pabyTREData, &nThisTRESize))
{
char* pszEscaped = CPLEscapeString( pabyTREData, nThisTRESize,
CPLES_BackslashQuotable );
printf( " TRE '%6.6s' : %s\n", szTREName, pszEscaped);
CPLFree(pszEscaped);
nOffset += 11 + nThisTRESize;
NITFDESFreeTREData(pabyTREData);
}
}
/* Report info from location table, if found. */
if( !bHasFoundLocationTable && nRPFDESOffset >= 0 )
{
int i;
int nLocCount = 0;
NITFLocation* pasLocations;
VSIFSeekL(psFile->fp, psSegInfo->nSegmentStart + nRPFDESOffset, SEEK_SET);
pasLocations = NITFReadRPFLocationTable(psFile->fp, &nLocCount);
if (pasLocations)
{
printf( " Location Table\n" );
for( i = 0; i < nLocCount; i++ )
{
printf( " LocName=%s, LocId=%d, Offset=%d, Size=%d\n",
GetLocationNameFromId(pasLocations[i].nLocId),
pasLocations[i].nLocId,
pasLocations[i].nLocOffset,
pasLocations[i].nLocSize );
}
CPLFree(pasLocations);
printf( "\n" );
}
}
DumpMetadata( " DES Metadata:", " ", psDES->papszMetadata );
if ( bExtractSHP && CSLFetchNameValue(psDES->papszMetadata, "NITF_SHAPE_USE") != NULL )
{
char szFilename[32];
char szRadix[32];
if (bExtractSHPInMem)
snprintf(szRadix, sizeof(szRadix), "/vsimem/nitf_segment_%d", iSegment + 1);
else
snprintf(szRadix, sizeof(szRadix), "nitf_segment_%d", iSegment + 1);
if (NITFDESExtractShapefile(psDES, szRadix))
{
OGRDataSourceH hDS;
OGRRegisterAll();
snprintf(szFilename, sizeof(szFilename), "%s.SHP", szRadix);
hDS = OGROpen(szFilename, FALSE, NULL);
if (hDS)
{
int nGeom = 0;
OGRLayerH hLayer = OGR_DS_GetLayer(hDS, 0);
if (hLayer)
{
OGRFeatureH hFeat;
printf("\n");
while ( (hFeat = OGR_L_GetNextFeature(hLayer)) != NULL )
{
OGRGeometryH hGeom = OGR_F_GetGeometryRef(hFeat);
if (hGeom)
{
char* pszWKT = NULL;
OGR_G_ExportToWkt(hGeom, &pszWKT);
if (pszWKT)
printf(" Geometry %d : %s\n", nGeom ++, pszWKT);
CPLFree(pszWKT);
}
OGR_F_Destroy(hFeat);
}
}
OGR_DS_Destroy(hDS);
}
}
if (bExtractSHPInMem)
{
snprintf(szFilename, sizeof(szFilename), "%s.SHP", szRadix);
VSIUnlink(szFilename);
snprintf(szFilename, sizeof(szFilename), "%s.SHX", szRadix);
VSIUnlink(szFilename);
snprintf(szFilename, sizeof(szFilename), "%s.DBF", szRadix);
VSIUnlink(szFilename);
}
}
}
/* -------------------------------------------------------------------- */
/* Close. */
/* -------------------------------------------------------------------- */
NITFClose( psFile );
}
CPLFinderClean();
CPLCleanupTLS();
VSICleanupFileManager();
OGRCleanupAll();
exit( 0 );
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct _param {
struct Option *dsn, *out, *layer, *spat, *where,
*min_area;
struct Option *snap, *type, *outloc, *cnames;
} param;
struct _flag {
struct Flag *list, *tlist, *no_clean, *z, *notab,
*region;
struct Flag *over, *extend, *formats, *tolower, *no_import;
} flag;
int i, j, layer, arg_s_num, nogeom, ncnames;
float xmin, ymin, xmax, ymax;
int ncols = 0, type;
double min_area, snap;
char buf[2000], namebuf[2000], tempvect[GNAME_MAX];
char *separator;
struct Key_Value *loc_proj_info, *loc_proj_units;
struct Key_Value *proj_info, *proj_units;
struct Cell_head cellhd, loc_wind, cur_wind;
char error_msg[8192];
/* Vector */
struct Map_info Map, Tmp, *Out;
int cat;
/* Attributes */
struct field_info *Fi;
dbDriver *driver;
dbString sql, strval;
int dim, with_z;
/* OGR */
OGRDataSourceH Ogr_ds;
OGRLayerH Ogr_layer;
OGRFieldDefnH Ogr_field;
char *Ogr_fieldname;
OGRFieldType Ogr_ftype;
OGRFeatureH Ogr_feature;
OGRFeatureDefnH Ogr_featuredefn;
OGRGeometryH Ogr_geometry, Ogr_oRing, poSpatialFilter;
OGRSpatialReferenceH Ogr_projection;
OGREnvelope oExt;
OGRwkbGeometryType Ogr_geom_type;
int OFTIntegerListlength;
char *output;
char **layer_names; /* names of layers to be imported */
int *layers; /* layer indexes */
int nlayers; /* number of layers to import */
char **available_layer_names; /* names of layers to be imported */
int navailable_layers;
int layer_id;
unsigned int n_features, feature_count;
int overwrite;
double area_size;
int use_tmp_vect;
xmin = ymin = xmax = ymax = 0.0;
loc_proj_info = loc_proj_units = NULL;
Ogr_ds = Ogr_oRing = poSpatialFilter = NULL;
OFTIntegerListlength = 40; /* hack due to limitation in OGR */
area_size = 0.0;
use_tmp_vect = FALSE;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("import"));
module->description = _("Converts vector data into a GRASS vector map using OGR library.");
param.dsn = G_define_option();
param.dsn->key = "dsn";
param.dsn->type = TYPE_STRING;
param.dsn->required =YES;
param.dsn->label = _("OGR datasource name");
param.dsn->description = _("Examples:\n"
"\t\tESRI Shapefile: directory containing shapefiles\n"
"\t\tMapInfo File: directory containing mapinfo files");
param.layer = G_define_option();
param.layer->key = "layer";
param.layer->type = TYPE_STRING;
param.layer->required = NO;
param.layer->multiple = YES;
param.layer->label =
_("OGR layer name. If not given, all available layers are imported");
param.layer->description =
_("Examples:\n" "\t\tESRI Shapefile: shapefile name\n"
"\t\tMapInfo File: mapinfo file name");
param.layer->guisection = _("Selection");
param.out = G_define_standard_option(G_OPT_V_OUTPUT);
param.out->required = NO;
param.out->guisection = _("Output");
param.spat = G_define_option();
param.spat->key = "spatial";
param.spat->type = TYPE_DOUBLE;
param.spat->multiple = YES;
param.spat->required = NO;
param.spat->key_desc = "xmin,ymin,xmax,ymax";
param.spat->label = _("Import subregion only");
param.spat->guisection = _("Selection");
param.spat->description =
_("Format: xmin,ymin,xmax,ymax - usually W,S,E,N");
param.where = G_define_standard_option(G_OPT_DB_WHERE);
param.where->guisection = _("Selection");
param.min_area = G_define_option();
param.min_area->key = "min_area";
param.min_area->type = TYPE_DOUBLE;
param.min_area->required = NO;
param.min_area->answer = "0.0001";
param.min_area->label =
_("Minimum size of area to be imported (square units)");
param.min_area->guisection = _("Selection");
param.min_area->description = _("Smaller areas and "
"islands are ignored. Should be greater than snap^2");
param.type = G_define_standard_option(G_OPT_V_TYPE);
param.type->options = "point,line,boundary,centroid";
param.type->answer = "";
param.type->description = _("Optionally change default input type");
param.type->descriptions =
_("point;import area centroids as points;"
"line;import area boundaries as lines;"
"boundary;import lines as area boundaries;"
"centroid;import points as centroids");
param.type->guisection = _("Selection");
param.snap = G_define_option();
param.snap->key = "snap";
param.snap->type = TYPE_DOUBLE;
param.snap->required = NO;
param.snap->answer = "-1";
param.snap->label = _("Snapping threshold for boundaries");
param.snap->description = _("'-1' for no snap");
param.outloc = G_define_option();
param.outloc->key = "location";
param.outloc->type = TYPE_STRING;
param.outloc->required = NO;
param.outloc->description = _("Name for new location to create");
param.outloc->key_desc = "name";
param.cnames = G_define_option();
param.cnames->key = "cnames";
param.cnames->type = TYPE_STRING;
param.cnames->required = NO;
param.cnames->multiple = YES;
param.cnames->description =
_("List of column names to be used instead of original names, "
"first is used for category column");
param.cnames->guisection = _("Attributes");
flag.list = G_define_flag();
flag.list->key = 'l';
flag.list->description = _("List available OGR layers in data source and exit");
flag.list->suppress_required = YES;
flag.list->guisection = _("Print");
flag.tlist = G_define_flag();
flag.tlist->key = 'a';
flag.tlist->description = _("List available OGR layers including feature types "
"in data source and exit");
flag.tlist->suppress_required = YES;
flag.tlist->guisection = _("Print");
flag.formats = G_define_flag();
flag.formats->key = 'f';
flag.formats->description = _("List supported formats and exit");
flag.formats->suppress_required = YES;
flag.formats->guisection = _("Print");
/* if using -c, you lose topological information ! */
flag.no_clean = G_define_flag();
flag.no_clean->key = 'c';
flag.no_clean->description = _("Do not clean polygons (not recommended)");
flag.no_clean->guisection = _("Output");
flag.z = G_define_flag();
flag.z->key = 'z';
flag.z->description = _("Create 3D output");
flag.z->guisection = _("Output");
flag.notab = G_define_flag();
flag.notab->key = 't';
flag.notab->description = _("Do not create attribute table");
flag.notab->guisection = _("Attributes");
flag.over = G_define_flag();
flag.over->key = 'o';
flag.over->description =
_("Override dataset projection (use location's projection)");
flag.region = G_define_flag();
flag.region->key = 'r';
flag.region->guisection = _("Selection");
flag.region->description = _("Limit import to the current region");
flag.extend = G_define_flag();
flag.extend->key = 'e';
flag.extend->description =
_("Extend location extents based on new dataset");
flag.tolower = G_define_flag();
flag.tolower->key = 'w';
flag.tolower->description =
_("Change column names to lowercase characters");
flag.tolower->guisection = _("Attributes");
flag.no_import = G_define_flag();
flag.no_import->key = 'i';
flag.no_import->description =
_("Create the location specified by the \"location\" parameter and exit."
" Do not import the vector data.");
/* The parser checks if the map already exists in current mapset, this is
* wrong if location options is used, so we switch out the check and do it
* in the module after the parser */
overwrite = G_check_overwrite(argc, argv);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
G_begin_polygon_area_calculations(); /* Used in geom() */
OGRRegisterAll();
/* list supported formats */
if (flag.formats->answer) {
int iDriver;
G_message(_("Available OGR Drivers:"));
for (iDriver = 0; iDriver < OGRGetDriverCount(); iDriver++) {
OGRSFDriverH poDriver = OGRGetDriver(iDriver);
const char *pszRWFlag;
if (OGR_Dr_TestCapability(poDriver, ODrCCreateDataSource))
pszRWFlag = "rw";
else
pszRWFlag = "ro";
fprintf(stdout, " %s (%s): %s\n",
OGR_Dr_GetName(poDriver),
pszRWFlag, OGR_Dr_GetName(poDriver));
}
exit(EXIT_SUCCESS);
}
if (param.dsn->answer == NULL) {
G_fatal_error(_("Required parameter <%s> not set"), param.dsn->key);
}
min_area = atof(param.min_area->answer);
snap = atof(param.snap->answer);
type = Vect_option_to_types(param.type);
ncnames = 0;
if (param.cnames->answers) {
i = 0;
while (param.cnames->answers[i++]) {
ncnames++;
}
}
/* Open OGR DSN */
Ogr_ds = NULL;
if (strlen(param.dsn->answer) > 0)
Ogr_ds = OGROpen(param.dsn->answer, FALSE, NULL);
if (Ogr_ds == NULL)
G_fatal_error(_("Unable to open data source <%s>"), param.dsn->answer);
/* Make a list of available layers */
navailable_layers = OGR_DS_GetLayerCount(Ogr_ds);
available_layer_names =
(char **)G_malloc(navailable_layers * sizeof(char *));
if (flag.list->answer || flag.tlist->answer)
G_message(_("Data source <%s> (format '%s') contains %d layers:"),
param.dsn->answer,
OGR_Dr_GetName(OGR_DS_GetDriver(Ogr_ds)), navailable_layers);
for (i = 0; i < navailable_layers; i++) {
Ogr_layer = OGR_DS_GetLayer(Ogr_ds, i);
Ogr_featuredefn = OGR_L_GetLayerDefn(Ogr_layer);
Ogr_geom_type = OGR_FD_GetGeomType(Ogr_featuredefn);
available_layer_names[i] =
G_store((char *)OGR_FD_GetName(Ogr_featuredefn));
if (flag.tlist->answer)
fprintf(stdout, "%s (%s)\n", available_layer_names[i],
OGRGeometryTypeToName(Ogr_geom_type));
else if (flag.list->answer)
fprintf(stdout, "%s\n", available_layer_names[i]);
}
if (flag.list->answer || flag.tlist->answer) {
fflush(stdout);
exit(EXIT_SUCCESS);
}
/* Make a list of layers to be imported */
if (param.layer->answer) { /* From option */
nlayers = 0;
while (param.layer->answers[nlayers])
nlayers++;
layer_names = (char **)G_malloc(nlayers * sizeof(char *));
layers = (int *)G_malloc(nlayers * sizeof(int));
for (i = 0; i < nlayers; i++) {
layer_names[i] = G_store(param.layer->answers[i]);
/* Find it in the source */
layers[i] = -1;
for (j = 0; j < navailable_layers; j++) {
if (strcmp(available_layer_names[j], layer_names[i]) == 0) {
layers[i] = j;
break;
}
}
if (layers[i] == -1)
G_fatal_error(_("Layer <%s> not available"), layer_names[i]);
}
}
else { /* use list of all layers */
nlayers = navailable_layers;
layer_names = available_layer_names;
layers = (int *)G_malloc(nlayers * sizeof(int));
for (i = 0; i < nlayers; i++)
layers[i] = i;
}
if (param.out->answer) {
output = G_store(param.out->answer);
}
else {
if (nlayers < 1)
G_fatal_error(_("No OGR layers available"));
output = G_store(layer_names[0]);
G_message(_("All available OGR layers will be imported into vector map <%s>"), output);
}
if (!param.outloc->answer) { /* Check if the map exists */
if (G_find_vector2(output, G_mapset()) && !overwrite)
G_fatal_error(_("Vector map <%s> already exists"),
output);
}
/* Get first imported layer to use for extents and projection check */
Ogr_layer = OGR_DS_GetLayer(Ogr_ds, layers[0]);
if (flag.region->answer) {
if (param.spat->answer)
G_fatal_error(_("Select either the current region flag or the spatial option, not both"));
G_get_window(&cur_wind);
xmin = cur_wind.west;
xmax = cur_wind.east;
ymin = cur_wind.south;
ymax = cur_wind.north;
}
if (param.spat->answer) {
/* See as reference: gdal/ogr/ogr_capi_test.c */
/* cut out a piece of the map */
/* order: xmin,ymin,xmax,ymax */
arg_s_num = 0;
i = 0;
while (param.spat->answers[i]) {
if (i == 0)
xmin = atof(param.spat->answers[i]);
if (i == 1)
ymin = atof(param.spat->answers[i]);
if (i == 2)
xmax = atof(param.spat->answers[i]);
if (i == 3)
ymax = atof(param.spat->answers[i]);
arg_s_num++;
i++;
}
if (arg_s_num != 4)
G_fatal_error(_("4 parameters required for 'spatial' parameter"));
}
if (param.spat->answer || flag.region->answer) {
G_debug(2, "cut out with boundaries: xmin:%f ymin:%f xmax:%f ymax:%f",
xmin, ymin, xmax, ymax);
/* in theory this could be an irregular polygon */
poSpatialFilter = OGR_G_CreateGeometry(wkbPolygon);
Ogr_oRing = OGR_G_CreateGeometry(wkbLinearRing);
OGR_G_AddPoint(Ogr_oRing, xmin, ymin, 0.0);
OGR_G_AddPoint(Ogr_oRing, xmin, ymax, 0.0);
OGR_G_AddPoint(Ogr_oRing, xmax, ymax, 0.0);
OGR_G_AddPoint(Ogr_oRing, xmax, ymin, 0.0);
OGR_G_AddPoint(Ogr_oRing, xmin, ymin, 0.0);
OGR_G_AddGeometryDirectly(poSpatialFilter, Ogr_oRing);
OGR_L_SetSpatialFilter(Ogr_layer, poSpatialFilter);
}
if (param.where->answer) {
/* select by attribute */
OGR_L_SetAttributeFilter(Ogr_layer, param.where->answer);
}
/* fetch boundaries */
if ((OGR_L_GetExtent(Ogr_layer, &oExt, 1)) == OGRERR_NONE) {
G_get_window(&cellhd);
cellhd.north = oExt.MaxY;
cellhd.south = oExt.MinY;
cellhd.west = oExt.MinX;
cellhd.east = oExt.MaxX;
cellhd.rows = 20; /* TODO - calculate useful values */
cellhd.cols = 20;
cellhd.ns_res = (cellhd.north - cellhd.south) / cellhd.rows;
cellhd.ew_res = (cellhd.east - cellhd.west) / cellhd.cols;
}
else {
cellhd.north = 1.;
cellhd.south = 0.;
cellhd.west = 0.;
cellhd.east = 1.;
cellhd.top = 1.;
cellhd.bottom = 1.;
cellhd.rows = 1;
cellhd.rows3 = 1;
cellhd.cols = 1;
cellhd.cols3 = 1;
cellhd.depths = 1;
cellhd.ns_res = 1.;
cellhd.ns_res3 = 1.;
cellhd.ew_res = 1.;
cellhd.ew_res3 = 1.;
cellhd.tb_res = 1.;
}
/* suppress boundary splitting ? */
if (flag.no_clean->answer) {
split_distance = -1.;
}
else {
split_distance = 0.;
area_size =
sqrt((cellhd.east - cellhd.west) * (cellhd.north - cellhd.south));
}
/* Fetch input map projection in GRASS form. */
proj_info = NULL;
proj_units = NULL;
Ogr_projection = OGR_L_GetSpatialRef(Ogr_layer); /* should not be freed later */
/* Do we need to create a new location? */
if (param.outloc->answer != NULL) {
/* Convert projection information non-interactively as we can't
* assume the user has a terminal open */
if (GPJ_osr_to_grass(&cellhd, &proj_info,
&proj_units, Ogr_projection, 0) < 0) {
G_fatal_error(_("Unable to convert input map projection to GRASS "
"format; cannot create new location."));
}
else {
G_make_location(param.outloc->answer, &cellhd,
proj_info, proj_units, NULL);
G_message(_("Location <%s> created"), param.outloc->answer);
}
/* If the i flag is set, clean up? and exit here */
if(flag.no_import->answer)
{
exit(EXIT_SUCCESS);
}
}
else {
int err = 0;
/* Projection only required for checking so convert non-interactively */
if (GPJ_osr_to_grass(&cellhd, &proj_info,
&proj_units, Ogr_projection, 0) < 0)
G_warning(_("Unable to convert input map projection information to "
"GRASS format for checking"));
/* Does the projection of the current location match the dataset? */
/* G_get_window seems to be unreliable if the location has been changed */
G__get_window(&loc_wind, "", "DEFAULT_WIND", "PERMANENT");
/* fetch LOCATION PROJ info */
if (loc_wind.proj != PROJECTION_XY) {
loc_proj_info = G_get_projinfo();
loc_proj_units = G_get_projunits();
}
if (flag.over->answer) {
cellhd.proj = loc_wind.proj;
cellhd.zone = loc_wind.zone;
G_message(_("Over-riding projection check"));
}
else if (loc_wind.proj != cellhd.proj
|| (err =
G_compare_projections(loc_proj_info, loc_proj_units,
proj_info, proj_units)) != TRUE) {
int i_value;
strcpy(error_msg,
_("Projection of dataset does not"
" appear to match current location.\n\n"));
/* TODO: output this info sorted by key: */
if (loc_wind.proj != cellhd.proj || err != -2) {
if (loc_proj_info != NULL) {
strcat(error_msg, _("GRASS LOCATION PROJ_INFO is:\n"));
for (i_value = 0; i_value < loc_proj_info->nitems;
i_value++)
sprintf(error_msg + strlen(error_msg), "%s: %s\n",
loc_proj_info->key[i_value],
loc_proj_info->value[i_value]);
strcat(error_msg, "\n");
}
if (proj_info != NULL) {
strcat(error_msg, _("Import dataset PROJ_INFO is:\n"));
for (i_value = 0; i_value < proj_info->nitems; i_value++)
sprintf(error_msg + strlen(error_msg), "%s: %s\n",
proj_info->key[i_value],
proj_info->value[i_value]);
}
else {
strcat(error_msg, _("Import dataset PROJ_INFO is:\n"));
if (cellhd.proj == PROJECTION_XY)
sprintf(error_msg + strlen(error_msg),
"Dataset proj = %d (unreferenced/unknown)\n",
cellhd.proj);
else if (cellhd.proj == PROJECTION_LL)
sprintf(error_msg + strlen(error_msg),
"Dataset proj = %d (lat/long)\n",
cellhd.proj);
else if (cellhd.proj == PROJECTION_UTM)
sprintf(error_msg + strlen(error_msg),
"Dataset proj = %d (UTM), zone = %d\n",
cellhd.proj, cellhd.zone);
else if (cellhd.proj == PROJECTION_SP)
sprintf(error_msg + strlen(error_msg),
"Dataset proj = %d (State Plane), zone = %d\n",
cellhd.proj, cellhd.zone);
else
sprintf(error_msg + strlen(error_msg),
"Dataset proj = %d (unknown), zone = %d\n",
cellhd.proj, cellhd.zone);
}
}
else {
if (loc_proj_units != NULL) {
strcat(error_msg, "GRASS LOCATION PROJ_UNITS is:\n");
for (i_value = 0; i_value < loc_proj_units->nitems;
i_value++)
sprintf(error_msg + strlen(error_msg), "%s: %s\n",
loc_proj_units->key[i_value],
loc_proj_units->value[i_value]);
strcat(error_msg, "\n");
}
if (proj_units != NULL) {
strcat(error_msg, "Import dataset PROJ_UNITS is:\n");
for (i_value = 0; i_value < proj_units->nitems; i_value++)
sprintf(error_msg + strlen(error_msg), "%s: %s\n",
proj_units->key[i_value],
proj_units->value[i_value]);
}
}
sprintf(error_msg + strlen(error_msg),
_("\nYou can use the -o flag to %s to override this projection check.\n"),
G_program_name());
strcat(error_msg,
_("Consider generating a new location with 'location' parameter"
" from input data set.\n"));
G_fatal_error(error_msg);
}
else {
G_message(_("Projection of input dataset and current location "
"appear to match"));
}
}
db_init_string(&sql);
db_init_string(&strval);
/* open output vector */
/* strip any @mapset from vector output name */
G_find_vector(output, G_mapset());
Vect_open_new(&Map, output, flag.z->answer != 0);
Out = ⤅
n_polygon_boundaries = 0;
if (!flag.no_clean->answer) {
/* check if we need a tmp vector */
/* estimate distance for boundary splitting --> */
for (layer = 0; layer < nlayers; layer++) {
layer_id = layers[layer];
Ogr_layer = OGR_DS_GetLayer(Ogr_ds, layer_id);
Ogr_featuredefn = OGR_L_GetLayerDefn(Ogr_layer);
n_features = feature_count = 0;
n_features = OGR_L_GetFeatureCount(Ogr_layer, 1);
OGR_L_ResetReading(Ogr_layer);
/* count polygons and isles */
G_message(_("Counting polygons for %d features (OGR layer <%s>)..."),
n_features, layer_names[layer]);
while ((Ogr_feature = OGR_L_GetNextFeature(Ogr_layer)) != NULL) {
G_percent(feature_count++, n_features, 1); /* show something happens */
/* Geometry */
Ogr_geometry = OGR_F_GetGeometryRef(Ogr_feature);
if (Ogr_geometry != NULL) {
poly_count(Ogr_geometry, (type & GV_BOUNDARY));
}
OGR_F_Destroy(Ogr_feature);
}
}
G_debug(1, "n polygon boundaries: %d", n_polygon_boundaries);
if (n_polygon_boundaries > 50) {
split_distance =
area_size / log(n_polygon_boundaries);
/* divisor is the handle: increase divisor to decrease split_distance */
split_distance = split_distance / 5.;
G_debug(1, "root of area size: %f", area_size);
G_verbose_message(_("Boundary splitting distance in map units: %G"),
split_distance);
}
/* <-- estimate distance for boundary splitting */
use_tmp_vect = n_polygon_boundaries > 0;
if (use_tmp_vect) {
/* open temporary vector, do the work in the temporary vector
* at the end copy alive lines to output vector
* in case of polygons this reduces the coor file size by a factor of 2 to 5
* only needed when cleaning polygons */
sprintf(tempvect, "%s_tmp", output);
G_verbose_message(_("Using temporary vector <%s>"), tempvect);
Vect_open_new(&Tmp, tempvect, flag.z->answer != 0);
Out = &Tmp;
}
}
Vect_hist_command(&Map);
/* Points and lines are written immediately with categories. Boundaries of polygons are
* written to the vector then cleaned and centroids are calculated for all areas in cleaan vector.
* Then second pass through finds all centroids in each polygon feature and adds its category
* to the centroid. The result is that one centroids may have 0, 1 ore more categories
* of one ore more (more input layers) fields. */
with_z = 0;
for (layer = 0; layer < nlayers; layer++) {
layer_id = layers[layer];
Ogr_layer = OGR_DS_GetLayer(Ogr_ds, layer_id);
Ogr_featuredefn = OGR_L_GetLayerDefn(Ogr_layer);
/* Add DB link */
if (!flag.notab->answer) {
char *cat_col_name = GV_KEY_COLUMN;
if (nlayers == 1) { /* one layer only */
Fi = Vect_default_field_info(&Map, layer + 1, NULL,
GV_1TABLE);
}
else {
Fi = Vect_default_field_info(&Map, layer + 1, NULL,
GV_MTABLE);
}
if (ncnames > 0) {
cat_col_name = param.cnames->answers[0];
}
Vect_map_add_dblink(&Map, layer + 1, layer_names[layer], Fi->table,
cat_col_name, Fi->database, Fi->driver);
ncols = OGR_FD_GetFieldCount(Ogr_featuredefn);
G_debug(2, "%d columns", ncols);
/* Create table */
sprintf(buf, "create table %s (%s integer", Fi->table,
cat_col_name);
db_set_string(&sql, buf);
for (i = 0; i < ncols; i++) {
Ogr_field = OGR_FD_GetFieldDefn(Ogr_featuredefn, i);
Ogr_ftype = OGR_Fld_GetType(Ogr_field);
G_debug(3, "Ogr_ftype: %i", Ogr_ftype); /* look up below */
if (i < ncnames - 1) {
Ogr_fieldname = G_store(param.cnames->answers[i + 1]);
}
else {
/* Change column names to [A-Za-z][A-Za-z0-9_]* */
Ogr_fieldname = G_store(OGR_Fld_GetNameRef(Ogr_field));
G_debug(3, "Ogr_fieldname: '%s'", Ogr_fieldname);
G_str_to_sql(Ogr_fieldname);
G_debug(3, "Ogr_fieldname: '%s'", Ogr_fieldname);
}
/* avoid that we get the 'cat' column twice */
if (strcmp(Ogr_fieldname, GV_KEY_COLUMN) == 0) {
sprintf(namebuf, "%s_", Ogr_fieldname);
Ogr_fieldname = G_store(namebuf);
}
/* captial column names are a pain in SQL */
if (flag.tolower->answer)
G_str_to_lower(Ogr_fieldname);
if (strcmp(OGR_Fld_GetNameRef(Ogr_field), Ogr_fieldname) != 0) {
G_warning(_("Column name changed: '%s' -> '%s'"),
OGR_Fld_GetNameRef(Ogr_field), Ogr_fieldname);
}
/** Simple 32bit integer OFTInteger = 0 **/
/** List of 32bit integers OFTIntegerList = 1 **/
/** Double Precision floating point OFTReal = 2 **/
/** List of doubles OFTRealList = 3 **/
/** String of ASCII chars OFTString = 4 **/
/** Array of strings OFTStringList = 5 **/
/** Double byte string (unsupported) OFTWideString = 6 **/
/** List of wide strings (unsupported) OFTWideStringList = 7 **/
/** Raw Binary data (unsupported) OFTBinary = 8 **/
/** OFTDate = 9 **/
/** OFTTime = 10 **/
/** OFTDateTime = 11 **/
if (Ogr_ftype == OFTInteger) {
sprintf(buf, ", %s integer", Ogr_fieldname);
}
else if (Ogr_ftype == OFTIntegerList) {
/* hack: treat as string */
sprintf(buf, ", %s varchar ( %d )", Ogr_fieldname,
OFTIntegerListlength);
G_warning(_("Writing column <%s> with fixed length %d chars (may be truncated)"),
Ogr_fieldname, OFTIntegerListlength);
}
else if (Ogr_ftype == OFTReal) {
sprintf(buf, ", %s double precision", Ogr_fieldname);
#if GDAL_VERSION_NUM >= 1320
}
else if (Ogr_ftype == OFTDate) {
sprintf(buf, ", %s date", Ogr_fieldname);
}
else if (Ogr_ftype == OFTTime) {
sprintf(buf, ", %s time", Ogr_fieldname);
}
else if (Ogr_ftype == OFTDateTime) {
sprintf(buf, ", %s datetime", Ogr_fieldname);
#endif
}
else if (Ogr_ftype == OFTString) {
int fwidth;
fwidth = OGR_Fld_GetWidth(Ogr_field);
/* TODO: read all records first and find the longest string length */
if (fwidth == 0) {
G_warning(_("Width for column %s set to 255 (was not specified by OGR), "
"some strings may be truncated!"),
Ogr_fieldname);
fwidth = 255;
}
sprintf(buf, ", %s varchar ( %d )", Ogr_fieldname,
fwidth);
}
else if (Ogr_ftype == OFTStringList) {
/* hack: treat as string */
sprintf(buf, ", %s varchar ( %d )", Ogr_fieldname,
OFTIntegerListlength);
G_warning(_("Writing column %s with fixed length %d chars (may be truncated)"),
Ogr_fieldname, OFTIntegerListlength);
}
else {
G_warning(_("Column type not supported (%s)"),
Ogr_fieldname);
buf[0] = 0;
}
db_append_string(&sql, buf);
G_free(Ogr_fieldname);
}
db_append_string(&sql, ")");
G_debug(3, db_get_string(&sql));
driver =
db_start_driver_open_database(Fi->driver,
Vect_subst_var(Fi->database,
&Map));
if (driver == NULL) {
G_fatal_error(_("Unable open database <%s> by driver <%s>"),
Vect_subst_var(Fi->database, &Map), Fi->driver);
}
if (db_execute_immediate(driver, &sql) != DB_OK) {
db_close_database(driver);
db_shutdown_driver(driver);
G_fatal_error(_("Unable to create table: '%s'"),
db_get_string(&sql));
}
if (db_create_index2(driver, Fi->table, cat_col_name) != DB_OK)
G_warning(_("Unable to create index for table <%s>, key <%s>"),
Fi->table, cat_col_name);
if (db_grant_on_table
(driver, Fi->table, DB_PRIV_SELECT,
DB_GROUP | DB_PUBLIC) != DB_OK)
G_fatal_error(_("Unable to grant privileges on table <%s>"),
Fi->table);
db_begin_transaction(driver);
}
/* Import feature */
cat = 1;
nogeom = 0;
OGR_L_ResetReading(Ogr_layer);
n_features = feature_count = 0;
n_features = OGR_L_GetFeatureCount(Ogr_layer, 1);
G_important_message(_("Importing %d features (OGR layer <%s>)..."),
n_features, layer_names[layer]);
while ((Ogr_feature = OGR_L_GetNextFeature(Ogr_layer)) != NULL) {
G_percent(feature_count++, n_features, 1); /* show something happens */
/* Geometry */
Ogr_geometry = OGR_F_GetGeometryRef(Ogr_feature);
if (Ogr_geometry == NULL) {
nogeom++;
}
else {
dim = OGR_G_GetCoordinateDimension(Ogr_geometry);
if (dim > 2)
with_z = 1;
geom(Ogr_geometry, Out, layer + 1, cat, min_area, type,
flag.no_clean->answer);
}
/* Attributes */
if (!flag.notab->answer) {
sprintf(buf, "insert into %s values ( %d", Fi->table, cat);
db_set_string(&sql, buf);
for (i = 0; i < ncols; i++) {
Ogr_field = OGR_FD_GetFieldDefn(Ogr_featuredefn, i);
Ogr_ftype = OGR_Fld_GetType(Ogr_field);
if (OGR_F_IsFieldSet(Ogr_feature, i)) {
if (Ogr_ftype == OFTInteger || Ogr_ftype == OFTReal) {
sprintf(buf, ", %s",
OGR_F_GetFieldAsString(Ogr_feature, i));
#if GDAL_VERSION_NUM >= 1320
/* should we use OGR_F_GetFieldAsDateTime() here ? */
}
else if (Ogr_ftype == OFTDate || Ogr_ftype == OFTTime
|| Ogr_ftype == OFTDateTime) {
char *newbuf;
db_set_string(&strval, (char *)
OGR_F_GetFieldAsString(Ogr_feature,
i));
db_double_quote_string(&strval);
sprintf(buf, ", '%s'", db_get_string(&strval));
newbuf = G_str_replace(buf, "/", "-"); /* fix 2001/10/21 to 2001-10-21 */
sprintf(buf, "%s", newbuf);
#endif
}
else if (Ogr_ftype == OFTString ||
Ogr_ftype == OFTIntegerList) {
db_set_string(&strval, (char *)
OGR_F_GetFieldAsString(Ogr_feature,
i));
db_double_quote_string(&strval);
sprintf(buf, ", '%s'", db_get_string(&strval));
}
}
else {
/* G_warning (_("Column value not set" )); */
if (Ogr_ftype == OFTInteger || Ogr_ftype == OFTReal) {
sprintf(buf, ", NULL");
#if GDAL_VERSION_NUM >= 1320
}
else if (Ogr_ftype == OFTString ||
Ogr_ftype == OFTIntegerList ||
Ogr_ftype == OFTDate) {
#else
}
else if (Ogr_ftype == OFTString ||
Ogr_ftype == OFTIntegerList) {
#endif
sprintf(buf, ", ''");
}
}
db_append_string(&sql, buf);
}
db_append_string(&sql, " )");
G_debug(3, db_get_string(&sql));
if (db_execute_immediate(driver, &sql) != DB_OK) {
db_close_database(driver);
db_shutdown_driver(driver);
G_fatal_error(_("Cannot insert new row: %s"),
db_get_string(&sql));
}
}
OGR_F_Destroy(Ogr_feature);
cat++;
}
G_percent(1, 1, 1); /* finish it */
if (!flag.notab->answer) {
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
}
if (nogeom > 0)
G_warning(_("%d %s without geometry"), nogeom,
nogeom == 1 ? "feature" : "features");
}
separator = "-----------------------------------------------------";
G_message("%s", separator);
if (use_tmp_vect) {
/* TODO: is it necessary to build here? probably not, consumes time */
/* GV_BUILD_BASE is sufficient to toggle boundary cleaning */
Vect_build_partial(&Tmp, GV_BUILD_BASE);
}
if (use_tmp_vect && !flag.no_clean->answer &&
Vect_get_num_primitives(Out, GV_BOUNDARY) > 0) {
int ret, centr, ncentr, otype, n_overlaps, n_nocat;
CENTR *Centr;
struct spatial_index si;
double x, y, total_area, overlap_area, nocat_area;
struct bound_box box;
struct line_pnts *Points;
int nmodif;
Points = Vect_new_line_struct();
G_message("%s", separator);
G_warning(_("Cleaning polygons, result is not guaranteed!"));
if (snap >= 0) {
G_message("%s", separator);
G_message(_("Snapping boundaries (threshold = %.3e)..."), snap);
Vect_snap_lines(&Tmp, GV_BOUNDARY, snap, NULL);
}
/* It is not to clean to snap centroids, but I have seen data with 2 duplicate polygons
* (as far as decimal places were printed) and centroids were not identical */
/* Disabled, because overlapping polygons result in many duplicate centroids anyway */
/*
fprintf ( stderr, separator );
fprintf ( stderr, "Snap centroids (threshold 0.000001):\n" );
Vect_snap_lines ( &Map, GV_CENTROID, 0.000001, NULL, stderr );
*/
G_message("%s", separator);
G_message(_("Breaking polygons..."));
Vect_break_polygons(&Tmp, GV_BOUNDARY, NULL);
/* It is important to remove also duplicate centroids in case of duplicate input polygons */
G_message("%s", separator);
G_message(_("Removing duplicates..."));
Vect_remove_duplicates(&Tmp, GV_BOUNDARY | GV_CENTROID, NULL);
/* in non-pathological cases, the bulk of the cleaning is now done */
/* Vect_clean_small_angles_at_nodes() can change the geometry so that new intersections
* are created. We must call Vect_break_lines(), Vect_remove_duplicates()
* and Vect_clean_small_angles_at_nodes() until no more small angles are found */
do {
G_message("%s", separator);
G_message(_("Breaking boundaries..."));
Vect_break_lines(&Tmp, GV_BOUNDARY, NULL);
G_message("%s", separator);
G_message(_("Removing duplicates..."));
Vect_remove_duplicates(&Tmp, GV_BOUNDARY, NULL);
G_message("%s", separator);
G_message(_("Cleaning boundaries at nodes..."));
nmodif =
Vect_clean_small_angles_at_nodes(&Tmp, GV_BOUNDARY, NULL);
} while (nmodif > 0);
/* merge boundaries */
G_message("%s", separator);
G_message(_("Merging boundaries..."));
Vect_merge_lines(&Tmp, GV_BOUNDARY, NULL, NULL);
G_message("%s", separator);
if (type & GV_BOUNDARY) { /* that means lines were converted to boundaries */
G_message(_("Changing boundary dangles to lines..."));
Vect_chtype_dangles(&Tmp, -1.0, NULL);
}
else {
G_message(_("Removing dangles..."));
Vect_remove_dangles(&Tmp, GV_BOUNDARY, -1.0, NULL);
}
G_message("%s", separator);
if (type & GV_BOUNDARY) {
G_message(_("Changing boundary bridges to lines..."));
Vect_chtype_bridges(&Tmp, NULL);
}
else {
G_message(_("Removing bridges..."));
Vect_remove_bridges(&Tmp, NULL);
}
/* Boundaries are hopefully clean, build areas */
G_message("%s", separator);
Vect_build_partial(&Tmp, GV_BUILD_ATTACH_ISLES);
/* Calculate new centroids for all areas, centroids have the same id as area */
ncentr = Vect_get_num_areas(&Tmp);
G_debug(3, "%d centroids/areas", ncentr);
Centr = (CENTR *) G_calloc(ncentr + 1, sizeof(CENTR));
Vect_spatial_index_init(&si, 0);
for (centr = 1; centr <= ncentr; centr++) {
Centr[centr].valid = 0;
Centr[centr].cats = Vect_new_cats_struct();
ret = Vect_get_point_in_area(&Tmp, centr, &x, &y);
if (ret < 0) {
G_warning(_("Unable to calculate area centroid"));
continue;
}
Centr[centr].x = x;
Centr[centr].y = y;
Centr[centr].valid = 1;
box.N = box.S = y;
box.E = box.W = x;
box.T = box.B = 0;
Vect_spatial_index_add_item(&si, centr, &box);
}
/* Go through all layers and find centroids for each polygon */
for (layer = 0; layer < nlayers; layer++) {
G_message("%s", separator);
G_message(_("Finding centroids for OGR layer <%s>..."), layer_names[layer]);
layer_id = layers[layer];
Ogr_layer = OGR_DS_GetLayer(Ogr_ds, layer_id);
n_features = OGR_L_GetFeatureCount(Ogr_layer, 1);
OGR_L_ResetReading(Ogr_layer);
cat = 0; /* field = layer + 1 */
G_percent(cat, n_features, 2);
while ((Ogr_feature = OGR_L_GetNextFeature(Ogr_layer)) != NULL) {
cat++;
G_percent(cat, n_features, 2);
/* Geometry */
Ogr_geometry = OGR_F_GetGeometryRef(Ogr_feature);
if (Ogr_geometry != NULL) {
centroid(Ogr_geometry, Centr, &si, layer + 1, cat,
min_area, type);
}
OGR_F_Destroy(Ogr_feature);
}
}
/* Write centroids */
G_message("%s", separator);
G_message(_("Writing centroids..."));
n_overlaps = n_nocat = 0;
total_area = overlap_area = nocat_area = 0.0;
for (centr = 1; centr <= ncentr; centr++) {
double area;
G_percent(centr, ncentr, 2);
area = Vect_get_area_area(&Tmp, centr);
total_area += area;
if (!(Centr[centr].valid)) {
continue;
}
if (Centr[centr].cats->n_cats == 0) {
nocat_area += area;
n_nocat++;
continue;
}
if (Centr[centr].cats->n_cats > 1) {
Vect_cat_set(Centr[centr].cats, nlayers + 1,
Centr[centr].cats->n_cats);
overlap_area += area;
n_overlaps++;
}
Vect_reset_line(Points);
Vect_append_point(Points, Centr[centr].x, Centr[centr].y, 0.0);
if (type & GV_POINT)
otype = GV_POINT;
else
otype = GV_CENTROID;
Vect_write_line(&Tmp, otype, Points, Centr[centr].cats);
}
if (Centr)
G_free(Centr);
Vect_spatial_index_destroy(&si);
if (n_overlaps > 0) {
G_warning(_("%d areas represent more (overlapping) features, because polygons overlap "
"in input layer(s). Such areas are linked to more than 1 row in attribute table. "
"The number of features for those areas is stored as category in layer %d"),
n_overlaps, nlayers + 1);
}
G_message("%s", separator);
Vect_hist_write(&Map, separator);
Vect_hist_write(&Map, "\n");
sprintf(buf, _("%d input polygons\n"), n_polygons);
G_message(_("%d input polygons"), n_polygons);
Vect_hist_write(&Map, buf);
sprintf(buf, _("Total area: %G (%d areas)\n"), total_area, ncentr);
G_message(_("Total area: %G (%d areas)"), total_area, ncentr);
Vect_hist_write(&Map, buf);
sprintf(buf, _("Overlapping area: %G (%d areas)\n"), overlap_area,
n_overlaps);
G_message(_("Overlapping area: %G (%d areas)"), overlap_area,
n_overlaps);
Vect_hist_write(&Map, buf);
sprintf(buf, _("Area without category: %G (%d areas)\n"), nocat_area,
n_nocat);
G_message(_("Area without category: %G (%d areas)"), nocat_area,
n_nocat);
Vect_hist_write(&Map, buf);
G_message("%s", separator);
}
/* needed?
* OGR_DS_Destroy( Ogr_ds );
*/
if (use_tmp_vect) {
/* Copy temporary vector to output vector */
Vect_copy_map_lines(&Tmp, &Map);
/* release memory occupied by topo, we may need that memory for main output */
Vect_set_release_support(&Tmp);
Vect_close(&Tmp);
Vect_delete(tempvect);
}
Vect_build(&Map);
Vect_close(&Map);
/* -------------------------------------------------------------------- */
/* Extend current window based on dataset. */
/* -------------------------------------------------------------------- */
if (flag.extend->answer) {
G_get_default_window(&loc_wind);
loc_wind.north = MAX(loc_wind.north, cellhd.north);
loc_wind.south = MIN(loc_wind.south, cellhd.south);
loc_wind.west = MIN(loc_wind.west, cellhd.west);
loc_wind.east = MAX(loc_wind.east, cellhd.east);
loc_wind.rows = (int)ceil((loc_wind.north - loc_wind.south)
/ loc_wind.ns_res);
loc_wind.south = loc_wind.north - loc_wind.rows * loc_wind.ns_res;
loc_wind.cols = (int)ceil((loc_wind.east - loc_wind.west)
/ loc_wind.ew_res);
loc_wind.east = loc_wind.west + loc_wind.cols * loc_wind.ew_res;
G__put_window(&loc_wind, "../PERMANENT", "DEFAULT_WIND");
}
if (with_z && !flag.z->answer)
G_warning(_("Input data contains 3D features. Created vector is 2D only, "
"use -z flag to import 3D vector."));
exit(EXIT_SUCCESS);
}
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;
}
void doTif2Con(char fileName[], int headerFormat, int BandNumber, char separator, char SHPMaskFile[])
{
bool flMask = false;
OGRDataSourceH poDS = NULL;
OGRSFDriverH poDriver = NULL;
if(strlen(SHPMaskFile)>0)
{
flMask = true;
poDS = OGROpen(SHPMaskFile, FALSE, &poDriver);
}
if(flMask && (poDS == NULL))
{
fputs("\nError open mask file!!!\n\n", stderr);
return ;
}
GDALDatasetH pDataset;
GDALRasterBandH pBand;
pDataset = GDALOpen( fileName, GA_ReadOnly );
if(pDataset!=NULL)
{
int bands = 0;
if(0 == BandNumber) bands = GDALGetRasterCount( pDataset );
else bands = 1;
int cols = GDALGetRasterXSize(pDataset);
int rows = GDALGetRasterYSize(pDataset);
double adfGeoTransform[6];
float xOrigin = 0;
float yOrigin = 0;
float pixelWidth = 0;
float pixelHeight = 0;
if( GDALGetGeoTransform( pDataset, adfGeoTransform ) == CE_None )
{
xOrigin = adfGeoTransform[0];
yOrigin = adfGeoTransform[3];
pixelWidth = adfGeoTransform[1];
pixelHeight = adfGeoTransform[5];
}
float *** pdata = NULL;
pdata = new float**[bands];
for(int i=0; i<bands; i++) pdata[i] = new float*[rows];
for(int i=0; i<bands; i++) for(int j=0; j<rows; j++) pdata[i][j] = new float[cols];
for(int i=0; i<bands; i++) for(int j=0; j<rows; j++) for(int k=0; k<cols; k++) pdata[i][j][k] = 0;
void *pbuf = NULL;
pBand = GDALGetRasterBand(pDataset, 1);
pbuf = CUtils::mallocData(pBand, pbuf, cols);
printHeader(headerFormat, BandNumber, bands, rows, cols, separator);
if(0 == BandNumber)
{
for(int i=1; i<=bands; i++)
{
pBand = GDALGetRasterBand(pDataset, i);
for(int j=0; j<rows; j++)
{
CUtils::getRasterLine(pBand, j, cols, pbuf);
for(int k=0; k<cols; k++) pdata[i-1][j][k] = CUtils::getDataAsFloat(pBand, pbuf, k);
}
}
}
else
{
pBand = GDALGetRasterBand(pDataset, BandNumber);
for(int j=0; j<rows; j++)
{
CUtils::getRasterLine(pBand, j, cols, pbuf);
for(int k=0; k<cols; k++) pdata[0][j][k] = CUtils::getDataAsFloat(pBand, pbuf, k);
}
}
CPLFree(pbuf);
GDALClose(pDataset);
printData((const float ***) pdata, headerFormat, bands, rows, cols,
xOrigin, yOrigin, pixelWidth, pixelHeight, separator, poDS);
if(poDS != NULL) OGR_DS_Destroy(poDS);
for(int i=0; i<bands; i++) for(int j=0; j<rows; j++) delete [] pdata[i][j];
for(int i=0; i<bands; i++) delete [] pdata[i];
delete [] pdata;
pdata = NULL;
fputs("\nProcessing COMPLETE.\n\n", stderr);
}
else
fputs("\nError open input image!!!\n\n", stderr);
}
CPLErr RasterliteDataset::CreateOverviewLevel(int nOvrFactor,
GDALProgressFunc pfnProgress,
void * pProgressData)
{
double dfXResolution = padfXResolutions[0] * nOvrFactor;
double dfYResolution = padfXResolutions[0] * nOvrFactor;
CPLString osSQL;
int nBlockXSize = 256;
int nBlockYSize = 256;
int nOvrXSize = nRasterXSize / nOvrFactor;
int nOvrYSize = nRasterYSize / nOvrFactor;
if (nOvrXSize == 0 || nOvrYSize == 0)
return CE_Failure;
int nXBlocks = (nOvrXSize + nBlockXSize - 1) / nBlockXSize;
int nYBlocks = (nOvrYSize + nBlockYSize - 1) / nBlockYSize;
const char* pszDriverName = "GTiff";
GDALDriverH hTileDriver = GDALGetDriverByName(pszDriverName);
if (hTileDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load GDAL %s driver", pszDriverName);
return CE_Failure;
}
GDALDriverH hMemDriver = GDALGetDriverByName("MEM");
if (hMemDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load GDAL MEM driver");
return CE_Failure;
}
GDALDataType eDataType = GetRasterBand(1)->GetRasterDataType();
int nDataTypeSize = GDALGetDataTypeSize(eDataType) / 8;
GByte* pabyMEMDSBuffer =
(GByte*)VSIMalloc3(nBlockXSize, nBlockYSize, nBands * nDataTypeSize);
if (pabyMEMDSBuffer == NULL)
{
return CE_Failure;
}
char** papszTileDriverOptions = NULL;
CPLString osTempFileName;
osTempFileName.Printf("/vsimem/%p", hDS);
int nTileId = 0;
int nBlocks = 0;
int nTotalBlocks = nXBlocks * nYBlocks;
CPLString osRasterLayer;
osRasterLayer.Printf("%s_rasters", osTableName.c_str());
CPLString osMetatadataLayer;
osMetatadataLayer.Printf("%s_metadata", osTableName.c_str());
OGRLayerH hRasterLayer = OGR_DS_GetLayerByName(hDS, osRasterLayer.c_str());
OGRLayerH hMetadataLayer = OGR_DS_GetLayerByName(hDS, osMetatadataLayer.c_str());
CPLString osSourceName = "unknown";
osSQL.Printf("SELECT source_name FROM \"%s\" WHERE "
"pixel_x_size >= %.15f AND pixel_x_size <= %.15f AND "
"pixel_y_size >= %.15f AND pixel_y_size <= %.15f LIMIT 1",
osMetatadataLayer.c_str(),
padfXResolutions[0] - 1e-15, padfXResolutions[0] + 1e-15,
padfYResolutions[0] - 1e-15, padfYResolutions[0] + 1e-15);
OGRLayerH hSQLLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
if (hSQLLyr)
{
OGRFeatureH hFeat = OGR_L_GetNextFeature(hSQLLyr);
if (hFeat)
{
const char* pszVal = OGR_F_GetFieldAsString(hFeat, 0);
if (pszVal)
osSourceName = pszVal;
OGR_F_Destroy(hFeat);
}
OGR_DS_ReleaseResultSet(hDS, hSQLLyr);
}
/* -------------------------------------------------------------------- */
/* Compute up to which existing overview level we can use for */
/* computing the requested overview */
/* -------------------------------------------------------------------- */
int iLev;
nLimitOvrCount = 0;
for(iLev=1;iLev<nResolutions;iLev++)
{
if (!(padfXResolutions[iLev] < dfXResolution - 1e-10 &&
padfYResolutions[iLev] < dfYResolution - 1e-10))
{
break;
}
nLimitOvrCount++;
}
/* -------------------------------------------------------------------- */
/* Iterate over blocks to add data into raster and metadata tables */
/* -------------------------------------------------------------------- */
OGR_DS_ExecuteSQL(hDS, "BEGIN", NULL, NULL);
CPLErr eErr = CE_None;
int nBlockXOff, nBlockYOff;
for(nBlockYOff=0;eErr == CE_None && nBlockYOff<nYBlocks;nBlockYOff++)
{
for(nBlockXOff=0;eErr == CE_None && nBlockXOff<nXBlocks;nBlockXOff++)
{
/* -------------------------------------------------------------------- */
/* Create in-memory tile */
/* -------------------------------------------------------------------- */
int nReqXSize = nBlockXSize, nReqYSize = nBlockYSize;
if ((nBlockXOff+1) * nBlockXSize > nOvrXSize)
nReqXSize = nOvrXSize - nBlockXOff * nBlockXSize;
if ((nBlockYOff+1) * nBlockYSize > nOvrYSize)
nReqYSize = nOvrYSize - nBlockYOff * nBlockYSize;
eErr = RasterIO(GF_Read,
nBlockXOff * nBlockXSize * nOvrFactor,
nBlockYOff * nBlockYSize * nOvrFactor,
nReqXSize * nOvrFactor, nReqYSize * nOvrFactor,
pabyMEMDSBuffer, nReqXSize, nReqYSize,
eDataType, nBands, NULL,
0, 0, 0);
if (eErr != CE_None)
{
break;
}
GDALDatasetH hMemDS = GDALCreate(hMemDriver, "MEM:::",
nReqXSize, nReqYSize, 0,
eDataType, NULL);
if (hMemDS == NULL)
{
eErr = CE_Failure;
break;
}
int iBand;
for(iBand = 0; iBand < nBands; iBand ++)
{
char** papszOptions = NULL;
char szTmp[64];
memset(szTmp, 0, sizeof(szTmp));
CPLPrintPointer(szTmp,
pabyMEMDSBuffer + iBand * nDataTypeSize *
nReqXSize * nReqYSize, sizeof(szTmp));
papszOptions = CSLSetNameValue(papszOptions, "DATAPOINTER", szTmp);
GDALAddBand(hMemDS, eDataType, papszOptions);
CSLDestroy(papszOptions);
}
GDALDatasetH hOutDS = GDALCreateCopy(hTileDriver,
osTempFileName.c_str(), hMemDS, FALSE,
papszTileDriverOptions, NULL, NULL);
GDALClose(hMemDS);
if (hOutDS)
GDALClose(hOutDS);
else
{
eErr = CE_Failure;
break;
}
/* -------------------------------------------------------------------- */
/* Insert new entry into raster table */
/* -------------------------------------------------------------------- */
vsi_l_offset nDataLength;
GByte *pabyData = VSIGetMemFileBuffer( osTempFileName.c_str(),
&nDataLength, FALSE);
OGRFeatureH hFeat = OGR_F_Create( OGR_L_GetLayerDefn(hRasterLayer) );
OGR_F_SetFieldBinary(hFeat, 0, (int)nDataLength, pabyData);
OGR_L_CreateFeature(hRasterLayer, hFeat);
/* Query raster ID to set it as the ID of the associated metadata */
int nRasterID = (int)OGR_F_GetFID(hFeat);
OGR_F_Destroy(hFeat);
VSIUnlink(osTempFileName.c_str());
/* -------------------------------------------------------------------- */
/* Insert new entry into metadata table */
/* -------------------------------------------------------------------- */
hFeat = OGR_F_Create( OGR_L_GetLayerDefn(hMetadataLayer) );
OGR_F_SetFID(hFeat, nRasterID);
OGR_F_SetFieldString(hFeat, 0, osSourceName);
OGR_F_SetFieldInteger(hFeat, 1, nTileId ++);
OGR_F_SetFieldInteger(hFeat, 2, nReqXSize);
OGR_F_SetFieldInteger(hFeat, 3, nReqYSize);
OGR_F_SetFieldDouble(hFeat, 4, dfXResolution);
OGR_F_SetFieldDouble(hFeat, 5, dfYResolution);
double minx, maxx, maxy, miny;
minx = adfGeoTransform[0] +
(nBlockXSize * nBlockXOff) * dfXResolution;
maxx = adfGeoTransform[0] +
(nBlockXSize * nBlockXOff + nReqXSize) * dfXResolution;
maxy = adfGeoTransform[3] +
(nBlockYSize * nBlockYOff) * (-dfYResolution);
miny = adfGeoTransform[3] +
(nBlockYSize * nBlockYOff + nReqYSize) * (-dfYResolution);
OGRGeometryH hRectangle = OGR_G_CreateGeometry(wkbPolygon);
OGRGeometryH hLinearRing = OGR_G_CreateGeometry(wkbLinearRing);
OGR_G_AddPoint_2D(hLinearRing, minx, miny);
OGR_G_AddPoint_2D(hLinearRing, minx, maxy);
OGR_G_AddPoint_2D(hLinearRing, maxx, maxy);
OGR_G_AddPoint_2D(hLinearRing, maxx, miny);
OGR_G_AddPoint_2D(hLinearRing, minx, miny);
OGR_G_AddGeometryDirectly(hRectangle, hLinearRing);
OGR_F_SetGeometryDirectly(hFeat, hRectangle);
OGR_L_CreateFeature(hMetadataLayer, hFeat);
OGR_F_Destroy(hFeat);
nBlocks++;
if (pfnProgress && !pfnProgress(1.0 * nBlocks / nTotalBlocks,
NULL, pProgressData))
eErr = CE_Failure;
}
}
nLimitOvrCount = -1;
if (eErr == CE_None)
OGR_DS_ExecuteSQL(hDS, "COMMIT", NULL, NULL);
else
OGR_DS_ExecuteSQL(hDS, "ROLLBACK", NULL, NULL);
VSIFree(pabyMEMDSBuffer);
/* -------------------------------------------------------------------- */
/* Update raster_pyramids table */
/* -------------------------------------------------------------------- */
if (eErr == CE_None)
{
OGRLayerH hRasterPyramidsLyr = OGR_DS_GetLayerByName(hDS, "raster_pyramids");
if (hRasterPyramidsLyr == NULL)
{
osSQL.Printf ("CREATE TABLE raster_pyramids ("
"table_prefix TEXT NOT NULL,"
"pixel_x_size DOUBLE NOT NULL,"
"pixel_y_size DOUBLE NOT NULL,"
"tile_count INTEGER NOT NULL)");
OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
/* Re-open the DB to take into account the new tables*/
OGRReleaseDataSource(hDS);
CPLString osOldVal = CPLGetConfigOption("SQLITE_LIST_ALL_TABLES", "FALSE");
CPLSetThreadLocalConfigOption("SQLITE_LIST_ALL_TABLES", "TRUE");
hDS = OGROpen(osFileName.c_str(), TRUE, NULL);
CPLSetThreadLocalConfigOption("SQLITE_LIST_ALL_TABLES", osOldVal.c_str());
}
/* Insert base resolution into raster_pyramids if not already done */
int bHasBaseResolution = FALSE;
osSQL.Printf("SELECT * FROM raster_pyramids WHERE "
"table_prefix = '%s' AND pixel_x_size >= %.15f AND pixel_x_size <= %.15f AND "
"pixel_y_size >= %.15f AND pixel_y_size <= %.15f",
osTableName.c_str(),
padfXResolutions[0] - 1e-15, padfXResolutions[0] + 1e-15,
padfYResolutions[0] - 1e-15, padfYResolutions[0] + 1e-15);
hSQLLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
if (hSQLLyr)
{
OGRFeatureH hFeat = OGR_L_GetNextFeature(hSQLLyr);
if (hFeat)
{
bHasBaseResolution = TRUE;
OGR_F_Destroy(hFeat);
}
OGR_DS_ReleaseResultSet(hDS, hSQLLyr);
}
if (!bHasBaseResolution)
{
osSQL.Printf("SELECT COUNT(*) FROM \"%s\" WHERE "
"pixel_x_size >= %.15f AND pixel_x_size <= %.15f AND "
"pixel_y_size >= %.15f AND pixel_y_size <= %.15f",
osMetatadataLayer.c_str(),
padfXResolutions[0] - 1e-15, padfXResolutions[0] + 1e-15,
padfYResolutions[0] - 1e-15, padfYResolutions[0] + 1e-15);
int nBlocksMainRes = 0;
hSQLLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
if (hSQLLyr)
{
OGRFeatureH hFeat = OGR_L_GetNextFeature(hSQLLyr);
if (hFeat)
{
nBlocksMainRes = OGR_F_GetFieldAsInteger(hFeat, 0);
OGR_F_Destroy(hFeat);
}
OGR_DS_ReleaseResultSet(hDS, hSQLLyr);
}
osSQL.Printf("INSERT INTO raster_pyramids "
"( table_prefix, pixel_x_size, pixel_y_size, tile_count ) "
"VALUES ( '%s', %.18f, %.18f, %d )",
osTableName.c_str(), padfXResolutions[0], padfYResolutions[0],
nBlocksMainRes);
OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
}
osSQL.Printf("INSERT INTO raster_pyramids "
"( table_prefix, pixel_x_size, pixel_y_size, tile_count ) "
"VALUES ( '%s', %.18f, %.18f, %d )",
osTableName.c_str(), dfXResolution, dfYResolution,
nTotalBlocks);
OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
}
return eErr;
}
