//--------------------------------------------------------- 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 ); }
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] ); } } }
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; }
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); }
OGRPLScenesLayer::OGRPLScenesLayer(OGRPLScenesDataset* poDS, const char* pszName, const char* pszBaseURL, json_object* poObjCount10) { this->poDS = poDS; osBaseURL = pszBaseURL; SetDescription(pszName); poFeatureDefn = new OGRFeatureDefn(pszName); poFeatureDefn->SetGeomType(wkbMultiPolygon); for(int i = 0; i < (int)sizeof(apsAttrs) / (int)sizeof(apsAttrs[0]); i++) { OGRFieldDefn oField(apsAttrs[i].pszName, apsAttrs[i].eType); poFeatureDefn->AddFieldDefn(&oField); } poFeatureDefn->Reference(); poSRS = new OGRSpatialReference(SRS_WKT_WGS84); poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(poSRS); bEOF = FALSE; nFeatureCount = -1; nNextFID = 1; poGeoJSONDS = NULL; poGeoJSONLayer = NULL; poMainFilter = NULL; nPageSize = atoi(CPLGetConfigOption("PLSCENES_PAGE_SIZE", "1000")); bStillInFirstPage = FALSE; bAcquiredAscending = -1; bFilterMustBeClientSideEvaluated = FALSE; ResetReading(); if( poObjCount10 != NULL ) { json_object* poCount = json_object_object_get(poObjCount10, "count"); if( poCount != NULL ) nFeatureCount = MAX(0, json_object_get_int64(poCount)); OGRGeoJSONDataSource* poTmpDS = new OGRGeoJSONDataSource(); OGRGeoJSONReader oReader; oReader.SetFlattenNestedAttributes(true, '.'); oReader.ReadLayer( poTmpDS, "layer", poObjCount10 ); OGRLayer* poTmpLayer = poTmpDS->GetLayer(0); if( poTmpLayer ) { OGRFeatureDefn* poTmpFDefn = poTmpLayer->GetLayerDefn(); std::vector<CPLString> aosNewFields; for(int i=0;i<poTmpFDefn->GetFieldCount();i++) { if( poFeatureDefn->GetFieldIndex(poTmpFDefn->GetFieldDefn(i)->GetNameRef()) < 0 ) aosNewFields.push_back(poTmpFDefn->GetFieldDefn(i)->GetNameRef()); } std::sort(aosNewFields.begin(), aosNewFields.end(), OGRPLScenesLayerFieldNameComparator); for(int i=0;i<(int)aosNewFields.size();i++) { OGRFieldDefn oField(poTmpFDefn->GetFieldDefn(poTmpFDefn->GetFieldIndex(aosNewFields[i]))); poFeatureDefn->AddFieldDefn(&oField); } } delete poTmpDS; } }
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 }
//#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"); } }
wxGISGridTable::wxGISGridTable(wxGISDataset* pGISDataset) { m_nRows = m_nCols = 0; m_pGISDataset = wxDynamicCast(pGISDataset, wxGISTable); OGRFeatureDefn* pOGRFeatureDefn = m_pGISDataset->GetDefinition(); if(pOGRFeatureDefn) { m_nCols = pOGRFeatureDefn->GetFieldCount(); m_nRows = m_pGISDataset->GetFeatureCount(); } }
JNIEXPORT jint JNICALL Java_es_gva_cit_jogr_JNIBase_getFieldCountNat (JNIEnv *env, jobject obj, jlong cPtr){ OGRFeatureDefn *df = (OGRFeatureDefn *) 0 ; int nfields=-1; df = *(OGRFeatureDefn **)&cPtr; if(df!=NULL){ nfields = df->GetFieldCount(); } return nfields; }
Handle<Value> LayerFields::reorder(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"); } Handle<Array> field_map = Array::New(0); NODE_ARG_ARRAY(0, "field map", field_map); int n = def->GetFieldCount(); OGRErr err = 0; if ((int)field_map->Length() != n) { return NODE_THROW("Array length must match field count"); } int *field_map_array = new int[n]; for (int i = 0; i < n; i++) { Handle<Value> val = field_map->Get(i); if (!val->IsNumber()) { delete [] field_map_array; return NODE_THROW("Array must only contain integers"); } int key = val->IntegerValue(); if (key < 0 || key >= n) { delete [] field_map_array; return NODE_THROW("Values must be between 0 and field count - 1"); } field_map_array[i] = key; } err = layer->get()->ReorderFields(field_map_array); delete [] field_map_array; if (err) { return NODE_THROW_OGRERR(err); } return Undefined(); }
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); }
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; }
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; }
Handle<Value> LayerFields::count(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"); } return scope.Close(Integer::New(def->GetFieldCount())); }
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)); }
static OGRFeatureDefn *defineLayer(const char *szName, OGRwkbGeometryType szType, S2I *poHeaders, S2I **ppoHeadersNew) { OGRFeatureDefn *poFeatureDefn = new OGRFeatureDefn( szName ); poFeatureDefn->SetGeomType( szType ); S2I* poHeadersNew = *ppoHeadersNew; for (S2I::iterator i=poHeaders->begin(); i!=poHeaders->end(); i++) { OGRSOSIDataType* poType = SOSIGetType(i->first); OGRSOSISimpleDataType* poElements = poType->getElements(); for (int k=0; k<poType->getElementCount(); k++) { if (strcmp(poElements[k].GetName(),"")==0) continue; OGRFieldDefn oFieldTemplate( poElements[k].GetName(), poElements[k].GetType() ); (*poHeadersNew)[CPLString(poElements[k].GetName())] = poFeatureDefn->GetFieldCount(); poFeatureDefn->AddFieldDefn( &oFieldTemplate ); } } return poFeatureDefn; }
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 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; }
/********************************************************************** * 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; }
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 ); } } }
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); } }
OGRFeatureDefn *OGRUnionLayer::GetLayerDefn() { if( poFeatureDefn != NULL ) return poFeatureDefn; poFeatureDefn = new OGRFeatureDefn( osName ); poFeatureDefn->Reference(); poFeatureDefn->SetGeomType(wkbNone); int iCompareFirstIndex = 0; if( osSourceLayerFieldName.size() ) { OGRFieldDefn oField(osSourceLayerFieldName, OFTString); poFeatureDefn->AddFieldDefn(&oField); iCompareFirstIndex = 1; } if( eFieldStrategy == FIELD_SPECIFIED ) { int i; for(i = 0; i < nFields; i++) poFeatureDefn->AddFieldDefn(papoFields[i]); for(i = 0; i < nGeomFields; i++) { poFeatureDefn->AddGeomFieldDefn(new OGRUnionLayerGeomFieldDefn(papoGeomFields[i]), FALSE); OGRUnionLayerGeomFieldDefn* poGeomFieldDefn = (OGRUnionLayerGeomFieldDefn* ) poFeatureDefn->GetGeomFieldDefn(i); if( poGeomFieldDefn->bGeomTypeSet == FALSE || poGeomFieldDefn->bSRSSet == FALSE ) { for(int iLayer = 0; iLayer < nSrcLayers; iLayer++) { OGRFeatureDefn* poSrcFeatureDefn = papoSrcLayers[iLayer]->GetLayerDefn(); int nIndex = poSrcFeatureDefn->GetGeomFieldIndex(poGeomFieldDefn->GetNameRef()); if( nIndex >= 0 ) { OGRGeomFieldDefn* poSrcGeomFieldDefn = poSrcFeatureDefn->GetGeomFieldDefn(nIndex); if( poGeomFieldDefn->bGeomTypeSet == FALSE ) { poGeomFieldDefn->bGeomTypeSet = TRUE; poGeomFieldDefn->SetType(poSrcGeomFieldDefn->GetType()); } if( poGeomFieldDefn->bSRSSet == FALSE ) { poGeomFieldDefn->bSRSSet = TRUE; poGeomFieldDefn->SetSpatialRef(poSrcGeomFieldDefn->GetSpatialRef()); if( i == 0 && poGlobalSRS == NULL ) { poGlobalSRS = poSrcGeomFieldDefn->GetSpatialRef(); if( poGlobalSRS != NULL ) poGlobalSRS->Reference(); } } break; } } } } } else if( eFieldStrategy == FIELD_FROM_FIRST_LAYER ) { OGRFeatureDefn* poSrcFeatureDefn = papoSrcLayers[0]->GetLayerDefn(); int i; for(i = 0; i < poSrcFeatureDefn->GetFieldCount(); i++) poFeatureDefn->AddFieldDefn(poSrcFeatureDefn->GetFieldDefn(i)); for(i = 0; nGeomFields != - 1 && i < poSrcFeatureDefn->GetGeomFieldCount(); i++) { OGRGeomFieldDefn* poFldDefn = poSrcFeatureDefn->GetGeomFieldDefn(i); poFeatureDefn->AddGeomFieldDefn( new OGRUnionLayerGeomFieldDefn(poFldDefn), FALSE); } } else if (eFieldStrategy == FIELD_UNION_ALL_LAYERS ) { if( nGeomFields == 1 ) { poFeatureDefn->AddGeomFieldDefn( new OGRUnionLayerGeomFieldDefn(papoGeomFields[0]), FALSE); } for(int iLayer = 0; iLayer < nSrcLayers; iLayer++) { OGRFeatureDefn* poSrcFeatureDefn = papoSrcLayers[iLayer]->GetLayerDefn(); /* Add any field that is found in the source layers */ int i; for(i = 0; i < poSrcFeatureDefn->GetFieldCount(); i++) { OGRFieldDefn* poSrcFieldDefn = poSrcFeatureDefn->GetFieldDefn(i); int nIndex = poFeatureDefn->GetFieldIndex(poSrcFieldDefn->GetNameRef()); if( nIndex < 0 ) poFeatureDefn->AddFieldDefn(poSrcFieldDefn); else { OGRFieldDefn* poFieldDefn = poFeatureDefn->GetFieldDefn(nIndex); MergeFieldDefn(poFieldDefn, poSrcFieldDefn); } } for(i = 0; nGeomFields != - 1 && i < poSrcFeatureDefn->GetGeomFieldCount(); i++) { OGRGeomFieldDefn* poSrcFieldDefn = poSrcFeatureDefn->GetGeomFieldDefn(i); int nIndex = poFeatureDefn->GetGeomFieldIndex(poSrcFieldDefn->GetNameRef()); if( nIndex < 0 ) { poFeatureDefn->AddGeomFieldDefn( new OGRUnionLayerGeomFieldDefn(poSrcFieldDefn), FALSE); if( poFeatureDefn->GetGeomFieldCount() == 1 && nGeomFields == 0 && GetSpatialRef() != NULL ) { OGRUnionLayerGeomFieldDefn* poGeomFieldDefn = (OGRUnionLayerGeomFieldDefn* ) poFeatureDefn->GetGeomFieldDefn(0); poGeomFieldDefn->bSRSSet = TRUE; poGeomFieldDefn->SetSpatialRef(GetSpatialRef()); } } else { if( nIndex == 0 && nGeomFields == 1 ) { OGRUnionLayerGeomFieldDefn* poGeomFieldDefn = (OGRUnionLayerGeomFieldDefn* ) poFeatureDefn->GetGeomFieldDefn(0); if( poGeomFieldDefn->bGeomTypeSet == FALSE ) { poGeomFieldDefn->bGeomTypeSet = TRUE; poGeomFieldDefn->SetType(poSrcFieldDefn->GetType()); } if( poGeomFieldDefn->bSRSSet == FALSE ) { poGeomFieldDefn->bSRSSet = TRUE; poGeomFieldDefn->SetSpatialRef(poSrcFieldDefn->GetSpatialRef()); } } /* TODO: merge type, SRS, extent ? */ } } } } else if (eFieldStrategy == FIELD_INTERSECTION_ALL_LAYERS ) { OGRFeatureDefn* poSrcFeatureDefn = papoSrcLayers[0]->GetLayerDefn(); int i; for(i = 0; i < poSrcFeatureDefn->GetFieldCount(); i++) poFeatureDefn->AddFieldDefn(poSrcFeatureDefn->GetFieldDefn(i)); for(i = 0; i < poSrcFeatureDefn->GetGeomFieldCount(); i++) { OGRGeomFieldDefn* poFldDefn = poSrcFeatureDefn->GetGeomFieldDefn(i); poFeatureDefn->AddGeomFieldDefn( new OGRUnionLayerGeomFieldDefn(poFldDefn), FALSE); } /* Remove any field that is not found in the source layers */ for(int iLayer = 1; iLayer < nSrcLayers; iLayer++) { OGRFeatureDefn* l_poSrcFeatureDefn = papoSrcLayers[iLayer]->GetLayerDefn(); for(i = iCompareFirstIndex; i < poFeatureDefn->GetFieldCount();) { OGRFieldDefn* poFieldDefn = poFeatureDefn->GetFieldDefn(i); int nSrcIndex = l_poSrcFeatureDefn->GetFieldIndex( poFieldDefn->GetNameRef()); if( nSrcIndex < 0 ) { poFeatureDefn->DeleteFieldDefn(i); } else { OGRFieldDefn* poSrcFieldDefn = l_poSrcFeatureDefn->GetFieldDefn(nSrcIndex); MergeFieldDefn(poFieldDefn, poSrcFieldDefn); i ++; } } for(i = 0; i < poFeatureDefn->GetGeomFieldCount();) { OGRGeomFieldDefn* poFieldDefn = poFeatureDefn->GetGeomFieldDefn(i); int nSrcIndex = l_poSrcFeatureDefn->GetGeomFieldIndex( poFieldDefn->GetNameRef()); if( nSrcIndex < 0 ) { poFeatureDefn->DeleteGeomFieldDefn(i); } else { /* TODO: merge type, SRS, extent ? */ i ++; } } } } return poFeatureDefn; }
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; }
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; }
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 ); } }