bool shape::load(string filename) { OGRRegisterAll(); // First open the shape file ds = OGRSFDriverRegistrar::Open( filename.c_str(), FALSE ); // Now to load in the points ..... points = vector<vector<glm::vec2>>(); // Grab the first layer OGRLayer* layer = ds->GetLayer(0); // Grab the spatial reference and create a coordinate transform function sr = layer->GetSpatialRef(); // Taking from http://www.compsci.wm.edu/SciClone/documentation/software/geo/gdal-1.9.0/html/ogr/ogr_apitut.html OGRFeature *poFeature; layer->ResetReading(); while( (poFeature = layer->GetNextFeature()) != NULL ) { OGRFeatureDefn *poFDefn = layer->GetLayerDefn(); int iField; OGRGeometry *poGeometry; poGeometry = poFeature->GetGeometryRef(); if( poGeometry != NULL && wkbFlatten(poGeometry->getGeometryType()) == wkbPoint ) { OGRPoint *poPoint = (OGRPoint *) poGeometry; //printf( "%.3f,%3.f\n", poPoint->getX(), poPoint->getY() ); } else if (poGeometry != NULL && wkbFlatten(poGeometry->getGeometryType()) == wkbLineString) { //cout << "LINES!!!!" << endl; OGRLineString* ls= (OGRLineString*)poGeometry; points.push_back(vector<glm::vec2>()); for(int i = 0; i < ls->getNumPoints(); i++ ) { OGRPoint p; ls->getPoint(i,&p); // This function can transform a larget set of points..... double x = p.getX(); double y = p.getY(); points[points.size()-1].push_back(glm::vec2(x,y)); //poTransform->Transform (1, &x, &y); //cout << p.getX() << " " << p.getY() << "Transformed!: " << x << " " << y << endl; } } else if (poGeometry != NULL && wkbFlatten(poGeometry->getGeometryType()) == wkbPolygon) { OGRLineString* ls= (OGRLineString*)poGeometry->getBoundary(); points.push_back(vector<glm::vec2>()); cout << "POLYGON" << ls->getNumPoints() << endl; //exit(0); for(int i = 0; i < ls->getNumPoints(); i++ ) { OGRPoint p; ls->getPoint(i,&p); // This function can transform a larget set of points..... double x = p.getX(); double y = p.getY(); points[points.size()-1].push_back(glm::vec2(x,y)); //poTransform->Transform (1, &x, &y); //cout << p.getX() << " " << p.getY() << "Transformed!: " << x << " " << y << endl; } } OGRFeature::DestroyFeature( poFeature ); } return true; }
OGRErr GTMTrackLayer::CreateFeature (OGRFeature *poFeature) { FILE* fpTmpTrackpoints = poDS->getTmpTrackpointsFP(); if (fpTmpTrackpoints == NULL) return CE_Failure; FILE* fpTmpTracks = poDS->getTmpTracksFP(); if (fpTmpTracks == NULL) return CE_Failure; OGRGeometry *poGeom = poFeature->GetGeometryRef(); if ( poGeom == NULL ) { CPLError( CE_Failure, CPLE_AppDefined, "Features without geometry not supported by GTM writer in track layer." ); return OGRERR_FAILURE; } if (NULL != poCT) { poGeom = poGeom->clone(); poGeom->transform( poCT ); } switch( poGeom->getGeometryType() ) { case wkbLineString: case wkbLineString25D: { WriteFeatureAttributes(poFeature); OGRLineString* line = (OGRLineString*)poGeom; for(int i = 0; i < line->getNumPoints(); ++i) { double lat = line->getY(i); double lon = line->getX(i); float altitude = 0; CheckAndFixCoordinatesValidity(lat, lon); poDS->checkBounds((float)lat, (float)lon); if (line->getGeometryType() == wkbLineString25D) altitude = (float)line->getZ(i); WriteTrackpoint( lat, lon, altitude, i==0 ); } break; } case wkbMultiLineString: case wkbMultiLineString25D: { int nGeometries = ((OGRGeometryCollection*)poGeom)->getNumGeometries (); for(int j = 0; j < nGeometries; ++j) { WriteFeatureAttributes(poFeature); OGRLineString* line = (OGRLineString*) ( ((OGRGeometryCollection*)poGeom)->getGeometryRef(j) ); int n = (line) ? line->getNumPoints() : 0; for(int i = 0; i < n; ++i) { double lat = line->getY(i); double lon = line->getX(i); float altitude = 0; CheckAndFixCoordinatesValidity(lat, lon); if (line->getGeometryType() == wkbLineString25D) altitude = (float) line->getZ(i); WriteTrackpoint( lat, lon, altitude, i==0 ); } } break; } default: { CPLError( CE_Failure, CPLE_NotSupported, "Geometry type of `%s' not supported for 'track' element.\n", OGRGeometryTypeToName(poGeom->getGeometryType()) ); if (NULL != poCT) delete poGeom; return OGRERR_FAILURE; } } if (NULL != poCT) delete poGeom; return OGRERR_NONE; }
OGRErr OGRCSVLayer::CreateFeature( OGRFeature *poNewFeature ) { int iField; if( !bInWriteMode ) { CPLError( CE_Failure, CPLE_AppDefined, "The CreateFeature() operation is not permitted on a read-only CSV." ); return OGRERR_FAILURE; } /* If we need rewind, it means that we have just written a feature before */ /* so there's no point seeking to the end of the file, as we're already */ /* at the end */ int bNeedSeekEnd = !bNeedRewindBeforeRead; bNeedRewindBeforeRead = TRUE; /* -------------------------------------------------------------------- */ /* Write field names if we haven't written them yet. */ /* Write .csvt file if needed */ /* -------------------------------------------------------------------- */ if( bNew ) { OGRErr eErr = WriteHeader(); if (eErr != OGRERR_NONE) return eErr; bNeedSeekEnd = FALSE; } if (fpCSV == NULL) return OGRERR_FAILURE; /* -------------------------------------------------------------------- */ /* Make sure we are at the end of the file. */ /* -------------------------------------------------------------------- */ if (bNeedSeekEnd) { if (bFirstFeatureAppendedDuringSession) { /* Add a newline character to the end of the file if necessary */ bFirstFeatureAppendedDuringSession = FALSE; VSIFSeekL( fpCSV, 0, SEEK_END ); VSIFSeekL( fpCSV, VSIFTellL(fpCSV) - 1, SEEK_SET); char chLast; VSIFReadL( &chLast, 1, 1, fpCSV ); VSIFSeekL( fpCSV, 0, SEEK_END ); if (chLast != '\n') { if( bUseCRLF ) VSIFPutcL( 13, fpCSV ); VSIFPutcL( '\n', fpCSV ); } } else { VSIFSeekL( fpCSV, 0, SEEK_END ); } } /* -------------------------------------------------------------------- */ /* Write out the geometry */ /* -------------------------------------------------------------------- */ if (eGeometryFormat == OGR_CSV_GEOM_AS_WKT) { OGRGeometry *poGeom = poNewFeature->GetGeometryRef(); char* pszWKT = NULL; if (poGeom && poGeom->exportToWkt(&pszWKT) == OGRERR_NONE) { VSIFPrintfL( fpCSV, "\"%s\"", pszWKT); } else { VSIFPrintfL( fpCSV, "\"\""); } CPLFree(pszWKT); if (poFeatureDefn->GetFieldCount() > 0) VSIFPrintfL( fpCSV, "%c", chDelimiter); } else if (eGeometryFormat == OGR_CSV_GEOM_AS_XYZ || eGeometryFormat == OGR_CSV_GEOM_AS_XY || eGeometryFormat == OGR_CSV_GEOM_AS_YX) { OGRGeometry *poGeom = poNewFeature->GetGeometryRef(); if (poGeom && wkbFlatten(poGeom->getGeometryType()) == wkbPoint) { OGRPoint* poPoint = (OGRPoint*) poGeom; char szBuffer[75]; if (eGeometryFormat == OGR_CSV_GEOM_AS_XYZ ) OGRMakeWktCoordinate(szBuffer, poPoint->getX(), poPoint->getY(), poPoint->getZ(), 3); else if (eGeometryFormat == OGR_CSV_GEOM_AS_XY ) OGRMakeWktCoordinate(szBuffer, poPoint->getX(), poPoint->getY(), 0, 2); else OGRMakeWktCoordinate(szBuffer, poPoint->getY(), poPoint->getX(), 0, 2); char* pc = szBuffer; while(*pc != '\0') { if (*pc == ' ') *pc = chDelimiter; pc ++; } VSIFPrintfL( fpCSV, "%s", szBuffer ); } else { VSIFPrintfL( fpCSV, "%c", chDelimiter ); if (eGeometryFormat == OGR_CSV_GEOM_AS_XYZ) VSIFPrintfL( fpCSV, "%c", chDelimiter ); } if (poFeatureDefn->GetFieldCount() > 0) VSIFPrintfL( fpCSV, "%c", chDelimiter ); } /* -------------------------------------------------------------------- */ /* Write out all the field values. */ /* -------------------------------------------------------------------- */ int bNonEmptyLine = FALSE; for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ ) { char *pszEscaped; if( iField > 0 ) VSIFPrintfL( fpCSV, "%c", chDelimiter ); if (poFeatureDefn->GetFieldDefn(iField)->GetType() == OFTReal) { pszEscaped = CPLStrdup(poNewFeature->GetFieldAsString(iField)); /* Use point as decimal separator */ char* pszComma = strchr(pszEscaped, ','); if (pszComma) *pszComma = '.'; } else { pszEscaped = CPLEscapeString( poNewFeature->GetFieldAsString(iField), -1, CPLES_CSV ); } int nLen = (int)strlen(pszEscaped); bNonEmptyLine |= (nLen != 0); VSIFWriteL( pszEscaped, 1, nLen, fpCSV ); CPLFree( pszEscaped ); } if( poFeatureDefn->GetFieldCount() == 1 && !bNonEmptyLine ) VSIFPrintfL( fpCSV, "%c", chDelimiter ); if( bUseCRLF ) VSIFPutcL( 13, fpCSV ); VSIFPutcL( '\n', fpCSV ); return OGRERR_NONE; }
OGRFeature *OGRMySQLLayer::RecordToFeature( char **papszRow, unsigned long *panLengths ) { mysql_field_seek( hResultSet, 0 ); /* -------------------------------------------------------------------- */ /* Create a feature from the current result. */ /* -------------------------------------------------------------------- */ int iField; OGRFeature *poFeature = new OGRFeature( poFeatureDefn ); poFeature->SetFID( iNextShapeId ); m_nFeaturesRead++; /* ==================================================================== */ /* Transfer all result fields we can. */ /* ==================================================================== */ for( iField = 0; iField < (int) mysql_num_fields(hResultSet); iField++ ) { int iOGRField; MYSQL_FIELD *psMSField = mysql_fetch_field(hResultSet); /* -------------------------------------------------------------------- */ /* Handle FID. */ /* -------------------------------------------------------------------- */ if( bHasFid && EQUAL(psMSField->name,pszFIDColumn) ) { if( papszRow[iField] == NULL ) { CPLError( CE_Failure, CPLE_AppDefined, "NULL primary key in RecordToFeature()" ); return NULL; } poFeature->SetFID( CPLAtoGIntBig(papszRow[iField]) ); } if( papszRow[iField] == NULL ) { // CPLDebug("MYSQL", "%s was null for %d", psMSField->name, // iNextShapeId); continue; } /* -------------------------------------------------------------------- */ /* Handle MySQL geometry */ /* -------------------------------------------------------------------- */ if( pszGeomColumn && EQUAL(psMSField->name,pszGeomColumn)) { OGRGeometry *poGeometry = NULL; // Geometry columns will have the first 4 bytes contain the SRID. OGRGeometryFactory::createFromWkb( ((GByte *)papszRow[iField]) + 4, NULL, &poGeometry, panLengths[iField] - 4 ); if( poGeometry != NULL ) { poGeometry->assignSpatialReference( GetSpatialRef() ); poFeature->SetGeometryDirectly( poGeometry ); } continue; } /* -------------------------------------------------------------------- */ /* Transfer regular data fields. */ /* -------------------------------------------------------------------- */ iOGRField = poFeatureDefn->GetFieldIndex(psMSField->name); if( iOGRField < 0 ) continue; OGRFieldDefn *psFieldDefn = poFeatureDefn->GetFieldDefn( iOGRField ); if( psFieldDefn->GetType() == OFTBinary ) { poFeature->SetField( iOGRField, panLengths[iField], (GByte *) papszRow[iField] ); } else { poFeature->SetField( iOGRField, papszRow[iField] ); } } return poFeature; }
OGRFeature* OGRPLScenesLayer::GetNextRawFeature() { if( bEOF || (!bFilterMustBeClientSideEvaluated && nFeatureCount >= 0 && nNextFID > nFeatureCount) ) return NULL; if( poGeoJSONLayer == NULL ) { if( !GetNextPage() ) return NULL; } #ifdef notdef if( CSLTestBoolean(CPLGetConfigOption("OGR_LIMIT_TOO_MANY_FEATURES", "FALSE")) && nFeatureCount > nPageSize ) { bEOF = TRUE; OGRFeature* poFeature = new OGRFeature(poFeatureDefn); OGRGeometry* poGeom; const char* pszWKT = "MULTIPOLYGON(((-180 90,180 90,180 -90,-180 -90,-180 90)))"; OGRGeometryFactory::createFromWkt((char**)&pszWKT, poSRS, &poGeom); poFeature->SetGeometryDirectly(poGeom); return poFeature; } #endif OGRFeature* poGeoJSONFeature = poGeoJSONLayer->GetNextFeature(); if( poGeoJSONFeature == NULL ) { osRequestURL = osNextURL; bStillInFirstPage = FALSE; if( !GetNextPage() ) return NULL; poGeoJSONFeature = poGeoJSONLayer->GetNextFeature(); if( poGeoJSONFeature == NULL ) { bEOF = TRUE; return NULL; } } OGRFeature* poFeature = new OGRFeature(poFeatureDefn); poFeature->SetFID(nNextFID++); OGRGeometry* poGeom = poGeoJSONFeature->StealGeometry(); if( poGeom != NULL ) { if( poGeom->getGeometryType() == wkbPolygon ) { OGRMultiPolygon* poMP = new OGRMultiPolygon(); poMP->addGeometryDirectly(poGeom); poGeom = poMP; } poGeom->assignSpatialReference(poSRS); poFeature->SetGeometryDirectly(poGeom); } for(int i=0;i<poFeatureDefn->GetFieldCount();i++) { OGRFieldDefn* poFieldDefn = poFeatureDefn->GetFieldDefn(i); OGRFieldType eType = poFieldDefn->GetType(); int iSrcField = poGeoJSONFeature->GetFieldIndex(poFieldDefn->GetNameRef()); if( iSrcField >= 0 && poGeoJSONFeature->IsFieldSet(iSrcField) ) { if( eType == OFTInteger ) poFeature->SetField(i, poGeoJSONFeature->GetFieldAsInteger(iSrcField)); else if( eType == OFTReal ) poFeature->SetField(i, poGeoJSONFeature->GetFieldAsDouble(iSrcField)); else poFeature->SetField(i, poGeoJSONFeature->GetFieldAsString(iSrcField)); } } delete poGeoJSONFeature; return poFeature; }
OGRErr OGRGFTTableLayer::SetFeature( OGRFeature *poFeature ) { GetLayerDefn(); if (!poDS->IsReadWrite()) { CPLError(CE_Failure, CPLE_AppDefined, "Operation not available in read-only mode"); return OGRERR_FAILURE; } if (osTableId.size() == 0) { CPLError(CE_Failure, CPLE_NotSupported, "Cannot set feature to non-created table"); return OGRERR_FAILURE; } if (poDS->GetAuth().size() == 0) { CPLError(CE_Failure, CPLE_AppDefined, "Operation not available in unauthenticated mode"); return OGRERR_FAILURE; } if (poFeature->GetFID() == OGRNullFID) { CPLError( CE_Failure, CPLE_AppDefined, "FID required on features given to SetFeature()." ); return OGRERR_FAILURE; } CPLString osCommand; osCommand += "UPDATE "; osCommand += osTableId; osCommand += " SET "; int iField; int nFieldCount = poFeatureDefn->GetFieldCount(); for(iField = 0; iField < nFieldCount + bHiddenGeometryField; iField++) { if (iField > 0) osCommand += ", "; if (iField == nFieldCount) { osCommand += EscapeAndQuote(GetGeometryColumn()); } else { const char* pszFieldName = poFeatureDefn->GetFieldDefn(iField)->GetNameRef(); osCommand += EscapeAndQuote(pszFieldName); } osCommand += " = "; OGRGeometry* poGeom = poFeature->GetGeometryRef(); if (iGeometryField != iLatitudeField && iField == iGeometryField && (iField == nFieldCount || poGeom != NULL || !poFeature->IsFieldSet( iField ))) { if (poGeom == NULL) osCommand += "''"; else { char* pszKML; if (poGeom->getSpatialReference() != NULL && !poGeom->getSpatialReference()->IsSame(poSRS)) { OGRGeometry* poGeom4326 = poGeom->clone(); poGeom4326->transformTo(poSRS); pszKML = poGeom4326->exportToKML(); delete poGeom4326; } else { pszKML = poGeom->exportToKML(); } osCommand += "'"; osCommand += pszKML; osCommand += "'"; CPLFree(pszKML); } continue; } if( !poFeature->IsFieldSet( iField ) ) { osCommand += "''"; } else { OGRFieldType eType = poFeatureDefn->GetFieldDefn(iField)->GetType(); if (eType != OFTInteger && eType != OFTReal) { CPLString osTmp; const char* pszVal = poFeature->GetFieldAsString(iField); if (!CPLIsUTF8(pszVal, -1)) { static int bFirstTime = TRUE; if (bFirstTime) { bFirstTime = FALSE; CPLError(CE_Warning, CPLE_AppDefined, "%s is not a valid UTF-8 string. Forcing it to ASCII.\n" "This warning won't be issued anymore", pszVal); } else { CPLDebug("OGR", "%s is not a valid UTF-8 string. Forcing it to ASCII", pszVal); } char* pszEscaped = CPLForceToASCII(pszVal, -1, '?'); osTmp = pszEscaped; CPLFree(pszEscaped); pszVal = osTmp.c_str(); } osCommand += EscapeAndQuote(pszVal); } else osCommand += poFeature->GetFieldAsString(iField); } } osCommand += " WHERE ROWID = '"; osCommand += CPLSPrintf("%ld", poFeature->GetFID()); osCommand += "'"; //CPLDebug("GFT", "%s", osCommand.c_str()); CPLHTTPResult * psResult = poDS->RunSQL(osCommand); if (psResult == NULL) { CPLError(CE_Failure, CPLE_AppDefined, "Feature update failed"); return OGRERR_FAILURE; } char* pszLine = (char*) psResult->pabyData; if (pszLine == NULL || strncmp(pszLine, "OK", 2) != 0 || psResult->pszErrBuf != NULL) { CPLError(CE_Failure, CPLE_AppDefined, "Feature update failed"); CPLHTTPDestroyResult(psResult); return OGRERR_FAILURE; } CPLHTTPDestroyResult(psResult); return OGRERR_NONE; }
OGRErr OGRSQLiteTableLayer::CreateFeature( OGRFeature *poFeature ) { sqlite3 *hDB = poDS->GetDB(); CPLString osCommand; CPLString osValues; int bNeedComma = FALSE; if (bSpatialiteReadOnly || !poDS->GetUpdate()) { CPLError( CE_Failure, CPLE_NotSupported, "Can't create feature on a read-only layer."); return OGRERR_FAILURE; } ResetReading(); /* -------------------------------------------------------------------- */ /* Form the INSERT command. */ /* -------------------------------------------------------------------- */ osCommand += CPLSPrintf( "INSERT INTO '%s' (", pszEscapedTableName ); /* -------------------------------------------------------------------- */ /* Add FID if we have a cleartext FID column. */ /* -------------------------------------------------------------------- */ if( pszFIDColumn != NULL // && !EQUAL(pszFIDColumn,"OGC_FID") && poFeature->GetFID() != OGRNullFID ) { osCommand += pszFIDColumn; osValues += CPLSPrintf( "%ld", poFeature->GetFID() ); bNeedComma = TRUE; } /* -------------------------------------------------------------------- */ /* Add geometry. */ /* -------------------------------------------------------------------- */ OGRGeometry *poGeom = poFeature->GetGeometryRef(); if( osGeomColumn.size() != 0 && poGeom != NULL && eGeomFormat != OSGF_FGF ) { if( bNeedComma ) { osCommand += ","; osValues += ","; } osCommand += osGeomColumn; osValues += "?"; bNeedComma = TRUE; } /* -------------------------------------------------------------------- */ /* Add field values. */ /* -------------------------------------------------------------------- */ int iField; int nFieldCount = poFeatureDefn->GetFieldCount(); for( iField = 0; iField < nFieldCount; iField++ ) { if( !poFeature->IsFieldSet( iField ) ) continue; if( bNeedComma ) { osCommand += ","; osValues += ","; } osCommand += "'"; osCommand +=poFeatureDefn->GetFieldDefn(iField)->GetNameRef(); osCommand += "'"; osValues += "?"; bNeedComma = TRUE; } /* -------------------------------------------------------------------- */ /* Merge final command. */ /* -------------------------------------------------------------------- */ osCommand += ") VALUES ("; osCommand += osValues; osCommand += ")"; /* -------------------------------------------------------------------- */ /* Prepare the statement. */ /* -------------------------------------------------------------------- */ int rc; sqlite3_stmt *hInsertStmt; #ifdef DEBUG CPLDebug( "OGR_SQLITE", "prepare(%s)", osCommand.c_str() ); #endif rc = sqlite3_prepare( hDB, osCommand, -1, &hInsertStmt, NULL ); if( rc != SQLITE_OK ) { CPLError( CE_Failure, CPLE_AppDefined, "In CreateFeature(): sqlite3_prepare(%s):\n %s", osCommand.c_str(), sqlite3_errmsg(hDB) ); return OGRERR_FAILURE; } /* -------------------------------------------------------------------- */ /* Bind the geometry */ /* -------------------------------------------------------------------- */ int nBindField = 1; if( osGeomColumn.size() != 0 && poGeom != NULL && eGeomFormat != OSGF_FGF ) { if ( eGeomFormat == OSGF_WKT ) { char *pszWKT = NULL; poGeom->exportToWkt( &pszWKT ); rc = sqlite3_bind_text( hInsertStmt, nBindField++, pszWKT, -1, CPLFree ); } else if( eGeomFormat == OSGF_WKB ) { int nWKBLen = poGeom->WkbSize(); GByte *pabyWKB = (GByte *) CPLMalloc(nWKBLen + 1); poGeom->exportToWkb( wkbNDR, pabyWKB ); rc = sqlite3_bind_blob( hInsertStmt, nBindField++, pabyWKB, nWKBLen, CPLFree ); } else if ( eGeomFormat == OSGF_SpatiaLite ) { int nBLOBLen; GByte *pabySLBLOB; ExportSpatiaLiteGeometry( poGeom, nSRSId, wkbNDR, bHasM, bSpatialite2D, &pabySLBLOB, &nBLOBLen ); rc = sqlite3_bind_blob( hInsertStmt, nBindField++, pabySLBLOB, nBLOBLen, CPLFree ); } else { CPLAssert(0); } if( rc != SQLITE_OK ) { CPLError( CE_Failure, CPLE_AppDefined, "sqlite3_bind_blob/text() failed:\n %s", sqlite3_errmsg(hDB) ); sqlite3_finalize( hInsertStmt ); return OGRERR_FAILURE; } } /* -------------------------------------------------------------------- */ /* Bind field values. */ /* -------------------------------------------------------------------- */ for( iField = 0; iField < nFieldCount; iField++ ) { const char *pszRawValue; if( !poFeature->IsFieldSet( iField ) ) continue; switch( poFeatureDefn->GetFieldDefn(iField)->GetType() ) { case OFTInteger: { int nFieldVal = poFeature->GetFieldAsInteger( iField ); rc = sqlite3_bind_int(hInsertStmt, nBindField++, nFieldVal); break; } case OFTReal: { double dfFieldVal = poFeature->GetFieldAsDouble( iField ); rc = sqlite3_bind_double(hInsertStmt, nBindField++, dfFieldVal); break; } case OFTBinary: { int nDataLength = 0; GByte* pabyData = poFeature->GetFieldAsBinary( iField, &nDataLength ); rc = sqlite3_bind_blob(hInsertStmt, nBindField++, pabyData, nDataLength, SQLITE_TRANSIENT); break; } default: { pszRawValue = poFeature->GetFieldAsString( iField ); rc = sqlite3_bind_text(hInsertStmt, nBindField++, pszRawValue, -1, SQLITE_TRANSIENT); break; } } if( rc != SQLITE_OK ) { CPLError( CE_Failure, CPLE_AppDefined, "sqlite3_bind_() for column %s failed:\n %s", poFeatureDefn->GetFieldDefn(iField)->GetNameRef(), sqlite3_errmsg(hDB) ); sqlite3_finalize( hInsertStmt ); return OGRERR_FAILURE; } } /* -------------------------------------------------------------------- */ /* Execute the insert. */ /* -------------------------------------------------------------------- */ rc = sqlite3_step( hInsertStmt ); if( rc != SQLITE_OK && rc != SQLITE_DONE ) { CPLError( CE_Failure, CPLE_AppDefined, "sqlite3_step() failed:\n %s", sqlite3_errmsg(hDB) ); sqlite3_finalize( hInsertStmt ); return OGRERR_FAILURE; } /* -------------------------------------------------------------------- */ /* Capture the FID/rowid. */ /* -------------------------------------------------------------------- */ const sqlite_int64 nFID = sqlite3_last_insert_rowid( hDB ); if(nFID > 0) { poFeature->SetFID( (long)nFID ); /* Possible truncation if nFID is 64bit */ } sqlite3_finalize( hInsertStmt ); return OGRERR_NONE; }
OGRFeature *OGRGMELayer::GetNextRawFeature() { /* -------------------------------------------------------------------- */ /* Fetch a new page of features if needed. */ /* -------------------------------------------------------------------- */ if (current_feature_page == NULL || index_in_page >= json_object_array_length(current_features_array)) { GetPageOfFeatures(); } if (current_feature_page == NULL) { return NULL; } /* -------------------------------------------------------------------- */ /* Identify our json feature. */ /* -------------------------------------------------------------------- */ json_object *feature_obj = json_object_array_get_idx(current_features_array, index_in_page++); if (feature_obj == NULL) return NULL; OGRFeature *poFeature = new OGRFeature(poFeatureDefn); /* -------------------------------------------------------------------- */ /* Handle properties. */ /* -------------------------------------------------------------------- */ json_object *properties_obj = json_object_object_get(feature_obj, "properties"); for (int iOGRField = 0; iOGRField < poFeatureDefn->GetFieldCount(); iOGRField++ ) { const char *pszValue = OGRGMEGetJSONString( properties_obj, poFeatureDefn->GetFieldDefn(iOGRField)->GetNameRef(), NULL); if (pszValue != NULL) { poFeature->SetField(iOGRField, pszValue); } } /* -------------------------------------------------------------------- */ /* Handle gx_id. */ /* -------------------------------------------------------------------- */ const char *gx_id = OGRGMEGetJSONString(properties_obj, "gx_id"); if (gx_id) { CPLString gmeId(gx_id); omnosIdToGMEKey[++m_nFeaturesRead] = gmeId; poFeature->SetFID(m_nFeaturesRead); CPLDebug("GME", "Mapping ids: \"%s\" to %d", gx_id, (int)m_nFeaturesRead); } /* -------------------------------------------------------------------- */ /* Handle geometry. */ /* -------------------------------------------------------------------- */ json_object *geometry_obj = json_object_object_get(feature_obj, "geometry"); OGRGeometry *poGeometry = NULL; if (geometry_obj != NULL) { poGeometry = OGRGeoJSONReadGeometry(geometry_obj); } if (poGeometry != NULL) { poGeometry->assignSpatialReference(poSRS); poFeature->SetGeometryDirectly(poGeometry); } return poFeature; }
OGRErr OGRPGDumpLayer::CreateFeatureViaInsert( OGRFeature *poFeature ) { CPLString osCommand; int i = 0; int bNeedComma = FALSE; OGRErr eErr = OGRERR_FAILURE; int bEmptyInsert = FALSE; if( NULL == poFeature ) { CPLError( CE_Failure, CPLE_AppDefined, "NULL pointer to OGRFeature passed to CreateFeatureViaInsert()." ); return eErr; } /* -------------------------------------------------------------------- */ /* Form the INSERT command. */ /* -------------------------------------------------------------------- */ osCommand.Printf( "INSERT INTO %s (", pszSqlTableName ); for(i = 0; i < poFeatureDefn->GetGeomFieldCount(); i++ ) { OGRGeometry *poGeom = poFeature->GetGeomFieldRef(i); if( poGeom != NULL ) { if( bNeedComma ) osCommand += ", "; OGRGeomFieldDefn* poGFldDefn = poFeature->GetGeomFieldDefnRef(i); osCommand = osCommand + OGRPGDumpEscapeColumnName(poGFldDefn->GetNameRef()) + " "; bNeedComma = TRUE; } } if( poFeature->GetFID() != OGRNullFID && pszFIDColumn != NULL ) { if( bNeedComma ) osCommand += ", "; osCommand = osCommand + OGRPGDumpEscapeColumnName(pszFIDColumn) + " "; bNeedComma = TRUE; } for( i = 0; i < poFeatureDefn->GetFieldCount(); i++ ) { if( !poFeature->IsFieldSet( i ) ) continue; if( !bNeedComma ) bNeedComma = TRUE; else osCommand += ", "; osCommand = osCommand + OGRPGDumpEscapeColumnName(poFeatureDefn->GetFieldDefn(i)->GetNameRef()); } if (!bNeedComma) bEmptyInsert = TRUE; osCommand += ") VALUES ("; /* Set the geometry */ bNeedComma = FALSE; for(i = 0; i < poFeatureDefn->GetGeomFieldCount(); i++ ) { OGRGeometry *poGeom = poFeature->GetGeomFieldRef(i); if( poGeom != NULL ) { char *pszWKT = NULL; OGRPGDumpGeomFieldDefn* poGFldDefn = (OGRPGDumpGeomFieldDefn*) poFeature->GetGeomFieldDefnRef(i); poGeom->closeRings(); poGeom->setCoordinateDimension( poGFldDefn->nCoordDimension ); if( bNeedComma ) osCommand += ", "; if( bWriteAsHex ) { char* pszHex = OGRGeometryToHexEWKB( poGeom, poGFldDefn->nSRSId ); osCommand += "'"; if (pszHex) osCommand += pszHex; osCommand += "'"; CPLFree(pszHex); } else { poGeom->exportToWkt( &pszWKT ); if( pszWKT != NULL ) { osCommand += CPLString().Printf( "GeomFromEWKT('SRID=%d;%s'::TEXT) ", poGFldDefn->nSRSId, pszWKT ); OGRFree( pszWKT ); } else osCommand += "''"; } bNeedComma = TRUE; } } /* Set the FID */ if( poFeature->GetFID() != OGRNullFID && pszFIDColumn != NULL ) { if( bNeedComma ) osCommand += ", "; osCommand += CPLString().Printf( "%ld ", poFeature->GetFID() ); bNeedComma = TRUE; } for( i = 0; i < poFeatureDefn->GetFieldCount(); i++ ) { if( !poFeature->IsFieldSet( i ) ) continue; if( bNeedComma ) osCommand += ", "; else bNeedComma = TRUE; AppendFieldValue(osCommand, poFeature, i); } osCommand += ")"; if (bEmptyInsert) osCommand.Printf( "INSERT INTO %s DEFAULT VALUES", pszSqlTableName ); /* -------------------------------------------------------------------- */ /* Execute the insert. */ /* -------------------------------------------------------------------- */ poDS->Log(osCommand); return OGRERR_NONE; }
int main( int argc, char ** argv ) { GDALDriverH hDriver; const char *pszSource=NULL, *pszDest=NULL, *pszFormat = "GTiff"; int bFormatExplicitelySet = FALSE; char **papszLayers = NULL; const char *pszBurnAttribute = NULL; double dfIncreaseBurnValue = 0.0; double dfMultiplyBurnValue = 1.0; const char *pszWHERE = NULL, *pszSQL = NULL; GDALDataType eOutputType = GDT_Float64; char **papszCreateOptions = NULL; GUInt32 nXSize = 0, nYSize = 0; double dfXMin = 0.0, dfXMax = 0.0, dfYMin = 0.0, dfYMax = 0.0; int bIsXExtentSet = FALSE, bIsYExtentSet = FALSE; GDALGridAlgorithm eAlgorithm = GGA_InverseDistanceToAPower; void *pOptions = NULL; char *pszOutputSRS = NULL; int bQuiet = FALSE; GDALProgressFunc pfnProgress = GDALTermProgress; int i; OGRGeometry *poSpatialFilter = NULL; int bClipSrc = FALSE; OGRGeometry *poClipSrc = NULL; const char *pszClipSrcDS = NULL; const char *pszClipSrcSQL = NULL; const char *pszClipSrcLayer = NULL; const char *pszClipSrcWhere = NULL; /* Check strict compilation and runtime library version as we use C++ API */ if (! GDAL_CHECK_VERSION(argv[0])) exit(1); GDALAllRegister(); OGRRegisterAll(); argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 ); if( argc < 1 ) exit( -argc ); /* -------------------------------------------------------------------- */ /* Parse arguments. */ /* -------------------------------------------------------------------- */ for( i = 1; i < argc; i++ ) { if( EQUAL(argv[i], "--utility_version") ) { printf("%s was compiled against GDAL %s and is running against GDAL %s\n", argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME")); return 0; } else if( EQUAL(argv[i],"--help") ) Usage(); else if( EQUAL(argv[i],"-of") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); pszFormat = argv[++i]; bFormatExplicitelySet = TRUE; } else if( EQUAL(argv[i],"-q") || EQUAL(argv[i],"-quiet") ) { bQuiet = TRUE; pfnProgress = GDALDummyProgress; } else if( EQUAL(argv[i],"-ot") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); int iType; for( iType = 1; iType < GDT_TypeCount; iType++ ) { if( GDALGetDataTypeName((GDALDataType)iType) != NULL && EQUAL(GDALGetDataTypeName((GDALDataType)iType), argv[i+1]) ) { eOutputType = (GDALDataType) iType; } } if( eOutputType == GDT_Unknown ) { Usage(CPLSPrintf("Unknown output pixel type: %s.", argv[i + 1] )); } i++; } else if( EQUAL(argv[i],"-txe") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2); dfXMin = atof(argv[++i]); dfXMax = atof(argv[++i]); bIsXExtentSet = TRUE; } else if( EQUAL(argv[i],"-tye") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2); dfYMin = atof(argv[++i]); dfYMax = atof(argv[++i]); bIsYExtentSet = TRUE; } else if( EQUAL(argv[i],"-outsize") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2); nXSize = atoi(argv[++i]); nYSize = atoi(argv[++i]); } else if( EQUAL(argv[i],"-co") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); papszCreateOptions = CSLAddString( papszCreateOptions, argv[++i] ); } else if( EQUAL(argv[i],"-zfield") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); pszBurnAttribute = argv[++i]; } else if( EQUAL(argv[i],"-z_increase") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); dfIncreaseBurnValue = atof(argv[++i]); } else if( EQUAL(argv[i],"-z_multiply") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); dfMultiplyBurnValue = atof(argv[++i]); } else if( EQUAL(argv[i],"-where") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); pszWHERE = argv[++i]; } else if( EQUAL(argv[i],"-l") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); papszLayers = CSLAddString( papszLayers, argv[++i] ); } else if( EQUAL(argv[i],"-sql") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); pszSQL = argv[++i]; } else if( EQUAL(argv[i],"-spat") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(4); OGRLinearRing oRing; oRing.addPoint( atof(argv[i+1]), atof(argv[i+2]) ); oRing.addPoint( atof(argv[i+1]), atof(argv[i+4]) ); oRing.addPoint( atof(argv[i+3]), atof(argv[i+4]) ); oRing.addPoint( atof(argv[i+3]), atof(argv[i+2]) ); oRing.addPoint( atof(argv[i+1]), atof(argv[i+2]) ); poSpatialFilter = new OGRPolygon(); ((OGRPolygon *) poSpatialFilter)->addRing( &oRing ); i += 4; } else if ( EQUAL(argv[i],"-clipsrc") ) { if (i + 1 >= argc) Usage(CPLSPrintf("%s option requires 1 or 4 arguments", argv[i])); bClipSrc = TRUE; errno = 0; const double unused = strtod( argv[i + 1], NULL ); // XXX: is it a number or not? if ( errno != 0 && argv[i + 2] != NULL && argv[i + 3] != NULL && argv[i + 4] != NULL) { OGRLinearRing oRing; oRing.addPoint( atof(argv[i + 1]), atof(argv[i + 2]) ); oRing.addPoint( atof(argv[i + 1]), atof(argv[i + 4]) ); oRing.addPoint( atof(argv[i + 3]), atof(argv[i + 4]) ); oRing.addPoint( atof(argv[i + 3]), atof(argv[i + 2]) ); oRing.addPoint( atof(argv[i + 1]), atof(argv[i + 2]) ); poClipSrc = new OGRPolygon(); ((OGRPolygon *) poClipSrc)->addRing( &oRing ); i += 4; (void)unused; } else if (EQUALN(argv[i + 1], "POLYGON", 7) || EQUALN(argv[i + 1], "MULTIPOLYGON", 12)) { OGRGeometryFactory::createFromWkt(&argv[i + 1], NULL, &poClipSrc); if ( poClipSrc == NULL ) { Usage("Invalid geometry. " "Must be a valid POLYGON or MULTIPOLYGON WKT."); } i++; } else if (EQUAL(argv[i + 1], "spat_extent") ) { i++; } else { pszClipSrcDS = argv[i + 1]; i++; } } else if ( EQUAL(argv[i], "-clipsrcsql") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); pszClipSrcSQL = argv[i + 1]; i++; } else if ( EQUAL(argv[i], "-clipsrclayer") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); pszClipSrcLayer = argv[i + 1]; i++; } else if ( EQUAL(argv[i], "-clipsrcwhere") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); pszClipSrcWhere = argv[i + 1]; i++; } else if( EQUAL(argv[i],"-a_srs") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); OGRSpatialReference oOutputSRS; if( oOutputSRS.SetFromUserInput( argv[i+1] ) != OGRERR_NONE ) { fprintf( stderr, "Failed to process SRS definition: %s\n", argv[i+1] ); GDALDestroyDriverManager(); exit( 1 ); } oOutputSRS.exportToWkt( &pszOutputSRS ); i++; } else if( EQUAL(argv[i],"-a") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); if ( ParseAlgorithmAndOptions( argv[++i], &eAlgorithm, &pOptions ) != CE_None ) { fprintf( stderr, "Failed to process algorithm name and parameters.\n" ); exit( 1 ); } } else if( argv[i][0] == '-' ) { Usage(CPLSPrintf("Unknown option name '%s'", argv[i])); } else if( pszSource == NULL ) { pszSource = argv[i]; } else if( pszDest == NULL ) { pszDest = argv[i]; } else { Usage("Too many command options."); } } if( pszSource == NULL ) { Usage("Source datasource is not specified."); } if( pszDest == NULL ) { Usage("Target dataset is not specified."); } if( pszSQL == NULL && papszLayers == NULL ) { Usage("Neither -sql nor -l are specified."); } if ( bClipSrc && pszClipSrcDS != NULL ) { poClipSrc = LoadGeometry( pszClipSrcDS, pszClipSrcSQL, pszClipSrcLayer, pszClipSrcWhere ); if ( poClipSrc == NULL ) { Usage("Cannot load source clip geometry."); } } else if ( bClipSrc && poClipSrc == NULL && !poSpatialFilter ) { Usage("-clipsrc must be used with -spat option or \n" "a bounding box, WKT string or datasource must be " "specified."); } if ( poSpatialFilter ) { if ( poClipSrc ) { OGRGeometry *poTemp = poSpatialFilter->Intersection( poClipSrc ); if ( poTemp ) { OGRGeometryFactory::destroyGeometry( poSpatialFilter ); poSpatialFilter = poTemp; } OGRGeometryFactory::destroyGeometry( poClipSrc ); poClipSrc = NULL; } } else { if ( poClipSrc ) { poSpatialFilter = poClipSrc; poClipSrc = NULL; } } /* -------------------------------------------------------------------- */ /* Find the output driver. */ /* -------------------------------------------------------------------- */ hDriver = GDALGetDriverByName( pszFormat ); if( hDriver == NULL ) { int iDr; fprintf( stderr, "FAILURE: Output driver `%s' not recognised.\n", pszFormat ); fprintf( stderr, "The following format drivers are configured and support output:\n" ); for( iDr = 0; iDr < GDALGetDriverCount(); iDr++ ) { GDALDriverH hDriver = GDALGetDriver(iDr); if( GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, NULL ) != NULL || GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATECOPY, NULL ) != NULL ) { fprintf( stderr, " %s: %s\n", GDALGetDriverShortName( hDriver ), GDALGetDriverLongName( hDriver ) ); } } printf( "\n" ); Usage(); } /* -------------------------------------------------------------------- */ /* Open input datasource. */ /* -------------------------------------------------------------------- */ OGRDataSourceH hSrcDS; hSrcDS = OGROpen( pszSource, FALSE, NULL ); if( hSrcDS == NULL ) { fprintf( stderr, "Unable to open input datasource \"%s\".\n", pszSource ); fprintf( stderr, "%s\n", CPLGetLastErrorMsg() ); exit( 3 ); } /* -------------------------------------------------------------------- */ /* Create target raster file. */ /* -------------------------------------------------------------------- */ GDALDatasetH hDstDS; int nLayerCount = CSLCount(papszLayers); int nBands = nLayerCount; if ( pszSQL ) nBands++; // FIXME if ( nXSize == 0 ) nXSize = 256; if ( nYSize == 0 ) nYSize = 256; if (!bQuiet && !bFormatExplicitelySet) CheckExtensionConsistency(pszDest, pszFormat); hDstDS = GDALCreate( hDriver, pszDest, nXSize, nYSize, nBands, eOutputType, papszCreateOptions ); if ( hDstDS == NULL ) { fprintf( stderr, "Unable to create target dataset \"%s\".\n", pszDest ); fprintf( stderr, "%s\n", CPLGetLastErrorMsg() ); exit( 3 ); } /* -------------------------------------------------------------------- */ /* If algorithm was not specified assigh default one. */ /* -------------------------------------------------------------------- */ if ( !pOptions ) ParseAlgorithmAndOptions( szAlgNameInvDist, &eAlgorithm, &pOptions ); /* -------------------------------------------------------------------- */ /* Process SQL request. */ /* -------------------------------------------------------------------- */ if( pszSQL != NULL ) { OGRLayerH hLayer; hLayer = OGR_DS_ExecuteSQL( hSrcDS, pszSQL, (OGRGeometryH)poSpatialFilter, NULL ); if( hLayer != NULL ) { // Custom layer will be rasterized in the first band. ProcessLayer( hLayer, hDstDS, poSpatialFilter, nXSize, nYSize, 1, bIsXExtentSet, bIsYExtentSet, dfXMin, dfXMax, dfYMin, dfYMax, pszBurnAttribute, dfIncreaseBurnValue, dfMultiplyBurnValue, eOutputType, eAlgorithm, pOptions, bQuiet, pfnProgress ); } } /* -------------------------------------------------------------------- */ /* Process each layer. */ /* -------------------------------------------------------------------- */ for( i = 0; i < nLayerCount; i++ ) { OGRLayerH hLayer = OGR_DS_GetLayerByName( hSrcDS, papszLayers[i]); if( hLayer == NULL ) { fprintf( stderr, "Unable to find layer \"%s\", skipping.\n", papszLayers[i] ); continue; } if( pszWHERE ) { if( OGR_L_SetAttributeFilter( hLayer, pszWHERE ) != OGRERR_NONE ) break; } if ( poSpatialFilter != NULL ) OGR_L_SetSpatialFilter( hLayer, (OGRGeometryH)poSpatialFilter ); // Fetch the first meaningful SRS definition if ( !pszOutputSRS ) { OGRSpatialReferenceH hSRS = OGR_L_GetSpatialRef( hLayer ); if ( hSRS ) OSRExportToWkt( hSRS, &pszOutputSRS ); } ProcessLayer( hLayer, hDstDS, poSpatialFilter, nXSize, nYSize, i + 1 + nBands - nLayerCount, bIsXExtentSet, bIsYExtentSet, dfXMin, dfXMax, dfYMin, dfYMax, pszBurnAttribute, dfIncreaseBurnValue, dfMultiplyBurnValue, eOutputType, eAlgorithm, pOptions, bQuiet, pfnProgress ); } /* -------------------------------------------------------------------- */ /* Apply geotransformation matrix. */ /* -------------------------------------------------------------------- */ double adfGeoTransform[6]; adfGeoTransform[0] = dfXMin; adfGeoTransform[1] = (dfXMax - dfXMin) / nXSize; adfGeoTransform[2] = 0.0; adfGeoTransform[3] = dfYMin; adfGeoTransform[4] = 0.0; adfGeoTransform[5] = (dfYMax - dfYMin) / nYSize; GDALSetGeoTransform( hDstDS, adfGeoTransform ); /* -------------------------------------------------------------------- */ /* Apply SRS definition if set. */ /* -------------------------------------------------------------------- */ if ( pszOutputSRS ) { GDALSetProjection( hDstDS, pszOutputSRS ); CPLFree( pszOutputSRS ); } /* -------------------------------------------------------------------- */ /* Cleanup */ /* -------------------------------------------------------------------- */ OGR_DS_Destroy( hSrcDS ); GDALClose( hDstDS ); OGRGeometryFactory::destroyGeometry( poSpatialFilter ); CPLFree( pOptions ); CSLDestroy( papszCreateOptions ); CSLDestroy( argv ); CSLDestroy( papszLayers ); OGRCleanupAll(); GDALDestroyDriverManager(); return 0; }
OGRErr OGRJMLWriterLayer::ICreateFeature( OGRFeature *poFeature ) { /* Finish column declaration if we haven't yet created a feature */ if( !bFeaturesWritten ) { if( bAddOGRStyleField && poFeatureDefn->GetFieldIndex("OGR_STYLE") < 0 ) { WriteColumnDeclaration( "OGR_STYLE", "STRING" ); } if( bAddRGBField && poFeatureDefn->GetFieldIndex("R_G_B") < 0 ) { WriteColumnDeclaration( "R_G_B", "STRING" ); } VSIFPrintfL(fp, "</ColumnDefinitions>\n</JCSGMLInputTemplate>\n<featureCollection>\n"); bFeaturesWritten = TRUE; } if( bClassicGML ) VSIFPrintfL(fp, " <featureMember>\n"); VSIFPrintfL(fp, " <feature>\n"); /* Add geometry */ VSIFPrintfL(fp, " <geometry>\n"); OGRGeometry* poGeom = poFeature->GetGeometryRef(); if( poGeom != NULL ) { char* pszGML = poGeom->exportToGML(); VSIFPrintfL(fp, " %s\n", pszGML); CPLFree(pszGML); } else { VSIFPrintfL(fp, " %s\n", "<gml:MultiGeometry></gml:MultiGeometry>"); } VSIFPrintfL(fp, " </geometry>\n"); /* Add fields */ for(int i=0;i<poFeature->GetFieldCount();i++) { char* pszName = OGRGetXML_UTF8_EscapedString( poFeatureDefn->GetFieldDefn(i)->GetNameRef() ); if( bClassicGML ) VSIFPrintfL(fp, " <%s>", pszName); else VSIFPrintfL(fp, " <property name=\"%s\">", pszName); if( poFeature->IsFieldSet(i) ) { OGRFieldType eType = poFeatureDefn->GetFieldDefn(i)->GetType(); if( eType == OFTString ) { char* pszValue = OGRGetXML_UTF8_EscapedString( poFeature->GetFieldAsString(i) ); VSIFPrintfL(fp, "%s", pszValue); CPLFree(pszValue); } else if( eType == OFTDateTime ) { int nYear, nMonth, nDay, nHour, nMinute, nTZFlag; float fSecond; poFeature->GetFieldAsDateTime(i, &nYear, &nMonth, &nDay, &nHour, &nMinute, &fSecond, &nTZFlag); /* When writing time zone, OpenJUMP expects .XXX seconds */ /* to be written */ if( nTZFlag > 1 || OGR_GET_MS(fSecond) != 0 ) VSIFPrintfL(fp, "%04d-%02d-%02dT%02d:%02d:%06.3f", nYear, nMonth, nDay, nHour, nMinute, fSecond); else VSIFPrintfL(fp, "%04d-%02d-%02dT%02d:%02d:%02d", nYear, nMonth, nDay, nHour, nMinute, (int)fSecond); if( nTZFlag > 1 ) { int nOffset = (nTZFlag - 100) * 15; int nHours = (int) (nOffset / 60); // round towards zero int nMinutes = ABS(nOffset - nHours * 60); if( nOffset < 0 ) { VSIFPrintfL(fp, "-" ); nHours = ABS(nHours); } else VSIFPrintfL(fp, "+" ); VSIFPrintfL(fp, "%02d%02d", nHours, nMinutes ); } } else { VSIFPrintfL(fp, "%s", poFeature->GetFieldAsString(i)); } } if( bClassicGML ) VSIFPrintfL(fp, "</%s>\n", pszName); else VSIFPrintfL(fp, "</property>\n"); CPLFree(pszName); } /* Add OGR_STYLE from feature style string (if asked) */ if( bAddOGRStyleField && poFeatureDefn->GetFieldIndex("OGR_STYLE") < 0 ) { if( bClassicGML ) VSIFPrintfL(fp, " <OGR_STYLE>"); else VSIFPrintfL(fp, " <property name=\"%s\">", "OGR_STYLE"); if( poFeature->GetStyleString() != NULL ) { char* pszValue = OGRGetXML_UTF8_EscapedString( poFeature->GetStyleString() ); VSIFPrintfL(fp, "%s", pszValue); CPLFree(pszValue); } if( bClassicGML ) VSIFPrintfL(fp, "</OGR_STYLE>\n"); else VSIFPrintfL(fp, "</property>\n"); } /* Derive R_G_B field from feature style string */ if( bAddRGBField && poFeatureDefn->GetFieldIndex("R_G_B") < 0 ) { if( bClassicGML ) VSIFPrintfL(fp, " <R_G_B>"); else VSIFPrintfL(fp, " <property name=\"%s\">", "R_G_B"); if( poFeature->GetStyleString() != NULL ) { OGRGeometry* poGeom = poFeature->GetGeometryRef(); OGRwkbGeometryType eGeomType = poGeom ? wkbFlatten(poGeom->getGeometryType()) : wkbUnknown; OGRStyleMgr oMgr; oMgr.InitFromFeature(poFeature); for(int i=0;i<oMgr.GetPartCount();i++) { OGRStyleTool* poTool = oMgr.GetPart(i); if( poTool != NULL ) { const char* pszColor = NULL; if( poTool->GetType() == OGRSTCPen && eGeomType != wkbPolygon && eGeomType != wkbMultiPolygon ) { GBool bIsNull; pszColor = ((OGRStylePen*)poTool)->Color(bIsNull); if( bIsNull ) pszColor = NULL; } else if( poTool->GetType() == OGRSTCBrush ) { GBool bIsNull; pszColor = ((OGRStyleBrush*)poTool)->ForeColor(bIsNull); if( bIsNull ) pszColor = NULL; } int R, G, B, A; if( pszColor != NULL && poTool->GetRGBFromString(pszColor, R, G, B, A) && A != 0 ) { VSIFPrintfL(fp, "%02X%02X%02X", R, G, B); } delete poTool; } } } if( bClassicGML ) VSIFPrintfL(fp, "</R_G_B>\n"); else VSIFPrintfL(fp, "</property>\n"); } VSIFPrintfL(fp, " </feature>\n"); if( bClassicGML ) VSIFPrintfL(fp, " </featureMember>\n"); poFeature->SetFID(nNextFID ++); return OGRERR_NONE; }
static OGRGeometryCollection* LoadGeometry( const char* pszDS, const char* pszSQL, const char* pszLyr, const char* pszWhere ) { OGRDataSource *poDS; OGRLayer *poLyr; OGRFeature *poFeat; OGRGeometryCollection *poGeom = NULL; poDS = OGRSFDriverRegistrar::Open( pszDS, FALSE ); if ( poDS == NULL ) return NULL; if ( pszSQL != NULL ) poLyr = poDS->ExecuteSQL( pszSQL, NULL, NULL ); else if ( pszLyr != NULL ) poLyr = poDS->GetLayerByName( pszLyr ); else poLyr = poDS->GetLayer(0); if ( poLyr == NULL ) { fprintf( stderr, "FAILURE: Failed to identify source layer from datasource.\n" ); OGRDataSource::DestroyDataSource( poDS ); return NULL; } if ( pszWhere ) poLyr->SetAttributeFilter( pszWhere ); while ( (poFeat = poLyr->GetNextFeature()) != NULL ) { OGRGeometry* poSrcGeom = poFeat->GetGeometryRef(); if ( poSrcGeom ) { OGRwkbGeometryType eType = wkbFlatten( poSrcGeom->getGeometryType() ); if ( poGeom == NULL ) poGeom = new OGRMultiPolygon(); if ( eType == wkbPolygon ) poGeom->addGeometry( poSrcGeom ); else if ( eType == wkbMultiPolygon ) { int iGeom; int nGeomCount = ((OGRMultiPolygon *)poSrcGeom)->getNumGeometries(); for ( iGeom = 0; iGeom < nGeomCount; iGeom++ ) { poGeom->addGeometry( ((OGRMultiPolygon *)poSrcGeom)->getGeometryRef(iGeom) ); } } else { fprintf( stderr, "FAILURE: Geometry not of polygon type.\n" ); OGRGeometryFactory::destroyGeometry( poGeom ); OGRFeature::DestroyFeature( poFeat ); if ( pszSQL != NULL ) poDS->ReleaseResultSet( poLyr ); OGRDataSource::DestroyDataSource( poDS ); return NULL; } } OGRFeature::DestroyFeature( poFeat ); } if( pszSQL != NULL ) poDS->ReleaseResultSet( poLyr ); OGRDataSource::DestroyDataSource( poDS ); return poGeom; }
void PCLoaderArcView::load(const std::string& file, OptionsCont& oc, PCPolyContainer& toFill, PCTypeMap&) { #ifdef HAVE_GDAL GeoConvHelper& geoConvHelper = GeoConvHelper::getProcessing(); // get defaults std::string prefix = oc.getString("prefix"); std::string type = oc.getString("type"); RGBColor color = RGBColor::parseColor(oc.getString("color")); int layer = oc.getInt("layer"); std::string idField = oc.getString("shapefile.id-column"); bool useRunningID = oc.getBool("shapefile.use-running-id"); // start parsing std::string shpName = file + ".shp"; OGRRegisterAll(); OGRDataSource* poDS = OGRSFDriverRegistrar::Open(shpName.c_str(), FALSE); if (poDS == NULL) { throw ProcessError("Could not open shape description '" + shpName + "'."); } // begin file parsing OGRLayer* poLayer = poDS->GetLayer(0); poLayer->ResetReading(); // build coordinate transformation OGRSpatialReference* origTransf = poLayer->GetSpatialRef(); OGRSpatialReference destTransf; // use wgs84 as destination destTransf.SetWellKnownGeogCS("WGS84"); OGRCoordinateTransformation* poCT = OGRCreateCoordinateTransformation(origTransf, &destTransf); if (poCT == NULL) { if (oc.isSet("shapefile.guess-projection")) { OGRSpatialReference origTransf2; origTransf2.SetWellKnownGeogCS("WGS84"); poCT = OGRCreateCoordinateTransformation(&origTransf2, &destTransf); } if (poCT == 0) { WRITE_WARNING("Could not create geocoordinates converter; check whether proj.4 is installed."); } } OGRFeature* poFeature; poLayer->ResetReading(); unsigned int runningID = 0; while ((poFeature = poLayer->GetNextFeature()) != NULL) { // read in edge attributes std::string id = useRunningID ? toString(runningID) : poFeature->GetFieldAsString(idField.c_str()); ++runningID; id = StringUtils::prune(id); if (id == "") { throw ProcessError("Missing id under '" + idField + "'"); } id = prefix + id; // read in the geometry OGRGeometry* poGeometry = poFeature->GetGeometryRef(); if (poGeometry == 0) { OGRFeature::DestroyFeature(poFeature); continue; } // try transform to wgs84 poGeometry->transform(poCT); OGRwkbGeometryType gtype = poGeometry->getGeometryType(); switch (gtype) { case wkbPoint: { OGRPoint* cgeom = (OGRPoint*) poGeometry; Position pos((SUMOReal) cgeom->getX(), (SUMOReal) cgeom->getY()); if (!geoConvHelper.x2cartesian(pos)) { WRITE_ERROR("Unable to project coordinates for POI '" + id + "'."); } PointOfInterest* poi = new PointOfInterest(id, type, color, pos, (SUMOReal)layer); if (!toFill.insert(id, poi, layer)) { WRITE_ERROR("POI '" + id + "' could not be added."); delete poi; } } break; case wkbLineString: { OGRLineString* cgeom = (OGRLineString*) poGeometry; PositionVector shape; for (int j = 0; j < cgeom->getNumPoints(); j++) { Position pos((SUMOReal) cgeom->getX(j), (SUMOReal) cgeom->getY(j)); if (!geoConvHelper.x2cartesian(pos)) { WRITE_ERROR("Unable to project coordinates for polygon '" + id + "'."); } shape.push_back_noDoublePos(pos); } Polygon* poly = new Polygon(id, type, color, shape, false, (SUMOReal)layer); if (!toFill.insert(id, poly, layer)) { WRITE_ERROR("Polygon '" + id + "' could not be added."); delete poly; } } break; case wkbPolygon: { OGRLinearRing* cgeom = ((OGRPolygon*) poGeometry)->getExteriorRing(); PositionVector shape; for (int j = 0; j < cgeom->getNumPoints(); j++) { Position pos((SUMOReal) cgeom->getX(j), (SUMOReal) cgeom->getY(j)); if (!geoConvHelper.x2cartesian(pos)) { WRITE_ERROR("Unable to project coordinates for polygon '" + id + "'."); } shape.push_back_noDoublePos(pos); } Polygon* poly = new Polygon(id, type, color, shape, true, (SUMOReal)layer); if (!toFill.insert(id, poly, layer)) { WRITE_ERROR("Polygon '" + id + "' could not be added."); delete poly; } } break; case wkbMultiPoint: { OGRMultiPoint* cgeom = (OGRMultiPoint*) poGeometry; for (int i = 0; i < cgeom->getNumGeometries(); ++i) { OGRPoint* cgeom2 = (OGRPoint*) cgeom->getGeometryRef(i); Position pos((SUMOReal) cgeom2->getX(), (SUMOReal) cgeom2->getY()); std::string tid = id + "#" + toString(i); if (!geoConvHelper.x2cartesian(pos)) { WRITE_ERROR("Unable to project coordinates for POI '" + tid + "'."); } PointOfInterest* poi = new PointOfInterest(tid, type, color, pos, (SUMOReal)layer); if (!toFill.insert(tid, poi, layer)) { WRITE_ERROR("POI '" + tid + "' could not be added."); delete poi; } } } break; case wkbMultiLineString: { OGRMultiLineString* cgeom = (OGRMultiLineString*) poGeometry; for (int i = 0; i < cgeom->getNumGeometries(); ++i) { OGRLineString* cgeom2 = (OGRLineString*) cgeom->getGeometryRef(i); PositionVector shape; std::string tid = id + "#" + toString(i); for (int j = 0; j < cgeom2->getNumPoints(); j++) { Position pos((SUMOReal) cgeom2->getX(j), (SUMOReal) cgeom2->getY(j)); if (!geoConvHelper.x2cartesian(pos)) { WRITE_ERROR("Unable to project coordinates for polygon '" + tid + "'."); } shape.push_back_noDoublePos(pos); } Polygon* poly = new Polygon(tid, type, color, shape, false, (SUMOReal)layer); if (!toFill.insert(tid, poly, layer)) { WRITE_ERROR("Polygon '" + tid + "' could not be added."); delete poly; } } } break; case wkbMultiPolygon: { OGRMultiPolygon* cgeom = (OGRMultiPolygon*) poGeometry; for (int i = 0; i < cgeom->getNumGeometries(); ++i) { OGRLinearRing* cgeom2 = ((OGRPolygon*) cgeom->getGeometryRef(i))->getExteriorRing(); PositionVector shape; std::string tid = id + "#" + toString(i); for (int j = 0; j < cgeom2->getNumPoints(); j++) { Position pos((SUMOReal) cgeom2->getX(j), (SUMOReal) cgeom2->getY(j)); if (!geoConvHelper.x2cartesian(pos)) { WRITE_ERROR("Unable to project coordinates for polygon '" + tid + "'."); } shape.push_back_noDoublePos(pos); } Polygon* poly = new Polygon(tid, type, color, shape, true, (SUMOReal)layer); if (!toFill.insert(tid, poly, layer)) { WRITE_ERROR("Polygon '" + tid + "' could not be added."); delete poly; } } } break; default: WRITE_WARNING("Unsupported shape type occured (id='" + id + "')."); break; } OGRFeature::DestroyFeature(poFeature); } PROGRESS_DONE_MESSAGE(); #else WRITE_ERROR("SUMO was compiled without GDAL support."); #endif }
OGRFeature *OGRDB2Layer::GetNextRawFeature() { if( GetStatement() == nullptr ) return nullptr; /* -------------------------------------------------------------------- */ /* If we are marked to restart then do so, and fetch a record. */ /* -------------------------------------------------------------------- */ if( !m_poStmt->Fetch() ) // fail is normal for final fetch { // CPLDebug("OGR_DB2Layer::GetNextRawFeature","Fetch failed"); delete m_poStmt; m_poStmt = nullptr; return nullptr; } // CPLDebug("OGR_DB2Layer::GetNextRawFeature","Create feature"); /* -------------------------------------------------------------------- */ /* Create a feature from the current result. */ /* -------------------------------------------------------------------- */ int iField; OGRFeature *poFeature = new OGRFeature( poFeatureDefn ); if( pszFIDColumn != nullptr && m_poStmt->GetColId(pszFIDColumn) > -1 ) poFeature->SetFID( atoi(m_poStmt->GetColData(m_poStmt->GetColId(pszFIDColumn))) ); else poFeature->SetFID( iNextShapeId ); iNextShapeId++; m_nFeaturesRead++; /* -------------------------------------------------------------------- */ /* Set the fields. */ /* -------------------------------------------------------------------- */ for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ ) { if ( poFeatureDefn->GetFieldDefn(iField)->IsIgnored() ) continue; int iSrcField = panFieldOrdinals[iField]; const char *pszValue = m_poStmt->GetColData( iSrcField ); if( pszValue == nullptr ) poFeature->SetFieldNull( iField ); else if( poFeature->GetFieldDefnRef(iField)->GetType() == OFTBinary ) poFeature->SetField( iField, m_poStmt->GetColDataLength(iSrcField), (GByte *) pszValue ); else poFeature->SetField( iField, pszValue ); } /* -------------------------------------------------------------------- */ /* Try to extract a geometry. */ /* -------------------------------------------------------------------- */ if( pszGeomColumn != nullptr && !poFeatureDefn->IsGeometryIgnored()) { iField = m_poStmt->GetColId( pszGeomColumn ); const char *pszGeomText = m_poStmt->GetColData( iField ); OGRGeometry *poGeom = nullptr; OGRErr eErr = OGRERR_NONE; if( pszGeomText != nullptr ) { eErr = OGRGeometryFactory::createFromWkt(pszGeomText, nullptr, &poGeom); } if ( eErr != OGRERR_NONE ) { const char *pszMessage; switch ( eErr ) { case OGRERR_NOT_ENOUGH_DATA: pszMessage = "Not enough data to deserialize"; break; case OGRERR_UNSUPPORTED_GEOMETRY_TYPE: pszMessage = "Unsupported geometry type"; break; case OGRERR_CORRUPT_DATA: pszMessage = "Corrupt data"; break; default: pszMessage = "Unrecognized error"; } CPLError(CE_Failure, CPLE_AppDefined, "GetNextRawFeature(): %s", pszMessage); } if( poGeom != nullptr ) { if ( GetSpatialRef() ) poGeom->assignSpatialReference( poSRS ); poFeature->SetGeometryDirectly( poGeom ); } } return poFeature; }
OGRErr OGRLayer::GetExtent(OGREnvelope *psExtent, int bForce ) { OGRFeature *poFeature; OGREnvelope oEnv; GBool bExtentSet = FALSE; psExtent->MinX = 0.0; psExtent->MaxX = 0.0; psExtent->MinY = 0.0; psExtent->MaxY = 0.0; /* -------------------------------------------------------------------- */ /* If this layer has a none geometry type, then we can */ /* reasonably assume there are not extents available. */ /* -------------------------------------------------------------------- */ if( GetLayerDefn()->GetGeomType() == wkbNone ) return OGRERR_FAILURE; /* -------------------------------------------------------------------- */ /* If not forced, we should avoid having to scan all the */ /* features and just return a failure. */ /* -------------------------------------------------------------------- */ if( !bForce ) return OGRERR_FAILURE; /* -------------------------------------------------------------------- */ /* OK, we hate to do this, but go ahead and read through all */ /* the features to collect geometries and build extents. */ /* -------------------------------------------------------------------- */ ResetReading(); while( (poFeature = GetNextFeature()) != NULL ) { OGRGeometry *poGeom = poFeature->GetGeometryRef(); if (poGeom == NULL || poGeom->IsEmpty()) { /* Do nothing */ } else if (!bExtentSet) { poGeom->getEnvelope(psExtent); bExtentSet = TRUE; } else { poGeom->getEnvelope(&oEnv); if (oEnv.MinX < psExtent->MinX) psExtent->MinX = oEnv.MinX; if (oEnv.MinY < psExtent->MinY) psExtent->MinY = oEnv.MinY; if (oEnv.MaxX > psExtent->MaxX) psExtent->MaxX = oEnv.MaxX; if (oEnv.MaxY > psExtent->MaxY) psExtent->MaxY = oEnv.MaxY; } delete poFeature; } ResetReading(); return (bExtentSet ? OGRERR_NONE : OGRERR_FAILURE); }
OGRErr OGRPGDumpLayer::CreateFeatureViaCopy( OGRFeature *poFeature ) { int i; CPLString osCommand; /* First process geometry */ for( i = 0; i < poFeature->GetGeomFieldCount(); i++ ) { OGRGeometry *poGeometry = poFeature->GetGeomFieldRef(i); char *pszGeom = NULL; if ( NULL != poGeometry /* && (bHasWkb || bHasPostGISGeometry || bHasPostGISGeography) */) { OGRPGDumpGeomFieldDefn* poGFldDefn = (OGRPGDumpGeomFieldDefn*) poFeature->GetGeomFieldDefnRef(i); poGeometry->closeRings(); poGeometry->setCoordinateDimension( poGFldDefn->nCoordDimension ); //CheckGeomTypeCompatibility(poGeometry); /*if (bHasWkb) pszGeom = GeometryToBYTEA( poGeometry ); else*/ pszGeom = OGRGeometryToHexEWKB( poGeometry, poGFldDefn->nSRSId ); } if (osCommand.size() > 0) osCommand += "\t"; if ( pszGeom ) { osCommand += pszGeom, CPLFree( pszGeom ); } else { osCommand += "\\N"; } } /* Next process the field id column */ int nFIDIndex = -1; if( bFIDColumnInCopyFields ) { if (osCommand.size() > 0) osCommand += "\t"; nFIDIndex = poFeatureDefn->GetFieldIndex( pszFIDColumn ); /* Set the FID */ if( poFeature->GetFID() != OGRNullFID ) { osCommand += CPLString().Printf("%ld ", poFeature->GetFID()); } else { osCommand += "\\N" ; } } /* Now process the remaining fields */ int nFieldCount = poFeatureDefn->GetFieldCount(); int bAddTab = osCommand.size() > 0; for( i = 0; i < nFieldCount; i++ ) { if (i == nFIDIndex) continue; const char *pszStrValue = poFeature->GetFieldAsString(i); char *pszNeedToFree = NULL; if (bAddTab) osCommand += "\t"; bAddTab = TRUE; if( !poFeature->IsFieldSet( i ) ) { osCommand += "\\N" ; continue; } int nOGRFieldType = poFeatureDefn->GetFieldDefn(i)->GetType(); // We need special formatting for integer list values. if( nOGRFieldType == OFTIntegerList ) { int nCount, nOff = 0, j; const int *panItems = poFeature->GetFieldAsIntegerList(i,&nCount); pszNeedToFree = (char *) CPLMalloc(nCount * 13 + 10); strcpy( pszNeedToFree, "{" ); for( j = 0; j < nCount; j++ ) { if( j != 0 ) strcat( pszNeedToFree+nOff, "," ); nOff += strlen(pszNeedToFree+nOff); sprintf( pszNeedToFree+nOff, "%d", panItems[j] ); } strcat( pszNeedToFree+nOff, "}" ); pszStrValue = pszNeedToFree; } // We need special formatting for real list values. else if( nOGRFieldType == OFTRealList ) { int nCount, nOff = 0, j; const double *padfItems =poFeature->GetFieldAsDoubleList(i,&nCount); pszNeedToFree = (char *) CPLMalloc(nCount * 40 + 10); strcpy( pszNeedToFree, "{" ); for( j = 0; j < nCount; j++ ) { if( j != 0 ) strcat( pszNeedToFree+nOff, "," ); nOff += strlen(pszNeedToFree+nOff); //Check for special values. They need to be quoted. if( CPLIsNan(padfItems[j]) ) sprintf( pszNeedToFree+nOff, "NaN" ); else if( CPLIsInf(padfItems[j]) ) sprintf( pszNeedToFree+nOff, (padfItems[j] > 0) ? "Infinity" : "-Infinity" ); else sprintf( pszNeedToFree+nOff, "%.16g", padfItems[j] ); } strcat( pszNeedToFree+nOff, "}" ); pszStrValue = pszNeedToFree; } // We need special formatting for string list values. else if( nOGRFieldType == OFTStringList ) { CPLString osStr; char **papszItems = poFeature->GetFieldAsStringList(i); pszStrValue = pszNeedToFree = CPLStrdup(OGRPGDumpEscapeStringList(papszItems, FALSE)); } // Binary formatting else if( nOGRFieldType == OFTBinary ) { int nLen = 0; GByte* pabyData = poFeature->GetFieldAsBinary( i, &nLen ); char* pszBytea = GByteArrayToBYTEA( pabyData, nLen); pszStrValue = pszNeedToFree = pszBytea; } else if( nOGRFieldType == OFTReal ) { char* pszComma = strchr((char*)pszStrValue, ','); if (pszComma) *pszComma = '.'; //Check for special values. They need to be quoted. double dfVal = poFeature->GetFieldAsDouble(i); if( CPLIsNan(dfVal) ) pszStrValue = "NaN"; else if( CPLIsInf(dfVal) ) pszStrValue = (dfVal > 0) ? "Infinity" : "-Infinity"; } if( nOGRFieldType != OFTIntegerList && nOGRFieldType != OFTRealList && nOGRFieldType != OFTInteger && nOGRFieldType != OFTReal && nOGRFieldType != OFTBinary ) { int iChar; int iUTFChar = 0; int nMaxWidth = poFeatureDefn->GetFieldDefn(i)->GetWidth(); for( iChar = 0; pszStrValue[iChar] != '\0'; iChar++ ) { //count of utf chars if ((pszStrValue[iChar] & 0xc0) != 0x80) { if( nMaxWidth > 0 && iUTFChar == nMaxWidth ) { CPLDebug( "PG", "Truncated %s field value, it was too long.", poFeatureDefn->GetFieldDefn(i)->GetNameRef() ); break; } iUTFChar++; } /* Escape embedded \, \t, \n, \r since they will cause COPY to misinterpret a line of text and thus abort */ if( pszStrValue[iChar] == '\\' || pszStrValue[iChar] == '\t' || pszStrValue[iChar] == '\r' || pszStrValue[iChar] == '\n' ) { osCommand += '\\'; } osCommand += pszStrValue[iChar]; } } else { osCommand += pszStrValue; } if( pszNeedToFree ) CPLFree( pszNeedToFree ); } /* Add end of line marker */ //osCommand += "\n"; /* ------------------------------------------------------------ */ /* Execute the copy. */ /* ------------------------------------------------------------ */ OGRErr result = OGRERR_NONE; poDS->Log(osCommand, FALSE); return result; }
OGRErr OGRGFTTableLayer::CreateFeature( OGRFeature *poFeature ) { if (!poDS->IsReadWrite()) { CPLError(CE_Failure, CPLE_AppDefined, "Operation not available in read-only mode"); return OGRERR_FAILURE; } if (osTableId.size() == 0) { CreateTableIfNecessary(); if (osTableId.size() == 0) { CPLError(CE_Failure, CPLE_NotSupported, "Cannot add feature to non-created table"); return OGRERR_FAILURE; } } if (poDS->GetAuth().size() == 0) { CPLError(CE_Failure, CPLE_AppDefined, "Operation not available in unauthenticated mode"); return OGRERR_FAILURE; } CPLString osCommand; osCommand += "INSERT INTO "; osCommand += osTableId; osCommand += " ("; int iField; int nFieldCount = poFeatureDefn->GetFieldCount(); for(iField = 0; iField < nFieldCount; iField++) { if (iField > 0) osCommand += ", "; const char* pszFieldName = poFeatureDefn->GetFieldDefn(iField)->GetNameRef(); osCommand += EscapeAndQuote(pszFieldName); } if (bHiddenGeometryField) { if (iField > 0) osCommand += ", "; osCommand += EscapeAndQuote(GetGeometryColumn()); } osCommand += ") VALUES ("; for(iField = 0; iField < nFieldCount + bHiddenGeometryField; iField++) { if (iField > 0) osCommand += ", "; OGRGeometry* poGeom = poFeature->GetGeometryRef(); /* If there's a geometry, let's use it in priority over the textual */ /* content of the field. */ if (iGeometryField != iLatitudeField && iField == iGeometryField && (iField == nFieldCount || poGeom != NULL || !poFeature->IsFieldSet( iField ))) { if (poGeom == NULL) osCommand += "''"; else { char* pszKML; if (poGeom->getSpatialReference() != NULL && !poGeom->getSpatialReference()->IsSame(poSRS)) { OGRGeometry* poGeom4326 = poGeom->clone(); poGeom4326->transformTo(poSRS); pszKML = poGeom4326->exportToKML(); delete poGeom4326; } else { pszKML = poGeom->exportToKML(); } osCommand += "'"; osCommand += pszKML; osCommand += "'"; CPLFree(pszKML); } continue; } if( !poFeature->IsFieldSet( iField ) ) { osCommand += "''"; } else { OGRFieldType eType = poFeatureDefn->GetFieldDefn(iField)->GetType(); if (eType != OFTInteger && eType != OFTReal) { CPLString osTmp; const char* pszVal = poFeature->GetFieldAsString(iField); if (!CPLIsUTF8(pszVal, -1)) { static int bFirstTime = TRUE; if (bFirstTime) { bFirstTime = FALSE; CPLError(CE_Warning, CPLE_AppDefined, "%s is not a valid UTF-8 string. Forcing it to ASCII.\n" "This warning won't be issued anymore", pszVal); } else { CPLDebug("OGR", "%s is not a valid UTF-8 string. Forcing it to ASCII", pszVal); } char* pszEscaped = CPLForceToASCII(pszVal, -1, '?'); osTmp = pszEscaped; CPLFree(pszEscaped); pszVal = osTmp.c_str(); } osCommand += EscapeAndQuote(pszVal); } else osCommand += poFeature->GetFieldAsString(iField); } } osCommand += ")"; //CPLDebug("GFT", "%s", osCommand.c_str()); if (bInTransaction) { nFeaturesInTransaction ++; if (nFeaturesInTransaction > 1) osTransaction += "; "; osTransaction += osCommand; return OGRERR_NONE; } CPLHTTPResult * psResult = poDS->RunSQL(osCommand); if (psResult == NULL) { CPLError(CE_Failure, CPLE_AppDefined, "Feature creation failed"); return OGRERR_FAILURE; } char* pszLine = (char*) psResult->pabyData; if (pszLine == NULL || strncmp(pszLine, "rowid", 5) != 0 || psResult->pszErrBuf != NULL) { CPLError(CE_Failure, CPLE_AppDefined, "Feature creation failed"); CPLHTTPDestroyResult(psResult); return OGRERR_FAILURE; } pszLine = OGRGFTGotoNextLine(pszLine); if (pszLine == NULL) { CPLError(CE_Failure, CPLE_AppDefined, "Feature creation failed"); CPLHTTPDestroyResult(psResult); return OGRERR_FAILURE; } char* pszNextLine = OGRGFTGotoNextLine(pszLine); if (pszNextLine) pszNextLine[-1] = 0; CPLDebug("GFT", "Feature id = %s", pszLine); int nFID = atoi(pszLine); if (strcmp(CPLSPrintf("%d", nFID), pszLine) == 0) poFeature->SetFID(nFID); CPLHTTPDestroyResult(psResult); return OGRERR_NONE; }
bool MapWidget::loadCountyShapes() { OGRRegisterAll(); std::string filename = g_dataDirectory + "/counties/tl_2009_48_county00.shp"; OGRDataSource * dataSource = OGRSFDriverRegistrar::Open(filename.c_str(), false); if(dataSource == NULL) { put_flog(LOG_ERROR, "could not open %s", filename.c_str()); return false; } OGRLayer * layer = dataSource->GetLayerByName("tl_2009_48_county00"); layer->ResetReading(); OGRFeature * feature; while((feature = layer->GetNextFeature()) != NULL) { // get county FIPS code int nodeId = feature->GetFieldAsInteger("COUNTYFP00"); if(nodeId == 0) { put_flog(LOG_WARN, "invalid county"); } // add a new county to the counties map corresponding to this nodeId boost::shared_ptr<MapShape> county(new MapShape()); counties_[nodeId] = county; OGRGeometry * geometry = feature->GetGeometryRef(); if(geometry != NULL && geometry->getGeometryType() == wkbPolygon) { OGRPolygon * polygon = (OGRPolygon *)geometry; OGRLinearRing * ring = polygon->getExteriorRing(); for(int i=0; i<ring->getNumPoints(); i++) { // x is longitude, y latitude county->addVertex(ring->getY(i), ring->getX(i)); } // set the centroid OGRPoint centroidPoint; if(polygon->Centroid(¢roidPoint) == OGRERR_NONE) { county->setCentroid(centroidPoint.getY(), centroidPoint.getX()); } else { put_flog(LOG_WARN, "no polygon centroid"); } } else { put_flog(LOG_WARN, "no polygon geometry"); } OGRFeature::DestroyFeature(feature); } OGRDataSource::DestroyDataSource(dataSource); return true; }
OGRGeometry* GML_BuildOGRGeometryFromList(const CPLXMLNode* const * papsGeometry, int bTryToMakeMultipolygons, int bInvertAxisOrderIfLatLong, const char* pszDefaultSRSName, int bConsiderEPSGAsURN, int bGetSecondaryGeometryOption, void* hCacheSRS) { OGRGeometry* poGeom = NULL; int i; OGRGeometryCollection* poCollection = NULL; for(i=0;papsGeometry[i] != NULL;i++) { OGRGeometry* poSubGeom = GML2OGRGeometry_XMLNode( papsGeometry[i], bGetSecondaryGeometryOption ); if (poSubGeom) { if (poGeom == NULL) poGeom = poSubGeom; else { if (poCollection == NULL) { if (bTryToMakeMultipolygons && wkbFlatten(poGeom->getGeometryType()) == wkbPolygon && wkbFlatten(poSubGeom->getGeometryType()) == wkbPolygon) { OGRGeometryCollection* poGeomColl = new OGRMultiPolygon(); poGeomColl->addGeometryDirectly(poGeom); poGeomColl->addGeometryDirectly(poSubGeom); poGeom = poGeomColl; } else if (bTryToMakeMultipolygons && wkbFlatten(poGeom->getGeometryType()) == wkbMultiPolygon && wkbFlatten(poSubGeom->getGeometryType()) == wkbPolygon) { OGRGeometryCollection* poGeomColl = (OGRGeometryCollection* )poGeom; poGeomColl->addGeometryDirectly(poSubGeom); } else if (bTryToMakeMultipolygons && wkbFlatten(poGeom->getGeometryType()) == wkbMultiPolygon && wkbFlatten(poSubGeom->getGeometryType()) == wkbMultiPolygon) { OGRGeometryCollection* poGeomColl = (OGRGeometryCollection* )poGeom; OGRGeometryCollection* poGeomColl2 = (OGRGeometryCollection* )poSubGeom; int nCount = poGeomColl2->getNumGeometries(); int i; for(i=0;i<nCount;i++) { poGeomColl->addGeometry(poGeomColl2->getGeometryRef(i)); } delete poSubGeom; } else if (bTryToMakeMultipolygons && wkbFlatten(poGeom->getGeometryType()) == wkbMultiPolygon) { delete poGeom; delete poSubGeom; return GML_BuildOGRGeometryFromList(papsGeometry, FALSE, bInvertAxisOrderIfLatLong, pszDefaultSRSName, bConsiderEPSGAsURN, bGetSecondaryGeometryOption, hCacheSRS); } else { poCollection = new OGRGeometryCollection(); poCollection->addGeometryDirectly(poGeom); poGeom = poCollection; } } if (poCollection != NULL) { poCollection->addGeometryDirectly(poSubGeom); } } } } if ( poGeom != NULL && bInvertAxisOrderIfLatLong ) { std::string osWork; const char* pszSRSName = GML_ExtractSrsNameFromGeometry(papsGeometry, osWork, bConsiderEPSGAsURN); const char* pszNameLookup = pszSRSName ? pszSRSName : pszDefaultSRSName; if (pszNameLookup != NULL) { SRSCache* poSRSCache = (SRSCache*)hCacheSRS; int bSwap; if (strcmp(poSRSCache->osLastSRSName.c_str(), pszNameLookup) == 0) { bSwap = poSRSCache->bAxisInvertLastSRSName; } else { bSwap = GML_IsSRSLatLongOrder(pszNameLookup); poSRSCache->osLastSRSName = pszNameLookup; poSRSCache->bAxisInvertLastSRSName= bSwap; } if (bSwap) poGeom->swapXY(); } } return poGeom; }
OGRFeature *OGRWalkLayer::GetNextRawFeature() { if( GetStatement() == NULL ) return NULL; /* -------------------------------------------------------------------- */ /* If we are marked to restart then do so, and fetch a record. */ /* -------------------------------------------------------------------- */ if( !poStmt->Fetch() ) { delete poStmt; poStmt = NULL; return NULL; } /* -------------------------------------------------------------------- */ /* Create a feature from the current result. */ /* -------------------------------------------------------------------- */ OGRFeature *poFeature = new OGRFeature( poFeatureDefn ); if( pszFIDColumn != NULL && poStmt->GetColId(pszFIDColumn) > -1 ) poFeature->SetFID( atoi(poStmt->GetColData(poStmt->GetColId(pszFIDColumn))) ); else poFeature->SetFID( iNextShapeId ); iNextShapeId++; m_nFeaturesRead++; /* -------------------------------------------------------------------- */ /* Set the fields. */ /* -------------------------------------------------------------------- */ for( int iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ ) { int iSrcField = panFieldOrdinals[iField]-1; const char *pszValue = poStmt->GetColData( iSrcField ); if( pszValue == NULL ) /* no value */; else if( poFeature->GetFieldDefnRef(iField)->GetType() == OFTBinary ) poFeature->SetField( iField, poStmt->GetColDataLength(iSrcField), (GByte *) pszValue ); else poFeature->SetField( iField, pszValue ); } /* -------------------------------------------------------------------- */ /* Try to extract a geometry. */ /* -------------------------------------------------------------------- */ if( pszGeomColumn != NULL ) { int iField = poStmt->GetColId( pszGeomColumn ); const char *pszGeomBin = poStmt->GetColData( iField ); int nGeomLength = poStmt->GetColDataLength( iField ); OGRGeometry *poGeom = NULL; OGRErr eErr = OGRERR_NONE; if( pszGeomBin != NULL && bGeomColumnWKB ) { WKBGeometry *WalkGeom = (WKBGeometry *)CPLMalloc(sizeof(WKBGeometry)); if( Binary2WkbGeom((unsigned char *)pszGeomBin, WalkGeom, nGeomLength) != OGRERR_NONE ) { CPLFree(WalkGeom); return NULL; } eErr = TranslateWalkGeom(&poGeom, WalkGeom); DeleteWKBGeometry(*WalkGeom); CPLFree(WalkGeom); } if ( eErr != OGRERR_NONE ) { const char *pszMessage; switch ( eErr ) { case OGRERR_NOT_ENOUGH_DATA: pszMessage = "Not enough data to deserialize"; break; case OGRERR_UNSUPPORTED_GEOMETRY_TYPE: pszMessage = "Unsupported geometry type"; break; case OGRERR_CORRUPT_DATA: pszMessage = "Corrupt data"; break; default: pszMessage = "Unrecognized error"; } CPLError(CE_Failure, CPLE_AppDefined, "GetNextRawFeature(): %s", pszMessage); } if( poGeom != NULL && eErr == OGRERR_NONE ) { poGeom->assignSpatialReference( poSRS ); poFeature->SetGeometryDirectly( poGeom ); } } return poFeature; }
OGRErr OGRCreateFromGeomedia( GByte *pabyGeom, OGRGeometry **ppoGeom, int nBytes ) { *ppoGeom = NULL; if( nBytes < 16 ) return OGRERR_FAILURE; if( !(pabyGeom[1] == 0xFF && pabyGeom[2] == 0xD2 && pabyGeom[3] == 0x0F) ) return OGRERR_FAILURE; int nGeomType = pabyGeom[0]; pabyGeom += 16; nBytes -= 16; if( nGeomType == GEOMEDIA_POINT || nGeomType == GEOMEDIA_ORIENTED_POINT ) { if (nBytes < 3 * 8) return OGRERR_FAILURE; double dfX, dfY, dfZ; memcpy(&dfX, pabyGeom, 8); CPL_LSBPTR64(&dfX); memcpy(&dfY, pabyGeom + 8, 8); CPL_LSBPTR64(&dfY); memcpy(&dfZ, pabyGeom + 16, 8); CPL_LSBPTR64(&dfZ); *ppoGeom = new OGRPoint( dfX, dfY, dfZ ); return OGRERR_NONE; } else if ( nGeomType == GEOMEDIA_POLYLINE ) { if (nBytes < 4) return OGRERR_FAILURE; int nPoints; memcpy(&nPoints, pabyGeom, 4); CPL_LSBPTR32(&nPoints); pabyGeom += 4; nBytes -= 4; if (nPoints < 0 || nPoints > INT_MAX / 24 || nBytes < nPoints * 24) return OGRERR_FAILURE; OGRLineString* poLS = new OGRLineString(); poLS->setNumPoints(nPoints); int i; for(i=0;i<nPoints;i++) { double dfX, dfY, dfZ; memcpy(&dfX, pabyGeom, 8); CPL_LSBPTR64(&dfX); memcpy(&dfY, pabyGeom + 8, 8); CPL_LSBPTR64(&dfY); memcpy(&dfZ, pabyGeom + 16, 8); CPL_LSBPTR64(&dfZ); poLS->setPoint(i, dfX, dfY, dfZ); pabyGeom += 24; } *ppoGeom = poLS; return OGRERR_NONE; } else if ( nGeomType == GEOMEDIA_POLYGON ) { if (nBytes < 4) return OGRERR_FAILURE; int nPoints; memcpy(&nPoints, pabyGeom, 4); CPL_LSBPTR32(&nPoints); pabyGeom += 4; nBytes -= 4; if (nPoints < 0 || nPoints > INT_MAX / 24 || nBytes < nPoints * 24) return OGRERR_FAILURE; OGRLinearRing* poRing = new OGRLinearRing(); poRing->setNumPoints(nPoints); int i; for(i=0;i<nPoints;i++) { double dfX, dfY, dfZ; memcpy(&dfX, pabyGeom, 8); CPL_LSBPTR64(&dfX); memcpy(&dfY, pabyGeom + 8, 8); CPL_LSBPTR64(&dfY); memcpy(&dfZ, pabyGeom + 16, 8); CPL_LSBPTR64(&dfZ); poRing->setPoint(i, dfX, dfY, dfZ); pabyGeom += 24; } OGRPolygon* poPoly = new OGRPolygon(); poPoly->addRingDirectly(poRing); *ppoGeom = poPoly; return OGRERR_NONE; } else if ( nGeomType == GEOMEDIA_BOUNDARY ) { if (nBytes < 4) return OGRERR_FAILURE; int nExteriorSize; memcpy(&nExteriorSize, pabyGeom, 4); CPL_LSBPTR32(&nExteriorSize); pabyGeom += 4; nBytes -= 4; if (nBytes < nExteriorSize) return OGRERR_FAILURE; OGRGeometry* poExteriorGeom = NULL; if (OGRCreateFromGeomedia( pabyGeom, &poExteriorGeom, nExteriorSize ) != OGRERR_NONE) return OGRERR_FAILURE; if ( wkbFlatten( poExteriorGeom->getGeometryType() ) != wkbPolygon ) { delete poExteriorGeom; return OGRERR_FAILURE; } pabyGeom += nExteriorSize; nBytes -= nExteriorSize; if (nBytes < 4) { delete poExteriorGeom; return OGRERR_FAILURE; } int nInteriorSize; memcpy(&nInteriorSize, pabyGeom, 4); CPL_LSBPTR32(&nInteriorSize); pabyGeom += 4; nBytes -= 4; if (nBytes < nInteriorSize) { delete poExteriorGeom; return OGRERR_FAILURE; } OGRGeometry* poInteriorGeom = NULL; if (OGRCreateFromGeomedia( pabyGeom, &poInteriorGeom, nInteriorSize ) != OGRERR_NONE) { delete poExteriorGeom; return OGRERR_FAILURE; } OGRwkbGeometryType interiorGeomType = wkbFlatten( poInteriorGeom->getGeometryType() ); if ( interiorGeomType == wkbPolygon ) { ((OGRPolygon*)poExteriorGeom)->addRing(((OGRPolygon*)poInteriorGeom)->getExteriorRing()); } else if ( interiorGeomType == wkbMultiPolygon ) { int numGeom = ((OGRMultiPolygon*)poInteriorGeom)->getNumGeometries(); for ( int i = 0; i < numGeom; ++i ) { OGRPolygon* poInteriorPolygon = (OGRPolygon*)((OGRMultiPolygon*)poInteriorGeom)->getGeometryRef(i); ((OGRPolygon*)poExteriorGeom)->addRing( poInteriorPolygon->getExteriorRing() ); } } else { delete poExteriorGeom; delete poInteriorGeom; return OGRERR_FAILURE; } delete poInteriorGeom; *ppoGeom = poExteriorGeom; return OGRERR_NONE; } else if ( nGeomType == GEOMEDIA_COLLECTION || nGeomType == GEOMEDIA_MULTILINE || nGeomType == GEOMEDIA_MULTIPOLYGON ) { if (nBytes < 4) return OGRERR_FAILURE; int i; int nParts; memcpy(&nParts, pabyGeom, 4); CPL_LSBPTR32(&nParts); pabyGeom += 4; nBytes -= 4; if (nParts < 0 || nParts > INT_MAX / (4 + 16) || nBytes < nParts * (4 + 16)) return OGRERR_FAILURE; /* Can this collection be considered as a multipolyline or multipolygon ? */ if ( nGeomType == GEOMEDIA_COLLECTION ) { GByte* pabyGeomBackup = pabyGeom; int nBytesBackup = nBytes; int bAllPolyline = TRUE; int bAllPolygon = TRUE; for(i=0;i<nParts;i++) { if (nBytes < 4) return OGRERR_FAILURE; int nSubBytes; memcpy(&nSubBytes, pabyGeom, 4); CPL_LSBPTR32(&nSubBytes); if (nSubBytes < 0) { return OGRERR_FAILURE; } pabyGeom += 4; nBytes -= 4; if (nBytes < nSubBytes) { return OGRERR_FAILURE; } if( nSubBytes < 16 ) return OGRERR_FAILURE; if( !(pabyGeom[1] == 0xFF && pabyGeom[2] == 0xD2 && pabyGeom[3] == 0x0F) ) return OGRERR_FAILURE; int nSubGeomType = pabyGeom[0]; if ( nSubGeomType != GEOMEDIA_POLYLINE ) bAllPolyline = FALSE; if ( nSubGeomType != GEOMEDIA_POLYGON ) bAllPolygon = FALSE; pabyGeom += nSubBytes; nBytes -= nSubBytes; } pabyGeom = pabyGeomBackup; nBytes = nBytesBackup; if (bAllPolyline) nGeomType = GEOMEDIA_MULTILINE; else if (bAllPolygon) nGeomType = GEOMEDIA_MULTIPOLYGON; } OGRGeometryCollection* poColl = (nGeomType == GEOMEDIA_MULTILINE) ? new OGRMultiLineString() : (nGeomType == GEOMEDIA_MULTIPOLYGON) ? new OGRMultiPolygon() : new OGRGeometryCollection(); for(i=0;i<nParts;i++) { if (nBytes < 4) return OGRERR_FAILURE; int nSubBytes; memcpy(&nSubBytes, pabyGeom, 4); CPL_LSBPTR32(&nSubBytes); if (nSubBytes < 0) { delete poColl; return OGRERR_FAILURE; } pabyGeom += 4; nBytes -= 4; if (nBytes < nSubBytes) { delete poColl; return OGRERR_FAILURE; } OGRGeometry* poSubGeom = NULL; if (OGRCreateFromGeomedia( pabyGeom, &poSubGeom, nSubBytes ) == OGRERR_NONE) { if (wkbFlatten(poColl->getGeometryType()) == wkbMultiPolygon && wkbFlatten(poSubGeom->getGeometryType()) == wkbLineString) { OGRPolygon* poPoly = new OGRPolygon(); OGRLinearRing* poRing = new OGRLinearRing(); poRing->addSubLineString((OGRLineString*)poSubGeom); poPoly->addRingDirectly(poRing); delete poSubGeom; poSubGeom = poPoly; } if (poColl->addGeometryDirectly(poSubGeom) != OGRERR_NONE) { //printf("%d %d\n", poColl->getGeometryType() & ~wkb25DBit, poSubGeom->getGeometryType() & ~wkb25DBit); delete poSubGeom; } } pabyGeom += nSubBytes; nBytes -= nSubBytes; } *ppoGeom = poColl; return OGRERR_NONE; } else { CPLDebug("GEOMEDIA", "Unhandled type %d", nGeomType); } return OGRERR_FAILURE; }
OGRErr OGRCSVEditableLayerSynchronizer::EditableSyncToDisk(OGRLayer* poEditableLayer, OGRLayer** ppoDecoratedLayer) { CPLAssert( m_poCSVLayer == *ppoDecoratedLayer ); CPLString osLayerName(m_poCSVLayer->GetName()); CPLString osFilename(m_poCSVLayer->GetFilename()); const bool bCreateCSVT = m_poCSVLayer->GetCreateCSVT(); CPLString osCSVTFilename(CPLResetExtension(osFilename, "csvt")); VSIStatBufL sStatBuf; const bool bHasCSVT = VSIStatL(osCSVTFilename, &sStatBuf) == 0; CPLString osTmpFilename(osFilename); CPLString osTmpCSVTFilename(osFilename); if( VSIStatL(osFilename, &sStatBuf) == 0 ) { osTmpFilename += "_ogr_tmp.csv"; osTmpCSVTFilename += "_ogr_tmp.csvt"; } const char chDelimiter = m_poCSVLayer->GetDelimiter(); OGRCSVLayer* poCSVTmpLayer = new OGRCSVLayer( osLayerName, NULL, osTmpFilename, true, true, chDelimiter ); poCSVTmpLayer->BuildFeatureDefn(NULL, NULL, m_papszOpenOptions); poCSVTmpLayer->SetCRLF( m_poCSVLayer->GetCRLF() ); poCSVTmpLayer->SetCreateCSVT( bCreateCSVT || bHasCSVT ); poCSVTmpLayer->SetWriteBOM( m_poCSVLayer->GetWriteBOM() ); if( m_poCSVLayer->GetGeometryFormat() == OGR_CSV_GEOM_AS_WKT ) poCSVTmpLayer->SetWriteGeometry( wkbNone, OGR_CSV_GEOM_AS_WKT, NULL ); OGRErr eErr = OGRERR_NONE; OGRFeatureDefn* poEditableFDefn = poEditableLayer->GetLayerDefn(); for( int i=0; eErr == OGRERR_NONE && i < poEditableFDefn->GetFieldCount(); i++ ) { OGRFieldDefn oFieldDefn(poEditableFDefn->GetFieldDefn(i)); int iGeomFieldIdx = 0; if( (EQUAL(oFieldDefn.GetNameRef(), "WKT") && (iGeomFieldIdx = poEditableFDefn->GetGeomFieldIndex("")) >= 0) || (iGeomFieldIdx = poEditableFDefn->GetGeomFieldIndex(oFieldDefn.GetNameRef())) >= 0 ) { OGRGeomFieldDefn oGeomFieldDefn( poEditableFDefn->GetGeomFieldDefn(iGeomFieldIdx) ); eErr = poCSVTmpLayer->CreateGeomField( &oGeomFieldDefn ); } else { eErr = poCSVTmpLayer->CreateField( &oFieldDefn ); } } const bool bHasXY = ( !m_poCSVLayer->GetXField().empty() && !m_poCSVLayer->GetYField().empty() ); const bool bHasZ = ( !m_poCSVLayer->GetZField().empty() ); if( bHasXY && !CPLFetchBool(m_papszOpenOptions, "KEEP_GEOM_COLUMNS", true) ) { if( poCSVTmpLayer->GetLayerDefn()->GetFieldIndex(m_poCSVLayer->GetXField()) < 0 ) { OGRFieldDefn oFieldDefn(m_poCSVLayer->GetXField(), OFTReal); if( eErr == OGRERR_NONE ) eErr = poCSVTmpLayer->CreateField( &oFieldDefn ); } if( poCSVTmpLayer->GetLayerDefn()->GetFieldIndex(m_poCSVLayer->GetYField()) < 0 ) { OGRFieldDefn oFieldDefn(m_poCSVLayer->GetYField(), OFTReal); if( eErr == OGRERR_NONE ) eErr = poCSVTmpLayer->CreateField( &oFieldDefn ); } if( bHasZ && poCSVTmpLayer->GetLayerDefn()->GetFieldIndex(m_poCSVLayer->GetZField()) < 0 ) { OGRFieldDefn oFieldDefn(m_poCSVLayer->GetZField(), OFTReal); if( eErr == OGRERR_NONE ) eErr = poCSVTmpLayer->CreateField( &oFieldDefn ); } } int nFirstGeomColIdx = 0; if( m_poCSVLayer->HasHiddenWKTColumn() ) { poCSVTmpLayer->SetWriteGeometry( poEditableFDefn->GetGeomFieldDefn(0)->GetType(), OGR_CSV_GEOM_AS_WKT, poEditableFDefn->GetGeomFieldDefn(0)->GetNameRef()); nFirstGeomColIdx = 1; } if( !(poEditableFDefn->GetGeomFieldCount() == 1 && bHasXY) ) { for( int i=nFirstGeomColIdx; eErr == OGRERR_NONE && i < poEditableFDefn->GetGeomFieldCount(); i++ ) { OGRGeomFieldDefn oGeomFieldDefn( poEditableFDefn->GetGeomFieldDefn(i) ); if( poCSVTmpLayer->GetLayerDefn()->GetGeomFieldIndex(oGeomFieldDefn.GetNameRef()) >= 0 ) continue; eErr = poCSVTmpLayer->CreateGeomField( &oGeomFieldDefn ); } } OGRFeature* poFeature = NULL; poEditableLayer->ResetReading(); while( eErr == OGRERR_NONE && (poFeature = poEditableLayer->GetNextFeature()) != NULL ) { OGRFeature* poNewFeature = new OGRFeature( poCSVTmpLayer->GetLayerDefn() ); poNewFeature->SetFrom(poFeature); if( bHasXY ) { OGRGeometry* poGeom = poFeature->GetGeometryRef(); if( poGeom != NULL && wkbFlatten(poGeom->getGeometryType()) == wkbPoint ) { poNewFeature->SetField( m_poCSVLayer->GetXField(), static_cast<OGRPoint*>(poGeom)->getX()); poNewFeature->SetField( m_poCSVLayer->GetYField(), static_cast<OGRPoint*>(poGeom)->getY()); if( bHasZ ) { poNewFeature->SetField( m_poCSVLayer->GetZField(), static_cast<OGRPoint*>(poGeom)->getZ()); } } } eErr = poCSVTmpLayer->CreateFeature(poNewFeature); delete poFeature; delete poNewFeature; } delete poCSVTmpLayer; if( eErr != OGRERR_NONE ) { CPLError(CE_Failure, CPLE_AppDefined, "Error while creating %s", osTmpFilename.c_str()); VSIUnlink( osTmpFilename ); VSIUnlink( CPLResetExtension(osTmpFilename, "csvt") ); return eErr; } delete m_poCSVLayer; if( osFilename != osTmpFilename ) { CPLString osTmpOriFilename(osFilename + ".ogr_bak"); CPLString osTmpOriCSVTFilename(osCSVTFilename + ".ogr_bak"); if( VSIRename( osFilename, osTmpOriFilename ) != 0 || (bHasCSVT && VSIRename( osCSVTFilename, osTmpOriCSVTFilename ) != 0 ) || VSIRename( osTmpFilename, osFilename) != 0 || (bHasCSVT && VSIRename( osTmpCSVTFilename, osCSVTFilename ) != 0) ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot rename files"); *ppoDecoratedLayer = NULL; m_poCSVLayer = NULL; return OGRERR_FAILURE; } VSIUnlink( osTmpOriFilename ); if( bHasCSVT ) VSIUnlink( osTmpOriCSVTFilename ); } VSILFILE* fp = VSIFOpenL( osFilename, "rb+" ); if( fp == NULL ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot reopen updated %s", osFilename.c_str()); *ppoDecoratedLayer = NULL; m_poCSVLayer = NULL; return OGRERR_FAILURE; } m_poCSVLayer = new OGRCSVLayer( osLayerName, fp, osFilename, false, /* new */ true, /* update */ chDelimiter ); m_poCSVLayer->BuildFeatureDefn(NULL, NULL, m_papszOpenOptions); *ppoDecoratedLayer = m_poCSVLayer; return OGRERR_NONE; }
CPLString OGRPLScenesLayer::BuildURL(int nFeatures) { CPLString osURL = osBaseURL + CPLSPrintf("?count=%d", nFeatures); if( bAcquiredAscending == 1 ) osURL += "&order_by=acquired%20asc"; else if( bAcquiredAscending == 0 ) osURL += "&order_by=acquired%20desc"; if( m_poFilterGeom != NULL || poMainFilter != NULL ) { OGRGeometry* poIntersection = NULL; OGRGeometry* poFilterGeom = m_poFilterGeom; if( poFilterGeom ) { OGREnvelope sEnvelope; poFilterGeom->getEnvelope(&sEnvelope); if( sEnvelope.MinX <= -180 && sEnvelope.MinY <= -90 && sEnvelope.MaxX >= 180 && sEnvelope.MaxY >= 90 ) poFilterGeom = NULL; } if( poFilterGeom && poMainFilter ) poIntersection = poFilterGeom->Intersection(poMainFilter); else if( poFilterGeom ) poIntersection = poFilterGeom; else if( poMainFilter ) poIntersection = poMainFilter; if( poIntersection ) { char* pszWKT = NULL; OGREnvelope sEnvelope; poIntersection->getEnvelope(&sEnvelope); if( sEnvelope.MinX == sEnvelope.MaxX && sEnvelope.MinY == sEnvelope.MaxY ) { pszWKT = CPLStrdup(CPLSPrintf("POINT(%.18g %.18g)", sEnvelope.MinX, sEnvelope.MinY)); } else poIntersection->exportToWkt(&pszWKT); osURL += "&intersects="; char* pszWKTEscaped = CPLEscapeString(pszWKT, -1, CPLES_URL); osURL += pszWKTEscaped; CPLFree(pszWKTEscaped); CPLFree(pszWKT); } if( poIntersection != m_poFilterGeom && poIntersection != poMainFilter ) delete poIntersection; } if( osFilterURLPart.size() ) { if( osFilterURLPart[0] == '&' ) osURL += osFilterURLPart; else osURL = osBaseURL + osFilterURLPart; } return osURL; }
OGRFeature *OGRGeomediaLayer::GetNextRawFeature() { OGRErr err = OGRERR_NONE; if( GetStatement() == NULL ) return NULL; /* -------------------------------------------------------------------- */ /* If we are marked to restart then do so, and fetch a record. */ /* -------------------------------------------------------------------- */ if( !poStmt->Fetch() ) { delete poStmt; poStmt = NULL; return NULL; } /* -------------------------------------------------------------------- */ /* Create a feature from the current result. */ /* -------------------------------------------------------------------- */ int iField; OGRFeature *poFeature = new OGRFeature( poFeatureDefn ); if( pszFIDColumn != NULL && poStmt->GetColId(pszFIDColumn) > -1 ) poFeature->SetFID( atoi(poStmt->GetColData(poStmt->GetColId(pszFIDColumn))) ); else poFeature->SetFID( iNextShapeId ); iNextShapeId++; m_nFeaturesRead++; /* -------------------------------------------------------------------- */ /* Set the fields. */ /* -------------------------------------------------------------------- */ for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ ) { int iSrcField = panFieldOrdinals[iField]-1; const char *pszValue = poStmt->GetColData( iSrcField ); if( pszValue == NULL ) /* no value */; else if( poFeature->GetFieldDefnRef(iField)->GetType() == OFTBinary ) poFeature->SetField( iField, poStmt->GetColDataLength(iSrcField), (GByte *) pszValue ); else poFeature->SetField( iField, pszValue ); } /* -------------------------------------------------------------------- */ /* Try to extract a geometry. */ /* -------------------------------------------------------------------- */ if( pszGeomColumn != NULL ) { int iField = poStmt->GetColId( pszGeomColumn ); GByte *pabyShape = (GByte *) poStmt->GetColData( iField ); int nBytes = poStmt->GetColDataLength(iField); OGRGeometry *poGeom = NULL; if( pabyShape != NULL ) { err = OGRCreateFromGeomedia( pabyShape, &poGeom, nBytes ); if( OGRERR_NONE != err ) { CPLDebug( "Geomedia", "Translation geomedia binary to OGR geometry failed (FID=%ld)", (long)poFeature->GetFID() ); } } if( poGeom != NULL && OGRERR_NONE == err ) { poGeom->assignSpatialReference( poSRS ); poFeature->SetGeometryDirectly( poGeom ); } } return poFeature; }
OGRErr OGRIngresTableLayer::GetExtent(OGREnvelope *psExtent, int bForce ) { if( GetLayerDefn()->GetGeomType() == wkbNone ) { psExtent->MinX = 0.0; psExtent->MaxX = 0.0; psExtent->MinY = 0.0; psExtent->MaxY = 0.0; return OGRERR_FAILURE; } OGREnvelope oEnv; CPLString osCommand; GBool bExtentSet = FALSE; osCommand.Printf( "SELECT Envelope(%s) FROM %s;", pszGeomColumn, pszGeomColumnTable); if (ingres_query(poDS->GetConn(), osCommand) == 0) { INGRES_RES* result = ingres_use_result(poDS->GetConn()); if ( result == NULL ) { poDS->ReportError( "ingres_use_result() failed on extents query." ); return OGRERR_FAILURE; } INGRES_ROW row; unsigned long *panLengths = NULL; while ((row = ingres_fetch_row(result))) { if (panLengths == NULL) { panLengths = ingres_fetch_lengths( result ); if ( panLengths == NULL ) { poDS->ReportError( "ingres_fetch_lengths() failed on extents query." ); return OGRERR_FAILURE; } } OGRGeometry *poGeometry = NULL; // Geometry columns will have the first 4 bytes contain the SRID. OGRGeometryFactory::createFromWkb(((GByte *)row[0]) + 4, NULL, &poGeometry, panLengths[0] - 4 ); if ( poGeometry != NULL ) { if (poGeometry && !bExtentSet) { poGeometry->getEnvelope(psExtent); bExtentSet = TRUE; } else if (poGeometry) { poGeometry->getEnvelope(&oEnv); if (oEnv.MinX < psExtent->MinX) psExtent->MinX = oEnv.MinX; if (oEnv.MinY < psExtent->MinY) psExtent->MinY = oEnv.MinY; if (oEnv.MaxX > psExtent->MaxX) psExtent->MaxX = oEnv.MaxX; if (oEnv.MaxY > psExtent->MaxY) psExtent->MaxY = oEnv.MaxY; } delete poGeometry; } } ingres_free_result(result); } return (bExtentSet ? OGRERR_NONE : OGRERR_FAILURE); }
OGRFeature *OGRUKOOAP190Layer::GetNextRawFeature() { if( bEOF ) return nullptr; while( true ) { const char* pszLine = CPLReadLine2L(fp, 81, nullptr); if (pszLine == nullptr || STARTS_WITH_CI(pszLine, "EOF")) { bEOF = true; return nullptr; } int nLineLen = static_cast<int>(strlen(pszLine)); while(nLineLen > 0 && pszLine[nLineLen-1] == ' ') { ((char*)pszLine)[nLineLen-1] = '\0'; nLineLen --; } if (pszLine[0] == 'H' || nLineLen < 46) continue; OGRFeature* poFeature = new OGRFeature(poFeatureDefn); poFeature->SetFID(nNextFID ++); char szLineName[12 + 1]; ExtractField(szLineName, pszLine, 2-1, 12); int i = 11; while (i >= 0) { if (szLineName[i] == ' ') szLineName[i] = '\0'; else break; i --; } poFeature->SetField(FIELD_LINENAME, szLineName); char szVesselId[1+1]; szVesselId[0] = pszLine[17-1]; if (szVesselId[0] != ' ') { szVesselId[1] = '\0'; poFeature->SetField(FIELD_VESSEL_ID, szVesselId); } char szSourceId[1+1]; szSourceId[0] = pszLine[18-1]; if (szSourceId[0] != ' ') { szSourceId[1] = '\0'; poFeature->SetField(FIELD_SOURCE_ID, szSourceId); } char szOtherId[1+1]; szOtherId[0] = pszLine[19-1]; if (szOtherId[0] != ' ') { szOtherId[1] = '\0'; poFeature->SetField(FIELD_OTHER_ID, szOtherId); } char szPointNumber[6+1]; ExtractField(szPointNumber, pszLine, 20-1, 6); poFeature->SetField(4, atoi(szPointNumber)); char szDeg[3+1]; char szMin[2+1]; char szSec[5+1]; ExtractField(szDeg, pszLine, 26-1, 2); ExtractField(szMin, pszLine, 26+2-1, 2); ExtractField(szSec, pszLine, 26+2+2-1, 5); double dfLat = atoi(szDeg) + atoi(szMin) / 60.0 + CPLAtof(szSec) / 3600.0; if (pszLine[26+2+2+5-1] == 'S') dfLat = -dfLat; poFeature->SetField(FIELD_LATITUDE, dfLat); ExtractField(szDeg, pszLine, 36-1, 3); ExtractField(szMin, pszLine, 36+3-1, 2); ExtractField(szSec, pszLine, 36+3+2-1, 5); double dfLon = atoi(szDeg) + atoi(szMin) / 60.0 + CPLAtof(szSec) / 3600.0; if (pszLine[36+3+2+5-1] == 'W') dfLon = -dfLon; poFeature->SetField(FIELD_LONGITUDE, dfLon); OGRGeometry* poGeom = nullptr; if (!bUseEastingNorthingAsGeometry) poGeom = new OGRPoint(dfLon, dfLat); if (nLineLen >= 64) { char szEasting[9+1]; ExtractField(szEasting, pszLine, 47-1, 9); double dfEasting = CPLAtof(szEasting); poFeature->SetField(FIELD_EASTING, dfEasting); char szNorthing[9+1]; ExtractField(szNorthing, pszLine, 56-1, 9); double dfNorthing = CPLAtof(szNorthing); poFeature->SetField(FIELD_NORTHING, dfNorthing); if (bUseEastingNorthingAsGeometry) poGeom = new OGRPoint(dfEasting, dfNorthing); } if (poGeom) { if (poSRS) poGeom->assignSpatialReference(poSRS); poFeature->SetGeometryDirectly(poGeom); } if (nLineLen >= 70) { char szDepth[6+1]; ExtractField(szDepth, pszLine, 65-1, 6); double dfDepth = CPLAtof(szDepth); poFeature->SetField(FIELD_DEPTH, dfDepth); } int nDayOfYear = 0; if (nLineLen >= 73) { char szDayOfYear[3+1]; ExtractField(szDayOfYear, pszLine, 71-1, 3); nDayOfYear = atoi(szDayOfYear); poFeature->SetField(FIELD_DAYOFYEAR, nDayOfYear); } if (nLineLen >= 79) { char szH[2+1], szM[2+1], szS[2+1]; ExtractField(szH, pszLine, 74-1, 2); ExtractField(szM, pszLine, 74-1+2, 2); ExtractField(szS, pszLine, 74-1+2+2, 2); poFeature->SetField(FIELD_TIME, 0, 0, 0, atoi(szH), atoi(szM), static_cast<float>(atoi(szS)) ); if( nYear != 0 ) { constexpr int mon_lengths[2][12] = { {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31} } ; const bool bIsLeap = isleap(nYear); int nMonth = 0; int nDays = 0; if ((bIsLeap && nDayOfYear >= 1 && nDayOfYear <= 366) || (!bIsLeap && nDayOfYear >= 1 && nDayOfYear <= 365)) { const int leap_offset = bIsLeap ? 1 : 0; while( nDayOfYear > nDays + mon_lengths[leap_offset][nMonth] ) { nDays += mon_lengths[leap_offset][nMonth]; nMonth ++; } const int nDayOfMonth = nDayOfYear - nDays; nMonth++; poFeature->SetField(FIELD_DATETIME, nYear, nMonth, nDayOfMonth, atoi(szH), atoi(szM), static_cast<float>(atoi(szS)) ); } } } return poFeature; } }
OGRErr OGRBNALayer::CreateFeature( OGRFeature *poFeature ) { int i,j,k,n; OGRGeometry *poGeom = poFeature->GetGeometryRef(); char eol[3]; const char* partialEol = (poDS->GetMultiLine()) ? eol : poDS->GetCoordinateSeparator(); if (poGeom == NULL || poGeom->IsEmpty() ) { CPLError(CE_Failure, CPLE_AppDefined, "OGR BNA driver cannot write features with empty geometries."); return OGRERR_FAILURE; } if (poDS->GetUseCRLF()) { eol[0] = 13; eol[1] = 10; eol[2] = 0; } else { eol[0] = 10; eol[1] = 0; } if ( ! bWriter ) { return OGRERR_FAILURE; } if( poFeature->GetFID() == OGRNullFID ) poFeature->SetFID( nFeatures++ ); VSILFILE* fp = poDS->GetOutputFP(); int nbPairPerLine = poDS->GetNbPairPerLine(); switch( poGeom->getGeometryType() ) { case wkbPoint: case wkbPoint25D: { OGRPoint* point = (OGRPoint*)poGeom; WriteFeatureAttributes(fp, poFeature); VSIFPrintfL( fp, "1"); VSIFPrintfL( fp, "%s", partialEol); WriteCoord(fp, point->getX(), point->getY()); VSIFPrintfL( fp, "%s", eol); break; } case wkbPolygon: case wkbPolygon25D: { OGRPolygon* polygon = (OGRPolygon*)poGeom; OGRLinearRing* ring = polygon->getExteriorRing(); if (ring == NULL) { return OGRERR_FAILURE; } double firstX = ring->getX(0); double firstY = ring->getY(0); int nBNAPoints = ring->getNumPoints(); int is_ellipse = FALSE; /* This code tries to detect an ellipse in a polygon geometry */ /* This will only work presumably on ellipses already read from a BNA file */ /* Mostly a BNA to BNA feature... */ if (poDS->GetEllipsesAsEllipses() && polygon->getNumInteriorRings() == 0 && nBNAPoints == 361) { double oppositeX = ring->getX(180); double oppositeY = ring->getY(180); double quarterX = ring->getX(90); double quarterY = ring->getY(90); double antiquarterX = ring->getX(270); double antiquarterY = ring->getY(270); double center1X = 0.5*(firstX + oppositeX); double center1Y = 0.5*(firstY + oppositeY); double center2X = 0.5*(quarterX + antiquarterX); double center2Y = 0.5*(quarterY + antiquarterY); if (fabs(center1X - center2X) < 1e-5 && fabs(center1Y - center2Y) < 1e-5 && fabs(oppositeY - firstY) < 1e-5 && fabs(quarterX - antiquarterX) < 1e-5) { double major_radius = fabs(firstX - center1X); double minor_radius = fabs(quarterY - center1Y); is_ellipse = TRUE; for(i=0;i<360;i++) { if (!(fabs(center1X + major_radius * cos(i * (M_PI / 180)) - ring->getX(i)) < 1e-5 && fabs(center1Y + minor_radius * sin(i * (M_PI / 180)) - ring->getY(i)) < 1e-5)) { is_ellipse = FALSE; break; } } if ( is_ellipse == TRUE ) { WriteFeatureAttributes(fp, poFeature); VSIFPrintfL( fp, "2"); VSIFPrintfL( fp, "%s", partialEol); WriteCoord(fp, center1X, center1Y); VSIFPrintfL( fp, "%s", partialEol); WriteCoord(fp, major_radius, minor_radius); VSIFPrintfL( fp, "%s", eol); } } } if ( is_ellipse == FALSE) { int nInteriorRings = polygon->getNumInteriorRings(); for(i=0;i<nInteriorRings;i++) { nBNAPoints += polygon->getInteriorRing(i)->getNumPoints() + 1; } if (nBNAPoints <= 3) { CPLError( CE_Failure, CPLE_AppDefined, "Invalid geometry" ); return OGRERR_FAILURE; } WriteFeatureAttributes(fp, poFeature); VSIFPrintfL( fp, "%d", nBNAPoints); n = ring->getNumPoints(); int nbPair = 0; for(i=0;i<n;i++) { VSIFPrintfL( fp, "%s", ((nbPair % nbPairPerLine) == 0) ? partialEol : " "); WriteCoord(fp, ring->getX(i), ring->getY(i)); nbPair++; } for(i=0;i<nInteriorRings;i++) { ring = polygon->getInteriorRing(i); n = ring->getNumPoints(); for(j=0;j<n;j++) { VSIFPrintfL( fp, "%s", ((nbPair % nbPairPerLine) == 0) ? partialEol : " "); WriteCoord(fp, ring->getX(j), ring->getY(j)); nbPair++; } VSIFPrintfL( fp, "%s", ((nbPair % nbPairPerLine) == 0) ? partialEol : " "); WriteCoord(fp, firstX, firstY); nbPair++; } VSIFPrintfL( fp, "%s", eol); } break; } case wkbMultiPolygon: case wkbMultiPolygon25D: { OGRMultiPolygon* multipolygon = (OGRMultiPolygon*)poGeom; int N = multipolygon->getNumGeometries(); int nBNAPoints = 0; double firstX = 0, firstY = 0; for(i=0;i<N;i++) { OGRPolygon* polygon = (OGRPolygon*)multipolygon->getGeometryRef(i); OGRLinearRing* ring = polygon->getExteriorRing(); if (ring == NULL) continue; if (nBNAPoints) nBNAPoints ++; else { firstX = ring->getX(0); firstY = ring->getY(0); } nBNAPoints += ring->getNumPoints(); int nInteriorRings = polygon->getNumInteriorRings(); for(j=0;j<nInteriorRings;j++) { nBNAPoints += polygon->getInteriorRing(j)->getNumPoints() + 1; } } if (nBNAPoints <= 3) { CPLError( CE_Failure, CPLE_AppDefined, "Invalid geometry" ); return OGRERR_FAILURE; } WriteFeatureAttributes(fp, poFeature); VSIFPrintfL( fp, "%d", nBNAPoints); int nbPair = 0; for(i=0;i<N;i++) { OGRPolygon* polygon = (OGRPolygon*)multipolygon->getGeometryRef(i); OGRLinearRing* ring = polygon->getExteriorRing(); if (ring == NULL) continue; n = ring->getNumPoints(); int nInteriorRings = polygon->getNumInteriorRings(); for(j=0;j<n;j++) { VSIFPrintfL( fp, "%s", ((nbPair % nbPairPerLine) == 0) ? partialEol : " "); WriteCoord(fp, ring->getX(j), ring->getY(j)); nbPair++; } if (i != 0) { VSIFPrintfL( fp, "%s", ((nbPair % nbPairPerLine) == 0) ? partialEol : " "); WriteCoord(fp, firstX, firstY); nbPair++; } for(j=0;j<nInteriorRings;j++) { ring = polygon->getInteriorRing(j); n = ring->getNumPoints(); for(k=0;k<n;k++) { VSIFPrintfL( fp, "%s", ((nbPair % nbPairPerLine) == 0) ? partialEol : " "); WriteCoord(fp, ring->getX(k), ring->getY(k)); nbPair++; } VSIFPrintfL( fp, "%s", ((nbPair % nbPairPerLine) == 0) ? partialEol : " "); WriteCoord(fp, firstX, firstY); nbPair++; } } VSIFPrintfL( fp, "%s", eol); break; } case wkbLineString: case wkbLineString25D: { OGRLineString* line = (OGRLineString*)poGeom; int n = line->getNumPoints(); int i; if (n < 2) { CPLError( CE_Failure, CPLE_AppDefined, "Invalid geometry" ); return OGRERR_FAILURE; } WriteFeatureAttributes(fp, poFeature); VSIFPrintfL( fp, "-%d", n); int nbPair = 0; for(i=0;i<n;i++) { VSIFPrintfL( fp, "%s", partialEol); WriteCoord(fp, line->getX(i), line->getY(i)); nbPair++; } VSIFPrintfL( fp, "%s", eol); break; } default: { CPLError( CE_Failure, CPLE_AppDefined, "Unsupported geometry type : %s.", poGeom->getGeometryName() ); return OGRERR_UNSUPPORTED_GEOMETRY_TYPE; } } return OGRERR_NONE; }
OGRFeature *OGRSEGP1Layer::GetNextRawFeature() { if( bEOF ) return nullptr; const char* pszLine = nullptr; while( true ) { pszLine = CPLReadLine2L(fp,81,nullptr); if (pszLine == nullptr || STARTS_WITH_CI(pszLine, "EOF")) { bEOF = true; return nullptr; } int nLineLen = static_cast<int>(strlen(pszLine)); while(nLineLen > 0 && pszLine[nLineLen-1] == ' ') { ((char*)pszLine)[nLineLen-1] = '\0'; nLineLen --; } char* pszExpandedLine = ExpandTabs(pszLine); pszLine = pszExpandedLine; nLineLen = static_cast<int>(strlen(pszLine)); OGRFeature* poFeature = new OGRFeature(poFeatureDefn); poFeature->SetFID(nNextFID ++); OGRGeometry* poGeom = nullptr; if (nLatitudeCol-1 + 19 <= nLineLen) { char szDeg[3+1]; char szMin[2+1]; char szSec[4+1]; ExtractField(szDeg, pszLine, nLatitudeCol-1, 2); ExtractField(szMin, pszLine, nLatitudeCol+2-1, 2); ExtractField(szSec, pszLine, nLatitudeCol+2+2-1, 4); double dfLat = atoi(szDeg) + atoi(szMin) / 60.0 + atoi(szSec) / 100.0 / 3600.0; if (pszLine[nLatitudeCol+2+2+4-1] == 'S') dfLat = -dfLat; poFeature->SetField(SEGP1_FIELD_LATITUDE, dfLat); ExtractField(szDeg, pszLine, nLatitudeCol+9-1, 3); ExtractField(szMin, pszLine, nLatitudeCol+9+3-1, 2); ExtractField(szSec, pszLine, nLatitudeCol+9+3+2-1, 4); double dfLon = atoi(szDeg) + atoi(szMin) / 60.0 + atoi(szSec) / 100.0 / 3600.0; if (pszLine[nLatitudeCol+9+3+2+4-1] == 'W') dfLon = -dfLon; poFeature->SetField(SEGP1_FIELD_LONGITUDE, dfLon); if (!bUseEastingNorthingAsGeometry) poGeom = new OGRPoint(dfLon, dfLat); } /* Normal layout -> extract other fields */ if (nLatitudeCol == 27 && nLineLen >= 26-1+1) { char szLineName[16 + 1]; ExtractField(szLineName, pszLine, 2-1, 16); int i = 15; while (i >= 0) { if (szLineName[i] == ' ') szLineName[i] = '\0'; else break; i --; } poFeature->SetField(SEGP1_FIELD_LINENAME, szLineName); char szPointNumber[8+1]; ExtractField(szPointNumber, pszLine, 18-1, 8); poFeature->SetField(SEGP1_FIELD_POINTNUMBER, atoi(szPointNumber)); char szReshootCode[1+1]; ExtractField(szReshootCode, pszLine, 26-1, 1); poFeature->SetField(SEGP1_FIELD_RESHOOTCODE, szReshootCode); if (nLineLen >= 61) { char szEasting[8+1]; ExtractField(szEasting, pszLine, 46-1, 8); double dfEasting = CPLAtof(szEasting); poFeature->SetField(SEGP1_FIELD_EASTING, dfEasting); char szNorthing[8+1]; ExtractField(szNorthing, pszLine, 54-1, 8); double dfNorthing = CPLAtof(szNorthing); poFeature->SetField(SEGP1_FIELD_NORTHING, dfNorthing); if (bUseEastingNorthingAsGeometry) poGeom = new OGRPoint(dfEasting, dfNorthing); } if (nLineLen >= 66) { char szDepth[5+1]; ExtractField(szDepth, pszLine, 62-1, 5); double dfDepth = CPLAtof(szDepth); poFeature->SetField(SEGP1_FIELD_DEPTH, dfDepth); } } if (poGeom) { if (poSRS) poGeom->assignSpatialReference(poSRS); poFeature->SetGeometryDirectly(poGeom); } CPLFree(pszExpandedLine); return poFeature; } }
feature_ptr ogr_featureset::next() { OGRFeature *poFeature; while ((poFeature = layer_.GetNextFeature()) != NULL) { // ogr feature ids start at 0, so add one to stay // consistent with other mapnik datasources that start at 1 const int feature_id = (poFeature->GetFID() + 1); feature_ptr feature(feature_factory::create(ctx_,feature_id)); OGRGeometry* geom = poFeature->GetGeometryRef(); if (geom && ! geom->IsEmpty()) { ogr_converter::convert_geometry(geom, feature); } else { MAPNIK_LOG_DEBUG(ogr) << "ogr_featureset: Feature with null geometry=" << poFeature->GetFID(); OGRFeature::DestroyFeature( poFeature ); continue; } ++count_; int fld_count = layerdef_->GetFieldCount(); for (int i = 0; i < fld_count; i++) { OGRFieldDefn* fld = layerdef_->GetFieldDefn(i); const OGRFieldType type_oid = fld->GetType(); const std::string fld_name = fld->GetNameRef(); switch (type_oid) { case OFTInteger: { feature->put( fld_name, poFeature->GetFieldAsInteger(i)); break; } case OFTReal: { feature->put( fld_name, poFeature->GetFieldAsDouble(i)); break; } case OFTString: case OFTWideString: // deprecated ! { UnicodeString ustr = tr_->transcode(poFeature->GetFieldAsString(i)); feature->put( fld_name, ustr); break; } case OFTIntegerList: case OFTRealList: case OFTStringList: case OFTWideStringList: // deprecated ! { MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unhandled type_oid=" << type_oid; break; } case OFTBinary: { MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unhandled type_oid=" << type_oid; //feature->put(name,feat->GetFieldAsBinary (i, size)); break; } case OFTDate: case OFTTime: case OFTDateTime: // unhandled ! { MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unhandled type_oid=" << type_oid; break; } default: // unknown { MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unknown type_oid=" << type_oid; break; } } } OGRFeature::DestroyFeature( poFeature ); return feature; } MAPNIK_LOG_DEBUG(ogr) << "ogr_featureset: " << count_ << " features"; return feature_ptr(); }
OGRErr OGRPCIDSKLayer::SetFeature( OGRFeature *poFeature ) { PCIDSK::ShapeId id = (PCIDSK::ShapeId) poFeature->GetFID(); /* -------------------------------------------------------------------- */ /* Translate attribute fields. */ /* -------------------------------------------------------------------- */ try { int iPCI; std::vector<PCIDSK::ShapeField> aoPCIFields; aoPCIFields.resize(poVecSeg->GetFieldCount()); for( iPCI = 0; iPCI < poVecSeg->GetFieldCount(); iPCI++ ) { int iOGR; iOGR = poFeatureDefn->GetFieldIndex( poVecSeg->GetFieldName(iPCI).c_str() ); if( iOGR == -1 ) continue; switch( poVecSeg->GetFieldType(iPCI) ) { case PCIDSK::FieldTypeInteger: aoPCIFields[iPCI].SetValue( poFeature->GetFieldAsInteger( iOGR ) ); break; case PCIDSK::FieldTypeFloat: aoPCIFields[iPCI].SetValue( (float) poFeature->GetFieldAsDouble( iOGR ) ); break; case PCIDSK::FieldTypeDouble: aoPCIFields[iPCI].SetValue( (double) poFeature->GetFieldAsDouble( iOGR ) ); break; case PCIDSK::FieldTypeString: aoPCIFields[iPCI].SetValue( poFeature->GetFieldAsString( iOGR ) ); break; case PCIDSK::FieldTypeCountedInt: { int nCount; const int *panList = poFeature->GetFieldAsIntegerList( iOGR, &nCount ); std::vector<PCIDSK::int32> anList; anList.resize( nCount ); memcpy( &(anList[0]), panList, 4 * anList.size() ); aoPCIFields[iPCI].SetValue( anList ); } break; default: CPLAssert( FALSE ); break; } } if( poVecSeg->GetFieldCount() > 0 ) poVecSeg->SetFields( id, aoPCIFields ); /* -------------------------------------------------------------------- */ /* Translate the geometry. */ /* -------------------------------------------------------------------- */ std::vector<PCIDSK::ShapeVertex> aoVertices; OGRGeometry *poGeometry = poFeature->GetGeometryRef(); if( poGeometry == NULL ) { } else if( wkbFlatten(poGeometry->getGeometryType()) == wkbPoint ) { OGRPoint *poPoint = (OGRPoint *) poGeometry; aoVertices.resize(1); aoVertices[0].x = poPoint->getX(); aoVertices[0].y = poPoint->getY(); aoVertices[0].z = poPoint->getZ(); } else if( wkbFlatten(poGeometry->getGeometryType()) == wkbLineString ) { OGRLineString *poLS = (OGRLineString *) poGeometry; unsigned int i; aoVertices.resize(poLS->getNumPoints()); for( i = 0; i < aoVertices.size(); i++ ) { aoVertices[i].x = poLS->getX(i); aoVertices[i].y = poLS->getY(i); aoVertices[i].z = poLS->getZ(i); } } else { CPLDebug( "PCIDSK", "Unsupported geometry type in SetFeature(): %s", poGeometry->getGeometryName() ); } poVecSeg->SetVertices( id, aoVertices ); } /* try */ /* -------------------------------------------------------------------- */ /* Trap exceptions and report as CPL errors. */ /* -------------------------------------------------------------------- */ catch( PCIDSK::PCIDSKException ex ) { CPLError( CE_Failure, CPLE_AppDefined, "%s", ex.what() ); return OGRERR_FAILURE; } catch(...) { CPLError( CE_Failure, CPLE_AppDefined, "Non-PCIDSK exception trapped." ); return OGRERR_FAILURE; } return OGRERR_NONE; }