void OGRILI1Layer::JoinGeomLayers() { bGeomsJoined = TRUE; int bResetConfigOption = FALSE; if (EQUAL(CPLGetConfigOption("OGR_ARC_STEPSIZE", ""), "")) { bResetConfigOption = TRUE; CPLSetThreadLocalConfigOption("OGR_ARC_STEPSIZE", "0.96"); } for (GeomFieldInfos::const_iterator it = oGeomFieldInfos.begin(); it != oGeomFieldInfos.end(); ++it) { OGRFeatureDefn* geomFeatureDefn = it->second.geomTable; if (geomFeatureDefn) { CPLDebug( "OGR_ILI", "Join geometry table %s of field '%s'", geomFeatureDefn->GetName(), it->first.c_str() ); OGRILI1Layer* poGeomLayer = poDS->GetLayerByName(geomFeatureDefn->GetName()); int nGeomFieldIndex = GetLayerDefn()->GetGeomFieldIndex(it->first.c_str()); if (it->second.iliGeomType == "Surface") { JoinSurfaceLayer(poGeomLayer, nGeomFieldIndex); } else if (it->second.iliGeomType == "Area") { CPLString pointField = it->first + "__Point"; int nPointFieldIndex = GetLayerDefn()->GetGeomFieldIndex(pointField.c_str()); PolygonizeAreaLayer(poGeomLayer, nGeomFieldIndex, nPointFieldIndex); } } } if( bResetConfigOption ) CPLSetThreadLocalConfigOption("OGR_ARC_STEPSIZE", NULL); }
void layer_by_index(gdal_dataset_type const datasource, int layer_index) { free_layer(); datasource_ = datasource; OGRLayer* ogr_layer = datasource_->GetLayer(layer_index); if (ogr_layer) { OGRFeatureDefn* def = ogr_layer->GetLayerDefn(); if (def != 0) { layer_ = ogr_layer; layer_name_ = def->GetName(); is_valid_ = true; MAPNIK_LOG_DEBUG(ogr) << "ogr_layer_ptr: layer_from_index layer=" << layer_name_; } } #ifdef MAPNIK_LOG debug_print_last_error(); #endif }
void layer_by_sql(gdal_dataset_type const datasource, std::string const& layer_sql) { free_layer(); datasource_ = datasource; owns_layer_ = true; // TODO - actually filter fields! // http://trac.osgeo.org/gdal/wiki/rfc29_desired_fields // http://trac.osgeo.org/gdal/wiki/rfc28_sqlfunc OGRGeometry* spatial_filter = nullptr; const char* sql_dialect = nullptr; OGRLayer* ogr_layer = datasource_->ExecuteSQL(layer_sql.c_str(), spatial_filter, sql_dialect); if (ogr_layer) { OGRFeatureDefn* def = ogr_layer->GetLayerDefn(); if (def != 0) { layer_ = ogr_layer; layer_name_ = def->GetName(); is_valid_ = true; MAPNIK_LOG_DEBUG(ogr) << "ogr_layer_ptr: layer_from_sql layer=" << layer_name_; } } #ifdef MAPNIK_LOG debug_print_last_error(); #endif }
//--------------------------------------------------------- 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 ); }
FeatureDefnInfo ImdReader::GetFeatureDefnInfo(const char *pszLayerName) { FeatureDefnInfo featureDefnInfo; for (FeatureDefnInfos::const_iterator it = featureDefnInfos.begin(); it != featureDefnInfos.end(); ++it) { OGRFeatureDefn* fdefn = it->poTableDefn; if (EQUAL(fdefn->GetName(), pszLayerName)) featureDefnInfo = *it; } return featureDefnInfo; }
OGRLayer* ILI2Reader::GetLayer(const char* pszName) { for (list<OGRLayer *>::reverse_iterator layerIt = m_listLayer.rbegin(); layerIt != m_listLayer.rend(); ++layerIt) { OGRFeatureDefn *fDef = (*layerIt)->GetLayerDefn(); if (cmpStr(fDef->GetName(), pszName) == 0) { return *layerIt; } } return NULL; }
int ILI1Reader::ReadModel( ImdReader *poImdReader, const char *pszModelFilename, OGRILI1DataSource *poDS) { poImdReader->ReadModel(pszModelFilename); for (FeatureDefnInfos::const_iterator it = poImdReader->featureDefnInfos.begin(); it != poImdReader->featureDefnInfos.end(); ++it) { #if DEBUG_VERBOSE CPLDebug( "OGR_ILI", "Adding OGRILI1Layer with table '%s'", it->GetTableDefnRef()->GetName() ); #endif OGRILI1Layer* layer = new OGRILI1Layer( it->GetTableDefnRef(), it->poGeomFieldInfos, poDS); AddLayer(layer); // Create additional layers for surface and area geometries. for (GeomFieldInfos::const_iterator it2 = it->poGeomFieldInfos.begin(); it2 != it->poGeomFieldInfos.end(); ++it2) { if (it2->second.GetGeomTableDefnRef()) { OGRFeatureDefn* poGeomTableDefn = it2->second.GetGeomTableDefnRef(); OGRGeomFieldDefn* poOGRGeomFieldDefn = poGeomTableDefn->GetGeomFieldDefn(0); GeomFieldInfos oGeomFieldInfos; // We add iliGeomType to recognize Ili1 geom tables oGeomFieldInfos[poOGRGeomFieldDefn->GetNameRef()].iliGeomType = it2->second.iliGeomType; #if DEBUG_VERBOSE CPLDebug( "OGR_ILI", "Adding OGRILI1Layer with geometry table '%s'", poGeomTableDefn->GetName() ); #endif OGRILI1Layer* geomlayer = new OGRILI1Layer(poGeomTableDefn, oGeomFieldInfos, poDS); AddLayer(geomlayer); } } } codeBlank = poImdReader->codeBlank; CPLDebug( "OGR_ILI", "Ili1Format blankCode '%c'", poImdReader->codeBlank ); codeUndefined = poImdReader->codeUndefined; CPLDebug( "OGR_ILI", "Ili1Format undefinedCode '%c'", poImdReader->codeUndefined ); codeContinue = poImdReader->codeContinue; CPLDebug( "OGR_ILI", "Ili1Format continueCode '%c'", poImdReader->codeContinue ); return 0; }
void OGRILI1Layer::JoinGeomLayers() { for (GeomFieldInfos::const_iterator it = oGeomFieldInfos.begin(); it != oGeomFieldInfos.end(); ++it) { OGRFeatureDefn* geomFeatureDefn = it->second.geomTable; if (geomFeatureDefn) { CPLDebug( "OGR_ILI", "Join geometry table %s of field '%s'", geomFeatureDefn->GetName(), it->first.c_str() ); OGRILI1Layer* poGeomLayer = poDS->GetLayerByName(geomFeatureDefn->GetName()); int nGeomFieldIndex = GetLayerDefn()->GetGeomFieldIndex(it->first.c_str()); if (it->second.iliGeomType == "Surface") { JoinSurfaceLayer(poGeomLayer, nGeomFieldIndex); } else if (it->second.iliGeomType == "Area") { CPLString pointField = it->first + "__Point"; int nPointFieldIndex = GetLayerDefn()->GetGeomFieldIndex(pointField.c_str()); PolygonizeAreaLayer(poGeomLayer, nGeomFieldIndex, nPointFieldIndex); } } } bGeomsJoined = TRUE; }
// Add additional Geometry table for Interlis 1 void AddGeomTable(CPLString layerName, const char* psFieldName, OGRwkbGeometryType eType, bool bRefTIDField = false) { OGRFeatureDefn* poGeomTableDefn = new OGRFeatureDefn(layerName); OGRFieldDefn fieldDef("_TID", OFTString); poGeomTableDefn->AddFieldDefn(&fieldDef); if (bRefTIDField) { OGRFieldDefn fieldDefRef("_RefTID", OFTString); poGeomTableDefn->AddFieldDefn(&fieldDefRef); } poGeomTableDefn->DeleteGeomFieldDefn(0); OGRGeomFieldDefn fieldDefGeom(psFieldName, eType); poGeomTableDefn->AddGeomFieldDefn(&fieldDefGeom); CPLDebug( "OGR_ILI", "Adding geometry table %s for field %s", poGeomTableDefn->GetName(), psFieldName); poGeomFieldInfos[psFieldName].geomTable = poGeomTableDefn; }
JNIEXPORT jstring JNICALL Java_es_gva_cit_jogr_OGRFeatureDefn_getNameNat (JNIEnv *env, jobject obj, jlong cPtr){ OGRFeatureDefn *fd = (OGRFeatureDefn *) 0 ; jstring nom_fd; fd = *(OGRFeatureDefn **)&cPtr; const char *name = fd->GetName(); if(name!=NULL) nom_fd = env->NewStringUTF(name); else return NULL; return nom_fd; }
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)); }
int ILI2Reader::AddFeature(DOMElement *elem) { bool newLayer = true; OGRLayer *curLayer = 0; char *pszName = XMLString::transcode(elem->getTagName()); // test if this layer exist for (list<OGRLayer *>::reverse_iterator layerIt = m_listLayer.rbegin(); layerIt != m_listLayer.rend(); ++layerIt) { OGRFeatureDefn *fDef = (*layerIt)->GetLayerDefn(); if (cmpStr(fDef->GetName(), pszName) == 0) { newLayer = false; curLayer = *layerIt; break; } } // add a layer if (newLayer) { // FIXME in Layer: SRS Writer Type datasource CPLDebug( "OGR_ILI", "Adding layer: %s", pszName ); // new layer data OGRSpatialReference *poSRSIn = NULL; // FIXME fix values for initial layer int bWriterIn = 0; OGRwkbGeometryType eReqType = wkbUnknown; OGRILI2DataSource *poDSIn = NULL; curLayer = new OGRILI2Layer(pszName, poSRSIn, bWriterIn, eReqType, poDSIn); m_listLayer.push_back(curLayer); } // the feature and field definition OGRFeatureDefn *featureDef = curLayer->GetLayerDefn(); if (newLayer) { // add TID field OGRFieldDefn ofieldDefn (ILI2_TID, OFTString); featureDef->AddFieldDefn(&ofieldDefn); setFieldDefn(featureDef, elem); } // add the features OGRFeature *feature = new OGRFeature(featureDef); // assign TID int fIndex = feature->GetFieldIndex(ILI2_TID); if (fIndex != -1) { XMLCh *pszIli2_tid = XMLString::transcode(ILI2_TID); char *fChVal = XMLString::transcode(elem->getAttribute(pszIli2_tid)); feature->SetField(fIndex, fChVal); XMLString::release (&pszIli2_tid); XMLString::release (&fChVal); } else { CPLDebug( "OGR_ILI","'%s' not found", ILI2_TID); } SetFieldValues(feature, elem); curLayer->SetFeature(feature); XMLString::release (&pszName); return 0; }
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 ); } } }
int ILI1Reader::ReadTable(CPL_UNUSED const char *layername) { char **tokens = NULL; int ret = TRUE; int warned = FALSE; int geomIdx = -1; OGRFeatureDefn *featureDef = curLayer->GetLayerDefn(); OGRFeature *feature = NULL; bool bFeatureAdded = false; while (ret && (tokens = ReadParseLine()) != NULL) { const char *firsttok = CSLGetField(tokens, 0); if (EQUAL(firsttok, "OBJE")) { if (featureDef->GetFieldCount() == 0 && curLayer->GetFeatureCount() == 0) { CPLError( CE_Warning, CPLE_AppDefined, "No field definition found for table: %s", featureDef->GetName() ); // Model not read - use heuristics. for( int fIndex=1; fIndex<CSLCount(tokens); fIndex++ ) { char szFieldName[32]; snprintf(szFieldName, sizeof(szFieldName), "Field%02d", fIndex); OGRFieldDefn oFieldDefn(szFieldName, OFTString); featureDef->AddFieldDefn(&oFieldDefn); } } //start new feature if( !bFeatureAdded ) delete feature; feature = new OGRFeature(featureDef); for( int fIndex=1, fieldno = 0; fIndex<CSLCount(tokens) && fieldno < featureDef->GetFieldCount(); fIndex++, fieldno++ ) { if (!(tokens[fIndex][0] == codeUndefined && tokens[fIndex][1] == '\0')) { #ifdef DEBUG_VERBOSE CPLDebug( "READ TABLE OGR_ILI", "Setting Field %d (Type %d): %s", fieldno, featureDef->GetFieldDefn(fieldno)->GetType(), tokens[fIndex] ); #endif if (featureDef->GetFieldDefn(fieldno)->GetType() == OFTString) { // Interlis 1 encoding is ISO 8859-1 (Latin1) -> Recode to UTF-8 char* pszRecoded = CPLRecode( tokens[fIndex], CPL_ENC_ISO8859_1, CPL_ENC_UTF8); // Replace space marks for( char* pszString = pszRecoded; *pszString != '\0'; pszString++ ) { if (*pszString == codeBlank) *pszString = ' '; } feature->SetField(fieldno, pszRecoded); CPLFree(pszRecoded); } else { feature->SetField(fieldno, tokens[fIndex]); } if (featureDef->GetFieldDefn(fieldno)->GetType() == OFTReal && fieldno > 0 && featureDef->GetFieldDefn(fieldno-1)->GetType() == OFTReal) { // Check for Point geometry (Coord type). // If there is no ili model read, // we have no chance to detect the // geometry column. CPLString geomfldname = featureDef->GetFieldDefn(fieldno)->GetNameRef(); // Check if name ends with _1. if (geomfldname.size() >= 2 && geomfldname[geomfldname.size()-2] == '_') { geomfldname = geomfldname.substr(0, geomfldname.size()-2); geomIdx = featureDef->GetGeomFieldIndex(geomfldname.c_str()); if (geomIdx == -1) { CPLError( CE_Warning, CPLE_AppDefined, "No matching definition for field '%s' of " "table %s found", geomfldname.c_str(), featureDef->GetName() ); } } else { geomIdx = -1; } if (geomIdx >= 0) { if (featureDef->GetGeomFieldDefn(geomIdx)->GetType() == wkbPoint) { // Add Point geometry. OGRPoint *ogrPoint = new OGRPoint( CPLAtof(tokens[fIndex-1]), CPLAtof(tokens[fIndex])); feature->SetGeomFieldDirectly(geomIdx, ogrPoint); } else if (featureDef->GetGeomFieldDefn(geomIdx)->GetType() == wkbPoint25D && fieldno > 1 && featureDef->GetFieldDefn(fieldno-2)->GetType() == OFTReal) { // Add 3D Point geometry. OGRPoint *ogrPoint = new OGRPoint( CPLAtof(tokens[fIndex-2]), CPLAtof(tokens[fIndex-1]), CPLAtof(tokens[fIndex]) ); feature->SetGeomFieldDirectly(geomIdx, ogrPoint); } } } } } if (!warned && featureDef->GetFieldCount() != CSLCount(tokens)-1) { CPLError( CE_Warning, CPLE_AppDefined, "Field count of table %s doesn't match. %d declared, " "%d found (e.g. ignored LINEATTR)", featureDef->GetName(), featureDef->GetFieldCount(), CSLCount(tokens) - 1 ); warned = TRUE; } if (feature->GetFieldCount() > 0) { // USE _TID as FID. TODO: respect IDENT field from model. feature->SetFID(feature->GetFieldAsInteger64(0)); } curLayer->AddFeature(feature); bFeatureAdded = true; geomIdx = -1; //Reset } else if (EQUAL(firsttok, "STPT") && feature != NULL) { //Find next non-Point geometry if (geomIdx < 0) geomIdx = 0; while (geomIdx < featureDef->GetGeomFieldCount() && featureDef->GetGeomFieldDefn(geomIdx)->GetType() == wkbPoint) { geomIdx++; } OGRwkbGeometryType geomType = (geomIdx < featureDef->GetGeomFieldCount()) ? featureDef->GetGeomFieldDefn(geomIdx)->GetType() : wkbNone; if( CSLCount(tokens) >= 3 ) ReadGeom(tokens, geomIdx, geomType, feature); } else if (EQUAL(firsttok, "ELIN")) { // Empty geom. } else if (EQUAL(firsttok, "EDGE") && feature != NULL) { CSLDestroy(tokens); tokens = ReadParseLine(); //STPT //Find next non-Point geometry do { geomIdx++; } while (geomIdx < featureDef->GetGeomFieldCount() && featureDef->GetGeomFieldDefn(geomIdx)->GetType() == wkbPoint); if( CSLCount(tokens) >= 3 ) ReadGeom(tokens, geomIdx, wkbMultiLineString, feature); } else if (EQUAL(firsttok, "PERI")) { } else if (EQUAL(firsttok, "ETAB")) { CPLDebug( "OGR_ILI", "Total features: " CPL_FRMT_GIB, curLayer->GetFeatureCount() ); CSLDestroy(tokens); if( !bFeatureAdded ) delete feature; return TRUE; } else { CPLError( CE_Warning, CPLE_AppDefined, "Unexpected token: %s", firsttok ); } CSLDestroy(tokens); } if( !bFeatureAdded ) delete feature; 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() ); 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); } 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; } /* -------------------------------------------------------------------- */ /* Read, and dump features. */ /* -------------------------------------------------------------------- */ #ifdef notdef OGRFeature *poFeature; int nId = -1; while( (nId = poTF->GetNextFeatureId_Spatial(nId)) != -1 ) { poFeature = poTF->GetFeatureRef( nId ); } #endif }
OGRLayer *OGRDataSource::CopyLayer( OGRLayer *poSrcLayer, const char *pszNewName, char **papszOptions ) { OGRFeatureDefn *poSrcDefn = poSrcLayer->GetLayerDefn(); OGRLayer *poDstLayer = NULL; /* -------------------------------------------------------------------- */ /* Create the layer. */ /* -------------------------------------------------------------------- */ if( !TestCapability( ODsCCreateLayer ) ) { CPLError( CE_Failure, CPLE_NotSupported, "This datasource does not support creation of layers." ); return NULL; } CPLErrorReset(); poDstLayer = CreateLayer( pszNewName, poSrcLayer->GetSpatialRef(), poSrcDefn->GetGeomType(), papszOptions ); if( poDstLayer == NULL ) return NULL; /* -------------------------------------------------------------------- */ /* Add fields. Default to copy all field. */ /* If only a subset of all fields requested, then output only */ /* the selected fields, and in the order that they were */ /* selected. */ /* -------------------------------------------------------------------- */ int iField; for( iField = 0; iField < poSrcDefn->GetFieldCount(); iField++ ) poDstLayer->CreateField( poSrcDefn->GetFieldDefn(iField) ); /* -------------------------------------------------------------------- */ /* Transfer features. */ /* -------------------------------------------------------------------- */ OGRFeature *poFeature; poSrcLayer->ResetReading(); while( TRUE ) { OGRFeature *poDstFeature = NULL; poFeature = poSrcLayer->GetNextFeature(); if( poFeature == NULL ) break; CPLErrorReset(); poDstFeature = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() ); if( poDstFeature->SetFrom( poFeature, TRUE ) != OGRERR_NONE ) { delete poFeature; CPLError( CE_Failure, CPLE_AppDefined, "Unable to translate feature %d from layer %s.\n", poFeature->GetFID(), poSrcDefn->GetName() ); return poDstLayer; } poDstFeature->SetFID( poFeature->GetFID() ); OGRFeature::DestroyFeature( poFeature ); CPLErrorReset(); if( poDstLayer->CreateFeature( poDstFeature ) != OGRERR_NONE ) { OGRFeature::DestroyFeature( poDstFeature ); return poDstLayer; } OGRFeature::DestroyFeature( poDstFeature ); } return poDstLayer; }
OGRFeatureDefn *OGRMySQLResultLayer::ReadResultDefinition() { /* -------------------------------------------------------------------- */ /* Parse the returned table information. */ /* -------------------------------------------------------------------- */ OGRFeatureDefn *poDefn = new OGRFeatureDefn( "sql_statement" ); SetDescription( poDefn->GetName() ); poDefn->Reference(); mysql_field_seek( hResultSet, 0 ); for( int iRawField = 0; iRawField < (int) mysql_num_fields(hResultSet); iRawField++ ) { MYSQL_FIELD *psMSField = mysql_fetch_field( hResultSet ); OGRFieldDefn oField( psMSField->name, OFTString); switch( psMSField->type ) { case FIELD_TYPE_TINY: case FIELD_TYPE_SHORT: case FIELD_TYPE_LONG: case FIELD_TYPE_INT24: case FIELD_TYPE_LONGLONG: { oField.SetType( OFTInteger ); const int width = (int)psMSField->length; oField.SetWidth(width); poDefn->AddFieldDefn( &oField ); break; } case FIELD_TYPE_DECIMAL: #ifdef FIELD_TYPE_NEWDECIMAL case FIELD_TYPE_NEWDECIMAL: #endif { oField.SetType( OFTReal ); // a bunch of hackery to munge the widths that MySQL gives // us into corresponding widths and precisions for OGR const int precision = (int)psMSField->decimals; int width = (int)psMSField->length; if (!precision) width = width - 1; width = width - precision; oField.SetWidth(width); oField.SetPrecision(precision); poDefn->AddFieldDefn( &oField ); break; } case FIELD_TYPE_FLOAT: case FIELD_TYPE_DOUBLE: /* MYSQL_FIELD is always reporting ->length = 22 and ->decimals = 31 for double type regardless of the data it returned. In an example, the data it returned had only 5 or 6 decimal places which were exactly as entered into the database but reported the decimals as 31. */ /* Assuming that a length of 22 means no particular width and 31 decimals means no particular precision. */ { const int width = (int)psMSField->length; const int precision = (int)psMSField->decimals; oField.SetType( OFTReal ); if( width != 22 ) oField.SetWidth(width); if( precision != 31 ) oField.SetPrecision(precision); poDefn->AddFieldDefn( &oField ); break; } case FIELD_TYPE_DATE: { oField.SetType( OFTDate ); oField.SetWidth(0); poDefn->AddFieldDefn( &oField ); break; } case FIELD_TYPE_TIME: { oField.SetType( OFTTime ); oField.SetWidth(0); poDefn->AddFieldDefn( &oField ); break; } case FIELD_TYPE_TIMESTAMP: case FIELD_TYPE_DATETIME: { oField.SetType( OFTDateTime ); oField.SetWidth(0); poDefn->AddFieldDefn( &oField ); break; } case FIELD_TYPE_YEAR: case FIELD_TYPE_STRING: case FIELD_TYPE_VAR_STRING: { oField.SetType( OFTString ); oField.SetWidth((int)psMSField->length); poDefn->AddFieldDefn( &oField ); break; } case FIELD_TYPE_TINY_BLOB: case FIELD_TYPE_MEDIUM_BLOB: case FIELD_TYPE_LONG_BLOB: case FIELD_TYPE_BLOB: { if( psMSField->charsetnr == 63 ) oField.SetType( OFTBinary ); else oField.SetType( OFTString ); oField.SetWidth((int)psMSField->max_length); poDefn->AddFieldDefn( &oField ); break; } case FIELD_TYPE_GEOMETRY: { if (pszGeomColumn == nullptr) { pszGeomColumnTable = CPLStrdup( psMSField->table); pszGeomColumn = CPLStrdup( psMSField->name); } break; } default: // any other field we ignore. break; } // assume a FID name first, and if it isn't there // take a field that is not null, a primary key, // and is an integer-like field if( EQUAL(psMSField->name,"ogc_fid") ) { bHasFid = TRUE; pszFIDColumn = CPLStrdup(oField.GetNameRef()); continue; } else if (IS_NOT_NULL(psMSField->flags) && IS_PRI_KEY(psMSField->flags) && ( psMSField->type == FIELD_TYPE_TINY || psMSField->type == FIELD_TYPE_SHORT || psMSField->type == FIELD_TYPE_LONG || psMSField->type == FIELD_TYPE_INT24 || psMSField->type == FIELD_TYPE_LONGLONG ) ) { bHasFid = TRUE; pszFIDColumn = CPLStrdup(oField.GetNameRef()); continue; } } poDefn->SetGeomType( wkbNone ); if (pszGeomColumn) { char* pszType=nullptr; CPLString osCommand; char **papszRow; // set to unknown first poDefn->SetGeomType( wkbUnknown ); poDefn->GetGeomFieldDefn(0)->SetName( pszGeomColumn ); osCommand.Printf( "SELECT type FROM geometry_columns WHERE f_table_name='%s'", pszGeomColumnTable ); if( hResultSet != nullptr ) mysql_free_result( hResultSet ); hResultSet = nullptr; if( !mysql_query( poDS->GetConn(), osCommand ) ) hResultSet = mysql_store_result( poDS->GetConn() ); papszRow = nullptr; if( hResultSet != nullptr ) papszRow = mysql_fetch_row( hResultSet ); if( papszRow != nullptr && papszRow[0] != nullptr ) { pszType = papszRow[0]; OGRwkbGeometryType l_nGeomType = OGRFromOGCGeomType(pszType); poDefn->SetGeomType( l_nGeomType ); } nSRSId = FetchSRSId(); } return poDefn; }
void OGRGMLDataSource::InsertHeader() { FILE *fpSchema; int nSchemaStart = 0; if( fpOutput == NULL || fpOutput == stdout ) return; /* -------------------------------------------------------------------- */ /* Do we want to write the schema within the GML instance doc */ /* or to a separate file? For now we only support external. */ /* -------------------------------------------------------------------- */ const char *pszSchemaURI = CSLFetchNameValue(papszCreateOptions, "XSISCHEMAURI"); const char *pszSchemaOpt = CSLFetchNameValue( papszCreateOptions, "XSISCHEMA" ); if( pszSchemaURI != NULL ) return; if( pszSchemaOpt == NULL || EQUAL(pszSchemaOpt,"EXTERNAL") ) { const char *pszXSDFilename = CPLResetExtension( pszName, "xsd" ); fpSchema = VSIFOpen( pszXSDFilename, "wt" ); if( fpSchema == NULL ) { CPLError( CE_Failure, CPLE_OpenFailed, "Failed to open file %.500s for schema output.", pszXSDFilename ); return; } fprintf( fpSchema, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" ); } else if( EQUAL(pszSchemaOpt,"INTERNAL") ) { nSchemaStart = VSIFTell( fpOutput ); fpSchema = fpOutput; } else return; /* ==================================================================== */ /* Write the schema section at the end of the file. Once */ /* complete, we will read it back in, and then move the whole */ /* file "down" enough to insert the schema at the beginning. */ /* ==================================================================== */ /* -------------------------------------------------------------------- */ /* Emit the start of the schema section. */ /* -------------------------------------------------------------------- */ const char *pszTargetNameSpace = "http://ogr.maptools.org/"; const char *pszPrefix = "ogr"; VSIFPrintf( fpSchema, "<xs:schema targetNamespace=\"%s\" xmlns:%s=\"%s\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:gml=\"http://www.opengis.net/gml\" elementFormDefault=\"qualified\" version=\"1.0\">\n", pszTargetNameSpace, pszPrefix, pszTargetNameSpace ); VSIFPrintf( fpSchema, "<xs:import namespace=\"http://www.opengis.net/gml\" schemaLocation=\"http://schemas.opengeospatial.net/gml/2.1.2/feature.xsd\"/>" ); /* -------------------------------------------------------------------- */ /* Define the FeatureCollection */ /* -------------------------------------------------------------------- */ VSIFPrintf( fpSchema, "<xs:element name=\"FeatureCollection\" type=\"%s:FeatureCollectionType\" substitutionGroup=\"gml:_FeatureCollection\"/>\n", pszPrefix ); VSIFPrintf( fpSchema, "<xs:complexType name=\"FeatureCollectionType\">\n" " <xs:complexContent>\n" " <xs:extension base=\"gml:AbstractFeatureCollectionType\">\n" " <xs:attribute name=\"lockId\" type=\"xs:string\" use=\"optional\"/>\n" " <xs:attribute name=\"scope\" type=\"xs:string\" use=\"optional\"/>\n" " </xs:extension>\n" " </xs:complexContent>\n" "</xs:complexType>\n" ); /* ==================================================================== */ /* Define the schema for each layer. */ /* ==================================================================== */ int iLayer; for( iLayer = 0; iLayer < GetLayerCount(); iLayer++ ) { OGRFeatureDefn *poFDefn = GetLayer(iLayer)->GetLayerDefn(); /* -------------------------------------------------------------------- */ /* Emit initial stuff for a feature type. */ /* -------------------------------------------------------------------- */ VSIFPrintf( fpSchema, "<xs:element name=\"%s\" type=\"%s:%s_Type\" substitutionGroup=\"gml:_Feature\"/>\n", poFDefn->GetName(), pszPrefix, poFDefn->GetName() ); VSIFPrintf( fpSchema, "<xs:complexType name=\"%s_Type\">\n" " <xs:complexContent>\n" " <xs:extension base=\"gml:AbstractFeatureType\">\n" " <xs:sequence>\n", poFDefn->GetName() ); /* -------------------------------------------------------------------- */ /* Define the geometry attribute. For now I always use the */ /* generic geometry type, but eventually we should express */ /* particulars if available. */ /* -------------------------------------------------------------------- */ VSIFPrintf( fpSchema, "<xs:element name=\"geometryProperty\" type=\"gml:GeometryPropertyType\" nillable=\"true\" minOccurs=\"1\" maxOccurs=\"1\"/>\n" ); /* -------------------------------------------------------------------- */ /* Emit each of the attributes. */ /* -------------------------------------------------------------------- */ for( int iField = 0; iField < poFDefn->GetFieldCount(); iField++ ) { OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn(iField); if( poFieldDefn->GetType() == OFTInteger ) { int nWidth; if( poFieldDefn->GetWidth() > 0 ) nWidth = poFieldDefn->GetWidth(); else nWidth = 16; VSIFPrintf( fpSchema, " <xs:element name=\"%s\" nillable=\"true\" minOccurs=\"0\" maxOccurs=\"1\">\n" " <xs:simpleType>\n" " <xs:restriction base=\"xs:integer\">\n" " <xs:totalDigits value=\"%d\"/>\n" " </xs:restriction>\n" " </xs:simpleType>\n" " </xs:element>\n", poFieldDefn->GetNameRef(), nWidth ); } else if( poFieldDefn->GetType() == OFTReal ) { int nWidth, nDecimals; if( poFieldDefn->GetPrecision() == 0 ) nDecimals = 0; else nDecimals = poFieldDefn->GetPrecision(); if( poFieldDefn->GetWidth() > 0 ) nWidth = poFieldDefn->GetWidth(); else nWidth = 33; VSIFPrintf( fpSchema, " <xs:element name=\"%s\" nillable=\"true\" minOccurs=\"0\" maxOccurs=\"1\">\n" " <xs:simpleType>\n" " <xs:restriction base=\"xs:decimal\">\n" " <xs:totalDigits value=\"%d\"/>\n" " <xs:fractionDigits value=\"%d\"/>\n" " </xs:restriction>\n" " </xs:simpleType>\n" " </xs:element>\n", poFieldDefn->GetNameRef(), nWidth, nDecimals ); } else if( poFieldDefn->GetType() == OFTString ) { char szMaxLength[48]; if( poFieldDefn->GetWidth() == 0 ) sprintf( szMaxLength, "unbounded" ); else sprintf( szMaxLength, "%d", poFieldDefn->GetWidth() ); VSIFPrintf( fpSchema, " <xs:element name=\"%s\" nillable=\"true\" minOccurs=\"0\" maxOccurs=\"1\">\n" " <xs:simpleType>\n" " <xs:restriction base=\"xs:string\">\n" " <xs:maxLength value=\"%s\"/>\n" " </xs:restriction>\n" " </xs:simpleType>\n" " </xs:element>\n", poFieldDefn->GetNameRef(), szMaxLength ); } else if( poFieldDefn->GetType() == OFTDate || poFieldDefn->GetType() == OFTDateTime ) { VSIFPrintf( fpSchema, " <xs:element name=\"%s\" nillable=\"true\" minOccurs=\"0\" maxOccurs=\"1\">\n" " <xs:simpleType>\n" " <xs:restriction base=\"xs:string\">\n" " <xs:maxLength value=\"unbounded\"/>\n" " </xs:restriction>\n" " </xs:simpleType>\n" " </xs:element>\n", poFieldDefn->GetNameRef() ); } else { /* TODO */ } } /* next field */ /* -------------------------------------------------------------------- */ /* Finish off feature type. */ /* -------------------------------------------------------------------- */ VSIFPrintf( fpSchema, " </xs:sequence>\n" " </xs:extension>\n" " </xs:complexContent>\n" "</xs:complexType>\n" ); } /* next layer */ VSIFPrintf( fpSchema, "</xs:schema>\n" ); /* ==================================================================== */ /* Move schema to the start of the file. */ /* ==================================================================== */ if( fpSchema == fpOutput ) { /* -------------------------------------------------------------------- */ /* Read the schema into memory. */ /* -------------------------------------------------------------------- */ int nSchemaSize = VSIFTell( fpOutput ) - nSchemaStart; char *pszSchema = (char *) CPLMalloc(nSchemaSize+1); VSIFSeek( fpOutput, nSchemaStart, SEEK_SET ); VSIFRead( pszSchema, 1, nSchemaSize, fpOutput ); pszSchema[nSchemaSize] = '\0'; /* -------------------------------------------------------------------- */ /* Move file data down by "schema size" bytes from after <?xml> */ /* header so we have room insert the schema. Move in pretty */ /* big chunks. */ /* -------------------------------------------------------------------- */ int nChunkSize = MIN(nSchemaStart-nSchemaInsertLocation,250000); char *pszChunk = (char *) CPLMalloc(nChunkSize); int nEndOfUnmovedData = nSchemaStart; for( nEndOfUnmovedData = nSchemaStart; nEndOfUnmovedData > nSchemaInsertLocation; ) { int nBytesToMove = MIN(nChunkSize, nEndOfUnmovedData - nSchemaInsertLocation ); VSIFSeek( fpOutput, nEndOfUnmovedData - nBytesToMove, SEEK_SET ); VSIFRead( pszChunk, 1, nBytesToMove, fpOutput ); VSIFSeek( fpOutput, nEndOfUnmovedData - nBytesToMove + nSchemaSize, SEEK_SET ); VSIFWrite( pszChunk, 1, nBytesToMove, fpOutput ); nEndOfUnmovedData -= nBytesToMove; } CPLFree( pszChunk ); /* -------------------------------------------------------------------- */ /* Write the schema in the opened slot. */ /* -------------------------------------------------------------------- */ VSIFSeek( fpOutput, nSchemaInsertLocation, SEEK_SET ); VSIFWrite( pszSchema, 1, nSchemaSize, fpOutput ); VSIFSeek( fpOutput, 0, SEEK_END ); nBoundedByLocation += nSchemaSize; } /* -------------------------------------------------------------------- */ /* Close external schema files. */ /* -------------------------------------------------------------------- */ else VSIFClose( fpSchema ); }
OGRLayer *OGRDataSource::CopyLayer( OGRLayer *poSrcLayer, const char *pszNewName, char **papszOptions ) { OGRFeatureDefn *poSrcDefn = poSrcLayer->GetLayerDefn(); OGRLayer *poDstLayer = NULL; /* -------------------------------------------------------------------- */ /* Create the layer. */ /* -------------------------------------------------------------------- */ if( !TestCapability( ODsCCreateLayer ) ) { CPLError( CE_Failure, CPLE_NotSupported, "This datasource does not support creation of layers." ); return NULL; } CPLErrorReset(); poDstLayer = CreateLayer( pszNewName, poSrcLayer->GetSpatialRef(), poSrcDefn->GetGeomType(), papszOptions ); if( poDstLayer == NULL ) return NULL; /* -------------------------------------------------------------------- */ /* Add fields. Default to copy all field. */ /* If only a subset of all fields requested, then output only */ /* the selected fields, and in the order that they were */ /* selected. */ /* -------------------------------------------------------------------- */ int iField; for( iField = 0; iField < poSrcDefn->GetFieldCount(); iField++ ) poDstLayer->CreateField( poSrcDefn->GetFieldDefn(iField) ); /* -------------------------------------------------------------------- */ /* Check if the destination layer supports transactions and set a */ /* default number of features in a single transaction. */ /* -------------------------------------------------------------------- */ int nGroupTransactions = 0; if( poDstLayer->TestCapability( OLCTransactions ) ) nGroupTransactions = 128; /* -------------------------------------------------------------------- */ /* Transfer features. */ /* -------------------------------------------------------------------- */ OGRFeature *poFeature; poSrcLayer->ResetReading(); if( nGroupTransactions <= 0 ) { while( TRUE ) { OGRFeature *poDstFeature = NULL; poFeature = poSrcLayer->GetNextFeature(); if( poFeature == NULL ) break; CPLErrorReset(); poDstFeature = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() ); if( poDstFeature->SetFrom( poFeature, TRUE ) != OGRERR_NONE ) { delete poFeature; CPLError( CE_Failure, CPLE_AppDefined, "Unable to translate feature %ld from layer %s.\n", poFeature->GetFID(), poSrcDefn->GetName() ); return poDstLayer; } poDstFeature->SetFID( poFeature->GetFID() ); OGRFeature::DestroyFeature( poFeature ); CPLErrorReset(); if( poDstLayer->CreateFeature( poDstFeature ) != OGRERR_NONE ) { OGRFeature::DestroyFeature( poDstFeature ); return poDstLayer; } OGRFeature::DestroyFeature( poDstFeature ); } } else { int i, bStopTransfer = FALSE, bStopTransaction = FALSE; int nFeatCount = 0; // Number of features in the temporary array int nFeaturesToAdd = 0; while( !bStopTransfer ) { OGRFeature **papoDstFeature = (OGRFeature **)CPLCalloc(sizeof(OGRFeature *), nGroupTransactions); /* -------------------------------------------------------------------- */ /* Fill the array with features */ /* -------------------------------------------------------------------- */ for( nFeatCount = 0; nFeatCount < nGroupTransactions; nFeatCount++ ) { poFeature = poSrcLayer->GetNextFeature(); if( poFeature == NULL ) { bStopTransfer = 1; break; } CPLErrorReset(); papoDstFeature[nFeatCount] = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() ); if( papoDstFeature[nFeatCount]->SetFrom( poFeature, TRUE ) != OGRERR_NONE ) { OGRFeature::DestroyFeature( poFeature ); CPLError( CE_Failure, CPLE_AppDefined, "Unable to translate feature %ld from layer %s.\n", poFeature->GetFID(), poSrcDefn->GetName() ); bStopTransfer = TRUE; break; } papoDstFeature[nFeatCount]->SetFID( poFeature->GetFID() ); OGRFeature::DestroyFeature( poFeature ); } nFeaturesToAdd = nFeatCount; CPLErrorReset(); bStopTransaction = FALSE; while( !bStopTransaction ) { bStopTransaction = TRUE; poDstLayer->StartTransaction(); for( i = 0; i < nFeaturesToAdd; i++ ) { if( poDstLayer->CreateFeature( papoDstFeature[i] ) != OGRERR_NONE ) { nFeaturesToAdd = i; bStopTransfer = TRUE; bStopTransaction = FALSE; } } if( bStopTransaction ) poDstLayer->CommitTransaction(); else poDstLayer->RollbackTransaction(); } for( i = 0; i < nFeatCount; i++ ) OGRFeature::DestroyFeature( papoDstFeature[i] ); } } return poDstLayer; }
void ogr_datasource::bind() const { if (is_bound_) return; // initialize ogr formats OGRRegisterAll(); // open ogr driver dataset_ = OGRSFDriverRegistrar::Open ((dataset_name_).c_str(), FALSE); if (!dataset_) { 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"); if (layer_by_name && layer_by_index) throw datasource_exception("OGR Plugin: you can only select an ogr layer by name ('layer' parameter) or by number ('layer_by_index' parameter), do not supply both parameters" ); if (layer_by_name) { layerName_ = *layer_by_name; layer_ = dataset_->GetLayerByName (layerName_.c_str()); } else if (layer_by_index) { 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()); } OGRLayer *ogr_layer = dataset_->GetLayer(*layer_by_index); if (ogr_layer) { OGRFeatureDefn* def = ogr_layer->GetLayerDefn(); if (def != 0) { layerName_ = def->GetName(); layer_ = ogr_layer; } } } else { std::ostringstream s; s << "OGR Plugin: missing <layer> or <layer_by_index> parameter, available layers are: "; unsigned num_layers = dataset_->GetLayerCount(); bool found = false; for (unsigned i = 0; i < num_layers; ++i ) { OGRLayer *ogr_layer = dataset_->GetLayer(i); OGRFeatureDefn* def = ogr_layer->GetLayerDefn(); if (def != 0) { found = true; s << " '" << def->GetName() << "' "; } } if (!found) { s << "None (no layers were found in dataset)"; } throw datasource_exception(s.str()); } if (!layer_) { 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; s += "' in dataset '" + dataset_name_ + "'"; throw datasource_exception(s); } // 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(); } // 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\n"; }*/ // deal with attributes descriptions OGRFeatureDefn* def = layer_->GetLayerDefn (); if (def != 0) { int fld_count = def->GetFieldCount (); for (int i = 0; i < fld_count; i++) { OGRFieldDefn* fld = def->GetFieldDefn (i); std::string fld_name = fld->GetNameRef (); 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; }
const char* GetName() { return poTableDefn->GetName(); }
ogr_datasource::ogr_datasource(parameters const& params) : datasource(params), extent_(), type_(datasource::Vector), desc_(*params.get<std::string>("type"), *params.get<std::string>("encoding","utf-8")), indexed_(false) { OGRRegisterAll(); boost::optional<std::string> file = params.get<std::string>("file"); if (!file) throw datasource_exception("missing <file> parameter"); multiple_geometries_ = *params_.get<mapnik::boolean>("multiple_geometries",false); boost::optional<std::string> base = params.get<std::string>("base"); if (base) dataset_name_ = *base + "/" + *file; else dataset_name_ = *file; // open ogr driver dataset_ = OGRSFDriverRegistrar::Open ((dataset_name_).c_str(), FALSE); if (!dataset_) { std::string err = CPLGetLastErrorMsg(); if( err.size() == 0 ) { throw datasource_exception("Connection failed: " + dataset_name_ + " was not found or is not a supported format"); } else { throw datasource_exception(err); } } // initialize layer boost::optional<std::string> layer = params.get<std::string>("layer"); if (!layer) { std::string s ("missing <layer> parameter, available layers are: "); unsigned num_layers = dataset_->GetLayerCount(); for (unsigned i = 0; i < num_layers; ++i ) { OGRLayer *ogr_layer = dataset_->GetLayer(i); OGRFeatureDefn* def = ogr_layer->GetLayerDefn(); if (def != 0) { s += " '"; s += def->GetName(); s += "' "; } else { s += "No layers found!"; } } throw datasource_exception(s); } layerName_ = *layer; layer_ = dataset_->GetLayerByName (layerName_.c_str()); if (! layer_) throw datasource_exception("cannot find <layer> in dataset"); // initialize envelope OGREnvelope envelope; layer_->GetExtent (&envelope); extent_.init (envelope.MinX, envelope.MinY, envelope.MaxX, envelope.MaxY); // scan for index file size_t breakpoint = dataset_name_.find_last_of ("."); if (breakpoint == std::string::npos) breakpoint = dataset_name_.length(); index_name_ = dataset_name_.substr(0, breakpoint) + ".index"; std::ifstream index_file (index_name_.c_str(), std::ios::in | std::ios::binary); if (index_file) { indexed_=true; index_file.close(); } // deal with attributes descriptions OGRFeatureDefn* def = layer_->GetLayerDefn (); if (def != 0) { int fld_count = def->GetFieldCount (); for (int i = 0; i < fld_count; i++) { OGRFieldDefn* fld = def->GetFieldDefn (i); std::string fld_name = fld->GetNameRef (); 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 clog << "unhandled type_oid=" << type_oid << endl; #endif break; case OFTDate: case OFTTime: case OFTDateTime: // unhandled ! #ifdef MAPNIK_DEBUG clog << "unhandled type_oid=" << type_oid << endl; #endif desc_.add_descriptor(attribute_descriptor(fld_name,mapnik::Object)); break; default: // unknown #ifdef MAPNIK_DEBUG clog << "unknown type_oid=" << type_oid << endl; #endif break; } } } }
OGRFeatureDefn *OGRIngresTableLayer::ReadTableDefinition( const char *pszTable ) { poDS->EstablishActiveLayer( NULL ); /* -------------------------------------------------------------------- */ /* Fire off commands to get back the schema of the table. */ /* -------------------------------------------------------------------- */ CPLString osCommand; OGRIngresStatement oStatement( poDS->GetConn() ); osCommand.Printf( "select column_name, column_datatype, column_length, " "column_scale, column_ingdatatype, " "column_internal_datatype " "from iicolumns where table_name = '%s'", pszTable ); if( !oStatement.ExecuteSQL( osCommand ) ) { return NULL; } /* -------------------------------------------------------------------- */ /* Parse the returned table information. */ /* -------------------------------------------------------------------- */ OGRFeatureDefn *poDefn = new OGRFeatureDefn( pszTable ); SetDescription( poDefn->GetName() ); poDefn->Reference(); poDefn->SetGeomType( wkbNone ); char **papszRow = NULL; while( (papszRow = oStatement.GetRow()) != NULL ) { CPLString osFieldName = papszRow[0]; CPLString osIngresType = papszRow[1]; CPLString osInternalType = papszRow[5]; GInt32 nWidth, nScale; osIngresType.Trim(); osFieldName.Trim(); osInternalType.Trim(); memcpy( &nWidth, papszRow[2], 4 ); memcpy( &nScale, papszRow[3], 4 ); OGRFieldDefn oField(osFieldName, OFTString); if( osGeomColumn.empty() && (EQUAL(osInternalType,"POINT") || EQUAL(osInternalType,"IPOINT") || EQUAL(osInternalType,"BOX") || EQUAL(osInternalType,"IBOX") || EQUAL(osInternalType,"LSEG") || EQUAL(osInternalType,"ILSEG") || EQUAL(osInternalType,"LINE") || EQUAL(osInternalType,"ILINE") || EQUAL(osInternalType,"LONG LINE") || EQUAL(osInternalType,"POLYGON") || EQUAL(osInternalType,"IPOLYGON") || EQUAL(osInternalType,"LONG POLYGON") || EQUAL(osInternalType,"CIRCLE") || EQUAL(osInternalType,"LINESTRING") || EQUAL(osInternalType,"MULTIPOINT") || EQUAL(osInternalType,"MULTIPOLYGON") || EQUAL(osInternalType,"MULTILINESTRING") || EQUAL(osInternalType,"GEOMETRYCOLLECTION") || EQUAL(osInternalType,"ICIRCLE")) ) { osGeomColumn = osFieldName; osIngresGeomType = osInternalType; if( strstr(osInternalType,"POINT") ) poDefn->SetGeomType( wkbPoint ); else if( strstr(osInternalType,"LINE") || strstr(osInternalType,"SEG") || strstr(osInternalType, "LINESTRING")) poDefn->SetGeomType( wkbLineString ); else if( strstr(osInternalType,"MULTIPOINT")) poDefn->SetGeomType(wkbMultiPoint); else if( strstr(osInternalType,"MULTIPOLYGON")) poDefn->SetGeomType(wkbMultiPolygon); else if( strstr(osInternalType,"MULTILINESTRING")) poDefn->SetGeomType(wkbMultiLineString); // Oddly this is the standin for a generic geometry type. else if( strstr(osInternalType,"GEOMETRYCOLLECTION")) poDefn->SetGeomType(wkbUnknown); else poDefn->SetGeomType( wkbPolygon ); continue; } else if( STARTS_WITH_CI(osIngresType, "byte") || STARTS_WITH_CI(osIngresType, "long byte") ) { oField.SetType( OFTBinary ); } else if( STARTS_WITH_CI(osIngresType, "varchar") || EQUAL(osIngresType,"text") || STARTS_WITH_CI(osIngresType, "long varchar") ) { oField.SetType( OFTString ); oField.SetWidth( nWidth ); } else if( STARTS_WITH_CI(osIngresType, "char") || EQUAL(osIngresType,"c") ) { oField.SetType( OFTString ); oField.SetWidth( nWidth ); } else if( EQUAL(osIngresType,"integer") ) { oField.SetType( OFTInteger ); } else if( STARTS_WITH_CI(osIngresType, "decimal") ) { if( nScale != 0 ) { oField.SetType( OFTReal ); oField.SetPrecision( nScale ); oField.SetWidth( nWidth ); } else { oField.SetType( OFTInteger ); oField.SetWidth( nWidth ); } } else if( STARTS_WITH_CI(osIngresType, "float") ) { oField.SetType( OFTReal ); } #ifdef notdef else if( EQUAL(osIngresType,"date") || EQUAL(osIngresType,"ansidate") || EQUAL(osIngresType,"ingresdate") ) { oField.SetType( OFTDate ); } #endif // Is this an integer primary key field? if( osFIDColumn.empty() && oField.GetType() == OFTInteger && EQUAL(oField.GetNameRef(),"ogr_fid") ) { osFIDColumn = oField.GetNameRef(); continue; } poDefn->AddFieldDefn( &oField ); } if( !osFIDColumn.empty() ) CPLDebug( "Ingres", "table %s has FID column %s.", pszTable, osFIDColumn.c_str() ); else CPLDebug( "Ingres", "table %s has no FID column, FIDs will not be reliable!", pszTable ); //We must close the current statement before calling this or else //The query within FetchSRSId will fail oStatement.Close(); // Fetch the SRID for this table now // But only if it's the new Ingres Geospatial if(poDS->IsNewIngres() == TRUE) nSRSId = FetchSRSId(poDefn); return poDefn; }