bool NgwGdalIo::getLayerInfo (NgwLayerInfo &layer_info, QString base_url, int resource_id)
{
GDALDatasetPtr dataset_p;
u_openDataset(dataset_p, base_url, resource_id, true);
if (dataset_p.data() == NULL)
{
error = QObject::tr("Unable to open NGW dataset via GDAL");
return false;
}
OGRLayer *layer = dataset_p.data()->GetLayer(0);
if (layer == NULL)
{
error = QObject::tr("Unable to open [0] layer of NGW dataset via GDAL");
return false;
}
OGRFeatureDefn *layer_defn = layer->GetLayerDefn();
layer_info.name = layer->GetName();
layer_info.geom_type = Core::g_findGeomTypeNgw(layer->GetGeomType());
for (int i = 0; i < layer_defn->GetFieldCount(); i++)
{
QString s_field_alias = QString("FIELD_%1_ALIAS").arg(i);
QString alias = layer->GetMetadataItem(s_field_alias.toUtf8().data());
OGRFieldDefn *field_defn = layer_defn->GetFieldDefn(i);
layer_info.fields.append({field_defn->GetNameRef(), alias,
Core::g_findFieldTypeNgw(field_defn->GetType())});
}
return true;
}
//#include "s57.h"
int main(int argc, char **argv)
{
OGRRegisterAll();
OGRDataSource *poDS;
printf("Opening %s\n",argv[1]);
poDS = OGRSFDriverRegistrar::Open( argv[1], FALSE );
if( poDS == NULL )
{
printf( "Open failed.\n" );
exit( 1 );
}
OGRLayer *poLayer;
int layers = poDS->GetLayerCount();
for (int layer =0 ; layer< layers; layer++) {
poLayer = poDS->GetLayer(layer);
if (poLayer == NULL) continue;
printf("%d, %s, %s",layer, poLayer->GetName(), OGRGeometryTypeToName(poLayer->GetGeomType()));
poLayer->ResetReading();
OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
int iField;
for( iField = 0; iField < poFDefn->GetFieldCount(); iField++ )
{
OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn( iField );
printf(", %s",poFieldDefn->GetNameRef());
}
printf("\n");
}
}
CPLErr GNMGenericNetwork::ConnectPointsByLines(char **papszLayerList,
double dfTolerance, double dfCost,
double dfInvCost, GNMDirection eDir)
{
if( CSLCount(papszLayerList) < 2 )
{
CPLError( CE_Failure, CPLE_IllegalArg, "Minimum 2 layers needed to connect" );
return CE_Failure;
}
std::vector<OGRLayer*> paLineLayers;
std::vector<OGRLayer*> paPointLayers;
int eType;
int iLayer;
OGRLayer* poLayer;
for(iLayer = 0; papszLayerList[iLayer] != NULL; ++iLayer)
{
poLayer = GetLayerByName(papszLayerList[iLayer]);
if(NULL == poLayer)
continue;
eType = wkbFlatten(poLayer->GetGeomType());
if(eType == wkbLineString || eType == wkbMultiLineString)
{
paLineLayers.push_back(poLayer);
}
else if(eType == wkbPoint)
{
paPointLayers.push_back(poLayer);
}
}
if (paLineLayers.empty() || paPointLayers.empty() )
{
CPLError( CE_Failure, CPLE_IllegalArg, "Need at least one line (or "
"multiline) layer and one point layer to connect" );
return CE_Failure;
}
// now walk through all lines and find nearest points for line start and end
OGRFeature* poFeature;
for(size_t i = 0; i < paLineLayers.size(); ++i)
{
poLayer = paLineLayers[i];
eType = wkbFlatten(poLayer->GetGeomType());
poLayer->ResetReading();
while((poFeature = poLayer->GetNextFeature()) != NULL)
{
const OGRGeometry* poGeom = poFeature->GetGeometryRef();
if(NULL != poGeom)
{
if(eType == wkbLineString)
{
const OGRLineString* poLineString =
(const OGRLineString*) poGeom;
ConnectPointsByLine(poFeature->GetFID(), poLineString,
paPointLayers, dfTolerance, dfCost,
dfInvCost, eDir);
}
else if( eType == wkbMultiLineString)
{
const OGRMultiLineString* poMultiLineString =
(const OGRMultiLineString*) poGeom;
ConnectPointsByMultiline(poFeature->GetFID(), poMultiLineString,
paPointLayers, dfTolerance, dfCost,
dfInvCost, eDir);
}
}
OGRFeature::DestroyFeature(poFeature);
}
}
return CE_None;
}
boost::optional<mapnik::datasource_geometry_t> ogr_datasource::get_geometry_type() const
{
boost::optional<mapnik::datasource_geometry_t> result;
if (dataset_ && layer_.is_valid())
{
OGRLayer* layer = layer_.layer();
// NOTE: wkbFlatten macro in ogr flattens 2.5d types into base 2d type
#if GDAL_VERSION_NUM < 1800
switch (wkbFlatten(layer->GetLayerDefn()->GetGeomType()))
#else
switch (wkbFlatten(layer->GetGeomType()))
#endif
{
case wkbPoint:
case wkbMultiPoint:
result.reset(mapnik::datasource_geometry_t::Point);
break;
case wkbLinearRing:
case wkbLineString:
case wkbMultiLineString:
result.reset(mapnik::datasource_geometry_t::LineString);
break;
case wkbPolygon:
case wkbMultiPolygon:
result.reset(mapnik::datasource_geometry_t::Polygon);
break;
case wkbGeometryCollection:
result.reset(mapnik::datasource_geometry_t::Collection);
break;
case wkbNone:
case wkbUnknown:
{
// fallback to inspecting first actual geometry
// TODO - csv and shapefile inspect first 4 features
if (dataset_ && layer_.is_valid())
{
layer = layer_.layer();
// only new either reset of setNext
//layer->ResetReading();
layer->SetNextByIndex(0);
OGRFeature *poFeature;
while ((poFeature = layer->GetNextFeature()) != nullptr)
{
OGRGeometry* geom = poFeature->GetGeometryRef();
if (geom && ! geom->IsEmpty())
{
switch (wkbFlatten(geom->getGeometryType()))
{
case wkbPoint:
case wkbMultiPoint:
result.reset(mapnik::datasource_geometry_t::Point);
break;
case wkbLinearRing:
case wkbLineString:
case wkbMultiLineString:
result.reset(mapnik::datasource_geometry_t::LineString);
break;
case wkbPolygon:
case wkbMultiPolygon:
result.reset(mapnik::datasource_geometry_t::Polygon);
break;
case wkbGeometryCollection:
result.reset(mapnik::datasource_geometry_t::Collection);
break;
default:
break;
}
}
OGRFeature::DestroyFeature( poFeature );
break;
}
}
break;
}
default:
break;
}
}
return result;
}
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();
}
MAIN_START(nArgc, papszArgv)
{
// Check strict compilation and runtime library version as we use C++ API.
if( !GDAL_CHECK_VERSION(papszArgv[0]) )
exit(1);
EarlySetConfigOptions(nArgc, papszArgv);
OGRRegisterAll();
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
nArgc = OGRGeneralCmdLineProcessor(nArgc, &papszArgv, 0);
if( nArgc < 1 )
exit(-nArgc);
char *pszWHERE = nullptr;
const char *pszDataSource = nullptr;
char **papszLayers = nullptr;
OGRGeometry *poSpatialFilter = nullptr;
int nRepeatCount = 1;
bool bAllLayers = false;
char *pszSQLStatement = nullptr;
const char *pszDialect = nullptr;
int nRet = 0;
const char* pszGeomField = nullptr;
char **papszOpenOptions = nullptr;
char **papszExtraMDDomains = nullptr;
bool bListMDD = false;
bool bShowMetadata = true;
bool bFeatureCount = true;
bool bExtent = true;
bool bDatasetGetNextFeature = false;
bool bReadOnly = false;
bool bUpdate = false;
const char* pszWKTFormat = "WKT2";
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"));
CSLDestroy(papszArgv);
return 0;
}
else if( EQUAL(papszArgv[iArg], "--help") )
{
Usage();
}
else if( EQUAL(papszArgv[iArg], "-ro") )
{
bReadOnly = true;
}
else if( EQUAL(papszArgv[iArg], "-update") )
{
bUpdate = true;
}
else if( EQUAL(papszArgv[iArg], "-q") ||
EQUAL(papszArgv[iArg], "-quiet"))
{
bVerbose = false;
}
else if( EQUAL(papszArgv[iArg], "-qq") )
{
/* Undocumented: mainly only useful for AFL testing */
bVerbose = false;
bSuperQuiet = true;
}
else if( EQUAL(papszArgv[iArg], "-fid") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
nFetchFID = CPLAtoGIntBig(papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg], "-spat") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(4);
OGRLinearRing oRing;
oRing.addPoint(CPLAtof(papszArgv[iArg+1]),
CPLAtof(papszArgv[iArg+2]));
oRing.addPoint(CPLAtof(papszArgv[iArg+1]),
CPLAtof(papszArgv[iArg+4]));
oRing.addPoint(CPLAtof(papszArgv[iArg+3]),
CPLAtof(papszArgv[iArg+4]));
oRing.addPoint(CPLAtof(papszArgv[iArg+3]),
CPLAtof(papszArgv[iArg+2]));
oRing.addPoint(CPLAtof(papszArgv[iArg+1]),
CPLAtof(papszArgv[iArg+2]));
poSpatialFilter = new OGRPolygon();
static_cast<OGRPolygon *>(poSpatialFilter)->addRing(&oRing);
iArg += 4;
}
else if( EQUAL(papszArgv[iArg], "-geomfield") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszGeomField = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg], "-where") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
iArg++;
CPLFree(pszWHERE);
GByte* pabyRet = nullptr;
if( papszArgv[iArg][0] == '@' &&
VSIIngestFile(nullptr, papszArgv[iArg] + 1, &pabyRet,
nullptr, 1024*1024) )
{
RemoveBOM(pabyRet);
pszWHERE = reinterpret_cast<char *>(pabyRet);
}
else
{
pszWHERE = CPLStrdup(papszArgv[iArg]);
}
}
else if( EQUAL(papszArgv[iArg], "-sql") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
iArg++;
CPLFree(pszSQLStatement);
GByte* pabyRet = nullptr;
if( papszArgv[iArg][0] == '@' &&
VSIIngestFile(nullptr, papszArgv[iArg] + 1, &pabyRet,
nullptr, 1024*1024) )
{
RemoveBOM(pabyRet);
pszSQLStatement = reinterpret_cast<char *>(pabyRet);
RemoveSQLComments(pszSQLStatement);
}
else
{
pszSQLStatement = CPLStrdup(papszArgv[iArg]);
}
}
else if( EQUAL(papszArgv[iArg], "-dialect") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszDialect = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg], "-rc") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
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( STARTS_WITH_CI(papszArgv[iArg], "-fields=") )
{
char* pszTemp =
static_cast<char *>(CPLMalloc(32 + strlen(papszArgv[iArg])));
snprintf(pszTemp,
32 + strlen(papszArgv[iArg]),
"DISPLAY_FIELDS=%s", papszArgv[iArg] + strlen("-fields="));
papszOptions = CSLAddString(papszOptions, pszTemp);
CPLFree(pszTemp);
}
else if( STARTS_WITH_CI(papszArgv[iArg], "-geom=") )
{
char* pszTemp =
static_cast<char *>(CPLMalloc(32 + strlen(papszArgv[iArg])));
snprintf(pszTemp,
32 + strlen(papszArgv[iArg]),
"DISPLAY_GEOMETRY=%s", papszArgv[iArg] + strlen("-geom="));
papszOptions = CSLAddString(papszOptions, pszTemp);
CPLFree(pszTemp);
}
else if( EQUAL(papszArgv[iArg], "-oo") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszOpenOptions = CSLAddString(papszOpenOptions,
papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg], "-nomd") )
{
bShowMetadata = false;
}
else if( EQUAL(papszArgv[iArg], "-listmdd") )
{
bListMDD = true;
}
else if( EQUAL(papszArgv[iArg], "-mdd") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszExtraMDDomains = CSLAddString(papszExtraMDDomains,
papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg], "-nocount") )
{
bFeatureCount = false;
}
else if( EQUAL(papszArgv[iArg], "-noextent") )
{
bExtent = false;
}
else if( EQUAL(papszArgv[iArg], "-rl"))
{
bDatasetGetNextFeature = true;
}
else if( EQUAL(papszArgv[iArg], "-wkt_format") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszWKTFormat = papszArgv[++iArg];
}
else if( papszArgv[iArg][0] == '-' )
{
Usage(CPLSPrintf("Unknown option name '%s'", papszArgv[iArg]));
}
else if( pszDataSource == nullptr )
{
pszDataSource = papszArgv[iArg];
}
else
{
papszLayers = CSLAddString(papszLayers, papszArgv[iArg]);
bAllLayers = false;
}
}
if( pszDataSource == nullptr )
Usage("No datasource specified.");
if( pszDialect != nullptr && pszWHERE != nullptr &&
pszSQLStatement == nullptr )
printf("Warning: -dialect is ignored with -where. Use -sql instead");
if( bDatasetGetNextFeature && pszSQLStatement )
{
Usage("-rl is incompatible with -sql");
}
#ifdef __AFL_HAVE_MANUAL_CONTROL
while (__AFL_LOOP(1000)) {
#endif
/* -------------------------------------------------------------------- */
/* Open data source. */
/* -------------------------------------------------------------------- */
GDALDataset *poDS = static_cast<GDALDataset *>(GDALOpenEx(
pszDataSource,
((bReadOnly || pszSQLStatement == nullptr) &&
!bUpdate ? GDAL_OF_READONLY : GDAL_OF_UPDATE) | GDAL_OF_VECTOR,
nullptr, papszOpenOptions, nullptr));
if( poDS == nullptr && !bReadOnly && !bUpdate &&
pszSQLStatement == nullptr )
{
// In some cases (empty geopackage for example), opening in read-only
// mode fails, so retry in update mode
if( GDALIdentifyDriverEx(pszDataSource, GDAL_OF_VECTOR,
nullptr, nullptr) )
{
poDS = static_cast<GDALDataset *>(GDALOpenEx(
pszDataSource,
GDAL_OF_UPDATE | GDAL_OF_VECTOR, nullptr,
papszOpenOptions, nullptr));
}
}
if( poDS == nullptr && !bReadOnly && !bUpdate &&
pszSQLStatement != nullptr )
{
poDS = static_cast<GDALDataset *>(GDALOpenEx(
pszDataSource,
GDAL_OF_READONLY | GDAL_OF_VECTOR, nullptr,
papszOpenOptions, nullptr));
if( poDS != nullptr && bVerbose )
{
printf("Had to open data source read-only.\n");
#ifdef __AFL_HAVE_MANUAL_CONTROL
bReadOnly = true;
#endif
}
}
GDALDriver *poDriver = nullptr;
if( poDS != nullptr )
poDriver = poDS->GetDriver();
/* -------------------------------------------------------------------- */
/* Report failure */
/* -------------------------------------------------------------------- */
if( poDS == nullptr )
{
printf("FAILURE:\n"
"Unable to open datasource `%s' with the following drivers.\n",
pszDataSource);
#ifdef __AFL_HAVE_MANUAL_CONTROL
continue;
#else
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
{
printf(" -> %s\n", poR->GetDriver(iDriver)->GetDescription());
}
nRet = 1;
goto end;
#endif
}
CPLAssert(poDriver != nullptr);
/* -------------------------------------------------------------------- */
/* Some information messages. */
/* -------------------------------------------------------------------- */
if( bVerbose )
printf("INFO: Open of `%s'\n"
" using driver `%s' successful.\n",
pszDataSource, poDriver->GetDescription());
if( bVerbose && !EQUAL(pszDataSource,poDS->GetDescription()) )
{
printf("INFO: Internal data source name `%s'\n"
" different from user name `%s'.\n",
poDS->GetDescription(), pszDataSource);
}
GDALInfoReportMetadata(static_cast<GDALMajorObjectH>(poDS),
bListMDD,
bShowMetadata,
papszExtraMDDomains);
if( bDatasetGetNextFeature )
{
nRepeatCount = 0; // skip layer reporting.
/* -------------------------------------------------------------------- */
/* Set filters if provided. */
/* -------------------------------------------------------------------- */
if( pszWHERE != nullptr || poSpatialFilter != nullptr )
{
for( int iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ )
{
OGRLayer *poLayer = poDS->GetLayer(iLayer);
if( poLayer == nullptr )
{
printf("FAILURE: Couldn't fetch advertised layer %d!\n",
iLayer);
exit(1);
}
if( pszWHERE != nullptr )
{
if( poLayer->SetAttributeFilter(pszWHERE) != OGRERR_NONE )
{
printf("WARNING: SetAttributeFilter(%s) "
"failed on layer %s.\n",
pszWHERE, poLayer->GetName());
}
}
if( poSpatialFilter != nullptr )
{
if( pszGeomField != nullptr )
{
OGRFeatureDefn *poDefn = poLayer->GetLayerDefn();
const int iGeomField =
poDefn->GetGeomFieldIndex(pszGeomField);
if( iGeomField >= 0 )
poLayer->SetSpatialFilter(iGeomField,
poSpatialFilter);
else
printf("WARNING: Cannot find geometry field %s.\n",
pszGeomField);
}
else
{
poLayer->SetSpatialFilter(poSpatialFilter);
}
}
}
}
std::set<OGRLayer*> oSetLayers;
while( true )
{
OGRLayer* poLayer = nullptr;
OGRFeature* poFeature = poDS->GetNextFeature(&poLayer, nullptr,
nullptr, nullptr);
if( poFeature == nullptr )
break;
if( papszLayers == nullptr || poLayer == nullptr ||
CSLFindString(papszLayers, poLayer->GetName()) >= 0 )
{
if( bVerbose && poLayer != nullptr &&
oSetLayers.find(poLayer) == oSetLayers.end() )
{
oSetLayers.insert(poLayer);
const bool bSummaryOnlyBackup = bSummaryOnly;
bSummaryOnly = true;
ReportOnLayer(poLayer, nullptr, nullptr, nullptr,
bListMDD, bShowMetadata,
papszExtraMDDomains,
bFeatureCount,
bExtent,
pszWKTFormat);
bSummaryOnly = bSummaryOnlyBackup;
}
if( !bSuperQuiet && !bSummaryOnly )
poFeature->DumpReadable(nullptr, papszOptions);
}
OGRFeature::DestroyFeature(poFeature);
}
}
/* -------------------------------------------------------------------- */
/* Special case for -sql clause. No source layers required. */
/* -------------------------------------------------------------------- */
else if( pszSQLStatement != nullptr )
{
nRepeatCount = 0; // skip layer reporting.
if( CSLCount(papszLayers) > 0 )
printf("layer names ignored in combination with -sql.\n");
OGRLayer *poResultSet =
poDS->ExecuteSQL(
pszSQLStatement,
pszGeomField == nullptr ? poSpatialFilter : nullptr,
pszDialect);
if( poResultSet != nullptr )
{
if( pszWHERE != nullptr )
{
if( poResultSet->SetAttributeFilter(pszWHERE) != OGRERR_NONE )
{
printf("FAILURE: SetAttributeFilter(%s) failed.\n",
pszWHERE);
exit(1);
}
}
if( pszGeomField != nullptr )
ReportOnLayer(poResultSet, nullptr,
pszGeomField, poSpatialFilter,
bListMDD, bShowMetadata, papszExtraMDDomains,
bFeatureCount, bExtent, pszWKTFormat);
else
ReportOnLayer(poResultSet, nullptr, nullptr, nullptr,
bListMDD, bShowMetadata, papszExtraMDDomains,
bFeatureCount, bExtent, pszWKTFormat);
poDS->ReleaseResultSet(poResultSet);
}
}
// coverity[tainted_data]
for( int iRepeat = 0; iRepeat < nRepeatCount; iRepeat++ )
{
if( papszLayers == nullptr || *papszLayers == nullptr )
{
if( iRepeat == 0 )
CPLDebug("OGR", "GetLayerCount() = %d\n",
poDS->GetLayerCount());
/* -------------------------------------------------------------------- */
/* Process each data source layer. */
/* -------------------------------------------------------------------- */
for( int iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ )
{
OGRLayer *poLayer = poDS->GetLayer(iLayer);
if( poLayer == nullptr )
{
printf("FAILURE: Couldn't fetch advertised layer %d!\n",
iLayer);
exit(1);
}
if( !bAllLayers )
{
printf("%d: %s", iLayer + 1, poLayer->GetName());
const int nGeomFieldCount =
poLayer->GetLayerDefn()->GetGeomFieldCount();
if( nGeomFieldCount > 1 )
{
printf(" (");
for( int iGeom = 0; iGeom < nGeomFieldCount; iGeom++ )
{
if( iGeom > 0 )
printf(", ");
OGRGeomFieldDefn* poGFldDefn =
poLayer->GetLayerDefn()->
GetGeomFieldDefn(iGeom);
printf(
"%s",
OGRGeometryTypeToName(
poGFldDefn->GetType()));
}
printf(")");
}
else if( poLayer->GetGeomType() != wkbUnknown )
printf(" (%s)",
OGRGeometryTypeToName(
poLayer->GetGeomType()));
printf("\n");
}
else
{
if( iRepeat != 0 )
poLayer->ResetReading();
ReportOnLayer(poLayer, pszWHERE,
pszGeomField, poSpatialFilter,
bListMDD, bShowMetadata, papszExtraMDDomains,
bFeatureCount, bExtent, pszWKTFormat);
}
}
}
else
{
/* -------------------------------------------------------------------- */
/* Process specified data source layers. */
/* -------------------------------------------------------------------- */
for( char** papszIter = papszLayers;
*papszIter != nullptr;
++papszIter )
{
OGRLayer *poLayer = poDS->GetLayerByName(*papszIter);
if( poLayer == nullptr )
{
printf("FAILURE: Couldn't fetch requested layer %s!\n",
*papszIter);
exit(1);
}
if( iRepeat != 0 )
poLayer->ResetReading();
ReportOnLayer(poLayer, pszWHERE, pszGeomField, poSpatialFilter,
bListMDD, bShowMetadata, papszExtraMDDomains,
bFeatureCount, bExtent, pszWKTFormat);
}
}
}
/* -------------------------------------------------------------------- */
/* Close down. */
/* -------------------------------------------------------------------- */
GDALClose(poDS);
#ifdef __AFL_HAVE_MANUAL_CONTROL
}
#else
end:
#endif
CSLDestroy(papszArgv);
CSLDestroy(papszLayers);
CSLDestroy(papszOptions);
CSLDestroy(papszOpenOptions);
CSLDestroy(papszExtraMDDomains);
if( poSpatialFilter )
OGRGeometryFactory::destroyGeometry(poSpatialFilter);
CPLFree(pszSQLStatement);
CPLFree(pszWHERE);
OGRCleanupAll();
return nRet;
}
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;
int nRet = 0;
/* 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() );
}
nRet = 1;
goto end;
}
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->GetName() );
if( poLayer->GetGeomType() != wkbUnknown )
printf( " (%s)",
OGRGeometryTypeToName(
poLayer->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. */
/* -------------------------------------------------------------------- */
end:
CSLDestroy( papszArgv );
CSLDestroy( papszLayers );
CSLDestroy( papszOptions );
OGRDataSource::DestroyDataSource( poDS );
if (poSpatialFilter)
OGRGeometryFactory::destroyGeometry( poSpatialFilter );
OGRCleanupAll();
return nRet;
}
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;
}
bool Shape::load(const std::string& filename) {
GDALAllRegister();
GDALDataset* poDS;
poDS = (GDALDataset*)GDALOpenEx(filename.c_str(), GDAL_OF_VECTOR, NULL, NULL, NULL);
if (poDS == NULL) return false;
// 初期化
shapeObjects.clear();
minBound.x = std::numeric_limits<float>::max();
minBound.y = std::numeric_limits<float>::max();
minBound.z = std::numeric_limits<float>::max();
maxBound.x = -std::numeric_limits<float>::max();
maxBound.y = -std::numeric_limits<float>::max();
maxBound.z = -std::numeric_limits<float>::max();
int nLayers = poDS->GetLayerCount();
int i = 0;
for (int n = 0; n < nLayers; ++n) {
OGRLayer* poLayer = poDS->GetLayer(n);
shapeType = poLayer->GetGeomType();
shapeObjects.resize(shapeObjects.size() + poLayer->GetFeatureCount());
OGRFeature* poFeature;
poLayer->ResetReading();
while ((poFeature = poLayer->GetNextFeature()) != NULL) {
// 属性の名前を読み込む
std::vector<std::string> fieldNames;
for (int j = 0; j < poFeature->GetFieldCount(); ++j) {
OGRFieldDefn* poFieldDefn = poFeature->GetFieldDefnRef(j);
fieldNames.push_back(poFieldDefn->GetNameRef());
}
// 属性の値を読み込む
OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
for (int j = 0; j < poFDefn->GetFieldCount(); ++j) {
OGRFieldDefn* poFieldDefn = poFDefn->GetFieldDefn(j);
if (poFieldDefn->GetType() == OFTInteger) {
shapeObjects[i].attributes[fieldNames[j]] = Variant(poFeature->GetFieldAsInteger(j));
}
else if (poFieldDefn->GetType() == OFTInteger64) {
shapeObjects[i].attributes[fieldNames[j]] = Variant(poFeature->GetFieldAsInteger(j));
}
else if (poFieldDefn->GetType() == OFTReal) {
shapeObjects[i].attributes[fieldNames[j]] = Variant(poFeature->GetFieldAsDouble(j));
}
else if (poFieldDefn->GetType() == OFTString) {
shapeObjects[i].attributes[fieldNames[j]] = Variant(poFeature->GetFieldAsString(j));
}
else {
shapeObjects[i].attributes[fieldNames[j]] = Variant(poFeature->GetFieldAsString(j));
}
}
// このshapeのベクトルデータを読み込む
OGRGeometry* poGeometry = poFeature->GetGeometryRef();
if (poGeometry != NULL) {
if (wkbFlatten(poGeometry->getGeometryType()) == wkbPoint) {
shapeObjects[i].parts.resize(1);
shapeObjects[i].parts[0].points.resize(1);
OGRPoint* poPoint = (OGRPoint*)poGeometry;
shapeObjects[i].parts[0].points[0].x = poPoint->getX();
shapeObjects[i].parts[0].points[0].y = poPoint->getY();
updateBounds(poPoint);
}
else if (wkbFlatten(poGeometry->getGeometryType()) == wkbLineString) {
OGRLineString* poLineString = (OGRLineString*)poGeometry;
readLineString(poLineString, shapeObjects[i]);
}
else if (wkbFlatten(poGeometry->getGeometryType()) == wkbPolygon) {
OGRPolygon* poPolygon = (OGRPolygon*)poGeometry;
readPolygon(poPolygon, shapeObjects[i]);
}
else if (wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPolygon) {
OGRMultiPolygon* poMultiPolygon = (OGRMultiPolygon*)poGeometry;
readMultiPolygon(poMultiPolygon, shapeObjects[i]);
}
else {
// not supported
}
}
// shapeObjectsのインデックスをインクリメント
i++;
// OGRが取得したメモリを開放
OGRFeature::DestroyFeature(poFeature);
}
}
GDALClose(poDS);
return true;
}
