int main(int argc, char **argv)
{
// Get data from ogr
OGRRegisterAll();
std::cout << "Opening: " << argv[1] << std::endl;
OGRDataSource *shp = OGRSFDriverRegistrar::Open(argv[1], FALSE);
IsValid(shp, "Error opening file.");
std::cout << "Shape contains " << shp->GetLayerCount() << " layers." << std::endl;
OGRLayer *layer = shp->GetLayerByName(argv[2]);
IsValid(layer, "Couldn't grab layer");
OGRSpatialReference *srcSRS = NULL;
srcSRS = layer->GetSpatialRef();
// Set up writing
const char *kDriverName = "ESRI Shapefile";
OGRSFDriver *shpDriver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(kDriverName);
IsValid(shpDriver, "Couldn't grab the shapefile driver.");
IsValid(argv[3], "Please provide a output shp.");
std::cout << "Writing to: " << argv[3] << std::endl;
OGRDataSource *shpOut = shpDriver->CreateDataSource(argv[3], NULL);
IsValid(shpOut, "Couldn't open output file");
OGRLayer *outLayer = shpOut->CreateLayer(layer->GetName(), srcSRS, wkbMultiLineString, NULL);
IsValid(outLayer, "Couldn't create an output layer");
// copy over the fields from the source file
OGRFeatureDefn *source = layer->GetLayerDefn();
for(int i=0; i < source->GetFieldCount(); i++){
OGRFieldDefn *field = source->GetFieldDefn(i);
if(outLayer->CreateField(field) != OGRERR_NONE) {
std::cout << "Couldn't make layer" << std::endl; exit(1);
};
}
// Loop through features and grab the hull and put it into CGAL then
// skeletonize the points
OGRFeature *feature;
int count = 0;
while((feature = layer->GetNextFeature()) != NULL)
{
OGRMultiPolygon *geometry = dynamic_cast<OGRMultiPolygon *>(OGRGeometryFactory::forceToMultiPolygon(feature->GetGeometryRef()));
IsValid(geometry, "No geometry.");
OGRFeature *outFeature = OGRFeature::CreateFeature(outLayer->GetLayerDefn());
IsValid(outFeature, "Couldn't make a feature.");
for(int i=0; i < source->GetFieldCount(); i++){
OGRField *field = feature->GetRawFieldRef(i);
outFeature->SetField(i, field);
}
OGRGeometry* line = NULL;
for(int i=0; i < geometry->getNumGeometries(); i++){
OGRGeometry* segment = BuildMultiLine(geometry->getGeometryRef(i));
if(segment != NULL){
if(line == NULL) { line = new OGRLineString; }
OGRGeometry* tmp = line->Union(segment);
if(tmp != NULL){
delete line;
line = tmp;
}
delete segment;
}
}
outFeature->SetGeometry(line);
if(outLayer->CreateFeature(outFeature) != OGRERR_NONE){
std::cout << "Couldn't create feature." << std::endl;
exit(1);
}
// clean up
OGRFeature::DestroyFeature(outFeature);
std::cout << std::endl << ++count << std::endl;
}
// cleanup
OGRDataSource::DestroyDataSource(shp);
OGRDataSource::DestroyDataSource(shpOut);
return 0;
}
bool V2vProj::Compute(const data::VectorBarral * barrel)
{
OGRDataSource * poSourceDs = VectorOpen(barrel->GetSrcDataSource().c_str(),
GA_ReadOnly);
ON_SCOPE_EXIT([&]() {OGRDataSource::DestroyDataSource(poSourceDs); });
OGRDataSource * poOutputDs = VectorOpen(barrel->GetDstDataSource().c_str(),
GA_Update);
ON_SCOPE_EXIT([&]() {OGRDataSource::DestroyDataSource(poOutputDs); });
OGRLayer * poSrcLayer = poSourceDs->GetLayerByName(
barrel->GetSrcLayer().c_str());
OGRLayer * poDstLayer = poOutputDs->GetLayerByName(
barrel->GetDstLayer().c_str());
OGRSpatialReference * poSourceSRS = poSrcLayer->GetSpatialRef();
OGRCoordinateTransformation * poCT = poCT = OGRCreateCoordinateTransformation(
poSourceSRS, m_ogrSr);
OGRFeatureDefn * poDstFeatureDefn = poDstLayer->GetLayerDefn();
auto features = barrel->GetFeatures();
std::for_each(begin(features), end(features)
, [&](int fid) {
poSrcLayer->GetFeature(fid);
OGRFeature * poDstFeature = OGRFeature::CreateFeature(poDstFeatureDefn);
ON_SCOPE_EXIT([&]() {OGRFeature::DestroyFeature(poDstFeature); });
poDstFeature->SetFrom(poSrcLayer->GetFeature(fid));
OGRGeometry * poDstGeometry = poDstFeature->GetGeometryRef();
OGRGeometry * poReprojectedGeom = OGRGeometryFactory::transformWithOptions(
poDstGeometry, poCT, NULL);
poDstFeature->SetGeometryDirectly(poReprojectedGeom);
poDstLayer->CreateFeature(poDstFeature);
});
return true;
}
void OGRDataSourceWithTransaction::RemapLayers()
{
std::set<OGRLayerWithTransaction*>::iterator oIter = m_oSetLayers.begin();
for(; oIter != m_oSetLayers.end(); ++oIter )
{
OGRLayerWithTransaction* poWrappedLayer = *oIter;
if( m_poBaseDataSource == NULL )
poWrappedLayer->m_poDecoratedLayer = NULL;
else
{
poWrappedLayer->m_poDecoratedLayer =
m_poBaseDataSource->GetLayerByName(poWrappedLayer->GetName());
}
}
m_oMapLayers.clear();
}
void MSN_Helper::LoadSamples(Config &config, Matrix &mat)
{
if(config.bShapefile)
{
OGRRegisterAll();
string pLayerName = StringGetFileName(config.sSamples);
OGRDataSource* poDS = OGRSFDriverRegistrar::Open(config.sSamples.c_str(),FALSE);
OGRLayer* poLayer = poDS->GetLayerByName(pLayerName.c_str());
config.nSamples = poLayer->GetFeatureCount();
mat.Resize(config.nSamples, 4);
OGRPoint *poPoint;
OGRFeature * pFeature =poLayer->GetNextFeature();
for(unsigned long i=1; i<=config.nSamples; i++)
{
//样本取值字段名为value，double型
poPoint = (OGRPoint *)pFeature->GetGeometryRef();
mat[i][1] = poPoint->getX();
mat[i][2] = poPoint->getY();
mat[i][3] = pFeature->GetFieldAsInteger("stratum");
mat[i][4] = pFeature->GetFieldAsDouble("value");
pFeature = poLayer->GetNextFeature();
}
OGRDataSource::DestroyDataSource( poDS );
}
else
{
double x, y, v, stratum;
string sline;
ifstream infile(config.sSamples.c_str());
infile >> config.nSamples;
mat.Resize(config.nSamples, 4);
for(unsigned long i=1; i<=config.nSamples; i++)
{
infile >> x >> y >> stratum >> v;
mat[i][1] = x;
mat[i][2] = y;
mat[i][3] = stratum;
mat[i][4] = v;
}
infile.close();
}
}
JNIEXPORT jlong JNICALL Java_es_gva_cit_jogr_OGRDataSource_getLayerByNameNat
(JNIEnv *env, jobject obj, jlong cPtr, jstring name){
OGRDataSource *ds = (OGRDataSource *) 0 ;
const char *layername;
OGRLayer *layer;
long ptro_layer=-1;
ds = *(OGRDataSource **)&cPtr;
layername = env->GetStringUTFChars( name, 0 );
if(ds!=NULL){
layer=ds->GetLayerByName(layername);
if(layer!=NULL)ptro_layer = (long)&(*layer);
}
env->ReleaseStringUTFChars( name, layername );
return (jlong)ptro_layer;
}
MyOGRHandler(const std::string& filename) :
m_data_source(NULL),
m_layer_point(NULL),
m_filter(true),
m_tohstore() {
OGRRegisterAll();
OGRSFDriver* driver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName("PostgreSQL");
if (driver == NULL) {
std::cerr << "PostgreSQL OGR driver not available.\n";
exit(1);
}
// using COPY is much faster than INSERT
CPLSetConfigOption("PG_USE_COPY", "YES");
const char* options[] = { NULL };
m_data_source = driver->CreateDataSource(filename.c_str(), const_cast<char**>(options));
if (m_data_source == NULL) {
std::cerr << "Database open failed.\n";
exit(1);
}
// OGR can't create a table with hstore column, so we do it ourselves here
OGRLayer* dummy = m_data_source->ExecuteSQL("CREATE TABLE nodes (id VARCHAR, tags hstore);", NULL, NULL);
if (dummy) {
m_data_source->ReleaseResultSet(dummy);
}
dummy = m_data_source->ExecuteSQL("SELECT AddGeometryColumn('nodes', 'geom', 4326, 'POINT', 2);", NULL, NULL);
if (dummy) {
m_data_source->ReleaseResultSet(dummy);
}
m_layer_point = m_data_source->GetLayerByName("nodes");
if (!m_layer_point) {
std::cerr << "Something went wrong setting up the 'nodes' layer.\n";
exit(1);
}
// using transactions makes this much faster than without
m_layer_point->StartTransaction();
m_filter.add(false, "created_by");
m_filter.add(false, "odbl");
}
OGRLayer *OGRDataSourceWithTransaction::GetLayerByName(const char *pszName)
{
if( !m_poBaseDataSource ) return NULL;
return WrapLayer(m_poBaseDataSource->GetLayerByName(pszName));
}
OGRLayer * OGRDataSource::ExecuteSQL( const char *pszStatement,
OGRGeometry *poSpatialFilter,
const char *pszDialect )
{
const char *pszError;
swq_select *psSelectInfo = NULL;
(void) pszDialect;
/* -------------------------------------------------------------------- */
/* Handle CREATE INDEX statements specially. */
/* -------------------------------------------------------------------- */
if( EQUALN(pszStatement,"CREATE INDEX",12) )
{
ProcessSQLCreateIndex( pszStatement );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Handle DROP INDEX statements specially. */
/* -------------------------------------------------------------------- */
if( EQUALN(pszStatement,"DROP INDEX",10) )
{
ProcessSQLDropIndex( pszStatement );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Preparse the SQL statement. */
/* -------------------------------------------------------------------- */
pszError = swq_select_preparse( pszStatement, &psSelectInfo );
if( pszError != NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"SQL: %s", pszError );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Validate that all the source tables are recognised, count */
/* fields. */
/* -------------------------------------------------------------------- */
int nFieldCount = 0, iTable;
for( iTable = 0; iTable < psSelectInfo->table_count; iTable++ )
{
swq_table_def *psTableDef = psSelectInfo->table_defs + iTable;
OGRLayer *poSrcLayer;
OGRDataSource *poTableDS = this;
if( psTableDef->data_source != NULL )
{
poTableDS = (OGRDataSource *)
OGROpenShared( psTableDef->data_source, FALSE, NULL );
if( poTableDS == NULL )
{
if( strlen(CPLGetLastErrorMsg()) == 0 )
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to open secondary datasource\n"
"`%s' required by JOIN.",
psTableDef->data_source );
swq_select_free( psSelectInfo );
return NULL;
}
// This drops explicit reference, but leave it open for use by
// code in ogr_gensql.cpp
poTableDS->Dereference();
}
poSrcLayer = poTableDS->GetLayerByName( psTableDef->table_name );
if( poSrcLayer == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"SELECT from table %s failed, no such table/featureclass.",
psTableDef->table_name );
swq_select_free( psSelectInfo );
return NULL;
}
nFieldCount += poSrcLayer->GetLayerDefn()->GetFieldCount();
}
/* -------------------------------------------------------------------- */
/* Build the field list for all indicated tables. */
/* -------------------------------------------------------------------- */
swq_field_list sFieldList;
int nFIDIndex = 0;
memset( &sFieldList, 0, sizeof(sFieldList) );
sFieldList.table_count = psSelectInfo->table_count;
sFieldList.table_defs = psSelectInfo->table_defs;
sFieldList.count = 0;
sFieldList.names = (char **) CPLMalloc( sizeof(char *) * (nFieldCount+1) );
sFieldList.types = (swq_field_type *)
CPLMalloc( sizeof(swq_field_type) * (nFieldCount+1) );
sFieldList.table_ids = (int *)
CPLMalloc( sizeof(int) * (nFieldCount+1) );
sFieldList.ids = (int *)
CPLMalloc( sizeof(int) * (nFieldCount+1) );
for( iTable = 0; iTable < psSelectInfo->table_count; iTable++ )
{
swq_table_def *psTableDef = psSelectInfo->table_defs + iTable;
OGRDataSource *poTableDS = this;
OGRLayer *poSrcLayer;
int iField;
if( psTableDef->data_source != NULL )
{
poTableDS = (OGRDataSource *)
OGROpenShared( psTableDef->data_source, FALSE, NULL );
CPLAssert( poTableDS != NULL );
poTableDS->Dereference();
}
poSrcLayer = poTableDS->GetLayerByName( psTableDef->table_name );
for( iField = 0;
iField < poSrcLayer->GetLayerDefn()->GetFieldCount();
iField++ )
{
OGRFieldDefn *poFDefn=poSrcLayer->GetLayerDefn()->GetFieldDefn(iField);
int iOutField = sFieldList.count++;
sFieldList.names[iOutField] = (char *) poFDefn->GetNameRef();
if( poFDefn->GetType() == OFTInteger )
sFieldList.types[iOutField] = SWQ_INTEGER;
else if( poFDefn->GetType() == OFTReal )
sFieldList.types[iOutField] = SWQ_FLOAT;
else if( poFDefn->GetType() == OFTString )
sFieldList.types[iOutField] = SWQ_STRING;
else
sFieldList.types[iOutField] = SWQ_OTHER;
sFieldList.table_ids[iOutField] = iTable;
sFieldList.ids[iOutField] = iField;
}
if( iTable == 0 )
nFIDIndex = poSrcLayer->GetLayerDefn()->GetFieldCount();
}
/* -------------------------------------------------------------------- */
/* Expand '*' in 'SELECT *' now before we add the pseudo field */
/* 'FID'. */
/* -------------------------------------------------------------------- */
pszError =
swq_select_expand_wildcard( psSelectInfo, &sFieldList );
if( pszError != NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"SQL: %s", pszError );
return NULL;
}
sFieldList.names[sFieldList.count] = "FID";
sFieldList.types[sFieldList.count] = SWQ_INTEGER;
sFieldList.table_ids[sFieldList.count] = 0;
sFieldList.ids[sFieldList.count] = nFIDIndex;
sFieldList.count++;
/* -------------------------------------------------------------------- */
/* Finish the parse operation. */
/* -------------------------------------------------------------------- */
pszError = swq_select_parse( psSelectInfo, &sFieldList, 0 );
CPLFree( sFieldList.names );
CPLFree( sFieldList.types );
CPLFree( sFieldList.table_ids );
CPLFree( sFieldList.ids );
if( pszError != NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"SQL: %s", pszError );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Everything seems OK, try to instantiate a results layer. */
/* -------------------------------------------------------------------- */
OGRGenSQLResultsLayer *poResults;
poResults = new OGRGenSQLResultsLayer( this, psSelectInfo,
poSpatialFilter );
// Eventually, we should keep track of layers to cleanup.
return poResults;
}
OGRLayer * OGRSQLiteExecuteSQL( OGRDataSource* poDS,
const char *pszStatement,
OGRGeometry *poSpatialFilter,
const char *pszDialect )
{
char* pszTmpDBName = (char*) CPLMalloc(256);
sprintf(pszTmpDBName, "/vsimem/ogr2sqlite/temp_%p.db", pszTmpDBName);
OGRSQLiteDataSource* poSQLiteDS = NULL;
int nRet;
int bSpatialiteDB = FALSE;
CPLString osOldVal;
const char* pszOldVal = CPLGetConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", NULL);
if( pszOldVal != NULL )
{
osOldVal = pszOldVal;
pszOldVal = osOldVal.c_str();
}
/* -------------------------------------------------------------------- */
/* Create in-memory sqlite/spatialite DB */
/* -------------------------------------------------------------------- */
#ifdef HAVE_SPATIALITE
/* -------------------------------------------------------------------- */
/* Creating an empty spatialite DB (with spatial_ref_sys populated */
/* has a non-neglectable cost. So at the first attempt, let's make */
/* one and cache it for later use. */
/* -------------------------------------------------------------------- */
#if 1
static vsi_l_offset nEmptyDBSize = 0;
static GByte* pabyEmptyDB = NULL;
{
static void* hMutex = NULL;
CPLMutexHolder oMutexHolder(&hMutex);
static int bTried = FALSE;
if( !bTried &&
CSLTestBoolean(CPLGetConfigOption("OGR_SQLITE_DIALECT_USE_SPATIALITE", "YES")) )
{
bTried = TRUE;
char* pszCachedFilename = (char*) CPLMalloc(256);
sprintf(pszCachedFilename, "/vsimem/ogr2sqlite/reference_%p.db",pszCachedFilename);
char** papszOptions = CSLAddString(NULL, "SPATIALITE=YES");
OGRSQLiteDataSource* poCachedDS = new OGRSQLiteDataSource();
nRet = poCachedDS->Create( pszCachedFilename, papszOptions );
CSLDestroy(papszOptions);
papszOptions = NULL;
delete poCachedDS;
if( nRet )
/* Note: the reference file keeps the ownership of the data, so that */
/* it gets released with VSICleanupFileManager() */
pabyEmptyDB = VSIGetMemFileBuffer( pszCachedFilename, &nEmptyDBSize, FALSE );
CPLFree( pszCachedFilename );
}
}
/* The following configuration option is usefull mostly for debugging/testing */
if( pabyEmptyDB != NULL && CSLTestBoolean(CPLGetConfigOption("OGR_SQLITE_DIALECT_USE_SPATIALITE", "YES")) )
{
GByte* pabyEmptyDBClone = (GByte*)VSIMalloc(nEmptyDBSize);
if( pabyEmptyDBClone == NULL )
{
CPLFree(pszTmpDBName);
return NULL;
}
memcpy(pabyEmptyDBClone, pabyEmptyDB, nEmptyDBSize);
VSIFCloseL(VSIFileFromMemBuffer( pszTmpDBName, pabyEmptyDBClone, nEmptyDBSize, TRUE ));
poSQLiteDS = new OGRSQLiteDataSource();
CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", "NO");
nRet = poSQLiteDS->Open( pszTmpDBName, TRUE );
CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", pszOldVal);
if( !nRet )
{
/* should not happen really ! */
delete poSQLiteDS;
VSIUnlink(pszTmpDBName);
CPLFree(pszTmpDBName);
return NULL;
}
bSpatialiteDB = TRUE;
}
#else
/* No caching version */
poSQLiteDS = new OGRSQLiteDataSource();
char** papszOptions = CSLAddString(NULL, "SPATIALITE=YES");
CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", "NO");
nRet = poSQLiteDS->Create( pszTmpDBName, papszOptions );
CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", pszOldVal);
CSLDestroy(papszOptions);
papszOptions = NULL;
if( nRet )
{
bSpatialiteDB = TRUE;
}
#endif
else
{
delete poSQLiteDS;
poSQLiteDS = NULL;
#else // HAVE_SPATIALITE
if( TRUE )
{
#endif // HAVE_SPATIALITE
poSQLiteDS = new OGRSQLiteDataSource();
CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", "NO");
nRet = poSQLiteDS->Create( pszTmpDBName, NULL );
CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", pszOldVal);
if( !nRet )
{
delete poSQLiteDS;
VSIUnlink(pszTmpDBName);
CPLFree(pszTmpDBName);
return NULL;
}
}
/* -------------------------------------------------------------------- */
/* Attach the Virtual Table OGR2SQLITE module to it. */
/* -------------------------------------------------------------------- */
OGR2SQLITEModule* poModule = OGR2SQLITE_Setup(poDS, poSQLiteDS);
sqlite3* hDB = poSQLiteDS->GetDB();
/* -------------------------------------------------------------------- */
/* Analysze the statement to determine which tables will be used. */
/* -------------------------------------------------------------------- */
std::set<LayerDesc> oSetLayers;
std::set<CPLString> oSetSpatialIndex;
CPLString osModifiedSQL;
OGR2SQLITEGetPotentialLayerNames(pszStatement, oSetLayers,
oSetSpatialIndex, osModifiedSQL);
std::set<LayerDesc>::iterator oIter = oSetLayers.begin();
if( strcmp(pszStatement, osModifiedSQL.c_str()) != 0 )
CPLDebug("OGR", "Modified SQL: %s", osModifiedSQL.c_str());
pszStatement = osModifiedSQL.c_str(); /* do not use it anymore */
int bFoundOGRStyle = ( osModifiedSQL.ifind("OGR_STYLE") != std::string::npos );
/* -------------------------------------------------------------------- */
/* For each of those tables, create a Virtual Table. */
/* -------------------------------------------------------------------- */
for(; oIter != oSetLayers.end(); ++oIter)
{
const LayerDesc& oLayerDesc = *oIter;
/*CPLDebug("OGR", "Layer desc : %s, %s, %s, %s",
oLayerDesc.osOriginalStr.c_str(),
oLayerDesc.osSubstitutedName.c_str(),
oLayerDesc.osDSName.c_str(),
oLayerDesc.osLayerName.c_str());*/
CPLString osSQL;
OGRLayer* poLayer = NULL;
CPLString osTableName;
int nExtraDS;
if( oLayerDesc.osDSName.size() == 0 )
{
poLayer = poDS->GetLayerByName(oLayerDesc.osLayerName);
/* Might be a false positive (unlikely) */
if( poLayer == NULL )
continue;
osTableName = oLayerDesc.osLayerName;
nExtraDS = -1;
osSQL.Printf("CREATE VIRTUAL TABLE \"%s\" USING VirtualOGR(%d,'%s',%d)",
OGRSQLiteEscapeName(osTableName).c_str(),
nExtraDS,
OGRSQLiteEscape(osTableName).c_str(),
bFoundOGRStyle);
}
else
{
OGRDataSource* poOtherDS = (OGRDataSource* )
OGROpen(oLayerDesc.osDSName, FALSE, NULL);
if( poOtherDS == NULL )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot open datasource '%s'",
oLayerDesc.osDSName.c_str() );
delete poSQLiteDS;
VSIUnlink(pszTmpDBName);
CPLFree(pszTmpDBName);
return NULL;
}
poLayer = poOtherDS->GetLayerByName(oLayerDesc.osLayerName);
if( poLayer == NULL )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot find layer '%s' in '%s'",
oLayerDesc.osLayerName.c_str(),
oLayerDesc.osDSName.c_str() );
delete poOtherDS;
delete poSQLiteDS;
VSIUnlink(pszTmpDBName);
CPLFree(pszTmpDBName);
return NULL;
}
osTableName = oLayerDesc.osSubstitutedName;
nExtraDS = OGR2SQLITE_AddExtraDS(poModule, poOtherDS);
osSQL.Printf("CREATE VIRTUAL TABLE \"%s\" USING VirtualOGR(%d,'%s',%d)",
OGRSQLiteEscapeName(osTableName).c_str(),
nExtraDS,
OGRSQLiteEscape(oLayerDesc.osLayerName).c_str(),
bFoundOGRStyle);
}
char* pszErrMsg = NULL;
int rc = sqlite3_exec( hDB, osSQL.c_str(),
NULL, NULL, &pszErrMsg );
if( rc != SQLITE_OK )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot create virtual table for layer '%s' : %s",
osTableName.c_str(), pszErrMsg);
sqlite3_free(pszErrMsg);
continue;
}
if( poLayer->GetGeomType() == wkbNone )
continue;
CPLString osGeomColRaw(OGR2SQLITE_GetNameForGeometryColumn(poLayer));
const char* pszGeomColRaw = osGeomColRaw.c_str();
CPLString osGeomColEscaped(OGRSQLiteEscape(pszGeomColRaw));
const char* pszGeomColEscaped = osGeomColEscaped.c_str();
CPLString osLayerNameEscaped(OGRSQLiteEscape(osTableName));
const char* pszLayerNameEscaped = osLayerNameEscaped.c_str();
CPLString osIdxNameRaw(CPLSPrintf("idx_%s_%s",
oLayerDesc.osLayerName.c_str(), pszGeomColRaw));
CPLString osIdxNameEscaped(OGRSQLiteEscapeName(osIdxNameRaw));
/* Make sure that the SRS is injected in spatial_ref_sys */
OGRSpatialReference* poSRS = poLayer->GetSpatialRef();
int nSRSId = poSQLiteDS->GetUndefinedSRID();
if( poSRS != NULL )
nSRSId = poSQLiteDS->FetchSRSId(poSRS);
int bCreateSpatialIndex = FALSE;
if( !bSpatialiteDB )
{
osSQL.Printf("INSERT INTO geometry_columns (f_table_name, "
"f_geometry_column, geometry_format, geometry_type, "
"coord_dimension, srid) "
"VALUES ('%s','%s','SpatiaLite',%d,%d,%d)",
pszLayerNameEscaped,
pszGeomColEscaped,
(int) wkbFlatten(poLayer->GetGeomType()),
( poLayer->GetGeomType() & wkb25DBit ) ? 3 : 2,
nSRSId);
}
#ifdef HAVE_SPATIALITE
else
{
/* We detect the need for creating a spatial index by 2 means : */
/* 1) if there's an explicit reference to a 'idx_layername_geometrycolumn' */
/* table in the SQL --> old/traditionnal way of requesting spatial indices */
/* with spatialite. */
std::set<LayerDesc>::iterator oIter2 = oSetLayers.begin();
for(; oIter2 != oSetLayers.end(); ++oIter2)
{
const LayerDesc& oLayerDescIter = *oIter2;
if( EQUAL(oLayerDescIter.osLayerName, osIdxNameRaw) )
{
bCreateSpatialIndex = TRUE;
break;
}
}
/* 2) or if there's a SELECT FROM SpatialIndex WHERE f_table_name = 'layername' */
if( !bCreateSpatialIndex )
{
std::set<CPLString>::iterator oIter3 = oSetSpatialIndex.begin();
for(; oIter3 != oSetSpatialIndex.end(); ++oIter3)
{
const CPLString& osNameIter = *oIter3;
if( EQUAL(osNameIter, oLayerDesc.osLayerName) )
{
bCreateSpatialIndex = TRUE;
break;
}
}
}
if( poSQLiteDS->HasSpatialite4Layout() )
{
int nGeomType = poLayer->GetGeomType();
int nCoordDimension = 2;
if( nGeomType & wkb25DBit )
{
nGeomType += 1000;
nCoordDimension = 3;
}
osSQL.Printf("INSERT INTO geometry_columns (f_table_name, "
"f_geometry_column, geometry_type, coord_dimension, "
"srid, spatial_index_enabled) "
"VALUES ('%s',Lower('%s'),%d ,%d ,%d, %d)",
pszLayerNameEscaped,
pszGeomColEscaped, nGeomType,
nCoordDimension,
nSRSId, bCreateSpatialIndex );
}
else
{
const char *pszGeometryType = OGRToOGCGeomType(poLayer->GetGeomType());
if (pszGeometryType[0] == '\0')
pszGeometryType = "GEOMETRY";
osSQL.Printf("INSERT INTO geometry_columns (f_table_name, "
"f_geometry_column, type, coord_dimension, "
"srid, spatial_index_enabled) "
"VALUES ('%s','%s','%s','%s',%d, %d)",
pszLayerNameEscaped,
pszGeomColEscaped, pszGeometryType,
( poLayer->GetGeomType() & wkb25DBit ) ? "XYZ" : "XY",
nSRSId, bCreateSpatialIndex );
}
}
#endif // HAVE_SPATIALITE
sqlite3_exec( hDB, osSQL.c_str(), NULL, NULL, NULL );
#ifdef HAVE_SPATIALITE
/* -------------------------------------------------------------------- */
/* Should we create a spatial index ?. */
/* -------------------------------------------------------------------- */
if( !bSpatialiteDB || !bCreateSpatialIndex )
continue;
CPLDebug("SQLITE", "Create spatial index %s", osIdxNameRaw.c_str());
/* ENABLE_VIRTUAL_OGR_SPATIAL_INDEX is not defined */
#ifdef ENABLE_VIRTUAL_OGR_SPATIAL_INDEX
osSQL.Printf("CREATE VIRTUAL TABLE \"%s\" USING "
"VirtualOGRSpatialIndex(%d, '%s', pkid, xmin, xmax, ymin, ymax)",
osIdxNameEscaped.c_str(),
nExtraDS,
OGRSQLiteEscape(oLayerDesc.osLayerName).c_str());
rc = sqlite3_exec( hDB, osSQL.c_str(), NULL, NULL, NULL );
if( rc != SQLITE_OK )
{
CPLDebug("SQLITE",
"Error occured during spatial index creation : %s",
sqlite3_errmsg(hDB));
}
#else // ENABLE_VIRTUAL_OGR_SPATIAL_INDEX
rc = sqlite3_exec( hDB, "BEGIN", NULL, NULL, NULL );
osSQL.Printf("CREATE VIRTUAL TABLE \"%s\" "
"USING rtree(pkid, xmin, xmax, ymin, ymax)",
osIdxNameEscaped.c_str());
if( rc == SQLITE_OK )
rc = sqlite3_exec( hDB, osSQL.c_str(), NULL, NULL, NULL );
sqlite3_stmt *hStmt = NULL;
if( rc == SQLITE_OK )
{
const char* pszInsertInto = CPLSPrintf(
"INSERT INTO \"%s\" (pkid, xmin, xmax, ymin, ymax) "
"VALUES (?,?,?,?,?)", osIdxNameEscaped.c_str());
rc = sqlite3_prepare(hDB, pszInsertInto, -1, &hStmt, NULL);
}
OGRFeature* poFeature;
OGREnvelope sEnvelope;
OGR2SQLITE_IgnoreAllFieldsExceptGeometry(poLayer);
poLayer->ResetReading();
while( rc == SQLITE_OK &&
(poFeature = poLayer->GetNextFeature()) != NULL )
{
OGRGeometry* poGeom = poFeature->GetGeometryRef();
if( poGeom != NULL && !poGeom->IsEmpty() )
{
poGeom->getEnvelope(&sEnvelope);
sqlite3_bind_int64(hStmt, 1,
(sqlite3_int64) poFeature->GetFID() );
sqlite3_bind_double(hStmt, 2, sEnvelope.MinX);
sqlite3_bind_double(hStmt, 3, sEnvelope.MaxX);
sqlite3_bind_double(hStmt, 4, sEnvelope.MinY);
sqlite3_bind_double(hStmt, 5, sEnvelope.MaxY);
rc = sqlite3_step(hStmt);
if( rc == SQLITE_OK || rc == SQLITE_DONE )
rc = sqlite3_reset(hStmt);
}
delete poFeature;
}
poLayer->SetIgnoredFields(NULL);
sqlite3_finalize(hStmt);
if( rc == SQLITE_OK )
rc = sqlite3_exec( hDB, "COMMIT", NULL, NULL, NULL );
else
{
CPLDebug("SQLITE",
"Error occured during spatial index creation : %s",
sqlite3_errmsg(hDB));
rc = sqlite3_exec( hDB, "ROLLBACK", NULL, NULL, NULL );
}
#endif // ENABLE_VIRTUAL_OGR_SPATIAL_INDEX
#endif // HAVE_SPATIALITE
}
/* -------------------------------------------------------------------- */
/* Reload, so that virtual tables are recognized */
/* -------------------------------------------------------------------- */
poSQLiteDS->ReloadLayers();
/* -------------------------------------------------------------------- */
/* Prepare the statement. */
/* -------------------------------------------------------------------- */
/* This will speed-up layer creation */
/* ORDER BY are costly to evaluate and are not necessary to establish */
/* the layer definition. */
int bUseStatementForGetNextFeature = TRUE;
int bEmptyLayer = FALSE;
sqlite3_stmt *hSQLStmt = NULL;
int rc = sqlite3_prepare( hDB,
pszStatement, strlen(pszStatement),
&hSQLStmt, NULL );
if( rc != SQLITE_OK )
{
CPLError( CE_Failure, CPLE_AppDefined,
"In ExecuteSQL(): sqlite3_prepare(%s):\n %s",
pszStatement, sqlite3_errmsg(hDB) );
if( hSQLStmt != NULL )
{
sqlite3_finalize( hSQLStmt );
}
delete poSQLiteDS;
VSIUnlink(pszTmpDBName);
CPLFree(pszTmpDBName);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Do we get a resultset? */
/* -------------------------------------------------------------------- */
rc = sqlite3_step( hSQLStmt );
if( rc != SQLITE_ROW )
{
if ( rc != SQLITE_DONE )
{
CPLError( CE_Failure, CPLE_AppDefined,
"In ExecuteSQL(): sqlite3_step(%s):\n %s",
pszStatement, sqlite3_errmsg(hDB) );
sqlite3_finalize( hSQLStmt );
delete poSQLiteDS;
VSIUnlink(pszTmpDBName);
CPLFree(pszTmpDBName);
return NULL;
}
if( !EQUALN(pszStatement, "SELECT ", 7) )
{
sqlite3_finalize( hSQLStmt );
delete poSQLiteDS;
VSIUnlink(pszTmpDBName);
CPLFree(pszTmpDBName);
return NULL;
}
bUseStatementForGetNextFeature = FALSE;
bEmptyLayer = TRUE;
}
/* -------------------------------------------------------------------- */
/* Create layer. */
/* -------------------------------------------------------------------- */
OGRSQLiteSelectLayer *poLayer = NULL;
poLayer = new OGRSQLiteExecuteSQLLayer( pszTmpDBName,
poSQLiteDS, pszStatement, hSQLStmt,
bUseStatementForGetNextFeature, bEmptyLayer );
if( poSpatialFilter != NULL )
poLayer->SetSpatialFilter( poSpatialFilter );
return poLayer;
}
/************************************************************************/
/* OGRSQLiteGetReferencedLayers() */
/************************************************************************/
std::set<LayerDesc> OGRSQLiteGetReferencedLayers(const char* pszStatement)
{
/* -------------------------------------------------------------------- */
/* Analysze the statement to determine which tables will be used. */
/* -------------------------------------------------------------------- */
std::set<LayerDesc> oSetLayers;
std::set<CPLString> oSetSpatialIndex;
CPLString osModifiedSQL;
OGR2SQLITEGetPotentialLayerNames(pszStatement, oSetLayers,
oSetSpatialIndex, osModifiedSQL);
return oSetLayers;
}
void lasclip(std::string &outfile, std::string &shapefile,
std::string &layername, std::vector<std::string> &files,
std::set<int> &classes, bool quiet) {
if (outfile.empty())
g_argerr("An output file is required.");
if (shapefile.empty())
g_argerr("A shape file is required.");
if (files.size() == 0)
g_argerr("At least one input file is required.");
if (classes.size() == 0)
g_warn("No classes specified, matching all classes.");
/* Attempt to open and load geometries from the shape file. */
OGRRegisterAll();
OGRLayer *layer;
OGRFeature *feat;
OGRGeometry *og;
OGRwkbGeometryType type;
gg::GeometryCollection *geomColl;
gg::Geometry *geom;
OGRDataSource *ds = OGRSFDriverRegistrar::Open(shapefile.c_str(), FALSE);
if (ds == nullptr)
g_runerr("Couldn't open shapefile.");
if (layername.empty()) {
layer = ds->GetLayer(0);
} else {
layer = ds->GetLayerByName(layername.c_str());
}
if (layer == nullptr)
g_runerr("Couldn't get layer.");
type = layer->GetGeomType();
if (type != wkbPolygon && type != wkbMultiPolygon)
g_runerr("Geometry must be polygon or multipolygon.");
const GEOSContextHandle_t gctx = OGRGeometry::createGEOSContext();
const gg::GeometryFactory *gf = gg::GeometryFactory::getDefaultInstance();
const gg::CoordinateSequenceFactory *cf =
gf->getCoordinateSequenceFactory();
std::vector<gg::Geometry *> geoms;
while ((feat = layer->GetNextFeature()) != NULL) {
og = feat->GetGeometryRef();
geom = (gg::Geometry *) og->exportToGEOS(gctx);
geoms.push_back(geom);
}
GDALClose(ds);
if (geoms.size() == 0)
g_runerr("No geometries were found.");
/* The geometry collection is used for checking whether a las file intersects
the region of interest. */
geomColl = gf->createGeometryCollection(geoms);
const gg::Envelope *env = geomColl->getEnvelopeInternal();
Bounds cbounds(env->getMinX(), env->getMinY(), env->getMaxX(),
env->getMaxY());
/* Loop over files and figure out which ones are relevant. */
liblas::ReaderFactory rf;
liblas::Header *dsth = nullptr;
std::vector<unsigned int> indices;
for (unsigned int i = 0; i < files.size(); ++i) {
std::ifstream in(files[i].c_str(), std::ios::in | std::ios::binary);
liblas::Reader r = rf.CreateWithStream(in);
liblas::Header h = r.GetHeader();
if (i == 0)
dsth = new liblas::Header(h);
std::vector<gg::Coordinate> coords;
coords.push_back(gg::Coordinate(h.GetMinX(), h.GetMinY()));
coords.push_back(gg::Coordinate(h.GetMaxX(), h.GetMinY()));
coords.push_back(gg::Coordinate(h.GetMaxX(), h.GetMaxY()));
coords.push_back(gg::Coordinate(h.GetMinX(), h.GetMaxY()));
coords.push_back(gg::Coordinate(h.GetMinX(), h.GetMinY()));
gg::CoordinateSequence *cs = cf->create(&coords);
gg::LinearRing *lr = gf->createLinearRing(cs);
gg::Polygon *bounds = gf->createPolygon(lr, NULL);
if (bounds->intersects(geomColl))
indices.push_back(i);
in.close();
}
if (indices.size() == 0)
g_runerr("No files matched the given bounds.");
std::ofstream out(outfile, std::ios::out | std::ios::binary);
liblas::WriterFactory wf;
liblas::Writer w(out, *dsth);
liblas::Header::RecordsByReturnArray recs;
int count = 0;
double bounds[] = { G_DBL_MAX_POS, G_DBL_MAX_NEG, G_DBL_MAX_POS,
G_DBL_MAX_NEG, G_DBL_MAX_POS, G_DBL_MAX_NEG };
g_trace("Using points from " << indices.size() << " files.");
for (int i = 0; i < 5; ++i)
recs.push_back(0);
for (unsigned int i = 0; i < indices.size(); ++i) {
std::ifstream in(files[indices[i]].c_str(),
std::ios::in | std::ios::binary);
liblas::Reader r = rf.CreateWithStream(in);
liblas::Header h = r.GetHeader();
g_trace("Processing file " << files[indices[i]]);
while (r.ReadNextPoint()) {
liblas::Point pt = r.GetPoint();
int cls = pt.GetClassification().GetClass();
if (classes.size() > 0 && !Util::inList(classes, cls))
continue;
double x = pt.GetX();
double y = pt.GetY();
const gg::Coordinate c(x, y);
gg::Point *p = gf->createPoint(c);
if (cbounds.contains(x, y) && geomColl->contains(p)) {
++recs[cls];
++count;
w.WritePoint(pt);
if (pt.GetX() < bounds[0])
bounds[0] = pt.GetX();
if (pt.GetX() > bounds[1])
bounds[1] = pt.GetX();
if (pt.GetY() < bounds[2])
bounds[2] = pt.GetY();
if (pt.GetY() > bounds[3])
bounds[3] = pt.GetY();
if (pt.GetZ() < bounds[4])
bounds[4] = pt.GetZ();
if (pt.GetZ() > bounds[5])
bounds[5] = pt.GetZ();
}
}
in.close();
}
// Set the total count and update the point record counts.
dsth->SetMin(bounds[0], bounds[2], bounds[4]);
dsth->SetMax(bounds[1], bounds[3], bounds[5]);
dsth->SetPointRecordsCount(count);
for (unsigned int i = 0; i < recs.size(); ++i)
dsth->SetPointRecordsByReturnCount(i, recs[i]);
w.WriteHeader();
}
OGRLayer * OGRDataSource::ExecuteSQL( const char *pszStatement,
OGRGeometry *poSpatialFilter,
const char *pszDialect )
{
const char *pszError;
swq_select *psSelectInfo = NULL;
(void) pszDialect;
swq_field_list sFieldList;
int nFIDIndex = 0;
OGRGenSQLResultsLayer *poResults = NULL;
memset( &sFieldList, 0, sizeof(sFieldList) );
/* -------------------------------------------------------------------- */
/* Handle CREATE INDEX statements specially. */
/* -------------------------------------------------------------------- */
if( EQUALN(pszStatement,"CREATE INDEX",12) )
{
ProcessSQLCreateIndex( pszStatement );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Handle DROP INDEX statements specially. */
/* -------------------------------------------------------------------- */
if( EQUALN(pszStatement,"DROP INDEX",10) )
{
ProcessSQLDropIndex( pszStatement );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Preparse the SQL statement. */
/* -------------------------------------------------------------------- */
pszError = swq_select_preparse( pszStatement, &psSelectInfo );
if( pszError != NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"SQL: %s", pszError );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Validate that all the source tables are recognised, count */
/* fields. */
/* -------------------------------------------------------------------- */
int nFieldCount = 0, iTable, iField;
int iEDS;
int nExtraDSCount = 0;
OGRDataSource** papoExtraDS = NULL;
OGRSFDriverRegistrar *poReg=OGRSFDriverRegistrar::GetRegistrar();
for( iTable = 0; iTable < psSelectInfo->table_count; iTable++ )
{
swq_table_def *psTableDef = psSelectInfo->table_defs + iTable;
OGRLayer *poSrcLayer;
OGRDataSource *poTableDS = this;
if( psTableDef->data_source != NULL )
{
poTableDS = (OGRDataSource *)
OGROpenShared( psTableDef->data_source, FALSE, NULL );
if( poTableDS == NULL )
{
if( strlen(CPLGetLastErrorMsg()) == 0 )
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to open secondary datasource\n"
"`%s' required by JOIN.",
psTableDef->data_source );
swq_select_free( psSelectInfo );
goto end;
}
/* Keep in an array to release at the end of this function */
papoExtraDS = (OGRDataSource** )CPLRealloc(papoExtraDS,
sizeof(OGRDataSource*) * (nExtraDSCount + 1));
papoExtraDS[nExtraDSCount++] = poTableDS;
}
poSrcLayer = poTableDS->GetLayerByName( psTableDef->table_name );
if( poSrcLayer == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"SELECT from table %s failed, no such table/featureclass.",
psTableDef->table_name );
swq_select_free( psSelectInfo );
goto end;
}
nFieldCount += poSrcLayer->GetLayerDefn()->GetFieldCount();
}
/* -------------------------------------------------------------------- */
/* Build the field list for all indicated tables. */
/* -------------------------------------------------------------------- */
sFieldList.table_count = psSelectInfo->table_count;
sFieldList.table_defs = psSelectInfo->table_defs;
sFieldList.count = 0;
sFieldList.names = (char **) CPLMalloc( sizeof(char *) * (nFieldCount+SPECIAL_FIELD_COUNT) );
sFieldList.types = (swq_field_type *)
CPLMalloc( sizeof(swq_field_type) * (nFieldCount+SPECIAL_FIELD_COUNT) );
sFieldList.table_ids = (int *)
CPLMalloc( sizeof(int) * (nFieldCount+SPECIAL_FIELD_COUNT) );
sFieldList.ids = (int *)
CPLMalloc( sizeof(int) * (nFieldCount+SPECIAL_FIELD_COUNT) );
for( iTable = 0; iTable < psSelectInfo->table_count; iTable++ )
{
swq_table_def *psTableDef = psSelectInfo->table_defs + iTable;
OGRDataSource *poTableDS = this;
OGRLayer *poSrcLayer;
if( psTableDef->data_source != NULL )
{
poTableDS = (OGRDataSource *)
OGROpenShared( psTableDef->data_source, FALSE, NULL );
CPLAssert( poTableDS != NULL );
poTableDS->Dereference();
}
poSrcLayer = poTableDS->GetLayerByName( psTableDef->table_name );
for( iField = 0;
iField < poSrcLayer->GetLayerDefn()->GetFieldCount();
iField++ )
{
OGRFieldDefn *poFDefn=poSrcLayer->GetLayerDefn()->GetFieldDefn(iField);
int iOutField = sFieldList.count++;
sFieldList.names[iOutField] = (char *) poFDefn->GetNameRef();
if( poFDefn->GetType() == OFTInteger )
sFieldList.types[iOutField] = SWQ_INTEGER;
else if( poFDefn->GetType() == OFTReal )
sFieldList.types[iOutField] = SWQ_FLOAT;
else if( poFDefn->GetType() == OFTString )
sFieldList.types[iOutField] = SWQ_STRING;
else
sFieldList.types[iOutField] = SWQ_OTHER;
sFieldList.table_ids[iOutField] = iTable;
sFieldList.ids[iOutField] = iField;
}
if( iTable == 0 )
nFIDIndex = poSrcLayer->GetLayerDefn()->GetFieldCount();
}
/* -------------------------------------------------------------------- */
/* Expand '*' in 'SELECT *' now before we add the pseudo fields */
/* -------------------------------------------------------------------- */
pszError =
swq_select_expand_wildcard( psSelectInfo, &sFieldList );
if( pszError != NULL )
{
swq_select_free( psSelectInfo );
CPLError( CE_Failure, CPLE_AppDefined,
"SQL: %s", pszError );
goto end;
}
for (iField = 0; iField < SPECIAL_FIELD_COUNT; iField++)
{
sFieldList.names[sFieldList.count] = (char*) SpecialFieldNames[iField];
sFieldList.types[sFieldList.count] = SpecialFieldTypes[iField];
sFieldList.table_ids[sFieldList.count] = 0;
sFieldList.ids[sFieldList.count] = nFIDIndex + iField;
sFieldList.count++;
}
/* -------------------------------------------------------------------- */
/* Finish the parse operation. */
/* -------------------------------------------------------------------- */
pszError = swq_select_parse( psSelectInfo, &sFieldList, 0 );
if( pszError != NULL )
{
swq_select_free( psSelectInfo );
CPLError( CE_Failure, CPLE_AppDefined,
"SQL: %s", pszError );
goto end;
}
/* -------------------------------------------------------------------- */
/* Everything seems OK, try to instantiate a results layer. */
/* -------------------------------------------------------------------- */
poResults = new OGRGenSQLResultsLayer( this, psSelectInfo,
poSpatialFilter );
// Eventually, we should keep track of layers to cleanup.
end:
CPLFree( sFieldList.names );
CPLFree( sFieldList.types );
CPLFree( sFieldList.table_ids );
CPLFree( sFieldList.ids );
/* Release the datasets we have opened with OGROpenShared() */
/* It is safe to do that as the 'new OGRGenSQLResultsLayer' itself */
/* has taken a reference on them, which it will release in its */
/* destructor */
for(iEDS = 0; iEDS < nExtraDSCount; iEDS++)
poReg->ReleaseDataSource( papoExtraDS[iEDS] );
CPLFree(papoExtraDS);
return poResults;
}
OGRLayer * OGRSQLiteExecuteSQL( GDALDataset* poDS,
const char *pszStatement,
OGRGeometry *poSpatialFilter,
CPL_UNUSED const char *pszDialect )
{
char* pszTmpDBName = (char*) CPLMalloc(256);
snprintf(pszTmpDBName, 256, "/vsimem/ogr2sqlite/temp_%p.db", pszTmpDBName);
OGRSQLiteDataSource* poSQLiteDS = NULL;
int nRet;
int bSpatialiteDB = FALSE;
CPLString osOldVal;
const char* pszOldVal = CPLGetConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", NULL);
if( pszOldVal != NULL )
{
osOldVal = pszOldVal;
pszOldVal = osOldVal.c_str();
}
/* -------------------------------------------------------------------- */
/* Create in-memory sqlite/spatialite DB */
/* -------------------------------------------------------------------- */
#ifdef HAVE_SPATIALITE
/* -------------------------------------------------------------------- */
/* Creating an empty SpatiaLite DB (with spatial_ref_sys populated */
/* has a significant cost. So at the first attempt, let's make */
/* one and cache it for later use. */
/* -------------------------------------------------------------------- */
#if 1
static size_t nEmptyDBSize = 0;
static GByte* pabyEmptyDB = NULL;
{
static CPLMutex* hMutex = NULL;
CPLMutexHolder oMutexHolder(&hMutex);
static int bTried = FALSE;
if( !bTried &&
CPLTestBool(CPLGetConfigOption("OGR_SQLITE_DIALECT_USE_SPATIALITE", "YES")) )
{
bTried = TRUE;
char* pszCachedFilename = (char*) CPLMalloc(256);
snprintf(pszCachedFilename, 256, "/vsimem/ogr2sqlite/reference_%p.db",
pszCachedFilename);
char** papszOptions = CSLAddString(NULL, "SPATIALITE=YES");
OGRSQLiteDataSource* poCachedDS = new OGRSQLiteDataSource();
nRet = poCachedDS->Create( pszCachedFilename, papszOptions );
CSLDestroy(papszOptions);
papszOptions = NULL;
delete poCachedDS;
if( nRet )
{
/* Note: the reference file keeps the ownership of the data, so that */
/* it gets released with VSICleanupFileManager() */
vsi_l_offset nEmptyDBSizeLarge = 0;
pabyEmptyDB = VSIGetMemFileBuffer( pszCachedFilename, &nEmptyDBSizeLarge, FALSE );
nEmptyDBSize = static_cast<size_t>(nEmptyDBSizeLarge);
}
CPLFree( pszCachedFilename );
}
}
/* The following configuration option is useful mostly for debugging/testing */
if( pabyEmptyDB != NULL && CPLTestBool(CPLGetConfigOption("OGR_SQLITE_DIALECT_USE_SPATIALITE", "YES")) )
{
GByte* pabyEmptyDBClone = (GByte*)VSI_MALLOC_VERBOSE(nEmptyDBSize);
if( pabyEmptyDBClone == NULL )
{
CPLFree(pszTmpDBName);
return NULL;
}
memcpy(pabyEmptyDBClone, pabyEmptyDB, nEmptyDBSize);
VSIFCloseL(VSIFileFromMemBuffer( pszTmpDBName, pabyEmptyDBClone, nEmptyDBSize, TRUE ));
poSQLiteDS = new OGRSQLiteDataSource();
CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", "NO");
nRet = poSQLiteDS->Open( pszTmpDBName, TRUE, NULL );
CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", pszOldVal);
if( !nRet )
{
/* should not happen really ! */
delete poSQLiteDS;
VSIUnlink(pszTmpDBName);
CPLFree(pszTmpDBName);
return NULL;
}
bSpatialiteDB = TRUE;
}
#else
/* No caching version */
poSQLiteDS = new OGRSQLiteDataSource();
char** papszOptions = CSLAddString(NULL, "SPATIALITE=YES");
CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", "NO");
nRet = poSQLiteDS->Create( pszTmpDBName, papszOptions );
CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", pszOldVal);
CSLDestroy(papszOptions);
papszOptions = NULL;
if( nRet )
{
bSpatialiteDB = TRUE;
}
#endif
else
{
delete poSQLiteDS;
poSQLiteDS = NULL;
#else // HAVE_SPATIALITE
if( true )
{
#endif // HAVE_SPATIALITE
poSQLiteDS = new OGRSQLiteDataSource();
CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", "NO");
nRet = poSQLiteDS->Create( pszTmpDBName, NULL );
CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", pszOldVal);
if( !nRet )
{
delete poSQLiteDS;
VSIUnlink(pszTmpDBName);
CPLFree(pszTmpDBName);
return NULL;
}
}
/* -------------------------------------------------------------------- */
/* Attach the Virtual Table OGR2SQLITE module to it. */
/* -------------------------------------------------------------------- */
OGR2SQLITEModule* poModule = OGR2SQLITE_Setup(poDS, poSQLiteDS);
sqlite3* hDB = poSQLiteDS->GetDB();
/* -------------------------------------------------------------------- */
/* Analysze the statement to determine which tables will be used. */
/* -------------------------------------------------------------------- */
std::set<LayerDesc> oSetLayers;
std::set<CPLString> oSetSpatialIndex;
CPLString osModifiedSQL;
OGR2SQLITEGetPotentialLayerNames(pszStatement, oSetLayers,
oSetSpatialIndex, osModifiedSQL);
std::set<LayerDesc>::iterator oIter = oSetLayers.begin();
if( strcmp(pszStatement, osModifiedSQL.c_str()) != 0 )
CPLDebug("OGR", "Modified SQL: %s", osModifiedSQL.c_str());
pszStatement = osModifiedSQL.c_str(); /* do not use it anymore */
int bFoundOGRStyle = ( osModifiedSQL.ifind("OGR_STYLE") != std::string::npos );
/* -------------------------------------------------------------------- */
/* For each of those tables, create a Virtual Table. */
/* -------------------------------------------------------------------- */
OGRLayer* poSingleSrcLayer = NULL;
for(; oIter != oSetLayers.end(); ++oIter)
{
const LayerDesc& oLayerDesc = *oIter;
/*CPLDebug("OGR", "Layer desc : %s, %s, %s, %s",
oLayerDesc.osOriginalStr.c_str(),
oLayerDesc.osSubstitutedName.c_str(),
oLayerDesc.osDSName.c_str(),
oLayerDesc.osLayerName.c_str());*/
CPLString osSQL;
OGRLayer* poLayer = NULL;
CPLString osTableName;
int nExtraDS;
if( oLayerDesc.osDSName.size() == 0 )
{
poLayer = poDS->GetLayerByName(oLayerDesc.osLayerName);
/* Might be a false positive (unlikely) */
if( poLayer == NULL )
continue;
osTableName = oLayerDesc.osLayerName;
nExtraDS = -1;
}
else
{
OGRDataSource* poOtherDS = (OGRDataSource* )
OGROpen(oLayerDesc.osDSName, FALSE, NULL);
if( poOtherDS == NULL )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot open datasource '%s'",
oLayerDesc.osDSName.c_str() );
delete poSQLiteDS;
VSIUnlink(pszTmpDBName);
CPLFree(pszTmpDBName);
return NULL;
}
poLayer = poOtherDS->GetLayerByName(oLayerDesc.osLayerName);
if( poLayer == NULL )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot find layer '%s' in '%s'",
oLayerDesc.osLayerName.c_str(),
oLayerDesc.osDSName.c_str() );
delete poOtherDS;
delete poSQLiteDS;
VSIUnlink(pszTmpDBName);
CPLFree(pszTmpDBName);
return NULL;
}
osTableName = oLayerDesc.osSubstitutedName;
nExtraDS = OGR2SQLITE_AddExtraDS(poModule, poOtherDS);
}
if( oSetLayers.size() == 1 )
poSingleSrcLayer = poLayer;
osSQL.Printf("CREATE VIRTUAL TABLE \"%s\" USING VirtualOGR(%d,'%s',%d,%d)",
OGRSQLiteEscapeName(osTableName).c_str(),
nExtraDS,
OGRSQLiteEscape(oLayerDesc.osLayerName).c_str(),
bFoundOGRStyle,
TRUE/*bExposeOGRNativeData*/);
char* pszErrMsg = NULL;
int rc = sqlite3_exec( hDB, osSQL.c_str(),
NULL, NULL, &pszErrMsg );
if( rc != SQLITE_OK )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot create virtual table for layer '%s' : %s",
osTableName.c_str(), pszErrMsg);
sqlite3_free(pszErrMsg);
continue;
}
for(int i=0; i<poLayer->GetLayerDefn()->GetGeomFieldCount(); i++)
{
OGR2SQLITEDealWithSpatialColumn(poLayer, i, oLayerDesc,
osTableName, poSQLiteDS, hDB,
bSpatialiteDB, oSetLayers,
oSetSpatialIndex);
}
}
/* -------------------------------------------------------------------- */
/* Reload, so that virtual tables are recognized */
/* -------------------------------------------------------------------- */
poSQLiteDS->ReloadLayers();
/* -------------------------------------------------------------------- */
/* Prepare the statement. */
/* -------------------------------------------------------------------- */
/* This will speed-up layer creation */
/* ORDER BY are costly to evaluate and are not necessary to establish */
/* the layer definition. */
int bUseStatementForGetNextFeature = TRUE;
int bEmptyLayer = FALSE;
sqlite3_stmt *hSQLStmt = NULL;
int rc = sqlite3_prepare( hDB,
pszStatement, -1,
&hSQLStmt, NULL );
if( rc != SQLITE_OK )
{
CPLError( CE_Failure, CPLE_AppDefined,
"In ExecuteSQL(): sqlite3_prepare(%s):\n %s",
pszStatement, sqlite3_errmsg(hDB) );
if( hSQLStmt != NULL )
{
sqlite3_finalize( hSQLStmt );
}
delete poSQLiteDS;
VSIUnlink(pszTmpDBName);
CPLFree(pszTmpDBName);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Do we get a resultset? */
/* -------------------------------------------------------------------- */
rc = sqlite3_step( hSQLStmt );
if( rc != SQLITE_ROW )
{
if ( rc != SQLITE_DONE )
{
CPLError( CE_Failure, CPLE_AppDefined,
"In ExecuteSQL(): sqlite3_step(%s):\n %s",
pszStatement, sqlite3_errmsg(hDB) );
sqlite3_finalize( hSQLStmt );
delete poSQLiteDS;
VSIUnlink(pszTmpDBName);
CPLFree(pszTmpDBName);
return NULL;
}
if( !STARTS_WITH_CI(pszStatement, "SELECT ") )
{
sqlite3_finalize( hSQLStmt );
delete poSQLiteDS;
VSIUnlink(pszTmpDBName);
CPLFree(pszTmpDBName);
return NULL;
}
bUseStatementForGetNextFeature = FALSE;
bEmptyLayer = TRUE;
}
/* -------------------------------------------------------------------- */
/* Create layer. */
/* -------------------------------------------------------------------- */
OGRSQLiteSelectLayer *poLayer = NULL;
poLayer = new OGRSQLiteExecuteSQLLayer( pszTmpDBName,
poSQLiteDS, pszStatement, hSQLStmt,
bUseStatementForGetNextFeature, bEmptyLayer );
if( poSpatialFilter != NULL )
poLayer->SetSpatialFilter( 0, poSpatialFilter );
if( poSingleSrcLayer != NULL )
poLayer->SetMetadata( poSingleSrcLayer->GetMetadata( "NATIVE_DATA" ),
"NATIVE_DATA" );
return poLayer;
}
/************************************************************************/
/* OGRSQLiteGetReferencedLayers() */
/************************************************************************/
std::set<LayerDesc> OGRSQLiteGetReferencedLayers(const char* pszStatement)
{
/* -------------------------------------------------------------------- */
/* Analysze the statement to determine which tables will be used. */
/* -------------------------------------------------------------------- */
std::set<LayerDesc> oSetLayers;
std::set<CPLString> oSetSpatialIndex;
CPLString osModifiedSQL;
OGR2SQLITEGetPotentialLayerNames(pszStatement, oSetLayers,
oSetSpatialIndex, osModifiedSQL);
return oSetLayers;
}
void DrawShape::featuredetect(int XPoint,int YPoint)
{
if(!sfile.empty() && XPoint>=(x_pos_shift-increase_width/2)*6.40 && XPoint<=(x_pos_shift-increase_width/2)*6.40+(100+increase_width)*6.4 && YPoint>=(y_pos_shift-increase_height/2)*4.8 && YPoint<=(y_pos_shift-increase_height/2)*4.8+(100+increase_height)*4.8 )//check if point is inside the view area
{
OGRDataSource *poDS;
string dfile = sfile + ".shp";
string shp = "g_4326/" + sfile + ".shp";
poDS = OGRSFDriverRegistrar::Open(shp.c_str(), FALSE ); //comment till here
if( poDS == NULL )
{
WApplication::instance()->doJavaScript("alert('Open failed')");
cout << "Open failed";
}
OGRLayer *poLayer;
poLayer = poDS->GetLayerByName( sfile.c_str() ); // comment here
OGRFeature *poFeature;
OGREnvelope * psExtent = new OGREnvelope();
poLayer->GetExtent(psExtent);
double xMin = psExtent->MinX;
double yMin = psExtent->MinY;
double xMax = psExtent->MaxX;
double yMax = psExtent->MaxY;
stringstream strm;
strm << xMin;
string exp;
double scaleFactor;
string bound_string = strm.str();
int size = bound_string.size();
size_t found=bound_string.find("+");
if (found!=string::npos) {
exp = bound_string.substr(found+1,size);
}
if(exp.empty()) {
stringstream strExtent;
strExtent << yMin;
bound_string = strExtent.str();
size = bound_string.size();
found = bound_string.find("+");
if(found!=string::npos) {
exp = bound_string.substr(found+1,size);
}
}
if(exp.empty()) {
stringstream strExtent;
strExtent << xMax;
bound_string = strExtent.str();
size = bound_string.size();
found = bound_string.find("+");
if(found!=string::npos) {
exp = bound_string.substr(found+1,size);
}
}
if(exp.empty()) {
stringstream strExtent;
strExtent << yMax;
bound_string = strExtent.str();
size = bound_string.size();
found = bound_string.find("+");
if(found!=string::npos) {
exp = bound_string.substr(found+1,size);
}
}
if(!exp.empty()) {
int exponent = boost::lexical_cast<int>(exp);
exponent-=3;
scaleFactor = pow (10,exponent);
}
else
{
scaleFactor = 1;
}
xMin/=scaleFactor;
xMax/=scaleFactor;
yMin/=scaleFactor;
yMax/=scaleFactor;
double gWidth = xMax - xMin;
double gHeight = yMax - yMin;
double widthFactor = 1;
double pwidth = abs(gWidth-gHeight);
double s = gWidth - gHeight;
if(s<0.16)
gWidth = gHeight + 0.16;
double scaledX=(XPoint*(gWidth* widthFactor*(100-increase_width)/100)/640 + (xMin+(-x_pos_shift+increase_width/2)/100*gWidth* widthFactor))*scaleFactor;
double scaledY=(YPoint*(gHeight*widthFactor*(-1+increase_height/100))/480 + (yMax+(y_pos_shift-increase_height/2)/100*gHeight*widthFactor))*scaleFactor;
OGRPoint *poPoint =new OGRPoint();
poPoint->setX(scaledX);
poPoint->setY(scaledY);
poLayer->ResetReading();
int index=0;bool flagFeature=false;
while( (poFeature = poLayer->GetNextFeature()) != NULL )
{
OGRGeometry *poGeometry;
poGeometry = poFeature->GetGeometryRef();
if(poGeometry->Distance(poPoint)/scaleFactor<=0.01*gWidth*widthFactor)
{
flagFeature=true;
//std::cerr<<index<<" " <<flagFeature<<" "<<poGeometry->Distance(poPoint);
break;
}
index++;
}
if(flagFeature)
DBFDialog *attrtable =new DBFDialog(cfile,sfile,flagFeature,index);
}
}
void readQuadIndex(int series, QString file, QString layerName, Projection *pj)
{
OGRDataSource *ds = OGRSFDriverRegistrar::Open(file.toLatin1().data(), false);
if (!ds) {
fprintf(stderr, "Could not open quad index '%s'.\n", file.toLatin1().data());
exit(-1);
}
OGRLayer *layer;
layer = ds->GetLayerByName(layerName.toLatin1().data());
if (!layer) {
fprintf(stderr, "Could not read layer '%s'.\n", layerName.toLatin1().data());
exit(-1);
}
OGRSpatialReference *srs = layer->GetSpatialRef();
if (!srs) {
fprintf(stderr, "Missing spatial reference for layer '%s'.\n",
layerName.toLatin1().data());
exit(-1);
}
char *proj = NULL;
srs->exportToProj4(&proj);
if (!proj) {
fprintf(stderr, "Error computing PROJ4 spatial reference for layer '%s'.\n",
layerName.toLatin1().data());
exit(-1);
}
Projection pjIndex(proj);
CPLFree(proj);
layer->ResetReading();
OGRFeatureDefn *def = layer->GetLayerDefn();
int idFieldNr = def->GetFieldIndex("ID");
int nameFieldNr = def->GetFieldIndex("NAME");
if (idFieldNr < 0 || nameFieldNr < 0) {
fprintf(stderr, "Missing index layer fields.\n");
exit(-1);
}
OGRFeature *f;
while ((f = layer->GetNextFeature()) != NULL) {
QString id(f->GetFieldAsString(idFieldNr));
QString name(f->GetFieldAsString(nameFieldNr));
// printf("Quad id: %s; name: %s\n", id.toLatin1().data(), name.toLatin1().data());
OGRGeometry *g;
g = f->GetGeometryRef();
if (g != NULL && wkbFlatten(g->getGeometryType()) == wkbPolygon) {
OGRPolygon *p = (OGRPolygon *)g;
OGRLinearRing *r = p->getExteriorRing();
if (!r) {
fprintf(stderr, "Quad has no exterior polygon ring %s\n",
id.toLatin1().data());
continue;
}
int size = r->getNumPoints();
QPolygonF boundary;
for (int i = 0; i < size; i++) {
OGRPoint p;
r->getPoint(i, &p);
boundary << QPointF(p.getX(), p.getY());
}
QPolygonF projBoundary = pj->transformFrom(&pjIndex, boundary);
quads[id] = Quad(series, id, name, projBoundary);
} else {
fprintf(stderr, "Missing or invalid geometry for quad %s\n",
id.toLatin1().data());
}
}
OGRDataSource::DestroyDataSource(ds);
}
static OGRGeometryCollection* LoadGeometry( const char* pszDS,
const char* pszSQL,
const char* pszLyr,
const char* pszWhere )
{
OGRDataSource *poDS;
OGRLayer *poLyr;
OGRFeature *poFeat;
OGRGeometryCollection *poGeom = NULL;
poDS = OGRSFDriverRegistrar::Open( pszDS, FALSE );
if ( poDS == NULL )
return NULL;
if ( pszSQL != NULL )
poLyr = poDS->ExecuteSQL( pszSQL, NULL, NULL );
else if ( pszLyr != NULL )
poLyr = poDS->GetLayerByName( pszLyr );
else
poLyr = poDS->GetLayer(0);
if ( poLyr == NULL )
{
fprintf( stderr,
"FAILURE: Failed to identify source layer from datasource.\n" );
OGRDataSource::DestroyDataSource( poDS );
return NULL;
}
if ( pszWhere )
poLyr->SetAttributeFilter( pszWhere );
while ( (poFeat = poLyr->GetNextFeature()) != NULL )
{
OGRGeometry* poSrcGeom = poFeat->GetGeometryRef();
if ( poSrcGeom )
{
OGRwkbGeometryType eType =
wkbFlatten( poSrcGeom->getGeometryType() );
if ( poGeom == NULL )
poGeom = new OGRMultiPolygon();
if ( eType == wkbPolygon )
poGeom->addGeometry( poSrcGeom );
else if ( eType == wkbMultiPolygon )
{
int iGeom;
int nGeomCount =
((OGRMultiPolygon *)poSrcGeom)->getNumGeometries();
for ( iGeom = 0; iGeom < nGeomCount; iGeom++ )
{
poGeom->addGeometry(
((OGRMultiPolygon *)poSrcGeom)->getGeometryRef(iGeom) );
}
}
else
{
fprintf( stderr, "FAILURE: Geometry not of polygon type.\n" );
OGRGeometryFactory::destroyGeometry( poGeom );
OGRFeature::DestroyFeature( poFeat );
if ( pszSQL != NULL )
poDS->ReleaseResultSet( poLyr );
OGRDataSource::DestroyDataSource( poDS );
return NULL;
}
}
OGRFeature::DestroyFeature( poFeat );
}
if( pszSQL != NULL )
poDS->ReleaseResultSet( poLyr );
OGRDataSource::DestroyDataSource( poDS );
return poGeom;
}
int main( int nArgc, char ** papszArgv )
{
const char *pszDataSource = NULL;
char** papszLayers = NULL;
const char *pszSQLStatement = NULL;
int bRet = TRUE;
/* Must process OGR_SKIP before OGRRegisterAll(), but we can't call */
/* OGRGeneralCmdLineProcessor before it needs the drivers to be registered */
/* for the --format or --formats options */
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg], "--config") && iArg + 2 < nArgc &&
EQUAL(papszArgv[iArg+1], "OGR_SKIP") )
{
CPLSetConfigOption(papszArgv[iArg+1], papszArgv[iArg+2]);
break;
}
}
/* -------------------------------------------------------------------- */
/* Register format(s). */
/* -------------------------------------------------------------------- */
OGRRegisterAll();
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
nArgc = OGRGeneralCmdLineProcessor( nArgc, &papszArgv, 0 );
if( nArgc < 1 )
exit( -nArgc );
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
papszArgv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(papszArgv[iArg],"-ro") )
bReadOnly = TRUE;
else if( EQUAL(papszArgv[iArg],"-q") || EQUAL(papszArgv[iArg],"-quiet"))
bVerbose = FALSE;
else if( EQUAL(papszArgv[iArg],"-sql") && iArg + 1 < nArgc)
pszSQLStatement = papszArgv[++iArg];
else if( papszArgv[iArg][0] == '-' )
{
Usage();
}
else if (pszDataSource == NULL)
pszDataSource = papszArgv[iArg];
else
papszLayers = CSLAddString(papszLayers, papszArgv[iArg]);
}
if( pszDataSource == NULL )
Usage();
/* -------------------------------------------------------------------- */
/* Open data source. */
/* -------------------------------------------------------------------- */
OGRDataSource *poDS;
OGRSFDriver *poDriver;
poDS = OGRSFDriverRegistrar::Open( pszDataSource, !bReadOnly, &poDriver );
if( poDS == NULL && !bReadOnly )
{
poDS = OGRSFDriverRegistrar::Open( pszDataSource, FALSE, &poDriver );
if( poDS != NULL && bVerbose )
{
printf( "Had to open data source read-only.\n" );
bReadOnly = TRUE;
}
}
/* -------------------------------------------------------------------- */
/* Report failure */
/* -------------------------------------------------------------------- */
if( poDS == NULL )
{
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
printf( "FAILURE:\n"
"Unable to open datasource `%s' with the following drivers.\n",
pszDataSource );
for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
{
printf( " -> %s\n", poR->GetDriver(iDriver)->GetName() );
}
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Some information messages. */
/* -------------------------------------------------------------------- */
if( bVerbose )
printf( "INFO: Open of `%s' using driver `%s' successful.\n",
pszDataSource, poDriver->GetName() );
if( bVerbose && !EQUAL(pszDataSource,poDS->GetName()) )
{
printf( "INFO: Internal data source name `%s'\n"
" different from user name `%s'.\n",
poDS->GetName(), pszDataSource );
}
/* -------------------------------------------------------------------- */
/* Process optionnal SQL request. */
/* -------------------------------------------------------------------- */
if (pszSQLStatement != NULL)
{
OGRLayer *poResultSet = poDS->ExecuteSQL(pszSQLStatement, NULL, NULL);
if (poResultSet == NULL)
exit(1);
printf( "INFO: Testing layer %s.\n",
poResultSet->GetName() );
bRet = TestOGRLayer( poDS, poResultSet, TRUE );
poDS->ReleaseResultSet(poResultSet);
}
/* -------------------------------------------------------------------- */
/* Process each data source layer. */
/* -------------------------------------------------------------------- */
else if (papszLayers == NULL)
{
for( int iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ )
{
OGRLayer *poLayer = poDS->GetLayer(iLayer);
if( poLayer == NULL )
{
printf( "FAILURE: Couldn't fetch advertised layer %d!\n",
iLayer );
exit( 1 );
}
printf( "INFO: Testing layer %s.\n",
poLayer->GetName() );
bRet &= TestOGRLayer( poDS, poLayer, FALSE );
}
}
else
{
/* -------------------------------------------------------------------- */
/* Or process layers specified by the user */
/* -------------------------------------------------------------------- */
char** papszLayerIter = papszLayers;
while (*papszLayerIter)
{
OGRLayer *poLayer = poDS->GetLayerByName(*papszLayerIter);
if( poLayer == NULL )
{
printf( "FAILURE: Couldn't fetch requested layer %s!\n",
*papszLayerIter );
exit( 1 );
}
printf( "INFO: Testing layer %s.\n",
poLayer->GetName() );
bRet &= TestOGRLayer( poDS, poLayer, FALSE );
papszLayerIter ++;
}
}
/* -------------------------------------------------------------------- */
/* Close down. */
/* -------------------------------------------------------------------- */
OGRDataSource::DestroyDataSource(poDS);
OGRCleanupAll();
CSLDestroy(papszLayers);
CSLDestroy(papszArgv);
#ifdef DBMALLOC
malloc_dump(1);
#endif
return (bRet) ? 0 : 1;
}
bool MapWidget::loadCountyShapes()
{
OGRRegisterAll();
std::string filename = g_dataDirectory + "/counties/tl_2009_48_county00.shp";
OGRDataSource * dataSource = OGRSFDriverRegistrar::Open(filename.c_str(), false);
if(dataSource == NULL)
{
put_flog(LOG_ERROR, "could not open %s", filename.c_str());
return false;
}
OGRLayer * layer = dataSource->GetLayerByName("tl_2009_48_county00");
layer->ResetReading();
OGRFeature * feature;
while((feature = layer->GetNextFeature()) != NULL)
{
// get county FIPS code
int nodeId = feature->GetFieldAsInteger("COUNTYFP00");
if(nodeId == 0)
{
put_flog(LOG_WARN, "invalid county");
}
// add a new county to the counties map corresponding to this nodeId
boost::shared_ptr<MapShape> county(new MapShape());
counties_[nodeId] = county;
OGRGeometry * geometry = feature->GetGeometryRef();
if(geometry != NULL && geometry->getGeometryType() == wkbPolygon)
{
OGRPolygon * polygon = (OGRPolygon *)geometry;
OGRLinearRing * ring = polygon->getExteriorRing();
for(int i=0; i<ring->getNumPoints(); i++)
{
// x is longitude, y latitude
county->addVertex(ring->getY(i), ring->getX(i));
}
// set the centroid
OGRPoint centroidPoint;
if(polygon->Centroid(¢roidPoint) == OGRERR_NONE)
{
county->setCentroid(centroidPoint.getY(), centroidPoint.getX());
}
else
{
put_flog(LOG_WARN, "no polygon centroid");
}
}
else
{
put_flog(LOG_WARN, "no polygon geometry");
}
OGRFeature::DestroyFeature(feature);
}
OGRDataSource::DestroyDataSource(dataSource);
return true;
}
void DataCvt_Log::CalAsShp()
{
double ptmptime_start = MPI_Wtime();
OGRRegisterAll();
//create a new shp to caculate
CBaseOperate pbaseOperate;
if(rankid==0)
{
pbaseOperate.CreateCopyShp(m_DatasourceConStr.c_str(),m_PathOrTableName.c_str(),m_ResultPathOrTableName.c_str());
}
MPI_Barrier(MPI_COMM_WORLD);
string pLayerName = m_ResultPathOrTableName;
if(strcmp(m_DatasourceConStr.c_str(),"")==0)//input is shp file
{
m_DatasourceConStr = m_ResultPathOrTableName;
string pShpPath = m_ResultPathOrTableName;
string p_LayerName = GetFileNameOnly(pShpPath.c_str());
int pindex = p_LayerName.find_first_of('.');
pLayerName = p_LayerName.erase(pindex,p_LayerName.size()-1);
}
OGRDataSource* poDS = OGRSFDriverRegistrar::Open(m_DatasourceConStr.c_str(),TRUE);
OGRLayer* poLayer = poDS->GetLayerByName(pLayerName.c_str());
OGRFeature * pFeature =poLayer->GetNextFeature();
m_RowNum = poLayer->GetFeatureCount();
//if -c argv is null, all field will be used
m_ColNum= pFeature->GetFieldCount();
if(c_CaculateCols.size()==0)
{
if(rankid==0)
cout<<"!!!!!!! No input columns ids, all fields in the input file will be used..."<<endl<<endl;
for(int i=0;i<m_ColNum;i++)
{
c_CaculateCols.push_back(i);
}
}
double ptmptime_end = MPI_Wtime();
m_GdalIOInCal_Time=m_GdalIOInCal_Time+ptmptime_end-ptmptime_start;
//assign number to each process
int pnum_start,pnum_end;
int pMyProcessNum=0; int pRemainder=m_RowNum%numproc;
if(rankid<pRemainder)
{
pMyProcessNum = m_RowNum/numproc+1;
pnum_start = rankid*pMyProcessNum;
pnum_end = pnum_start+pMyProcessNum-1;
}
else
{
pMyProcessNum = m_RowNum/numproc;
pnum_start = pRemainder*(pMyProcessNum+1)+(rankid-pRemainder)*pMyProcessNum;
pnum_end = pnum_start+pMyProcessNum-1;
}
//postgis: fid begins from 1, not 0
string pwhere="";
if(strcmp(m_DatasourceConStr.substr(0,3).c_str(),"PG:")==0)//input is postgis
{
pwhere = "gid>="+toString(pnum_start+1)+" and gid<="+toString(pnum_end+1);
}
else//shpfile: fid begins from 0, not 1
{
pwhere = "fid>="+toString(pnum_start)+" and fid<="+toString(pnum_end);
}
poLayer->SetAttributeFilter(pwhere.c_str());
pFeature = poLayer->GetNextFeature();
while(pFeature!=NULL)
{
for(int i=0;i<c_CaculateCols.size();i++)
{
double tmp = pFeature->GetFieldAsDouble(c_CaculateCols[i]);
if(tmp!=0)
tmp = log(fabs(tmp));
else
tmp=0;
double pstart = MPI_Wtime();
pFeature->SetField(c_CaculateCols[i],tmp);
poLayer->SetFeature(pFeature);
double pend = MPI_Wtime();
m_GdalIOInCal_Time = m_GdalIOInCal_Time+pend-pstart;
}
pFeature = poLayer->GetNextFeature();
}
OGRDataSource::DestroyDataSource( poDS );
double ptmptime_endall = MPI_Wtime();
Mpi_Caculate_Time = ptmptime_endall-ptmptime_start-m_GdalIOInCal_Time;
double tmp=Mpi_Caculate_Time;
MPI_Reduce(&Mpi_Caculate_Time,&tmp,1,MPI_DOUBLE,MPI_MIN,0,MPI_COMM_WORLD);
Mpi_Caculate_Time = tmp;
}
int main( int nArgc, char ** papszArgv )
{
const char *pszWHERE = NULL;
const char *pszDataSource = NULL;
char **papszLayers = NULL;
OGRGeometry *poSpatialFilter = NULL;
int nRepeatCount = 1, bAllLayers = FALSE;
const char *pszSQLStatement = NULL;
const char *pszDialect = NULL;
/* Check strict compilation and runtime library version as we use C++ API */
if (! GDAL_CHECK_VERSION(papszArgv[0]))
exit(1);
/* -------------------------------------------------------------------- */
/* Register format(s). */
/* -------------------------------------------------------------------- */
OGRRegisterAll();
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
nArgc = OGRGeneralCmdLineProcessor( nArgc, &papszArgv, 0 );
if( nArgc < 1 )
exit( -nArgc );
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
papszArgv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(papszArgv[iArg],"-ro") )
bReadOnly = TRUE;
else if( EQUAL(papszArgv[iArg],"-q") || EQUAL(papszArgv[iArg],"-quiet"))
bVerbose = FALSE;
else if( EQUAL(papszArgv[iArg],"-fid") && iArg < nArgc-1 )
nFetchFID = atoi(papszArgv[++iArg]);
else if( EQUAL(papszArgv[iArg],"-spat")
&& papszArgv[iArg+1] != NULL
&& papszArgv[iArg+2] != NULL
&& papszArgv[iArg+3] != NULL
&& papszArgv[iArg+4] != NULL )
{
OGRLinearRing oRing;
oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+2]) );
oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+4]) );
oRing.addPoint( atof(papszArgv[iArg+3]), atof(papszArgv[iArg+4]) );
oRing.addPoint( atof(papszArgv[iArg+3]), atof(papszArgv[iArg+2]) );
oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+2]) );
poSpatialFilter = new OGRPolygon();
((OGRPolygon *) poSpatialFilter)->addRing( &oRing );
iArg += 4;
}
else if( EQUAL(papszArgv[iArg],"-where") && papszArgv[iArg+1] != NULL )
{
pszWHERE = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-sql") && papszArgv[iArg+1] != NULL )
{
pszSQLStatement = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-dialect")
&& papszArgv[iArg+1] != NULL )
{
pszDialect = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-rc") && papszArgv[iArg+1] != NULL )
{
nRepeatCount = atoi(papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg],"-al") )
{
bAllLayers = TRUE;
}
else if( EQUAL(papszArgv[iArg],"-so")
|| EQUAL(papszArgv[iArg],"-summary") )
{
bSummaryOnly = TRUE;
}
else if( EQUALN(papszArgv[iArg],"-fields=", strlen("-fields=")) )
{
char* pszTemp = (char*)CPLMalloc(32 + strlen(papszArgv[iArg]));
sprintf(pszTemp, "DISPLAY_FIELDS=%s", papszArgv[iArg] + strlen("-fields="));
papszOptions = CSLAddString(papszOptions, pszTemp);
CPLFree(pszTemp);
}
else if( EQUALN(papszArgv[iArg],"-geom=", strlen("-geom=")) )
{
char* pszTemp = (char*)CPLMalloc(32 + strlen(papszArgv[iArg]));
sprintf(pszTemp, "DISPLAY_GEOMETRY=%s", papszArgv[iArg] + strlen("-geom="));
papszOptions = CSLAddString(papszOptions, pszTemp);
CPLFree(pszTemp);
}
else if( papszArgv[iArg][0] == '-' )
{
Usage();
}
else if( pszDataSource == NULL )
pszDataSource = papszArgv[iArg];
else
{
papszLayers = CSLAddString( papszLayers, papszArgv[iArg] );
bAllLayers = FALSE;
}
}
if( pszDataSource == NULL )
Usage();
/* -------------------------------------------------------------------- */
/* Open data source. */
/* -------------------------------------------------------------------- */
OGRDataSource *poDS = NULL;
OGRSFDriver *poDriver = NULL;
poDS = OGRSFDriverRegistrar::Open( pszDataSource, !bReadOnly, &poDriver );
if( poDS == NULL && !bReadOnly )
{
poDS = OGRSFDriverRegistrar::Open( pszDataSource, FALSE, &poDriver );
if( poDS != NULL && bVerbose )
{
printf( "Had to open data source read-only.\n" );
bReadOnly = TRUE;
}
}
/* -------------------------------------------------------------------- */
/* Report failure */
/* -------------------------------------------------------------------- */
if( poDS == NULL )
{
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
printf( "FAILURE:\n"
"Unable to open datasource `%s' with the following drivers.\n",
pszDataSource );
for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
{
printf( " -> %s\n", poR->GetDriver(iDriver)->GetName() );
}
exit( 1 );
}
CPLAssert( poDriver != NULL);
/* -------------------------------------------------------------------- */
/* Some information messages. */
/* -------------------------------------------------------------------- */
if( bVerbose )
printf( "INFO: Open of `%s'\n"
" using driver `%s' successful.\n",
pszDataSource, poDriver->GetName() );
if( bVerbose && !EQUAL(pszDataSource,poDS->GetName()) )
{
printf( "INFO: Internal data source name `%s'\n"
" different from user name `%s'.\n",
poDS->GetName(), pszDataSource );
}
/* -------------------------------------------------------------------- */
/* Special case for -sql clause. No source layers required. */
/* -------------------------------------------------------------------- */
if( pszSQLStatement != NULL )
{
OGRLayer *poResultSet = NULL;
nRepeatCount = 0; // skip layer reporting.
if( CSLCount(papszLayers) > 0 )
printf( "layer names ignored in combination with -sql.\n" );
poResultSet = poDS->ExecuteSQL( pszSQLStatement, poSpatialFilter,
pszDialect );
if( poResultSet != NULL )
{
if( pszWHERE != NULL )
poResultSet->SetAttributeFilter( pszWHERE );
ReportOnLayer( poResultSet, NULL, NULL );
poDS->ReleaseResultSet( poResultSet );
}
}
CPLDebug( "OGR", "GetLayerCount() = %d\n", poDS->GetLayerCount() );
for( int iRepeat = 0; iRepeat < nRepeatCount; iRepeat++ )
{
if ( CSLCount(papszLayers) == 0 )
{
/* -------------------------------------------------------------------- */
/* Process each data source layer. */
/* -------------------------------------------------------------------- */
for( int iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ )
{
OGRLayer *poLayer = poDS->GetLayer(iLayer);
if( poLayer == NULL )
{
printf( "FAILURE: Couldn't fetch advertised layer %d!\n",
iLayer );
exit( 1 );
}
if (!bAllLayers)
{
printf( "%d: %s",
iLayer+1,
poLayer->GetLayerDefn()->GetName() );
if( poLayer->GetLayerDefn()->GetGeomType() != wkbUnknown )
printf( " (%s)",
OGRGeometryTypeToName(
poLayer->GetLayerDefn()->GetGeomType() ) );
printf( "\n" );
}
else
{
if( iRepeat != 0 )
poLayer->ResetReading();
ReportOnLayer( poLayer, pszWHERE, poSpatialFilter );
}
}
}
else
{
/* -------------------------------------------------------------------- */
/* Process specified data source layers. */
/* -------------------------------------------------------------------- */
char** papszIter = papszLayers;
for( ; *papszIter != NULL; papszIter++ )
{
OGRLayer *poLayer = poDS->GetLayerByName(*papszIter);
if( poLayer == NULL )
{
printf( "FAILURE: Couldn't fetch requested layer %s!\n",
*papszIter );
exit( 1 );
}
if( iRepeat != 0 )
poLayer->ResetReading();
ReportOnLayer( poLayer, pszWHERE, poSpatialFilter );
}
}
}
/* -------------------------------------------------------------------- */
/* Close down. */
/* -------------------------------------------------------------------- */
CSLDestroy( papszArgv );
CSLDestroy( papszLayers );
CSLDestroy( papszOptions );
OGRDataSource::DestroyDataSource( poDS );
if (poSpatialFilter)
OGRGeometryFactory::destroyGeometry( poSpatialFilter );
OGRCleanupAll();
return 0;
}
bool CStakeInfo::Load()
{
OGRRegisterAll();
OGRDataSource* poDataSource = NULL;
poDataSource = OGRSFDriverRegistrar::Open(m_strPath.c_str());
if (poDataSource == NULL)
{
printf("Open file faild [%s]", m_strPath.c_str());
return false;
}
OGRLayer *poLayer;
OGRFeature *poFeature;
poLayer = poDataSource->GetLayerByName(CPLGetBasename(m_strPath.c_str()));
poLayer->ResetReading();
while ((poFeature = poLayer->GetNextFeature()) != NULL)
{
StakeInfo stStakeInfo;
try
{
stStakeInfo.routeID = poFeature->GetFieldAsString("RD_NAME");
stStakeInfo.lLinkID = poFeature->GetFieldAsInteger("LINKID");
stStakeInfo.dcoord.Lat = poFeature->GetFieldAsDouble("XSWD");
stStakeInfo.dcoord.Lon = poFeature->GetFieldAsDouble("XSJD");
#ifdef ONLY_STAKE_DATA
stStakeInfo.strRouteName = poFeature->GetFieldAsString("LXMC");
stStakeInfo.iDir = poFeature->GetFieldAsInteger("SXX");
stStakeInfo.stakeID = atoi(poFeature->GetFieldAsString("LCZ"));
#else
stStakeInfo.stakeID = (int)poFeature->GetFieldAsDouble("LCZ");
#endif //
auto itWay = m_mapStakeInfo.find(stStakeInfo.routeID);
if (itWay != m_mapStakeInfo.end())
{
std::map<long long, std::vector<StakeInfo>>& mapStakeLink = itWay->second;
auto itLink = mapStakeLink.find(stStakeInfo.lLinkID);
if (itLink != mapStakeLink.end())
{
std::vector<StakeInfo>& vecStakeInfo = itLink->second;
for (int ii = 0;ii < vecStakeInfo.size(); ii++)
{
if (vecStakeInfo[ii].stakeID == stStakeInfo.stakeID)
{
auto itStake = vecStakeInfo.begin();
itStake += ii;
vecStakeInfo.erase(itStake);
}
}
vecStakeInfo.push_back(stStakeInfo);
}
else
{
std::vector<StakeInfo> vecStakeInfo;
mapStakeLink.insert(std::pair<long long, std::vector<StakeInfo>>(stStakeInfo.lLinkID, vecStakeInfo));
itLink = mapStakeLink.find(stStakeInfo.lLinkID);
itLink->second.push_back(stStakeInfo);
}
}
else
{
std::map<long long, std::vector<StakeInfo>> mapStakeLink;
m_mapStakeInfo.insert(std::pair<std::string, std::map<long long, std::vector<StakeInfo>>>(
stStakeInfo.routeID, mapStakeLink));
itWay = m_mapStakeInfo.find(stStakeInfo.routeID);
std::vector<StakeInfo> vecStakeInfo;
itWay->second.insert(std::pair<long long, std::vector<StakeInfo>>(stStakeInfo.lLinkID, vecStakeInfo));
auto itLink = itWay->second.find(stStakeInfo.lLinkID);
itLink->second.push_back(stStakeInfo);
}
}
catch (const std::exception&)
{
return false;
}
OGRFeature::DestroyFeature(poFeature);
}
OGRDataSource::DestroyDataSource(poDataSource);
return true;
}
