//--------------------------------------------------------- CSG_Shapes * COGR_DataSource::Read_Shapes(int iLayer) { OGRLayer *pLayer = Get_Layer(iLayer); //----------------------------------------------------- if( pLayer && Get_Type(iLayer) != SHAPE_TYPE_Undefined ) { int iField; OGRFeature *pFeature; OGRFeatureDefn *pDef = pLayer->GetLayerDefn(); CSG_Shapes *pShapes = SG_Create_Shapes(Get_Type(iLayer), CSG_String(pDef->GetName())); for(iField=0; iField<pDef->GetFieldCount(); iField++) { OGRFieldDefn *pDefField = pDef->GetFieldDefn(iField); pShapes->Add_Field(pDefField->GetNameRef(), COGR_Driver::Get_Type(pDefField->GetType())); } pLayer->ResetReading(); //------------------------------------------------- while( (pFeature = pLayer->GetNextFeature()) != NULL && SG_UI_Process_Get_Okay(false) ) { OGRGeometry *pGeometry = pFeature->GetGeometryRef(); if( pGeometry != NULL ) { CSG_Shape *pShape = pShapes->Add_Shape(); for(iField=0; iField<pDef->GetFieldCount(); iField++) { OGRFieldDefn *pDefField = pDef->GetFieldDefn(iField); switch( pDefField->GetType() ) { default: pShape->Set_Value(iField, SG_STR_MBTOSG(pFeature->GetFieldAsString (iField))); break; case OFTString: pShape->Set_Value(iField, SG_STR_MBTOSG(pFeature->GetFieldAsString (iField))); break; case OFTInteger: pShape->Set_Value(iField, pFeature->GetFieldAsInteger(iField)); break; case OFTReal: pShape->Set_Value(iField, pFeature->GetFieldAsDouble (iField)); break; } } //----------------------------------------- if( _Read_Geometry(pShape, pGeometry) == false ) { pShapes->Del_Shape(pShape); } } OGRFeature::DestroyFeature(pFeature); } return( pShapes ); } //----------------------------------------------------- return( NULL ); }
bool SourceAddDialog::checkRequiredFields() { if (mp_DataSource == NULL) return false; OGRFeatureDefn* Defn = mp_DataSource->GetLayerByName(m_SrcInfos.LayerName.toStdString().c_str())->GetLayerDefn(); int FIndex = Defn->GetFieldIndex(OGRGDAL_UNITID_FIELD); if (FIndex >=0 && (Defn->GetFieldDefn(FIndex)->GetType() == OFTInteger || Defn->GetFieldDefn(FIndex)->GetType() == OFTReal || Defn->GetFieldDefn(FIndex)->GetType() == OFTString)) return true; return false; }
//#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"); } }
QDebug operator<<(QDebug dbg, OGRLayer* layer) { layer->ResetReading(); OGRFeatureDefn* def = layer->GetLayerDefn(); FeaturePtr feat; while ((feat = FeaturePtr(layer->GetNextFeature())) != nullptr) { for (int i = 0; i < def->GetFieldCount(); ++i) { OGRFieldDefn* fdef = def->GetFieldDefn(i); switch (fdef->GetType()) { case OFTInteger: dbg << fdef->GetNameRef() << feat->GetFieldAsInteger(i); break; case OFTReal: dbg << fdef->GetNameRef() << feat->GetFieldAsDouble(i); break; case OFTString: dbg << fdef->GetNameRef() << feat->GetFieldAsString(i); break; default: dbg << "Unknown type:" << fdef->GetType(); } } dbg << "-----"; } return dbg; }
void cvct2gdal::CVCT2GDALLayer( VCTLayer * poVCTLayer, OGRLayer * poOGRLayer ) { OGRFeatureDefn * poOGRFeatDefn = cvct2gdal::CVCT2GDALFeatureDefn ( & (poVCTLayer->featuredefn ) ); for ( int ifield = 0; ifield < poOGRFeatDefn->GetFieldCount(); ++ifield ) { poOGRLayer->CreateField ( poOGRFeatDefn->GetFieldDefn ( ifield ) ); } for (auto ifeat = 0; ifeat != poVCTLayer->GetFeatureCount(); ++ifeat) { VCTFeature * poVCTFeat = poVCTLayer->GetFeatureByIndex(ifeat); //注意:feature在析构时,会将featuredefn也析构 //将featuredefn复制后传入 OGRFeature * poOGRFeat = cvct2gdal::CVCT2GDALFeature ( poVCTFeat, poOGRFeatDefn->Clone()); poOGRLayer->CreateFeature ( poOGRFeat ); //在window下,释放内存会报错 #ifndef WIN32 OGRFeature::DestroyFeature(poOGRFeat); #endif } //在window下,释放内存会报错 #ifndef WIN32 poOGRFeatDefn->Release(); #endif }
Handle<Value> LayerFields::getNames(const Arguments& args) { HandleScope scope; Handle<Object> parent = args.This()->GetHiddenValue(String::NewSymbol("parent_"))->ToObject(); Layer *layer = ObjectWrap::Unwrap<Layer>(parent); if (!layer->get()) { return NODE_THROW("Layer object already destroyed"); } OGRFeatureDefn *def = layer->get()->GetLayerDefn(); if (!def) { return NODE_THROW("Layer has no layer definition set"); } int n = def->GetFieldCount(); Handle<Array> result = Array::New(n); for (int i = 0; i < n; i++) { OGRFieldDefn *field_def = def->GetFieldDefn(i); result->Set(i, SafeString::New(field_def->GetNameRef())); } return scope.Close(result); }
int main( int nArgc, char ** papszArgv ) { OGROCISession *poSession = NULL; const char *pszStatement = "SELECT * FROM NEPSITE"; int nColCount; char **papszResult; if( nArgc > 1 ) pszStatement = papszArgv[1]; poSession = OGRGetOCISession( "system", "LetoKing", "" ); if( poSession == NULL ) exit( 1 ); OGROCIStatement oStatement( poSession ); if( oStatement.Execute( pszStatement ) == CE_Failure ) exit( 2 ); while( (papszResult = oStatement.SimpleFetchRow()) != NULL ) { OGRFeatureDefn *poDefn = oStatement.GetResultDefn(); int nColCount = poDefn->GetFieldCount(); int i; printf( "\n" ); for( i = 0; i < nColCount; i++ ) { printf( " %s = %s\n", poDefn->GetFieldDefn(i)->GetNameRef(), papszResult[i] ); } } }
static void OGR2SQLITE_ogr_geocode_set_result(sqlite3_context* pContext, OGRLayerH hLayer, const char* pszField) { if( hLayer == NULL ) sqlite3_result_null (pContext); else { OGRLayer* poLayer = (OGRLayer*)hLayer; OGRFeatureDefn* poFDefn = poLayer->GetLayerDefn(); OGRFeature* poFeature = poLayer->GetNextFeature(); int nIdx = -1; if( poFeature == NULL ) sqlite3_result_null (pContext); else if( strcmp(pszField, "geometry") == 0 && poFeature->GetGeometryRef() != NULL ) { GByte* pabyGeomBLOB = NULL; int nGeomBLOBLen = 0; if( OGRSQLiteLayer::ExportSpatiaLiteGeometry( poFeature->GetGeometryRef(), 4326, wkbNDR, FALSE, FALSE, FALSE, &pabyGeomBLOB, &nGeomBLOBLen ) != CE_None ) { sqlite3_result_null (pContext); } else { sqlite3_result_blob (pContext, pabyGeomBLOB, nGeomBLOBLen, CPLFree); } } else if( (nIdx = poFDefn->GetFieldIndex(pszField)) >= 0 && poFeature->IsFieldSet(nIdx) ) { OGRFieldType eType = poFDefn->GetFieldDefn(nIdx)->GetType(); if( eType == OFTInteger ) sqlite3_result_int(pContext, poFeature->GetFieldAsInteger(nIdx)); else if( eType == OFTInteger64 ) sqlite3_result_int64(pContext, poFeature->GetFieldAsInteger64(nIdx)); else if( eType == OFTReal ) sqlite3_result_double(pContext, poFeature->GetFieldAsDouble(nIdx)); else sqlite3_result_text(pContext, poFeature->GetFieldAsString(nIdx), -1, SQLITE_TRANSIENT); } else sqlite3_result_null (pContext); delete poFeature; OGRGeocodeFreeResult(hLayer); } }
OGRErr OGRLayer::SetIgnoredFields( const char **papszFields ) { OGRFeatureDefn *poDefn = GetLayerDefn(); // first set everything as *not* ignored for( int iField = 0; iField < poDefn->GetFieldCount(); iField++ ) { poDefn->GetFieldDefn(iField)->SetIgnored( FALSE ); } poDefn->SetGeometryIgnored( FALSE ); poDefn->SetStyleIgnored( FALSE ); if ( papszFields == NULL ) return OGRERR_NONE; // ignore some fields while ( *papszFields ) { const char* pszFieldName = *papszFields; // check special fields if ( EQUAL(pszFieldName, "OGR_GEOMETRY") ) poDefn->SetGeometryIgnored( TRUE ); else if ( EQUAL(pszFieldName, "OGR_STYLE") ) poDefn->SetStyleIgnored( TRUE ); else { // check ordinary fields int iField = poDefn->GetFieldIndex(pszFieldName); if ( iField == -1 ) return OGRERR_FAILURE; else poDefn->GetFieldDefn(iField)->SetIgnored( TRUE ); } papszFields++; } return OGRERR_NONE; }
static void OGR2SQLITE_IgnoreAllFieldsExceptGeometry(OGRLayer* poLayer) { char** papszIgnored = NULL; papszIgnored = CSLAddString(papszIgnored, "OGR_STYLE"); OGRFeatureDefn* poFeatureDefn = poLayer->GetLayerDefn(); for(int i=0; i < poFeatureDefn->GetFieldCount(); i++) { papszIgnored = CSLAddString(papszIgnored, poFeatureDefn->GetFieldDefn(i)->GetNameRef()); } poLayer->SetIgnoredFields((const char**)papszIgnored); CSLDestroy(papszIgnored); }
JNIEXPORT jlong JNICALL Java_es_gva_cit_jogr_OGRFeatureDefn_getFieldDefnNat (JNIEnv *env, jobject obj, jlong cPtr, jint i){ OGRFeatureDefn *df = (OGRFeatureDefn *) 0 ; OGRFieldDefn *field; long ptro_field; df = *(OGRFeatureDefn **)&cPtr; if(df!=NULL){ field = df->GetFieldDefn(i); ptro_field = (long)&(*field); } return (jlong)ptro_field; }
int main() { // Read in raster data for night time lights int band_number = 1; // only one band, starts with one Raster* raster = import_raster("raster.tif", band_number); // Read in shapefile data containing municipality administrative regions int layer_number = 0; // only one layer, starts with zero OGRLayer* shapelayer = import_shapefile("MEX_adm2.shp", layer_number); shapelayer->SetAttributeFilter("ID_1 = 1834"); // Filter for Yucatan const int idx_of_number_field = 5; // Column number of municipality number const int idx_of_name_field = 6; // Column number of municipality name OGRFeature* poFeature; int feature_ctr = 0; while( (poFeature = shapelayer->GetNextFeature()) != NULL ) { cerr << "Feature: " << feature_ctr++ << "\t"; int feature_num = poFeature->GetFieldAsInteger(idx_of_number_field); string feature_name = poFeature->GetFieldAsString(idx_of_name_field); OGRFeatureDefn *poFDefn = shapelayer->GetLayerDefn(); for( int iField = 0; iField < poFDefn->GetFieldCount(); iField++ ) { OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn( iField ); if( poFieldDefn->GetType() == OFTString ) cerr << poFeature->GetFieldAsString(iField) << ","; } OGRGeometry* poGeometry = poFeature->GetGeometryRef(); if( poGeometry != NULL) { // For contiguous regions if ( wkbFlatten(poGeometry->getGeometryType()) == wkbPolygon ) { cerr << " polygon" << endl; report_raster_data_within_polygon(raster, (OGRPolygon *) poGeometry, feature_num, feature_name); // For disjoint regions } else if ( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPolygon ) { cerr << " multipolygon" << endl; OGRMultiPolygon *multipolygon = (OGRMultiPolygon *) poGeometry; for (int i = 0; i<multipolygon->getNumGeometries(); i++) { report_raster_data_within_polygon(raster, (OGRPolygon*) multipolygon->getGeometryRef(i), feature_num, feature_name); } // Is this really the right shapefile? } else { cerr << "No polygon or multipolygon geometry for this feature: " << poGeometry->getGeometryName() << endl; } } else { cerr << "No geometry for this feature" << endl; } } OGRFeature::DestroyFeature( poFeature ); }
json_object* OGRGMEAttributesToGeoJSON( OGRFeature* poFeature ) { if ( NULL == poFeature ) return NULL; json_object* pjoProperties = json_object_new_object(); CPLAssert( NULL != pjoProperties ); OGRFeatureDefn* poDefn = poFeature->GetDefnRef(); for( int nField = 0; nField < poDefn->GetFieldCount(); ++nField ) { json_object* pjoProperty = NULL; OGRFieldDefn* poFieldDefn = poDefn->GetFieldDefn( nField ); if ( NULL == poFieldDefn ) continue; OGRFieldType eType = poFieldDefn->GetType(); if( !poFeature->IsFieldSet(nField) ) pjoProperty = NULL; // In GME integers are encoded as strings. else if( OFTInteger == eType ) pjoProperty = json_object_new_string( poFeature->GetFieldAsString( nField ) ); else if( OFTReal == eType ) pjoProperty = json_object_new_gme_double( poFeature->GetFieldAsDouble(nField) ); // Supported types are integer, double and string. So treating everything else as strings else pjoProperty = json_object_new_string( poFeature->GetFieldAsString(nField) ); json_object_object_add( pjoProperties, poFieldDefn->GetNameRef(), pjoProperty ); } int nGxId = poFeature->GetFieldIndex("gx_id"); if (nGxId < 0) { json_object* pjoProperty = NULL; GIntBig nFID = poFeature->GetFID(); char acGxId[128]; snprintf(acGxId, 128, "GDAL-" CPL_FRMT_GIB, nFID); CPLDebug("GME", "gx_id is not set, so adding \"gx_id\": \"%s\" field.", acGxId); pjoProperty = json_object_new_string( acGxId ); json_object_object_add( pjoProperties, "gx_id", pjoProperty); } return pjoProperties; }
wxString wxGISGridTable::GetColLabelValue(int col) { wxString label; OGRFeatureDefn* pOGRFeatureDefn = m_pGISDataset->GetDefinition(); if(!pOGRFeatureDefn) return wxEmptyString; OGRFieldDefn* pOGRFieldDefn = pOGRFeatureDefn->GetFieldDefn(col); if(pOGRFieldDefn) label = wxString(pOGRFieldDefn->GetNameRef(), wxConvUTF8); if(label.IsSameAs(m_pGISDataset->GetFIDColumn(), false)) { label.Append(_(" [*]")); } return label; }
OGRESRIFeatureServiceLayer::OGRESRIFeatureServiceLayer(OGRESRIFeatureServiceDataset* poDS) { this->poDS = poDS; OGRFeatureDefn* poSrcFeatDefn = poDS->GetUnderlyingLayer()->GetLayerDefn(); poFeatureDefn = new OGRFeatureDefn(poSrcFeatDefn->GetName()); SetDescription(poFeatureDefn->GetName()); poFeatureDefn->Reference(); poFeatureDefn->SetGeomType(wkbNone); for(int i=0;i<poSrcFeatDefn->GetFieldCount();i++) poFeatureDefn->AddFieldDefn(poSrcFeatDefn->GetFieldDefn(i)); for(int i=0;i<poSrcFeatDefn->GetGeomFieldCount();i++) poFeatureDefn->AddGeomFieldDefn(poSrcFeatDefn->GetGeomFieldDefn(i)); nFeaturesRead = 0; nLastFID = 0; bOtherPage = FALSE; bUseSequentialFID = FALSE; }
static void ReportOnLayer( OGRLayer * poLayer ) { OGRFeatureDefn *poDefn = poLayer->GetLayerDefn(); printf( "\n" ); printf( "Layer name: %s\n", poDefn->GetName() ); printf( "Feature Count: %d\n", poLayer->GetFeatureCount() ); if( bVerbose ) { char *pszWKT; if( poLayer->GetSpatialRef() == NULL ) pszWKT = CPLStrdup( "(NULL)" ); else poLayer->GetSpatialRef()->exportToWkt( &pszWKT ); printf( "Layer SRS WKT: %s\n", pszWKT ); CPLFree( pszWKT ); } for( int iAttr = 0; iAttr < poDefn->GetFieldCount(); iAttr++ ) { OGRFieldDefn *poField = poDefn->GetFieldDefn( iAttr ); printf( "%s: %s (%d.%d)\n", poField->GetNameRef(), poField->GetFieldTypeName( poField->GetType() ), poField->GetWidth(), poField->GetPrecision() ); } /* -------------------------------------------------------------------- */ /* Read, and dump features. */ /* -------------------------------------------------------------------- */ OGRFeature *poFeature; while( (poFeature = poLayer->GetNextFeature()) != NULL ) { poFeature->DumpReadable( stdout ); delete poFeature; } }
OGRESRIFeatureServiceLayer::OGRESRIFeatureServiceLayer( OGRESRIFeatureServiceDataset* poDSIn) : poDS(poDSIn), nFeaturesRead(0), nLastFID(0), bOtherPage(false), bUseSequentialFID(false) { OGRFeatureDefn* poSrcFeatDefn = poDS->GetUnderlyingLayer()->GetLayerDefn(); poFeatureDefn = new OGRFeatureDefn(poSrcFeatDefn->GetName()); SetDescription(poFeatureDefn->GetName()); poFeatureDefn->Reference(); poFeatureDefn->SetGeomType(wkbNone); for(int i=0;i<poSrcFeatDefn->GetFieldCount();i++) poFeatureDefn->AddFieldDefn(poSrcFeatDefn->GetFieldDefn(i)); for(int i=0;i<poSrcFeatDefn->GetGeomFieldCount();i++) poFeatureDefn->AddGeomFieldDefn(poSrcFeatDefn->GetGeomFieldDefn(i)); }
void SourceAddDialog::proceedToImport() { if (prepareToImport()) { m_SrcInfos.SourceGeomType = mp_DataSource->GetLayer(ui->LayersTableWidget->currentRow())->GetGeomType(); m_SrcInfos.LayerName = QString(mp_DataSource->GetLayer(ui->LayersTableWidget->currentRow())->GetName()); if (checkRequiredFields()) { OGRFeatureDefn* Defn = mp_DataSource->GetLayerByName(m_SrcInfos.LayerName.toStdString().c_str())->GetLayerDefn(); for (int i=0; i< Defn->GetFieldCount();i++) m_SrcInfos.AvailableFields.append(Defn->GetFieldDefn(i)->GetNameRef()); if (m_SrcInfos.AvailableFields.contains(OGRGDAL_PSORD_FIELD)) m_SrcInfos.UnitsPcsOrdField = OGRGDAL_PSORD_FIELD; if (m_SrcInfos.AvailableFields.contains(OGRGDAL_TOCONN_FIELD)) m_SrcInfos.ToConnectionsField = OGRGDAL_TOCONN_FIELD; if (m_SrcInfos.AvailableFields.contains(OGRGDAL_CHILDOF_FIELD)) m_SrcInfos.ChildofConnectionsField = OGRGDAL_CHILDOF_FIELD; accept(); } else { QMessageBox::critical(this,tr("Import error"), tr("Error importing from source")+"\n"+ m_CurrentSourceURI+"\n\n"+ tr("The mandatory field \"OFLD_ID\" cannot be found.")+"\n\n"+ tr("Aborting.")); reject(); } } else { QMessageBox::critical(this,tr("Import error"), tr("Error importing from source")+"\n"+ m_CurrentSourceURI+"\n\n"+ tr("Aborting.")); reject(); } }
OGRErr OGRLayerWithTransaction::AlterFieldDefn( int iField, OGRFieldDefn* poNewFieldDefn, int nFlags ) { if( !m_poDecoratedLayer ) return OGRERR_FAILURE; OGRErr eErr = m_poDecoratedLayer->AlterFieldDefn(iField, poNewFieldDefn, nFlags); if( m_poFeatureDefn && eErr == OGRERR_NONE ) { OGRFieldDefn* poSrcFieldDefn = m_poDecoratedLayer->GetLayerDefn()->GetFieldDefn(iField); OGRFieldDefn* poDstFieldDefn = m_poFeatureDefn->GetFieldDefn(iField); poDstFieldDefn->SetName(poSrcFieldDefn->GetNameRef()); poDstFieldDefn->SetType(poSrcFieldDefn->GetType()); poDstFieldDefn->SetSubType(poSrcFieldDefn->GetSubType()); poDstFieldDefn->SetWidth(poSrcFieldDefn->GetWidth()); poDstFieldDefn->SetPrecision(poSrcFieldDefn->GetPrecision()); poDstFieldDefn->SetDefault(poSrcFieldDefn->GetDefault()); poDstFieldDefn->SetNullable(poSrcFieldDefn->IsNullable()); } return eErr; }
Handle<Value> LayerFields::get(const Arguments& args) { HandleScope scope; Handle<Object> parent = args.This()->GetHiddenValue(String::NewSymbol("parent_"))->ToObject(); Layer *layer = ObjectWrap::Unwrap<Layer>(parent); if (!layer->get()) { return NODE_THROW("Layer object already destroyed"); } if (args.Length() < 1) { return NODE_THROW("Field index or name must be given"); } OGRFeatureDefn *def = layer->get()->GetLayerDefn(); if (!def) { return NODE_THROW("Layer has no layer definition set"); } int field_index; ARG_FIELD_ID(0, def, field_index); return scope.Close(FieldDefn::New(def->GetFieldDefn(field_index))); }
int main( int nArgc, char ** papszArgv ) { int nFirstSourceDataset = -1, bLayersWildcarded = TRUE, iArg; const char *pszFormat = "ESRI Shapefile"; const char *pszTileIndexField = "LOCATION"; const char *pszOutputName = NULL; int write_absolute_path = FALSE; int skip_different_projection = FALSE; char* current_path = NULL; int accept_different_schemas = FALSE; int bFirstWarningForNonMatchingAttributes = TRUE; /* 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. */ /* -------------------------------------------------------------------- */ for( 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],"-f") && iArg < nArgc-1 ) { pszFormat = papszArgv[++iArg]; } else if( EQUAL(papszArgv[iArg],"-write_absolute_path")) { write_absolute_path = TRUE; } else if( EQUAL(papszArgv[iArg],"-skip_different_projection")) { skip_different_projection = TRUE; } else if( EQUAL(papszArgv[iArg],"-accept_different_schemas")) { accept_different_schemas = TRUE; } else if( EQUAL(papszArgv[iArg],"-tileindex") && iArg < nArgc-1 ) { pszTileIndexField = papszArgv[++iArg]; } else if( EQUAL(papszArgv[iArg],"-lnum") || EQUAL(papszArgv[iArg],"-lname") ) { iArg++; bLayersWildcarded = FALSE; } else if( papszArgv[iArg][0] == '-' ) Usage(); else if( pszOutputName == NULL ) pszOutputName = papszArgv[iArg]; else if( nFirstSourceDataset == -1 ) nFirstSourceDataset = iArg; } if( pszOutputName == NULL || nFirstSourceDataset == -1 ) Usage(); /* -------------------------------------------------------------------- */ /* Try to open as an existing dataset for update access. */ /* -------------------------------------------------------------------- */ OGRDataSource *poDstDS; OGRLayer *poDstLayer = NULL; poDstDS = OGRSFDriverRegistrar::Open( pszOutputName, TRUE ); /* -------------------------------------------------------------------- */ /* If that failed, find the driver so we can create the tile index.*/ /* -------------------------------------------------------------------- */ if( poDstDS == NULL ) { OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar(); OGRSFDriver *poDriver = NULL; int iDriver; for( iDriver = 0; iDriver < poR->GetDriverCount() && poDriver == NULL; iDriver++ ) { if( EQUAL(poR->GetDriver(iDriver)->GetName(),pszFormat) ) { poDriver = poR->GetDriver(iDriver); } } if( poDriver == NULL ) { fprintf( stderr, "Unable to find driver `%s'.\n", pszFormat ); fprintf( stderr, "The following drivers are available:\n" ); for( iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ ) { fprintf( stderr, " -> `%s'\n", poR->GetDriver(iDriver)->GetName() ); } exit( 1 ); } if( !poDriver->TestCapability( ODrCCreateDataSource ) ) { fprintf( stderr, "%s driver does not support data source creation.\n", pszFormat ); exit( 1 ); } /* -------------------------------------------------------------------- */ /* Now create it. */ /* -------------------------------------------------------------------- */ poDstDS = poDriver->CreateDataSource( pszOutputName, NULL ); if( poDstDS == NULL ) { fprintf( stderr, "%s driver failed to create %s\n", pszFormat, pszOutputName ); exit( 1 ); } if( poDstDS->GetLayerCount() == 0 ) { OGRFieldDefn oLocation( pszTileIndexField, OFTString ); oLocation.SetWidth( 200 ); if( nFirstSourceDataset < nArgc && papszArgv[nFirstSourceDataset][0] == '-' ) { nFirstSourceDataset++; } OGRSpatialReference* poSrcSpatialRef = NULL; /* Fetches the SRS of the first layer and use it when creating the tileindex layer */ if (nFirstSourceDataset < nArgc) { OGRDataSource* poDS = OGRSFDriverRegistrar::Open( papszArgv[nFirstSourceDataset], FALSE ); if (poDS) { int iLayer; for( iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ ) { int bRequested = bLayersWildcarded; OGRLayer *poLayer = poDS->GetLayer(iLayer); for( iArg = 1; iArg < nArgc && !bRequested; iArg++ ) { if( EQUAL(papszArgv[iArg],"-lnum") && atoi(papszArgv[iArg+1]) == iLayer ) bRequested = TRUE; else if( EQUAL(papszArgv[iArg],"-lname") && EQUAL(papszArgv[iArg+1], poLayer->GetLayerDefn()->GetName()) ) bRequested = TRUE; } if( !bRequested ) continue; if ( poLayer->GetSpatialRef() ) poSrcSpatialRef = poLayer->GetSpatialRef()->Clone(); break; } } OGRDataSource::DestroyDataSource( poDS ); } poDstLayer = poDstDS->CreateLayer( "tileindex", poSrcSpatialRef ); poDstLayer->CreateField( &oLocation, OFTString ); OGRSpatialReference::DestroySpatialReference( poSrcSpatialRef ); } } /* -------------------------------------------------------------------- */ /* Identify target layer and field. */ /* -------------------------------------------------------------------- */ int iTileIndexField; poDstLayer = poDstDS->GetLayer(0); if( poDstLayer == NULL ) { fprintf( stderr, "Can't find any layer in output tileindex!\n" ); exit( 1 ); } iTileIndexField = poDstLayer->GetLayerDefn()->GetFieldIndex( pszTileIndexField ); if( iTileIndexField == -1 ) { fprintf( stderr, "Can't find %s field in tile index dataset.\n", pszTileIndexField ); exit( 1 ); } OGRFeatureDefn* poFeatureDefn = NULL; /* Load in memory existing file names in SHP */ int nExistingLayers = 0; char** existingLayersTab = NULL; OGRSpatialReference* alreadyExistingSpatialRef = NULL; int alreadyExistingSpatialRefValid = FALSE; nExistingLayers = poDstLayer->GetFeatureCount(); if (nExistingLayers) { int i; existingLayersTab = (char**)CPLMalloc(nExistingLayers * sizeof(char*)); for(i=0;i<nExistingLayers;i++) { OGRFeature* feature = poDstLayer->GetNextFeature(); existingLayersTab[i] = CPLStrdup(feature->GetFieldAsString( iTileIndexField)); if (i == 0) { OGRDataSource *poDS; char* filename = CPLStrdup(existingLayersTab[i]); int j; for(j=strlen(filename)-1;j>=0;j--) { if (filename[j] == ',') break; } if (j >= 0) { int iLayer = atoi(filename + j + 1); filename[j] = 0; poDS = OGRSFDriverRegistrar::Open(filename, FALSE ); if (poDS) { OGRLayer *poLayer = poDS->GetLayer(iLayer); if (poLayer) { alreadyExistingSpatialRefValid = TRUE; alreadyExistingSpatialRef = (poLayer->GetSpatialRef()) ? poLayer->GetSpatialRef()->Clone() : NULL; if (poFeatureDefn == NULL) poFeatureDefn = poLayer->GetLayerDefn()->Clone(); } OGRDataSource::DestroyDataSource( poDS ); } } } } } if (write_absolute_path) { current_path = CPLGetCurrentDir(); if (current_path == NULL) { fprintf( stderr, "This system does not support the CPLGetCurrentDir call. " "The option -write_absolute_path will have no effect\n"); write_absolute_path = FALSE; } } /* ==================================================================== */ /* Process each input datasource in turn. */ /* ==================================================================== */ for(; nFirstSourceDataset < nArgc; nFirstSourceDataset++ ) { int i; OGRDataSource *poDS; if( papszArgv[nFirstSourceDataset][0] == '-' ) { nFirstSourceDataset++; continue; } char* fileNameToWrite; VSIStatBuf sStatBuf; if (write_absolute_path && CPLIsFilenameRelative( papszArgv[nFirstSourceDataset] ) && VSIStat( papszArgv[nFirstSourceDataset], &sStatBuf ) == 0) { fileNameToWrite = CPLStrdup(CPLProjectRelativeFilename(current_path,papszArgv[nFirstSourceDataset])); } else { fileNameToWrite = CPLStrdup(papszArgv[nFirstSourceDataset]); } poDS = OGRSFDriverRegistrar::Open( papszArgv[nFirstSourceDataset], FALSE ); if( poDS == NULL ) { fprintf( stderr, "Failed to open dataset %s, skipping.\n", papszArgv[nFirstSourceDataset] ); CPLFree(fileNameToWrite); continue; } /* -------------------------------------------------------------------- */ /* Check all layers, and see if they match requests. */ /* -------------------------------------------------------------------- */ int iLayer; for( iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ ) { int bRequested = bLayersWildcarded; OGRLayer *poLayer = poDS->GetLayer(iLayer); for( iArg = 1; iArg < nArgc && !bRequested; iArg++ ) { if( EQUAL(papszArgv[iArg],"-lnum") && atoi(papszArgv[iArg+1]) == iLayer ) bRequested = TRUE; else if( EQUAL(papszArgv[iArg],"-lname") && EQUAL(papszArgv[iArg+1], poLayer->GetLayerDefn()->GetName()) ) bRequested = TRUE; } if( !bRequested ) continue; /* Checks that the layer is not already in tileindex */ for(i=0;i<nExistingLayers;i++) { char szLocation[5000]; sprintf( szLocation, "%s,%d", fileNameToWrite, iLayer ); if (EQUAL(szLocation, existingLayersTab[i])) { fprintf(stderr, "Layer %d of %s is already in tileindex. Skipping it.\n", iLayer, papszArgv[nFirstSourceDataset]); break; } } if (i != nExistingLayers) { continue; } OGRSpatialReference* spatialRef = poLayer->GetSpatialRef(); if (alreadyExistingSpatialRefValid) { if ((spatialRef != NULL && alreadyExistingSpatialRef != NULL && spatialRef->IsSame(alreadyExistingSpatialRef) == FALSE) || ((spatialRef != NULL) != (alreadyExistingSpatialRef != NULL))) { fprintf(stderr, "Warning : layer %d of %s is not using the same projection system as " "other files in the tileindex. This may cause problems when " "using it in MapServer for example.%s\n", iLayer, papszArgv[nFirstSourceDataset], (skip_different_projection) ? " Skipping it" : ""); if (skip_different_projection) { continue; } } } else { alreadyExistingSpatialRefValid = TRUE; alreadyExistingSpatialRef = (spatialRef) ? spatialRef->Clone() : NULL; } /* -------------------------------------------------------------------- */ /* Check if all layers in dataset have the same attributes schema. */ /* -------------------------------------------------------------------- */ if( poFeatureDefn == NULL ) { poFeatureDefn = poLayer->GetLayerDefn()->Clone(); } else if ( !accept_different_schemas ) { OGRFeatureDefn* poFeatureDefnCur = poLayer->GetLayerDefn(); assert(NULL != poFeatureDefnCur); int fieldCount = poFeatureDefnCur->GetFieldCount(); if( fieldCount != poFeatureDefn->GetFieldCount()) { fprintf( stderr, "Number of attributes of layer %s of %s does not match ... skipping it.\n", poLayer->GetLayerDefn()->GetName(), papszArgv[nFirstSourceDataset]); if (bFirstWarningForNonMatchingAttributes) { fprintf( stderr, "Note : you can override this behaviour with -accept_different_schemas option\n" "but this may result in a tileindex incompatible with MapServer\n"); bFirstWarningForNonMatchingAttributes = FALSE; } continue; } int bSkip = FALSE; for( int fn = 0; fn < poFeatureDefnCur->GetFieldCount(); fn++ ) { OGRFieldDefn* poField = poFeatureDefn->GetFieldDefn(fn); OGRFieldDefn* poFieldCur = poFeatureDefnCur->GetFieldDefn(fn); /* XXX - Should those pointers be checked against NULL? */ assert(NULL != poField); assert(NULL != poFieldCur); if( poField->GetType() != poFieldCur->GetType() || poField->GetWidth() != poFieldCur->GetWidth() || poField->GetPrecision() != poFieldCur->GetPrecision() || !EQUAL( poField->GetNameRef(), poFieldCur->GetNameRef() ) ) { fprintf( stderr, "Schema of attributes of layer %s of %s does not match ... skipping it.\n", poLayer->GetLayerDefn()->GetName(), papszArgv[nFirstSourceDataset]); if (bFirstWarningForNonMatchingAttributes) { fprintf( stderr, "Note : you can override this behaviour with -accept_different_schemas option\n" "but this may result in a tileindex incompatible with MapServer\n"); bFirstWarningForNonMatchingAttributes = FALSE; } bSkip = TRUE; break; } } if (bSkip) continue; } /* -------------------------------------------------------------------- */ /* Get layer extents, and create a corresponding polygon */ /* geometry. */ /* -------------------------------------------------------------------- */ OGREnvelope sExtents; OGRPolygon oRegion; OGRLinearRing oRing; if( poLayer->GetExtent( &sExtents, TRUE ) != OGRERR_NONE ) { fprintf( stderr, "GetExtent() failed on layer %s of %s, skipping.\n", poLayer->GetLayerDefn()->GetName(), papszArgv[nFirstSourceDataset] ); continue; } oRing.addPoint( sExtents.MinX, sExtents.MinY ); oRing.addPoint( sExtents.MinX, sExtents.MaxY ); oRing.addPoint( sExtents.MaxX, sExtents.MaxY ); oRing.addPoint( sExtents.MaxX, sExtents.MinY ); oRing.addPoint( sExtents.MinX, sExtents.MinY ); oRegion.addRing( &oRing ); /* -------------------------------------------------------------------- */ /* Add layer to tileindex. */ /* -------------------------------------------------------------------- */ char szLocation[5000]; OGRFeature oTileFeat( poDstLayer->GetLayerDefn() ); sprintf( szLocation, "%s,%d", fileNameToWrite, iLayer ); oTileFeat.SetGeometry( &oRegion ); oTileFeat.SetField( iTileIndexField, szLocation ); if( poDstLayer->CreateFeature( &oTileFeat ) != OGRERR_NONE ) { fprintf( stderr, "Failed to create feature on tile index ... terminating." ); OGRDataSource::DestroyDataSource( poDstDS ); exit( 1 ); } } /* -------------------------------------------------------------------- */ /* Cleanup this data source. */ /* -------------------------------------------------------------------- */ CPLFree(fileNameToWrite); OGRDataSource::DestroyDataSource( poDS ); } /* -------------------------------------------------------------------- */ /* Close tile index and clear buffers. */ /* -------------------------------------------------------------------- */ OGRDataSource::DestroyDataSource( poDstDS ); OGRFeatureDefn::DestroyFeatureDefn( poFeatureDefn ); if (alreadyExistingSpatialRef != NULL) OGRSpatialReference::DestroySpatialReference( alreadyExistingSpatialRef ); CPLFree(current_path); if (nExistingLayers) { int i; for(i=0;i<nExistingLayers;i++) { CPLFree(existingLayersTab[i]); } CPLFree(existingLayersTab); } return 0; }
bool ShpReader::Open(std::wstring fullPath, StudyControllerPtr studyController, VectorMapControllerPtr vectorMapController, ProgressDlgPtr progressDlg) { // Registers all format drivers built into GDAL/OGR. OGRRegisterAll(); OGRDataSource *OGRDataset; // Open vector file path std::string tempStr( fullPath.begin(), fullPath.end() ); OGRDataset = OGRSFDriverRegistrar::Open( tempStr.c_str(), FALSE ); // Return if no vector files are found if( OGRDataset == NULL ) { Log::Inst().Warning("(Warning) Failed to open file at " + tempStr + "."); return false; } if ( App::Inst().GetLayerTreeController()->GetNumMapLayers() >0 ) MapControllerPtr mapController= App::Inst().GetLayerTreeController()->GetLayerTreeModel()->GetStudy(0)->GetMapLayer(0)->GetMapController(); // It appears that shapefiles (*.SHP) only support up to one layer per file // This will need to be further investigated for other vector filetypes (e.g., KML) // For now just grab layer at position 0 OGRLayer *poLayer = OGRDataset->GetLayer( 0 ); // Determine the XY boundaries for the entire vector dataset OGREnvelope psEnvelope; VectorMapModelPtr vectorMapModel = vectorMapController->GetVectorMapModel(); poLayer->GetExtent( &psEnvelope ); vectorMapModel->SetVectorBoundary(psEnvelope); if(!SetupVectorProjection(OGRDataset,studyController,poLayer,vectorMapController )) { OGRDataset->DestroyDataSource(OGRDataset); return false; } if(progressDlg) { if(!progressDlg->Update(0, _T("Reading Vector Map Information..."))) { OGRDataset->DestroyDataSource(OGRDataset); return false; } } GLdouble minX, minY, maxX, maxY; minX = minY = std::numeric_limits<float>::max(); maxX = maxY = -std::numeric_limits<float>::max(); // Retrieve features from the dataset OGRFeature *poFeature; poLayer->ResetReading(); int numFeatures = poLayer->GetFeatureCount(); int count=0; //Log::Inst().Write("Loading shapefile with the following meta data:"); while ( ( poFeature = poLayer->GetNextFeature() ) != NULL ) { ///////////////////////////////////////////////// // PHASE 1: Retrieve METADATA from the dataset // ///////////////////////////////////////////////// OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn(); int iField; for( iField = 0; iField < poFDefn->GetFieldCount(); iField++ ) { OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn( iField ); //if( poFieldDefn->GetType() == OFTInteger ) // printf( "%d,", poFeature->GetFieldAsInteger( iField ) ); //else if( poFieldDefn->GetType() == OFTReal ) // printf( "%.3f,", poFeature->GetFieldAsDouble(iField) ); //else if( poFieldDefn->GetType() == OFTString ) // printf( "%s,", poFeature->GetFieldAsString(iField) ); //else // printf( "%s,", poFeature->GetFieldAsString(iField) ); //ofs << poFeature->GetFieldAsString(iField) << ","; std::string metaData = poFeature->GetFieldAsString(iField); // do something with the meta data... //Log::Inst().Write(metaData); } count++; if(progressDlg) { if(!progressDlg->Update(int(50 + (float(count)/numFeatures)*50))) return false; } /////////////////////////////////////////////////// // PHASE 2: Retrieve GEOMETRIES from the dataset // /////////////////////////////////////////////////// OGRGeometry *poGeometry; poGeometry = poFeature->GetGeometryRef(); // Move to the next feature in the set if no geometry present if( poGeometry == NULL ) { OGRFeature::DestroyFeature( poFeature ); continue; } OGRwkbGeometryType whatisit = poGeometry->getGeometryType(); // Handle POINTS if ( wkbFlatten( poGeometry->getGeometryType() ) == wkbPoint ) { GeoVector* geoVector = new GeoVector(); OGRPoint *poPoint = (OGRPoint *) poGeometry; geoVector->SetGeometryType( wkbPoint ); geoVector->SetNumberOfPoints( 1 ); if(needProjection) { double x,y; x= poPoint->getX(); y= poPoint->getY(); if(!poTransform->Transform(1, &x, &y)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } // project and store the points geoVector->pointX[0] = x; geoVector->pointY[0] = y; if(x < minX) minX=x; if(y < minY) minY=y; if(x > maxX) maxX=x; if(y > maxY) maxY=y; } else { geoVector->pointX[0] = poPoint->getX(); geoVector->pointY[0] = poPoint->getY(); } vectorMapController->GetVectorMapModel()->AddGeoVector( geoVector ); } //Handle MultiPoint else if ( wkbFlatten( poGeometry->getGeometryType() ) == wkbMultiPoint ) { OGRMultiPoint *poMultiPoint = (OGRMultiPoint *) poGeometry; for ( int currGeometry = 0; currGeometry < poMultiPoint->getNumGeometries(); currGeometry++ ) { GeoVector* geoVector = new GeoVector(); OGRPoint *poPoint = ( OGRPoint* )poMultiPoint->getGeometryRef( currGeometry ); geoVector->SetGeometryType( wkbPoint ); geoVector->SetNumberOfPoints( 1 ); if(needProjection) { double x,y; x= poPoint->getX(); y= poPoint->getY(); if(!poTransform->Transform(1, &x, &y)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } // project and store the points geoVector->pointX[0] = x; geoVector->pointY[0] = y; if(x < minX) minX=x; if(y < minY) minY=y; if(x > maxX) maxX=x; if(y > maxY) maxY=y; } else { geoVector->pointX[0] = poPoint->getX(); geoVector->pointY[0] = poPoint->getY(); } vectorMapController->GetVectorMapModel()->AddGeoVector( geoVector ); } } //Handle Polylines else if ( wkbFlatten( poGeometry->getGeometryType() ) == wkbLineString ) { GeoVector* geoVector = new GeoVector(); OGRLineString *poLine = (OGRLineString *) poGeometry; geoVector->SetGeometryType( wkbLineString ); geoVector->SetNumberOfPoints( poLine->getNumPoints() ); // Convert and store the points for ( int currentPoint = 0; currentPoint < poLine->getNumPoints(); currentPoint++ ) { // Convert and store the points if(needProjection) { double x,y; x= poLine->getX( currentPoint ); y= poLine->getY( currentPoint ); if(!poTransform->Transform(1, &x, &y)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } // project and store the points geoVector->pointX[currentPoint] = x; geoVector->pointY[currentPoint] = y; if(x < minX) minX=x; if(y < minY) minY=y; if(x > maxX) maxX=x; if(y > maxY) maxY=y; } else { geoVector->pointX[currentPoint] = poLine->getX( currentPoint ); geoVector->pointY[currentPoint] = poLine->getY( currentPoint ); } } vectorMapController->GetVectorMapModel()->AddGeoVector( geoVector ); } // Handle MultiPolyLine else if ( wkbFlatten( poGeometry->getGeometryType() ) == wkbMultiLineString ) { OGRMultiLineString *poMultiLine = (OGRMultiLineString *) poGeometry; for ( int currGeometry = 0; currGeometry < poMultiLine->getNumGeometries(); currGeometry++ ) { GeoVector* geoVector = new GeoVector(); OGRLineString *poLine = ( OGRLineString* )poMultiLine->getGeometryRef( currGeometry ); geoVector->SetGeometryType( wkbLineString ); geoVector->SetNumberOfPoints( poLine->getNumPoints() ); for ( int currentPoint = 0; currentPoint < poLine ->getNumPoints(); currentPoint++ ) { if(needProjection) { double x,y; x= poLine->getX( currentPoint ); y= poLine->getY( currentPoint ); if(!poTransform->Transform(1, &x, &y)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } // project and store the points geoVector->pointX[currentPoint] = x; geoVector->pointY[currentPoint] = y; if(x < minX) minX=x; if(y < minY) minY=y; if(x > maxX) maxX=x; if(y > maxY) maxY=y; } else { geoVector->pointX[currentPoint] = poLine->getX( currentPoint ); geoVector->pointY[currentPoint] = poLine->getY( currentPoint ); } } vectorMapController->GetVectorMapModel()->AddGeoVector( geoVector ); } } // Handle POLYGONS else if ( wkbFlatten( poGeometry->getGeometryType() ) == wkbPolygon ) { GeoVector* geoVector = new GeoVector(); OGRPolygon *poPolygon = ( OGRPolygon* )poGeometry; OGRLinearRing *poLinearRing = poPolygon->getExteriorRing(); geoVector->SetGeometryType( wkbLinearRing ); geoVector->SetNumberOfPoints( poLinearRing->getNumPoints() ); for ( int currentPoint = 0; currentPoint < poLinearRing->getNumPoints(); currentPoint++ ) { if(needProjection) { double x,y; x= poLinearRing->getX( currentPoint ); y= poLinearRing->getY( currentPoint ); if(!poTransform->Transform(1, &x, &y)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } // project and store the points geoVector->pointX[currentPoint] = x; geoVector->pointY[currentPoint] = y; if(x < minX) minX=x; if(y < minY) minY=y; if(x > maxX) maxX=x; if(y > maxY) maxY=y; } else { geoVector->pointX[currentPoint] = poLinearRing->getX( currentPoint ); geoVector->pointY[currentPoint] = poLinearRing->getY( currentPoint ); } } vectorMapController->GetVectorMapModel()->AddGeoVector( geoVector ); } // Handle MULTIPOLYGONS else if ( wkbFlatten( poGeometry->getGeometryType() ) == wkbMultiPolygon ) { OGRMultiPolygon *poMultiPolygon = (OGRMultiPolygon *) poGeometry; for ( int currGeometry = 0; currGeometry < poMultiPolygon->getNumGeometries(); currGeometry++ ) { GeoVector* geoVector = new GeoVector(); // OGRPolygon http://www.gdal.org/ogr/classOGRPolygon.html OGRPolygon *poPolygon = ( OGRPolygon* )poMultiPolygon->getGeometryRef( currGeometry ); // Retrieve the EXTERNAL ring of the multipolygon OGRLinearRing *poLinearRing = poPolygon->getExteriorRing(); geoVector->SetGeometryType( wkbLinearRing ); geoVector->SetNumberOfPoints( poLinearRing->getNumPoints() ); for ( int currentPoint = 0; currentPoint < poLinearRing->getNumPoints(); currentPoint++ ) { if(needProjection) { double x,y; x= poLinearRing->getX( currentPoint ); y= poLinearRing->getY( currentPoint ); if(!poTransform->Transform(1, &x, &y)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } // project and store the points geoVector->pointX[currentPoint] = x; geoVector->pointY[currentPoint] = y; if(x < minX) minX=x; if(y < minY) minY=y; if(x > maxX) maxX=x; if(y > maxY) maxY=y; } else { geoVector->pointX[currentPoint] = poLinearRing->getX( currentPoint ); geoVector->pointY[currentPoint] = poLinearRing->getY( currentPoint ); } } vectorMapController->GetVectorMapModel()->AddGeoVector( geoVector ); // Retrieve all the INTERNAL rings of the multipolygon for ( int currentRing = 0; currentRing < poPolygon->getNumInteriorRings(); currentRing++ ) { GeoVector* geoVector2 = new GeoVector(); poLinearRing = poPolygon->getInteriorRing( currentRing ); geoVector2->SetGeometryType( wkbLinearRing ); geoVector2->SetNumberOfPoints( poLinearRing->getNumPoints() ); for ( int currentPoint = 0; currentPoint < poLinearRing->getNumPoints(); currentPoint++ ) { if(needProjection) { double x,y; x= poLinearRing->getX( currentPoint ); y= poLinearRing->getY( currentPoint ); if(!poTransform->Transform(1, &x, &y)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } // project and store the points geoVector2->pointX[currentPoint] = x; geoVector2->pointY[currentPoint] = y; if(x < minX) minX=x; if(y < minY) minY=y; if(x > maxX) maxX=x; if(y > maxY) maxY=y; } else { geoVector2->pointX[currentPoint] = poLinearRing->getX( currentPoint ); geoVector2->pointY[currentPoint] = poLinearRing->getY( currentPoint ); } } vectorMapController->GetVectorMapModel()->AddGeoVector( geoVector2 ); } } } // Report a warning message for unhandled geometries else { Log::Inst().Warning("(Warning) Could not load vector data: unsupported geometry."); } OGRFeature::DestroyFeature( poFeature ); } if (float(minX) == float(maxX) && float(minY) == float(maxY)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } if(needProjection) { vectorMapModel->SetVectorBoundary_MinX(minX); vectorMapModel->SetVectorBoundary_MaxX(maxX); vectorMapModel->SetVectorBoundary_MinY(minY); vectorMapModel->SetVectorBoundary_MaxY(maxY); } if(!SetupVectorScaling(vectorMapModel,progressDlg)) { OGRDataset->DestroyDataSource(OGRDataset); return false; } VectorMetaDataInfo(OGRDataset, studyController, vectorMapController); OGRDataSource::DestroyDataSource( OGRDataset ); return true; }
/********************************************************************** * Tab2Tab() * * Copy features from source dataset to a new dataset **********************************************************************/ static int Tab2Tab(const char *pszSrcFname, const char *pszDstFname, int nMaxFeatures, GBool bQuickSpatialIndexMode, GBool bOptSpatialIndexMode) { IMapInfoFile *poSrcFile = NULL, *poDstFile = NULL; int nFeatureId, iField, numFeatures=0; TABFeature *poFeature; double dXMin, dYMin, dXMax, dYMax; /*--------------------------------------------------------------------- * If there is a "micdsys.txt" in current directory then load it *--------------------------------------------------------------------*/ MITABLoadCoordSysTable("micdsys.txt"); /*--------------------------------------------------------------------- * Try to open source file *--------------------------------------------------------------------*/ if ((poSrcFile = IMapInfoFile::SmartOpen(pszSrcFname)) == NULL) { printf("Failed to open %s\n", pszSrcFname); return -1; } OGRFeatureDefn *poDefn = poSrcFile->GetLayerDefn(); /*--------------------------------------------------------------------- * The extension of the output filename tells us if we should create * a MIF or a TAB file for output. *--------------------------------------------------------------------*/ if (EQUAL(".mif", pszDstFname + strlen(pszDstFname)-4) || EQUAL(".mid", pszDstFname + strlen(pszDstFname)-4) ) { // Create a MIF file poDstFile = new MIFFile; } else { /*----------------------------------------------------------------- * Create a TAB dataset. * Find out if the file contains at least 1 unique field... if so we * will create a TABView instead of a TABFile *----------------------------------------------------------------*/ GBool bFoundUniqueField = FALSE; for(iField=0; iField< poDefn->GetFieldCount(); iField++) { if (poSrcFile->IsFieldUnique(iField)) bFoundUniqueField = TRUE; } if (bFoundUniqueField) poDstFile = new TABView; else poDstFile = new TABFile; } /*--------------------------------------------------------------------- * Try to open destination file *--------------------------------------------------------------------*/ if (poDstFile->Open(pszDstFname, "wb") != 0) { printf("Failed to open %s\n", pszDstFname); poSrcFile->Close(); delete poSrcFile; delete poDstFile; return -1; } if ( (bQuickSpatialIndexMode && poDstFile->SetQuickSpatialIndexMode(TRUE) != 0) || (bOptSpatialIndexMode && poDstFile->SetQuickSpatialIndexMode(FALSE) != 0) ) { printf("Failed setting Quick Spatial Index Mode (-q|-o) on %s\n", pszDstFname); poSrcFile->Close(); delete poSrcFile; poDstFile->Close(); delete poDstFile; return -1; } // Pass Proj. info directly // TABProjInfo sProjInfo; // if (poSrcFile->GetProjInfo(&sProjInfo) == 0) // poDstFile->SetProjInfo(&sProjInfo); OGRSpatialReference *poSR; poSR = poSrcFile->GetSpatialRef(); if( poSR != NULL ) { poDstFile->SetSpatialRef( poSR ); } // Set bounds (must be done after setting spatialref) if (poSrcFile->GetBounds(dXMin, dYMin, dXMax, dYMax) == 0) poDstFile->SetBounds(dXMin, dYMin, dXMax, dYMax); /*--------------------------------------------------------------------- * Pass compplete fields information *--------------------------------------------------------------------*/ for(iField=0; iField< poDefn->GetFieldCount(); iField++) { OGRFieldDefn *poFieldDefn = poDefn->GetFieldDefn(iField); poDstFile->AddFieldNative(poFieldDefn->GetNameRef(), poSrcFile->GetNativeFieldType(iField), poFieldDefn->GetWidth(), poFieldDefn->GetPrecision(), poSrcFile->IsFieldIndexed(iField), poSrcFile->IsFieldUnique(iField)); } /*--------------------------------------------------------------------- * Copy objects until EOF is reached *--------------------------------------------------------------------*/ nFeatureId = -1; while ( (nFeatureId = poSrcFile->GetNextFeatureId(nFeatureId)) != -1 && (nMaxFeatures < 1 || numFeatures++ < nMaxFeatures )) { poFeature = poSrcFile->GetFeatureRef(nFeatureId); if (poFeature) { // poFeature->DumpReadable(stdout); // poFeature->DumpMIF(); poDstFile->CreateFeature(poFeature); } else { printf( "Failed to read feature %d.\n", nFeatureId ); return -1; // GetFeatureRef() failed: Error } } /*--------------------------------------------------------------------- * Cleanup and exit. *--------------------------------------------------------------------*/ poDstFile->Close(); delete poDstFile; poSrcFile->Close(); delete poSrcFile; MITABFreeCoordSysTable(); return 0; }
json_object* OGRGeoJSONWriteAttributes( OGRFeature* poFeature ) { CPLAssert( NULL != poFeature ); json_object* poObjProps = json_object_new_object(); CPLAssert( NULL != poObjProps ); OGRFeatureDefn* poDefn = poFeature->GetDefnRef(); for( int nField = 0; nField < poDefn->GetFieldCount(); ++nField ) { json_object* poObjProp; OGRFieldDefn* poFieldDefn = poDefn->GetFieldDefn( nField ); CPLAssert( NULL != poFieldDefn ); OGRFieldType eType = poFieldDefn->GetType(); OGRFieldSubType eSubType = poFieldDefn->GetSubType(); if( !poFeature->IsFieldSet(nField) ) { poObjProp = NULL; } else if( OFTInteger == eType ) { if( eSubType == OFSTBoolean ) poObjProp = json_object_new_boolean( poFeature->GetFieldAsInteger( nField ) ); else poObjProp = json_object_new_int( poFeature->GetFieldAsInteger( nField ) ); } else if( OFTInteger64 == eType ) { if( eSubType == OFSTBoolean ) poObjProp = json_object_new_boolean( (json_bool)poFeature->GetFieldAsInteger64( nField ) ); else poObjProp = json_object_new_int64( poFeature->GetFieldAsInteger64( nField ) ); } else if( OFTReal == eType ) { poObjProp = json_object_new_double( poFeature->GetFieldAsDouble(nField) ); } else if( OFTString == eType ) { poObjProp = json_object_new_string( poFeature->GetFieldAsString(nField) ); } else if( OFTIntegerList == eType ) { int nSize = 0; const int* panList = poFeature->GetFieldAsIntegerList(nField, &nSize); poObjProp = json_object_new_array(); for(int i=0;i<nSize;i++) { if( eSubType == OFSTBoolean ) json_object_array_add(poObjProp, json_object_new_boolean(panList[i])); else json_object_array_add(poObjProp, json_object_new_int(panList[i])); } } else if( OFTInteger64List == eType ) { int nSize = 0; const GIntBig* panList = poFeature->GetFieldAsInteger64List(nField, &nSize); poObjProp = json_object_new_array(); for(int i=0;i<nSize;i++) { if( eSubType == OFSTBoolean ) json_object_array_add(poObjProp, json_object_new_boolean((json_bool)panList[i])); else json_object_array_add(poObjProp, json_object_new_int64(panList[i])); } } else if( OFTRealList == eType ) { int nSize = 0; const double* padfList = poFeature->GetFieldAsDoubleList(nField, &nSize); poObjProp = json_object_new_array(); for(int i=0;i<nSize;i++) { json_object_array_add(poObjProp, json_object_new_double(padfList[i])); } } else if( OFTStringList == eType ) { char** papszStringList = poFeature->GetFieldAsStringList(nField); poObjProp = json_object_new_array(); for(int i=0; papszStringList && papszStringList[i]; i++) { json_object_array_add(poObjProp, json_object_new_string(papszStringList[i])); } } else { poObjProp = json_object_new_string( poFeature->GetFieldAsString(nField) ); } json_object_object_add( poObjProps, poFieldDefn->GetNameRef(), poObjProp ); } return poObjProps; }
int OGRGFTResultLayer::RunSQL() { CPLString osChangedSQL(osSQL); int bHasSetLimit = FALSE; OGRGFTTableLayer* poTableLayer = NULL; OGRFeatureDefn* poTableDefn = NULL; CPLString osTableId; if (EQUALN(osSQL.c_str(), "SELECT", 6)) { size_t nPosFROM = osSQL.ifind(" FROM "); if (nPosFROM == std::string::npos) { CPLError(CE_Failure, CPLE_AppDefined, "RunSQL() failed. Missing FROM in SELECT"); return FALSE; } CPLString osReminder; nPosFROM += 6; osTableId = OGRGFTExtractTableID(osSQL.c_str() + nPosFROM, osReminder); poTableLayer = (OGRGFTTableLayer*) poDS->GetLayerByName(osTableId); if (poTableLayer != NULL) poTableDefn = poTableLayer->GetLayerDefn(); if (poTableLayer != NULL && poTableLayer->GetTableId().size() && !EQUAL(osTableId, poTableLayer->GetTableId())) { osChangedSQL = osSQL; osChangedSQL.resize(nPosFROM); osChangedSQL += poTableLayer->GetTableId(); osChangedSQL += osReminder; osSQL = osChangedSQL; CPLDebug("GFT", "Patching table name (%s) to table id (%s)", osTableId.c_str(), poTableLayer->GetTableId().c_str()); } int nFeaturesToFetch = GetFeaturesToFetch(); if (osSQL.ifind(" OFFSET ") == std::string::npos && osSQL.ifind(" LIMIT ") == std::string::npos && nFeaturesToFetch > 0) { osChangedSQL += CPLSPrintf(" LIMIT %d", nFeaturesToFetch); bHasSetLimit = TRUE; } } else { bGotAllRows = bEOF = TRUE; poFeatureDefn->SetGeomType( wkbNone ); } CPLHTTPResult * psResult = poDS->RunSQL(osChangedSQL); if (psResult == NULL) return FALSE; char* pszLine = (char*) psResult->pabyData; if (pszLine == NULL || psResult->pszErrBuf != NULL) { CPLError(CE_Failure, CPLE_AppDefined, "RunSQL() failed"); CPLHTTPDestroyResult(psResult); return FALSE; } if (EQUALN(osSQL.c_str(), "SELECT", 6) || EQUAL(osSQL.c_str(), "SHOW TABLES") || EQUALN(osSQL.c_str(), "DESCRIBE", 8)) { ParseCSVResponse(pszLine, aosRows); if (aosRows.size() > 0) { char** papszTokens = OGRGFTCSVSplitLine(aosRows[0], ','); for(int i=0;papszTokens && papszTokens[i];i++) { CPLString osLaunderedColName(LaunderColName(papszTokens[i])); int iIndex = (poTableDefn) ? poTableDefn->GetFieldIndex(osLaunderedColName) : -1; if (iIndex >= 0) { poFeatureDefn->AddFieldDefn(poTableDefn->GetFieldDefn(iIndex)); if (iIndex == poTableLayer->GetGeometryFieldIndex()) iGeometryField = i; if (iIndex == poTableLayer->GetLatitudeFieldIndex()) iLatitudeField = i; if (iIndex == poTableLayer->GetLongitudeFieldIndex()) iLongitudeField = i; } else { OGRFieldType eType = OFTString; if (EQUAL(osLaunderedColName, "COUNT()")) eType = OFTInteger; OGRFieldDefn oFieldDefn(osLaunderedColName, eType); poFeatureDefn->AddFieldDefn(&oFieldDefn); } } CSLDestroy(papszTokens); aosRows.erase(aosRows.begin()); } if (iLatitudeField >= 0 && iLongitudeField >= 0) { iGeometryField = iLatitudeField; poFeatureDefn->SetGeomType( wkbPoint ); } if (bHasSetLimit) bGotAllRows = bEOF = (int)aosRows.size() < GetFeaturesToFetch(); else bGotAllRows = bEOF = TRUE; } SetGeomFieldName(); CPLHTTPDestroyResult(psResult); return TRUE; }
void OGRUnionLayer::ConfigureActiveLayer() { AutoWarpLayerIfNecessary(iCurLayer); ApplyAttributeFilterToSrcLayer(iCurLayer); SetSpatialFilterToSourceLayer(papoSrcLayers[iCurLayer]); papoSrcLayers[iCurLayer]->ResetReading(); /* Establish map */ GetLayerDefn(); OGRFeatureDefn* poSrcFeatureDefn = papoSrcLayers[iCurLayer]->GetLayerDefn(); CPLFree(panMap); panMap = (int*) CPLMalloc(poSrcFeatureDefn->GetFieldCount() * sizeof(int)); for(int i=0; i < poSrcFeatureDefn->GetFieldCount(); i++) { OGRFieldDefn* poSrcFieldDefn = poSrcFeatureDefn->GetFieldDefn(i); if( CSLFindString(papszIgnoredFields, poSrcFieldDefn->GetNameRef() ) == -1 ) { panMap[i] = poFeatureDefn->GetFieldIndex(poSrcFieldDefn->GetNameRef()); } else { panMap[i] = -1; } } if( papoSrcLayers[iCurLayer]->TestCapability(OLCIgnoreFields) ) { char** papszIter = papszIgnoredFields; char** papszFieldsSrc = NULL; while ( papszIter != NULL && *papszIter != NULL ) { const char* pszFieldName = *papszIter; if ( EQUAL(pszFieldName, "OGR_GEOMETRY") || EQUAL(pszFieldName, "OGR_STYLE") || poSrcFeatureDefn->GetFieldIndex(pszFieldName) >= 0 || poSrcFeatureDefn->GetGeomFieldIndex(pszFieldName) >= 0 ) { papszFieldsSrc = CSLAddString(papszFieldsSrc, pszFieldName); } papszIter++; } /* Attribute fields */ int* panSrcFieldsUsed = (int*) CPLCalloc(sizeof(int), poSrcFeatureDefn->GetFieldCount()); for(int iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++) { OGRFieldDefn* poFieldDefn = poFeatureDefn->GetFieldDefn(iField); int iSrcField = poSrcFeatureDefn->GetFieldIndex(poFieldDefn->GetNameRef()); if (iSrcField >= 0) panSrcFieldsUsed[iSrcField] = TRUE; } for(int iSrcField = 0; iSrcField < poSrcFeatureDefn->GetFieldCount(); iSrcField ++) { if( !panSrcFieldsUsed[iSrcField] ) { OGRFieldDefn *poSrcDefn = poSrcFeatureDefn->GetFieldDefn( iSrcField ); papszFieldsSrc = CSLAddString(papszFieldsSrc, poSrcDefn->GetNameRef()); } } CPLFree(panSrcFieldsUsed); /* geometry fields now */ panSrcFieldsUsed = (int*) CPLCalloc(sizeof(int), poSrcFeatureDefn->GetGeomFieldCount()); for(int iField = 0; iField < poFeatureDefn->GetGeomFieldCount(); iField++) { OGRGeomFieldDefn* poFieldDefn = poFeatureDefn->GetGeomFieldDefn(iField); int iSrcField = poSrcFeatureDefn->GetGeomFieldIndex(poFieldDefn->GetNameRef()); if (iSrcField >= 0) panSrcFieldsUsed[iSrcField] = TRUE; } for(int iSrcField = 0; iSrcField < poSrcFeatureDefn->GetGeomFieldCount(); iSrcField ++) { if( !panSrcFieldsUsed[iSrcField] ) { OGRGeomFieldDefn *poSrcDefn = poSrcFeatureDefn->GetGeomFieldDefn( iSrcField ); papszFieldsSrc = CSLAddString(papszFieldsSrc, poSrcDefn->GetNameRef()); } } CPLFree(panSrcFieldsUsed); papoSrcLayers[iCurLayer]->SetIgnoredFields((const char**)papszFieldsSrc); CSLDestroy(papszFieldsSrc); } }
void ogr_datasource::bind() const { if (is_bound_) return; // initialize ogr formats OGRRegisterAll(); std::string driver = *params_.get<std::string>("driver",""); if (! driver.empty()) { OGRSFDriver * ogr_driver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(driver.c_str()); if (ogr_driver && ogr_driver != NULL) { dataset_ = ogr_driver->Open((dataset_name_).c_str(), FALSE); } } else { // open ogr driver dataset_ = OGRSFDriverRegistrar::Open((dataset_name_).c_str(), FALSE); } if (! dataset_) { const std::string err = CPLGetLastErrorMsg(); if (err.size() == 0) { throw datasource_exception("OGR Plugin: connection failed: " + dataset_name_ + " was not found or is not a supported format"); } else { throw datasource_exception("OGR Plugin: " + err); } } // initialize layer boost::optional<std::string> layer_by_name = params_.get<std::string>("layer"); boost::optional<unsigned> layer_by_index = params_.get<unsigned>("layer_by_index"); boost::optional<std::string> layer_by_sql = params_.get<std::string>("layer_by_sql"); int passed_parameters = 0; passed_parameters += layer_by_name ? 1 : 0; passed_parameters += layer_by_index ? 1 : 0; passed_parameters += layer_by_sql ? 1 : 0; if (passed_parameters > 1) { throw datasource_exception("OGR Plugin: you can only select an ogr layer by name " "('layer' parameter), by number ('layer_by_index' parameter), " "or by sql ('layer_by_sql' parameter), " "do not supply 2 or more of them at the same time" ); } if (layer_by_name) { layer_name_ = *layer_by_name; layer_.layer_by_name(dataset_, layer_name_); } else if (layer_by_index) { const unsigned num_layers = dataset_->GetLayerCount(); if (*layer_by_index >= num_layers) { std::ostringstream s; s << "OGR Plugin: only "; s << num_layers; s << " layer(s) exist, cannot find layer by index '" << *layer_by_index << "'"; throw datasource_exception(s.str()); } layer_.layer_by_index(dataset_, *layer_by_index); layer_name_ = layer_.layer_name(); } else if (layer_by_sql) { layer_.layer_by_sql(dataset_, *layer_by_sql); layer_name_ = layer_.layer_name(); } else { std::ostringstream s; s << "OGR Plugin: missing <layer> or <layer_by_index> or <layer_by_sql> " << "parameter, available layers are: "; unsigned num_layers = dataset_->GetLayerCount(); bool layer_found = false; for (unsigned i = 0; i < num_layers; ++i ) { OGRLayer* ogr_layer = dataset_->GetLayer(i); OGRFeatureDefn* ogr_layer_def = ogr_layer->GetLayerDefn(); if (ogr_layer_def != 0) { layer_found = true; s << " '" << ogr_layer_def->GetName() << "' "; } } if (! layer_found) { s << "None (no layers were found in dataset)"; } throw datasource_exception(s.str()); } if (! layer_.is_valid()) { std::string s("OGR Plugin: "); if (layer_by_name) { s += "cannot find layer by name '" + *layer_by_name; } else if (layer_by_index) { s += "cannot find layer by index number '" + *layer_by_index; } else if (layer_by_sql) { s += "cannot find layer by sql query '" + *layer_by_sql; } s += "' in dataset '" + dataset_name_ + "'"; throw datasource_exception(s); } // work with real OGR layer OGRLayer* layer = layer_.layer(); // initialize envelope OGREnvelope envelope; layer->GetExtent(&envelope); extent_.init(envelope.MinX, envelope.MinY, envelope.MaxX, envelope.MaxY); // scan for index file // TODO - layer names don't match dataset name, so this will break for // any layer types of ogr than shapefiles, etc // fix here and in ogrindex size_t breakpoint = dataset_name_.find_last_of("."); if (breakpoint == std::string::npos) { breakpoint = dataset_name_.length(); } index_name_ = dataset_name_.substr(0, breakpoint) + ".ogrindex"; std::ifstream index_file(index_name_.c_str(), std::ios::in | std::ios::binary); if (index_file) { indexed_ = true; index_file.close(); } #if 0 // TODO - enable this warning once the ogrindex tool is a bit more stable/mature else { std::clog << "### Notice: no ogrindex file found for " << dataset_name_ << ", use the 'ogrindex' program to build an index for faster rendering" << std::endl; } #endif // deal with attributes descriptions OGRFeatureDefn* def = layer->GetLayerDefn(); if (def != 0) { const int fld_count = def->GetFieldCount(); for (int i = 0; i < fld_count; i++) { OGRFieldDefn* fld = def->GetFieldDefn(i); const std::string fld_name = fld->GetNameRef(); const OGRFieldType type_oid = fld->GetType(); switch (type_oid) { case OFTInteger: desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::Integer)); break; case OFTReal: desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::Double)); break; case OFTString: case OFTWideString: // deprecated desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::String)); break; case OFTBinary: desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::Object)); break; case OFTIntegerList: case OFTRealList: case OFTStringList: case OFTWideStringList: // deprecated ! #ifdef MAPNIK_DEBUG std::clog << "OGR Plugin: unhandled type_oid=" << type_oid << std::endl; #endif break; case OFTDate: case OFTTime: case OFTDateTime: // unhandled ! #ifdef MAPNIK_DEBUG std::clog << "OGR Plugin: unhandled type_oid=" << type_oid << std::endl; #endif desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::Object)); break; default: // unknown #ifdef MAPNIK_DEBUG std::clog << "OGR Plugin: unknown type_oid=" << type_oid << std::endl; #endif break; } } } is_bound_ = true; }
int ILI1Reader::ReadTable(const char *layername) { char **tokens = NULL; const char *firsttok = NULL; int ret = TRUE; int warned = FALSE; int fIndex; int geomIdx; // curLayer is NULL if we have more than one // point geometry column if(curLayer == NULL) { OGRFeature *metaFeature = NULL; metaLayer->ResetReading(); while((metaFeature = metaLayer->GetNextFeature()) != NULL ) { if(EQUAL(layername, metaFeature->GetFieldAsString(0))) { const char *geomlayername = metaFeature->GetFieldAsString(2); curLayer = GetLayerByName(geomlayername); break; } } } OGRFeatureDefn *featureDef = curLayer->GetLayerDefn(); OGRFeature *feature = NULL; // get the geometry index of the current layer // only if the model is read if(featureDef->GetFieldCount() != 0) { OGRFeature *metaFeature = NULL; metaLayer->ResetReading(); while((metaFeature = metaLayer->GetNextFeature()) != NULL ) { if(EQUAL(curLayer->GetLayerDefn()->GetName(), metaFeature->GetFieldAsString(2))) { geomIdx = metaFeature->GetFieldAsInteger(1); } } } long fpos = VSIFTell(fpItf); while (ret && (tokens = ReadParseLine())) { firsttok = CSLGetField(tokens, 0); if (EQUAL(firsttok, "OBJE")) { //Check for features spread over multiple objects if (featureDef->GetGeomType() == wkbPolygon) { //Multiple polygon rings feature = curLayer->GetFeatureRef(atol(CSLGetField(tokens, 2))); } else if (featureDef->GetGeomType() == wkbGeometryCollection) { //AREA lines spread over mutltiple objects } else { feature = NULL; } if (feature == NULL) { if (featureDef->GetFieldCount() == 0) { CPLDebug( "OGR_ILI", "No field definition found for table: %s", featureDef->GetName() ); //Model not read - use heuristics for (fIndex=1; fIndex<CSLCount(tokens); fIndex++) { char szFieldName[32]; sprintf(szFieldName, "Field%02d", fIndex); OGRFieldDefn oFieldDefn(szFieldName, OFTString); featureDef->AddFieldDefn(&oFieldDefn); } } //start new feature feature = new OGRFeature(featureDef); int fieldno = 0; for (fIndex=1; fIndex<CSLCount(tokens) && fieldno < featureDef->GetFieldCount(); fIndex++, fieldno++) { if (!EQUAL(tokens[fIndex], "@")) { //CPLDebug( "READ TABLE OGR_ILI", "Adding Field %d: %s", fieldno, tokens[fIndex]); feature->SetField(fieldno, tokens[fIndex]); if (featureDef->GetFieldDefn(fieldno)->GetType() == OFTReal && fieldno > 0 && featureDef->GetFieldDefn(fieldno-1)->GetType() == OFTReal && featureDef->GetGeomType() == wkbPoint /* // if there is no ili model read, // we have no chance to detect the // geometry column!! */ && (fieldno-2) == geomIdx) { //add Point geometry OGRPoint *ogrPoint = new OGRPoint(atof(tokens[fIndex-1]), atof(tokens[fIndex])); feature->SetGeometryDirectly(ogrPoint); } } } if (!warned && featureDef->GetFieldCount() != CSLCount(tokens)-1 && !(featureDef->GetFieldCount() == CSLCount(tokens) && EQUAL(featureDef->GetFieldDefn(featureDef->GetFieldCount()-1)->GetNameRef(), "ILI_Geometry"))) { CPLDebug( "OGR_ILI", "Field count doesn't match. %d declared, %d found", featureDef->GetFieldCount(), CSLCount(tokens)-1); warned = TRUE; } if (featureDef->GetGeomType() == wkbPolygon) feature->SetFID(atol(feature->GetFieldAsString(1))); else if (feature->GetFieldCount() > 0) feature->SetFID(atol(feature->GetFieldAsString(0))); curLayer->AddFeature(feature); } } else if (EQUAL(firsttok, "STPT")) { ReadGeom(tokens, featureDef->GetGeomType(), feature); if (EQUAL(featureDef->GetFieldDefn(featureDef->GetFieldCount()-1)->GetNameRef(), "ILI_Geometry")) { AddIliGeom(feature, featureDef->GetFieldCount()-1, fpos); //TODO: append multi-OBJECT geometries } } else if (EQUAL(firsttok, "ELIN")) { //empty geom } else if (EQUAL(firsttok, "EDGE")) { tokens = ReadParseLine(); //STPT ReadGeom(tokens, wkbMultiLineString, feature); if (EQUAL(featureDef->GetFieldDefn(featureDef->GetFieldCount()-1)->GetNameRef(), "ILI_Geometry")) { AddIliGeom(feature, featureDef->GetFieldCount()-1, fpos); } } else if (EQUAL(firsttok, "PERI")) { } else if (EQUAL(firsttok, "ETAB")) { if(HasMultiplePointGeom(layername) > 0) { OGRFeature *metaFeature = NULL; metaLayer->ResetReading(); while((metaFeature = metaLayer->GetNextFeature()) != NULL ) { int pntCln = 1; if(EQUAL(layername, metaFeature->GetFieldAsString(0)) && !EQUAL(curLayer->GetLayerDefn()->GetName(), metaFeature->GetFieldAsString(2))) { pntCln++; OGRILI1Layer *curLayerTmp = GetLayerByName(metaFeature->GetFieldAsString(2)); OGRFeature *tmpFeature = NULL; int geomIdxTmp = metaFeature->GetFieldAsInteger(1); curLayer->ResetReading(); while((tmpFeature = curLayer->GetNextFeature()) != NULL ) { OGRPoint *ogrPoint = new OGRPoint(atof(tmpFeature->GetFieldAsString(geomIdxTmp + pntCln)), atof(tmpFeature->GetFieldAsString(geomIdxTmp + pntCln + 1))); tmpFeature->SetGeometryDirectly(ogrPoint); curLayerTmp->AddFeature(tmpFeature); } } } } CSLDestroy(tokens); return TRUE; } else { CPLDebug( "OGR_ILI", "Unexpected token: %s", firsttok ); } CSLDestroy(tokens); fpos = VSIFTell(fpItf); } return ret; }
static void ReportOnLayer( OGRLayer * poLayer, const char *pszWHERE, OGRGeometry *poSpatialFilter ) { OGRFeatureDefn *poDefn = poLayer->GetLayerDefn(); /* -------------------------------------------------------------------- */ /* Set filters if provided. */ /* -------------------------------------------------------------------- */ if( pszWHERE != NULL ) poLayer->SetAttributeFilter( pszWHERE ); if( poSpatialFilter != NULL ) poLayer->SetSpatialFilter( poSpatialFilter ); /* -------------------------------------------------------------------- */ /* Report various overall information. */ /* -------------------------------------------------------------------- */ printf( "\n" ); printf( "Layer name: %s\n", poDefn->GetName() ); if( bVerbose ) { printf( "Geometry: %s\n", OGRGeometryTypeToName( poDefn->GetGeomType() ) ); printf( "Feature Count: %d\n", poLayer->GetFeatureCount() ); OGREnvelope oExt; if (poLayer->GetExtent(&oExt, TRUE) == OGRERR_NONE) { printf("Extent: (%f, %f) - (%f, %f)\n", oExt.MinX, oExt.MinY, oExt.MaxX, oExt.MaxY); } char *pszWKT; if( poLayer->GetSpatialRef() == NULL ) pszWKT = CPLStrdup( "(unknown)" ); else { poLayer->GetSpatialRef()->exportToPrettyWkt( &pszWKT ); } printf( "Layer SRS WKT:\n%s\n", pszWKT ); CPLFree( pszWKT ); if( strlen(poLayer->GetFIDColumn()) > 0 ) printf( "FID Column = %s\n", poLayer->GetFIDColumn() ); if( strlen(poLayer->GetGeometryColumn()) > 0 ) printf( "Geometry Column = %s\n", poLayer->GetGeometryColumn() ); for( int iAttr = 0; iAttr < poDefn->GetFieldCount(); iAttr++ ) { OGRFieldDefn *poField = poDefn->GetFieldDefn( iAttr ); printf( "%s: %s (%d.%d)\n", poField->GetNameRef(), poField->GetFieldTypeName( poField->GetType() ), poField->GetWidth(), poField->GetPrecision() ); } } /* -------------------------------------------------------------------- */ /* Read, and dump features. */ /* -------------------------------------------------------------------- */ OGRFeature *poFeature = NULL; if( nFetchFID == OGRNullFID && !bSummaryOnly ) { while( (poFeature = poLayer->GetNextFeature()) != NULL ) { poFeature->DumpReadable( NULL, papszOptions ); OGRFeature::DestroyFeature( poFeature ); } } else if( nFetchFID != OGRNullFID ) { poFeature = poLayer->GetFeature( nFetchFID ); if( poFeature == NULL ) { printf( "Unable to locate feature id %d on this layer.\n", nFetchFID ); } else { poFeature->DumpReadable( NULL, papszOptions ); OGRFeature::DestroyFeature( poFeature ); } } }
static void ReportOnLayer( OGRLayer * poLayer, int bVerbose ) { OGRFeatureDefn *poDefn = poLayer->GetLayerDefn(); /* -------------------------------------------------------------------- */ /* Report various overall information. */ /* -------------------------------------------------------------------- */ printf( "\n" ); printf( "Layer name: %s\n", poLayer->GetName() ); if( bVerbose ) { int nGeomFieldCount = poLayer->GetLayerDefn()->GetGeomFieldCount(); if( nGeomFieldCount > 1 ) { for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ ) { OGRGeomFieldDefn* poGFldDefn = poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom); printf( "Geometry (%s): %s\n", poGFldDefn->GetNameRef(), OGRGeometryTypeToName( poGFldDefn->GetType() ) ); } } else { printf( "Geometry: %s\n", OGRGeometryTypeToName( poLayer->GetGeomType() ) ); } printf( "Feature Count: " CPL_FRMT_GIB "\n", poLayer->GetFeatureCount() ); OGREnvelope oExt; if( nGeomFieldCount > 1 ) { for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ ) { if (poLayer->GetExtent(iGeom, &oExt, TRUE) == OGRERR_NONE) { OGRGeomFieldDefn* poGFldDefn = poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom); CPLprintf("Extent (%s): (%f, %f) - (%f, %f)\n", poGFldDefn->GetNameRef(), oExt.MinX, oExt.MinY, oExt.MaxX, oExt.MaxY); } } } else if ( poLayer->GetExtent(&oExt, TRUE) == OGRERR_NONE) { CPLprintf("Extent: (%f, %f) - (%f, %f)\n", oExt.MinX, oExt.MinY, oExt.MaxX, oExt.MaxY); } char *pszWKT; if( nGeomFieldCount > 1 ) { for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ ) { OGRGeomFieldDefn* poGFldDefn = poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom); OGRSpatialReference* poSRS = poGFldDefn->GetSpatialRef(); if( poSRS == NULL ) pszWKT = CPLStrdup( "(unknown)" ); else { poSRS->exportToPrettyWkt( &pszWKT ); } printf( "SRS WKT (%s):\n%s\n", poGFldDefn->GetNameRef(), pszWKT ); CPLFree( pszWKT ); } } else { if( poLayer->GetSpatialRef() == NULL ) pszWKT = CPLStrdup( "(unknown)" ); else { poLayer->GetSpatialRef()->exportToPrettyWkt( &pszWKT ); } printf( "Layer SRS WKT:\n%s\n", pszWKT ); CPLFree( pszWKT ); } if( strlen(poLayer->GetFIDColumn()) > 0 ) printf( "FID Column = %s\n", poLayer->GetFIDColumn() ); for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ ) { OGRGeomFieldDefn* poGFldDefn = poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom); if( nGeomFieldCount == 1 && EQUAL(poGFldDefn->GetNameRef(), "") && poGFldDefn->IsNullable() ) break; printf( "Geometry Column "); if( nGeomFieldCount > 1 ) printf("%d ", iGeom + 1); if( !poGFldDefn->IsNullable() ) printf("NOT NULL "); printf("= %s\n", poGFldDefn->GetNameRef() ); } for( int iAttr = 0; iAttr < poDefn->GetFieldCount(); iAttr++ ) { OGRFieldDefn *poField = poDefn->GetFieldDefn( iAttr ); const char* pszType = (poField->GetSubType() != OFSTNone) ? CPLSPrintf("%s(%s)", poField->GetFieldTypeName( poField->GetType() ), poField->GetFieldSubTypeName(poField->GetSubType())) : poField->GetFieldTypeName( poField->GetType() ); printf( "%s: %s (%d.%d)", poField->GetNameRef(), pszType, poField->GetWidth(), poField->GetPrecision() ); if( !poField->IsNullable() ) printf(" NOT NULL"); if( poField->GetDefault() != NULL ) printf(" DEFAULT %s", poField->GetDefault() ); printf( "\n" ); } } /* -------------------------------------------------------------------- */ /* Read, and dump features. */ /* -------------------------------------------------------------------- */ OGRFeature *poFeature = NULL; while( (poFeature = poLayer->GetNextFeature()) != NULL ) { poFeature->DumpReadable( NULL ); OGRFeature::DestroyFeature( poFeature ); } }