char* OGRGetXML_UTF8_EscapedString(const char* pszString) { char *pszEscaped; if (!CPLIsUTF8(pszString, -1) && CSLTestBoolean(CPLGetConfigOption("OGR_FORCE_ASCII", "YES"))) { 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" "If you still want the original string and change the XML file encoding\n" "afterwards, you can define OGR_FORCE_ASCII=NO as configuration option.\n" "This warning won't be issued anymore", pszString); } else { CPLDebug("OGR", "%s is not a valid UTF-8 string. Forcing it to ASCII", pszString); } char* pszTemp = CPLForceToASCII(pszString, -1, '?'); pszEscaped = CPLEscapeString( pszTemp, -1, CPLES_XML ); CPLFree(pszTemp); } else pszEscaped = CPLEscapeString( pszString, -1, CPLES_XML ); return pszEscaped; }
CPLErr WMSMiniDriver_AGS::TiledImageRequest(WMSHTTPRequest &request, const GDALWMSImageRequestInfo &iri, CPL_UNUSED const GDALWMSTiledImageRequestInfo &tiri) { CPLString &url = request.URL; url = m_base_url; // Assume map service if exportImage is not explicitly requested. if( (url.ifind("/export?") == std::string::npos) && (url.ifind("/exportImage?") == std::string::npos) ) { url += "/export?"; } URLPrepare(url); url += "f=image&dpi=&layerdefs=&layerTimeOptions=&dynamicLayers="; char *pszEscapedValue = CPLEscapeString(m_layers, -1, CPLES_URL); url += CPLOPrintf("&bbox=%.8f%%2C%.8f%%2C%.8f%%2C%.8f", GetBBoxCoord(iri, m_bbox_order[0]), GetBBoxCoord(iri, m_bbox_order[1]), GetBBoxCoord(iri, m_bbox_order[2]), GetBBoxCoord(iri, m_bbox_order[3])) + CPLOPrintf("&size=%d%%2C%d", iri.m_sx, iri.m_sy) + CPLOPrintf("&imageSR=%s", m_irs.c_str()) + CPLOPrintf("&bboxSR=%s", m_irs.c_str()) + CPLOPrintf("&format=%s", m_image_format.c_str()) + CPLOPrintf("&layers=%s", pszEscapedValue); CPLFree(pszEscapedValue); if( !m_transparent.empty() ) { url += "&transparent=" + m_transparent; } else { url += "&transparent=false"; } if( !m_time_range.empty() ) { pszEscapedValue = CPLEscapeString(m_time_range, -1, CPLES_URL); url += CPLOPrintf("&time=%s", pszEscapedValue); CPLFree(pszEscapedValue); } else { url += "&time="; } return CE_None; }
static int WFS_ExprDumpRawLitteral(CPLString& osFilter, const swq_expr_node* poExpr) { if( poExpr->field_type == SWQ_INTEGER || poExpr->field_type == SWQ_INTEGER64 ) osFilter += CPLSPrintf(CPL_FRMT_GIB, poExpr->int_value); else if( poExpr->field_type == SWQ_FLOAT ) osFilter += CPLSPrintf("%.16g", poExpr->float_value); else if( poExpr->field_type == SWQ_STRING ) { char* pszXML = CPLEscapeString(poExpr->string_value, -1, CPLES_XML); osFilter += pszXML; CPLFree(pszXML); } else if( poExpr->field_type == SWQ_TIMESTAMP ) { OGRField sDate; if( !OGRParseDate(poExpr->string_value, &sDate, 0) ) return FALSE; char* pszDate = OGRGetXMLDateTime(&sDate); osFilter += pszDate; CPLFree(pszDate); } else return FALSE; return TRUE; }
void OGRGMELayer::SetSpatialFilter( OGRGeometry *poGeomIn) { if (poGeomIn == NULL) { osIntersects.clear(); OGRLayer::SetSpatialFilter( poGeomIn ); return; } switch( poGeomIn->getGeometryType() ) { case wkbPolygon: WindPolygonCCW((OGRPolygon *) poGeomIn); case wkbPoint: case wkbLineString: if( poGeomIn == NULL ) { osIntersects = ""; } else { char * pszWkt; poGeomIn->exportToWkt(&pszWkt); char * pszEscaped = CPLEscapeString(pszWkt, -1, CPLES_URL); osIntersects = CPLString(pszEscaped); CPLFree(pszEscaped); CPLFree(pszWkt); } ResetReading(); break; default: m_iGeomFieldFilter = 0; if( InstallFilter( poGeomIn ) ) ResetReading(); break; } }
OGRErr OGRCouchDBDataSource::DeleteLayer(int iLayer) { if( !bReadWrite ) { CPLError(CE_Failure, CPLE_AppDefined, "Operation not available in read-only mode"); return OGRERR_FAILURE; } if( iLayer < 0 || iLayer >= nLayers ) { CPLError( CE_Failure, CPLE_AppDefined, "Layer %d not in legal range of 0 to %d.", iLayer, nLayers-1 ); return OGRERR_FAILURE; } CPLString osLayerName = GetLayer(iLayer)->GetName(); /* -------------------------------------------------------------------- */ /* Blow away our OGR structures related to the layer. This is */ /* pretty dangerous if anything has a reference to this layer! */ /* -------------------------------------------------------------------- */ CPLDebug( "CouchDB", "DeleteLayer(%s)", osLayerName.c_str() ); delete papoLayers[iLayer]; memmove( papoLayers + iLayer, papoLayers + iLayer + 1, sizeof(void *) * (nLayers - iLayer - 1) ); nLayers--; /* -------------------------------------------------------------------- */ /* Remove from the database. */ /* -------------------------------------------------------------------- */ char* pszEscapedName = CPLEscapeString(osLayerName, -1, CPLES_URL); CPLString osEscapedName = pszEscapedName; CPLFree(pszEscapedName); CPLString osURI; osURI = "/"; osURI += osEscapedName; json_object* poAnswerObj = DELETE(osURI); if (poAnswerObj == NULL) return OGRERR_FAILURE; if( !IsOK(poAnswerObj, "Layer deletion failed") ) { json_object_put(poAnswerObj); return OGRERR_FAILURE; } json_object_put(poAnswerObj); return OGRERR_NONE; }
char *GOA2GetAuthorizationURL(const char *pszScope) { CPLString osScope; CPLString osURL; osScope.Seize(CPLEscapeString(pszScope, -1, CPLES_URL)); osURL.Printf( "%s/auth?scope=%s&redirect_uri=urn:ietf:wg:oauth:2.0:oob&response_type=code&client_id=%s", GOOGLE_AUTH_URL, osScope.c_str(), CPLGetConfigOption("GOA2_CLIENT_ID", GDAL_CLIENT_ID)); return CPLStrdup(osURL); }
OGRErr OGRGMELayer::SetAttributeFilter( const char *pszWhere ) { OGRErr eErr; eErr = OGRLayer::SetAttributeFilter(pszWhere); if( eErr == OGRERR_NONE ) { if ( pszWhere ) { char * pszEscaped = CPLEscapeString(pszWhere, -1, CPLES_URL); osWhere = CPLString(pszEscaped); CPLFree(pszEscaped); } else { osWhere = ""; } } return eErr; }
static int WFS_ExprDumpGmlObjectIdFilter(CPLString& osFilter, const swq_expr_node* poExpr, int bUseFeatureId, int bGmlObjectIdNeedsGMLPrefix, int nVersion) { if (poExpr->eNodeType == SNT_OPERATION && poExpr->nOperation == SWQ_EQ && poExpr->nSubExprCount == 2 && poExpr->papoSubExpr[0]->eNodeType == SNT_COLUMN && strcmp(poExpr->papoSubExpr[0]->string_value, "gml_id") == 0 && poExpr->papoSubExpr[1]->eNodeType == SNT_CONSTANT) { if (bUseFeatureId) osFilter += "<FeatureId fid=\""; else if (nVersion >= 200) osFilter += "<ResourceId rid=\""; else if (!bGmlObjectIdNeedsGMLPrefix) osFilter += "<GmlObjectId id=\""; else osFilter += "<GmlObjectId gml:id=\""; if( poExpr->papoSubExpr[1]->field_type == SWQ_INTEGER || poExpr->papoSubExpr[1]->field_type == SWQ_INTEGER64 ) osFilter += CPLSPrintf(CPL_FRMT_GIB, poExpr->papoSubExpr[1]->int_value); else if( poExpr->papoSubExpr[1]->field_type == SWQ_STRING ) { char* pszXML = CPLEscapeString(poExpr->papoSubExpr[1]->string_value, -1, CPLES_XML); osFilter += pszXML; CPLFree(pszXML); } else return FALSE; osFilter += "\"/>"; return TRUE; } else if (poExpr->eNodeType == SNT_OPERATION && poExpr->nOperation == SWQ_OR && poExpr->nSubExprCount == 2 ) { return WFS_ExprDumpGmlObjectIdFilter(osFilter, poExpr->papoSubExpr[0], bUseFeatureId, bGmlObjectIdNeedsGMLPrefix, nVersion) && WFS_ExprDumpGmlObjectIdFilter(osFilter, poExpr->papoSubExpr[1], bUseFeatureId, bGmlObjectIdNeedsGMLPrefix, nVersion); } return FALSE; }
OGRErr OGRCSVLayer::WriteHeader() { if( !bNew ) return OGRERR_NONE; /* -------------------------------------------------------------------- */ /* Write field names if we haven't written them yet. */ /* Write .csvt file if needed */ /* -------------------------------------------------------------------- */ bNew = FALSE; bHasFieldNames = TRUE; for(int iFile=0;iFile<((bCreateCSVT) ? 2 : 1);iFile++) { VSILFILE* fpCSVT = NULL; if (bCreateCSVT && iFile == 0) { char* pszDirName = CPLStrdup(CPLGetDirname(pszFilename)); char* pszBaseName = CPLStrdup(CPLGetBasename(pszFilename)); fpCSVT = VSIFOpenL(CPLFormFilename(pszDirName, pszBaseName, ".csvt"), "wb"); CPLFree(pszDirName); CPLFree(pszBaseName); } else { if( strncmp(pszFilename, "/vsistdout/", 11) == 0 || strncmp(pszFilename, "/vsizip/", 8) == 0 ) fpCSV = VSIFOpenL( pszFilename, "wb" ); else fpCSV = VSIFOpenL( pszFilename, "w+b" ); if( fpCSV == NULL ) { CPLError( CE_Failure, CPLE_OpenFailed, "Failed to create %s:\n%s", pszFilename, VSIStrerror( errno ) ); return OGRERR_FAILURE; } } if (bWriteBOM && fpCSV) { VSIFWriteL("\xEF\xBB\xBF", 1, 3, fpCSV); } if (eGeometryFormat == OGR_CSV_GEOM_AS_WKT) { if (fpCSV) VSIFPrintfL( fpCSV, "%s", "WKT"); if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", "String"); if (poFeatureDefn->GetFieldCount() > 0) { if (fpCSV) VSIFPrintfL( fpCSV, "%c", chDelimiter ); if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", ","); } } else if (eGeometryFormat == OGR_CSV_GEOM_AS_XYZ) { if (fpCSV) VSIFPrintfL( fpCSV, "X%cY%cZ", chDelimiter, chDelimiter); if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", "Real,Real,Real"); if (poFeatureDefn->GetFieldCount() > 0) { if (fpCSV) VSIFPrintfL( fpCSV, "%c", chDelimiter ); if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", ","); } } else if (eGeometryFormat == OGR_CSV_GEOM_AS_XY) { if (fpCSV) VSIFPrintfL( fpCSV, "X%cY", chDelimiter); if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", "Real,Real"); if (poFeatureDefn->GetFieldCount() > 0) { if (fpCSV) VSIFPrintfL( fpCSV, "%c", chDelimiter ); if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", ","); } } else if (eGeometryFormat == OGR_CSV_GEOM_AS_YX) { if (fpCSV) VSIFPrintfL( fpCSV, "Y%cX", chDelimiter); if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", "Real,Real"); if (poFeatureDefn->GetFieldCount() > 0) { if (fpCSV) VSIFPrintfL( fpCSV, "%c", chDelimiter ); if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", ","); } } for( int iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ ) { char *pszEscaped; if( iField > 0 ) { if (fpCSV) VSIFPrintfL( fpCSV, "%c", chDelimiter ); if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", ","); } pszEscaped = CPLEscapeString( poFeatureDefn->GetFieldDefn(iField)->GetNameRef(), -1, CPLES_CSV ); if (fpCSV) VSIFPrintfL( fpCSV, "%s", pszEscaped ); CPLFree( pszEscaped ); if (fpCSVT) { switch( poFeatureDefn->GetFieldDefn(iField)->GetType() ) { case OFTInteger: VSIFPrintfL( fpCSVT, "%s", "Integer"); break; case OFTReal: VSIFPrintfL( fpCSVT, "%s", "Real"); break; case OFTDate: VSIFPrintfL( fpCSVT, "%s", "Date"); break; case OFTTime: VSIFPrintfL( fpCSVT, "%s", "Time"); break; case OFTDateTime: VSIFPrintfL( fpCSVT, "%s", "DateTime"); break; default: VSIFPrintfL( fpCSVT, "%s", "String"); break; } int nWidth = poFeatureDefn->GetFieldDefn(iField)->GetWidth(); int nPrecision = poFeatureDefn->GetFieldDefn(iField)->GetPrecision(); if (nWidth != 0) { if (nPrecision != 0) VSIFPrintfL( fpCSVT, "(%d.%d)", nWidth, nPrecision); else VSIFPrintfL( fpCSVT, "(%d)", nWidth); } } } /* The CSV driver will not recognize single column tables, so add */ /* a fake second blank field */ if( poFeatureDefn->GetFieldCount() == 1 ) { if (fpCSV) VSIFPrintfL( fpCSV, "%c", chDelimiter ); } if( bUseCRLF ) { if (fpCSV) VSIFPutcL( 13, fpCSV ); if (fpCSVT) VSIFPutcL( 13, fpCSVT ); } if (fpCSV) VSIFPutcL( '\n', fpCSV ); if (fpCSVT) VSIFPutcL( '\n', fpCSVT ); if (fpCSVT) VSIFCloseL(fpCSVT); } if (fpCSV == NULL) return OGRERR_FAILURE; else 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; }
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; }
NITFDES *NITFDESAccess( NITFFile *psFile, int iSegment ) { NITFDES *psDES; char *pachHeader; NITFSegmentInfo *psSegInfo; char szDESID[26]; char szTemp[128]; int nOffset; int bHasDESOFLW; int nDESSHL; /* -------------------------------------------------------------------- */ /* Verify segment, and return existing DES accessor if there */ /* is one. */ /* -------------------------------------------------------------------- */ if( iSegment < 0 || iSegment >= psFile->nSegmentCount ) return NULL; psSegInfo = psFile->pasSegmentInfo + iSegment; if( !EQUAL(psSegInfo->szSegmentType,"DE") ) return NULL; if( psSegInfo->hAccess != NULL ) return (NITFDES *) psSegInfo->hAccess; /* -------------------------------------------------------------------- */ /* Read the DES subheader. */ /* -------------------------------------------------------------------- */ if (psSegInfo->nSegmentHeaderSize < 200) { CPLError(CE_Failure, CPLE_AppDefined, "DES header too small"); return NULL; } pachHeader = (char*) VSIMalloc(psSegInfo->nSegmentHeaderSize); if (pachHeader == NULL) { CPLError(CE_Failure, CPLE_OutOfMemory, "Cannot allocate memory for segment header"); return NULL; } retry: if( VSIFSeekL( psFile->fp, psSegInfo->nSegmentHeaderStart, SEEK_SET ) != 0 || VSIFReadL( pachHeader, 1, psSegInfo->nSegmentHeaderSize, psFile->fp ) != psSegInfo->nSegmentHeaderSize ) { CPLError( CE_Failure, CPLE_FileIO, "Failed to read %u byte DES subheader from " CPL_FRMT_GUIB ".", psSegInfo->nSegmentHeaderSize, psSegInfo->nSegmentHeaderStart ); CPLFree(pachHeader); return NULL; } if (!EQUALN(pachHeader, "DE", 2)) { if (EQUALN(pachHeader + 4, "DERegistered", 12)) { /* BAO_46_Ed1/rpf/conc/concz10/000fz010.ona and cie are buggy */ CPLDebug("NITF", "Patching nSegmentHeaderStart and nSegmentStart for DE segment %d", iSegment); psSegInfo->nSegmentHeaderStart += 4; psSegInfo->nSegmentStart += 4; goto retry; } CPLError(CE_Failure, CPLE_AppDefined, "Invalid segment prefix for DE segment %d", iSegment); CPLFree(pachHeader); return NULL; } /* -------------------------------------------------------------------- */ /* Initialize DES object. */ /* -------------------------------------------------------------------- */ psDES = (NITFDES *) CPLCalloc(sizeof(NITFDES),1); psDES->psFile = psFile; psDES->iSegment = iSegment; psDES->pachHeader = pachHeader; psSegInfo->hAccess = psDES; /* -------------------------------------------------------------------- */ /* Collect a variety of information as metadata. */ /* -------------------------------------------------------------------- */ #define GetMD( length, name ) \ do { NITFExtractMetadata( &(psDES->papszMetadata), pachHeader, \ nOffset, length, \ "NITF_" #name ); \ nOffset += length; } while(0) nOffset = 2; GetMD( 25, DESID ); GetMD( 2, DESVER ); GetMD( 1, DECLAS ); GetMD( 2, DESCLSY ); GetMD( 11, DESCODE ); GetMD( 2, DESCTLH ); GetMD( 20, DESREL ); GetMD( 2, DESDCTP ); GetMD( 8, DESDCDT ); GetMD( 4, DESDCXM ); GetMD( 1, DESDG ); GetMD( 8, DESDGDT ); GetMD( 43, DESCLTX ); GetMD( 1, DESCATP ); GetMD( 40, DESCAUT ); GetMD( 1, DESCRSN ); GetMD( 8, DESSRDT ); GetMD( 15, DESCTLN ); /* Load DESID */ NITFGetField( szDESID, pachHeader, 2, 25); /* For NITF < 02.10, we cannot rely on DESID=TRE_OVERFLOW to detect */ /* if DESOFLW and DESITEM are present. So if the next 4 bytes are non */ /* numeric, we'll assume that DESOFLW is there */ bHasDESOFLW = EQUALN(szDESID, "TRE_OVERFLOW", strlen("TRE_OVERFLOW")) || (!((pachHeader[nOffset+0] >= '0' && pachHeader[nOffset+0] <= '9') && (pachHeader[nOffset+1] >= '0' && pachHeader[nOffset+1] <= '9') && (pachHeader[nOffset+2] >= '0' && pachHeader[nOffset+2] <= '9') && (pachHeader[nOffset+3] >= '0' && pachHeader[nOffset+3] <= '9'))); if (bHasDESOFLW) { if ((int)psSegInfo->nSegmentHeaderSize < nOffset + 6 + 3 ) { CPLError(CE_Failure, CPLE_AppDefined, "DES header too small"); NITFDESDeaccess(psDES); return NULL; } GetMD( 6, DESOFLW ); GetMD( 3, DESITEM ); } if ((int)psSegInfo->nSegmentHeaderSize < nOffset + 4 ) { CPLError(CE_Failure, CPLE_AppDefined, "DES header too small"); NITFDESDeaccess(psDES); return NULL; } nDESSHL = atoi(NITFGetField( szTemp, pachHeader, nOffset, 4)); nOffset += 4; if (nDESSHL < 0) { CPLError(CE_Failure, CPLE_AppDefined, "Invalid value for DESSHL"); NITFDESDeaccess(psDES); return NULL; } if ( (int)psSegInfo->nSegmentHeaderSize < nOffset + nDESSHL) { CPLError(CE_Failure, CPLE_AppDefined, "DES header too small"); NITFDESDeaccess(psDES); return NULL; } if (EQUALN(szDESID, "CSSHPA DES", strlen("CSSHPA DES"))) { if ( nDESSHL != 62 && nDESSHL != 80) { CPLError(CE_Failure, CPLE_AppDefined, "Invalid DESSHL for CSSHPA DES"); NITFDESDeaccess(psDES); return NULL; } GetMD( 25, SHAPE_USE ); GetMD( 10, SHAPE_CLASS ); if (nDESSHL == 80) GetMD( 18, CC_SOURCE ); GetMD( 3, SHAPE1_NAME ); GetMD( 6, SHAPE1_START ); GetMD( 3, SHAPE2_NAME ); GetMD( 6, SHAPE2_START ); GetMD( 3, SHAPE3_NAME ); GetMD( 6, SHAPE3_START ); } else if (nDESSHL > 0) GetMD( nDESSHL, DESSHF ); if ((int)psSegInfo->nSegmentHeaderSize > nOffset) { char* pszEscapedDESDATA = CPLEscapeString( pachHeader + nOffset, (int)psSegInfo->nSegmentHeaderSize - nOffset, CPLES_BackslashQuotable ); psDES->papszMetadata = CSLSetNameValue( psDES->papszMetadata, "NITF_DESDATA", pszEscapedDESDATA ); CPLFree(pszEscapedDESDATA); } return psDES; }
OGRLayer * OGRGmtDataSource::CreateLayer( const char * pszLayerName, OGRSpatialReference *poSRS, OGRwkbGeometryType eType, char ** papszOptions ) { /* -------------------------------------------------------------------- */ /* Establish the geometry type. Note this logic */ /* -------------------------------------------------------------------- */ const char *pszGeom; switch( wkbFlatten(eType) ) { case wkbPoint: pszGeom = " @GPOINT"; break; case wkbLineString: pszGeom = " @GLINESTRING"; break; case wkbPolygon: pszGeom = " @GPOLYGON"; break; case wkbMultiPoint: pszGeom = " @GMULTIPOINT"; break; case wkbMultiLineString: pszGeom = " @GMULTILINESTRING"; break; case wkbMultiPolygon: pszGeom = " @GMULTIPOLYGON"; break; default: pszGeom = ""; break; } /* -------------------------------------------------------------------- */ /* If this is the first layer for this datasource, and if the */ /* datasource name ends in .gmt we will override the provided */ /* layer name with the name from the gmt. */ /* -------------------------------------------------------------------- */ CPLString osPath = CPLGetPath( pszName ); CPLString osFilename; if( EQUAL(CPLGetExtension(pszName),"gmt") ) osFilename = pszName; else osFilename = CPLFormFilename( osPath, pszLayerName, "gmt" ); /* -------------------------------------------------------------------- */ /* Open the file. */ /* -------------------------------------------------------------------- */ FILE *fp = VSIFOpenL( osFilename, "w" ); if( fp == NULL ) { CPLError( CE_Failure, CPLE_OpenFailed, "open(%s) failed: %s", osFilename.c_str(), VSIStrerror(errno) ); return NULL; } /* -------------------------------------------------------------------- */ /* Write out header. */ /* -------------------------------------------------------------------- */ VSIFPrintfL( fp, "# @VGMT1.0%s\n", pszGeom ); VSIFPrintfL( fp, "# REGION_STUB \n" ); /* -------------------------------------------------------------------- */ /* Write the projection, if possible. */ /* -------------------------------------------------------------------- */ if( poSRS != NULL ) { char *pszValue = NULL; if( poSRS->IsProjected() && poSRS->GetAuthorityName("PROJCS") && EQUAL(poSRS->GetAuthorityName("PROJCS"),"EPSG") ) { VSIFPrintfL( fp, "# @Je%s\n", poSRS->GetAuthorityCode("PROJCS") ); } else if( poSRS->IsGeographic() && poSRS->GetAuthorityName("GEOGCS") && EQUAL(poSRS->GetAuthorityName("GEOGCS"),"EPSG") ) { VSIFPrintfL( fp, "# @Je%s\n", poSRS->GetAuthorityCode("GEOGCS") ); } if( poSRS->exportToProj4( &pszValue ) == OGRERR_NONE ) { VSIFPrintfL( fp, "# @Jp\"%s\"\n", pszValue ); CPLFree( pszValue ); pszValue = NULL; } if( poSRS->exportToWkt( &pszValue ) == OGRERR_NONE ) { char *pszEscapedWkt = CPLEscapeString( pszValue, -1, CPLES_BackslashQuotable ); VSIFPrintfL( fp, "# @Jw\"%s\"\n", pszEscapedWkt ); CPLFree( pszValue ); CPLFree( pszEscapedWkt ); pszValue = NULL; } } /* -------------------------------------------------------------------- */ /* Finish header and close. */ /* -------------------------------------------------------------------- */ VSIFCloseL( fp ); /* -------------------------------------------------------------------- */ /* Return open layer handle. */ /* -------------------------------------------------------------------- */ if( Open( osFilename, TRUE ) ) return papoLayers[nLayers-1]; else return NULL; }
const char *GDALWMSRasterBand::GetMetadataItem( const char * pszName, const char * pszDomain ) { /* ==================================================================== */ /* LocationInfo handling. */ /* ==================================================================== */ if( pszDomain != NULL && EQUAL(pszDomain,"LocationInfo") && (STARTS_WITH_CI(pszName, "Pixel_") || STARTS_WITH_CI(pszName, "GeoPixel_")) ) { int iPixel, iLine; /* -------------------------------------------------------------------- */ /* What pixel are we aiming at? */ /* -------------------------------------------------------------------- */ if( STARTS_WITH_CI(pszName, "Pixel_") ) { if( sscanf( pszName+6, "%d_%d", &iPixel, &iLine ) != 2 ) return NULL; } else if( STARTS_WITH_CI(pszName, "GeoPixel_") ) { double adfGeoTransform[6]; double adfInvGeoTransform[6]; double dfGeoX, dfGeoY; { dfGeoX = CPLAtof(pszName + 9); const char* pszUnderscore = strchr(pszName + 9, '_'); if( !pszUnderscore ) return NULL; dfGeoY = CPLAtof(pszUnderscore+1); } if( m_parent_dataset->GetGeoTransform( adfGeoTransform ) != CE_None ) return NULL; if( !GDALInvGeoTransform( adfGeoTransform, adfInvGeoTransform ) ) return NULL; iPixel = (int) floor( adfInvGeoTransform[0] + adfInvGeoTransform[1] * dfGeoX + adfInvGeoTransform[2] * dfGeoY ); iLine = (int) floor( adfInvGeoTransform[3] + adfInvGeoTransform[4] * dfGeoX + adfInvGeoTransform[5] * dfGeoY ); /* The GetDataset() for the WMS driver is always the main overview level, so rescale */ /* the values if we are an overview */ if (m_overview >= 0) { iPixel = (int) (1.0 * iPixel * GetXSize() / m_parent_dataset->GetRasterBand(1)->GetXSize()); iLine = (int) (1.0 * iLine * GetYSize() / m_parent_dataset->GetRasterBand(1)->GetYSize()); } } else return NULL; if( iPixel < 0 || iLine < 0 || iPixel >= GetXSize() || iLine >= GetYSize() ) return NULL; if (nBand != 1) { GDALRasterBand* poFirstBand = m_parent_dataset->GetRasterBand(1); if (m_overview >= 0) poFirstBand = poFirstBand->GetOverview(m_overview); if (poFirstBand) return poFirstBand->GetMetadataItem(pszName, pszDomain); } GDALWMSImageRequestInfo iri; GDALWMSTiledImageRequestInfo tiri; int nBlockXOff = iPixel / nBlockXSize; int nBlockYOff = iLine / nBlockYSize; ComputeRequestInfo(iri, tiri, nBlockXOff, nBlockYOff); CPLString url; m_parent_dataset->m_mini_driver->GetTiledImageInfo(&url, iri, tiri, iPixel % nBlockXSize, iLine % nBlockXSize); char* pszRes = NULL; if (url.size() != 0) { if (url == osMetadataItemURL) { return osMetadataItem.size() != 0 ? osMetadataItem.c_str() : NULL; } osMetadataItemURL = url; char **http_request_opts = BuildHTTPRequestOpts(); CPLHTTPResult* psResult = CPLHTTPFetch( url.c_str(), http_request_opts); if( psResult && psResult->pabyData ) pszRes = CPLStrdup((const char*) psResult->pabyData); CPLHTTPDestroyResult(psResult); CSLDestroy(http_request_opts); } if (pszRes) { osMetadataItem = "<LocationInfo>"; CPLPushErrorHandler(CPLQuietErrorHandler); CPLXMLNode* psXML = CPLParseXMLString(pszRes); CPLPopErrorHandler(); if (psXML != NULL && psXML->eType == CXT_Element) { if (strcmp(psXML->pszValue, "?xml") == 0) { if (psXML->psNext) { char* pszXML = CPLSerializeXMLTree(psXML->psNext); osMetadataItem += pszXML; CPLFree(pszXML); } } else { osMetadataItem += pszRes; } } else { char* pszEscapedXML = CPLEscapeString(pszRes, -1, CPLES_XML_BUT_QUOTES); osMetadataItem += pszEscapedXML; CPLFree(pszEscapedXML); } if (psXML != NULL) CPLDestroyXMLNode(psXML); osMetadataItem += "</LocationInfo>"; CPLFree(pszRes); return osMetadataItem.c_str(); } else { osMetadataItem = ""; return NULL; } } return GDALPamRasterBand::GetMetadataItem(pszName, pszDomain); }
json_object* OGRAmigoCloudDataSource::RunSQL(const char* pszUnescapedSQL) { CPLString osSQL; osSQL = "/users/0/projects/" + CPLString(pszProjetctId) + "/sql"; /* -------------------------------------------------------------------- */ /* Provide the API Key */ /* -------------------------------------------------------------------- */ if( osAPIKey.size() > 0 ) { osSQL += "?token="; osSQL += osAPIKey; } osSQL += "&query="; char * pszEscaped = CPLEscapeString( pszUnescapedSQL, -1, CPLES_URL ); std::string escaped = pszEscaped; CPLFree( pszEscaped ); osSQL += escaped; /* -------------------------------------------------------------------- */ /* Collection the header options and execute request. */ /* -------------------------------------------------------------------- */ std::string pszAPIURL = GetAPIURL(); char** papszOptions = NULL; pszAPIURL += osSQL; CPLHTTPResult * psResult = CPLHTTPFetch( pszAPIURL.c_str(), papszOptions); CSLDestroy(papszOptions); if( psResult == NULL ) return NULL; /* -------------------------------------------------------------------- */ /* Check for some error conditions and report. HTML Messages */ /* are transformed info failure. */ /* -------------------------------------------------------------------- */ if (psResult->pszContentType && strncmp(psResult->pszContentType, "text/html", 9) == 0) { CPLDebug( "AMIGOCLOUD", "RunSQL HTML Response:%s", psResult->pabyData ); CPLError(CE_Failure, CPLE_AppDefined, "HTML error page returned by server"); CPLHTTPDestroyResult(psResult); return NULL; } if (psResult->pszErrBuf != NULL) { CPLDebug( "AMIGOCLOUD", "RunSQL Error Message:%s", psResult->pszErrBuf ); } else if (psResult->nStatus != 0) { CPLDebug( "AMIGOCLOUD", "RunSQL Error Status:%d", psResult->nStatus ); } if( psResult->pabyData == NULL ) { CPLHTTPDestroyResult(psResult); return NULL; } CPLDebug( "AMIGOCLOUD", "RunSQL Response:%s", psResult->pabyData ); json_tokener* jstok = NULL; json_object* poObj = NULL; jstok = json_tokener_new(); poObj = json_tokener_parse_ex(jstok, (const char*) psResult->pabyData, -1); if( jstok->err != json_tokener_success) { CPLError( CE_Failure, CPLE_AppDefined, "JSON parsing error: %s (at offset %d)", json_tokener_error_desc(jstok->err), jstok->char_offset); json_tokener_free(jstok); CPLHTTPDestroyResult(psResult); return NULL; } json_tokener_free(jstok); CPLHTTPDestroyResult(psResult); if( poObj != NULL ) { if( json_object_get_type(poObj) == json_type_object ) { json_object* poError = CPL_json_object_object_get(poObj, "error"); if( poError != NULL && json_object_get_type(poError) == json_type_array && json_object_array_length(poError) > 0 ) { poError = json_object_array_get_idx(poError, 0); if( poError != NULL && json_object_get_type(poError) == json_type_string ) { CPLError(CE_Failure, CPLE_AppDefined, "Error returned by server : %s", json_object_get_string(poError)); json_object_put(poObj); return NULL; } } } else { json_object_put(poObj); return NULL; } } return poObj; }
int main( int nArgc, char ** papszArgv ) { DDFModule oModule; const char *pszFilename = NULL; int bFSPTHack = FALSE; int bXML = FALSE; /* -------------------------------------------------------------------- */ /* Check arguments. */ /* -------------------------------------------------------------------- */ for( int iArg = 1; iArg < nArgc; iArg++ ) { if( EQUAL(papszArgv[iArg],"-fspt_repeating") ) bFSPTHack = TRUE; else if( EQUAL(papszArgv[iArg],"-xml") ) bXML = TRUE; else pszFilename = papszArgv[iArg]; } if( pszFilename == NULL ) { printf( "Usage: 8211dump [-xml] [-fspt_repeating] filename\n" ); exit( 1 ); } /* -------------------------------------------------------------------- */ /* Open file. */ /* -------------------------------------------------------------------- */ if( !oModule.Open( pszFilename ) ) exit( 1 ); /* -------------------------------------------------------------------- */ /* Apply FSPT hack if required. */ /* -------------------------------------------------------------------- */ if( bFSPTHack ) { DDFFieldDefn *poFSPT = oModule.FindFieldDefn( "FSPT" ); if( poFSPT == NULL ) fprintf( stderr, "unable to find FSPT field to set repeating flag.\n" ); else poFSPT->SetRepeatingFlag( TRUE ); } /* -------------------------------------------------------------------- */ /* Dump header, and all records. */ /* -------------------------------------------------------------------- */ DDFRecord *poRecord; if( bXML ) { printf("<DDFModule>\n"); int nFieldDefnCount = oModule.GetFieldCount(); for( int i = 0; i < nFieldDefnCount; i++ ) { DDFFieldDefn* poFieldDefn = oModule.GetField(i); const char* pszDataStructCode; switch( poFieldDefn->GetDataStructCode() ) { case dsc_elementary: pszDataStructCode = "elementary"; break; case dsc_vector: pszDataStructCode = "vector"; break; case dsc_array: pszDataStructCode = "array"; break; case dsc_concatenated: pszDataStructCode = "concatenated"; break; default: pszDataStructCode = "(unknown)"; break; } const char* pszDataTypeCode; switch( poFieldDefn->GetDataTypeCode() ) { case dtc_char_string: pszDataTypeCode = "char_string"; break; case dtc_implicit_point: pszDataTypeCode = "implicit_point"; break; case dtc_explicit_point: pszDataTypeCode = "explicit_point"; break; case dtc_explicit_point_scaled: pszDataTypeCode = "explicit_point_scaled"; break; case dtc_char_bit_string: pszDataTypeCode = "char_bit_string"; break; case dtc_bit_string: pszDataTypeCode = "bit_string"; break; case dtc_mixed_data_type: pszDataTypeCode = "mixed_data_type"; break; default: pszDataTypeCode = "(unknown)"; break; } printf("<DDFFieldDefn tag=\"%s\" fieldName=\"%s\" arrayDescr=\"%s\" " "formatControls=\"%s\" dataStructCode=\"%s\" dataTypeCode=\"%s\">\n", poFieldDefn->GetName(), poFieldDefn->GetDescription(), poFieldDefn->GetArrayDescr(), poFieldDefn->GetFormatControls(), pszDataStructCode, pszDataTypeCode); int nSubfieldCount = poFieldDefn->GetSubfieldCount(); for( int iSubField = 0; iSubField < nSubfieldCount; iSubField++ ) { DDFSubfieldDefn* poSubFieldDefn = poFieldDefn->GetSubfield(iSubField); printf(" <DDFSubfieldDefn name=\"%s\" format=\"%s\"/>\n", poSubFieldDefn->GetName(), poSubFieldDefn->GetFormat()); } printf("</DDFFieldDefn>\n"); } for( poRecord = oModule.ReadRecord(); poRecord != NULL; poRecord = oModule.ReadRecord() ) { printf("<DDFRecord>\n"); int nFieldCount = poRecord->GetFieldCount(); for( int iField = 0; iField < nFieldCount; iField++ ) { DDFField* poField = poRecord->GetField(iField); DDFFieldDefn* poDefn = poField->GetFieldDefn(); const char* pszFieldName = poDefn->GetName(); printf(" <DDFField name=\"%s\"", pszFieldName); if( poField->GetRepeatCount() > 1 ) printf(" repeatCount=\"%d\"", poField->GetRepeatCount()); int iOffset = 0, nLoopCount; int nRepeatCount = poField->GetRepeatCount(); const char* pachData = poField->GetData(); int nDataSize = poField->GetDataSize(); if( nRepeatCount == 1 && poDefn->GetSubfieldCount() == 0 ) { printf(" value=\"0x"); for( int i = 0; i < nDataSize - 1; i++ ) printf( "%02X", pachData[i] ); printf("\">\n"); } else printf(">\n"); for( nLoopCount = 0; nLoopCount < nRepeatCount; nLoopCount++ ) { for( int iSubField = 0; iSubField < poDefn->GetSubfieldCount(); iSubField++ ) { int nBytesConsumed; DDFSubfieldDefn* poSubFieldDefn = poDefn->GetSubfield(iSubField); const char* pszSubFieldName = poSubFieldDefn->GetName(); printf(" <DDFSubfield name=\"%s\" ", pszSubFieldName); DDFDataType eType = poSubFieldDefn->GetType(); const char* pachSubdata = pachData + iOffset; int nMaxBytes = nDataSize - iOffset; if( eType == DDFFloat ) printf("type=\"float\">%f", poSubFieldDefn->ExtractFloatData( pachSubdata, nMaxBytes, NULL ) ); else if( eType == DDFInt ) printf("type=\"integer\">%d", poSubFieldDefn->ExtractIntData( pachSubdata, nMaxBytes, NULL ) ); else if( eType == DDFBinaryString ) { int nBytes, i; GByte *pabyBString = (GByte *) poSubFieldDefn->ExtractStringData( pachSubdata, nMaxBytes, &nBytes ); printf( "type=\"binary\">0x" ); for( i = 0; i < nBytes; i++ ) printf( "%02X", pabyBString[i] ); } else { GByte* pabyString = (GByte *)poSubFieldDefn->ExtractStringData( pachSubdata, nMaxBytes, NULL ); int bBinary = FALSE; int i; for( i = 0; pabyString[i] != '\0'; i ++ ) { if( pabyString[i] < 32 || pabyString[i] > 127 ) { bBinary = TRUE; break; } } if( bBinary ) { printf( "type=\"binary\">0x" ); for( i = 0; pabyString[i] != '\0'; i ++ ) printf( "%02X", pabyString[i] ); } else { char* pszEscaped = CPLEscapeString((const char*)pabyString, -1, CPLES_XML); printf("type=\"string\">%s", pszEscaped); CPLFree(pszEscaped); } } printf("</DDFSubfield>\n"); poSubFieldDefn->GetDataLength( pachSubdata, nMaxBytes, &nBytesConsumed ); iOffset += nBytesConsumed; } } printf(" </DDFField>\n"); } printf("</DDFRecord>\n"); } printf("</DDFModule>\n"); } else { oModule.Dump( stdout ); long nStartLoc; nStartLoc = VSIFTellL( oModule.GetFP() ); for( poRecord = oModule.ReadRecord(); poRecord != NULL; poRecord = oModule.ReadRecord() ) { printf( "File Offset: %ld\n", nStartLoc ); poRecord->Dump( stdout ); nStartLoc = VSIFTellL( oModule.GetFP() ); } } oModule.Close(); #ifdef DBMALLOC malloc_dump(1); #endif }
static CPLXMLNode * GDALWMSDatasetGetConfigFromTileMap(CPLXMLNode* psXML) { CPLXMLNode* psRoot = CPLGetXMLNode( psXML, "=TileMap" ); if (psRoot == NULL) return NULL; CPLXMLNode* psTileSets = CPLGetXMLNode(psRoot, "TileSets"); if (psTileSets == NULL) return NULL; const char* pszURL = CPLGetXMLValue(psRoot, "tilemapservice", NULL); int bCanChangeURL = TRUE; CPLString osURL; if (pszURL) { osURL = pszURL; /* Special hack for http://tilecache.osgeo.org/wms-c/Basic.py/1.0.0/basic/ */ if (strlen(pszURL) > 10 && strncmp(pszURL, "http://tilecache.osgeo.org/wms-c/Basic.py/1.0.0/", strlen("http://tilecache.osgeo.org/wms-c/Basic.py/1.0.0/")) == 0 && strcmp(pszURL + strlen(pszURL) - strlen("1.0.0/"), "1.0.0/") == 0) { osURL.resize(strlen(pszURL) - strlen("1.0.0/")); bCanChangeURL = FALSE; } osURL += "${z}/${x}/${y}.${format}"; } const char* pszSRS = CPLGetXMLValue(psRoot, "SRS", NULL); if (pszSRS == NULL) return NULL; CPLXMLNode* psBoundingBox = CPLGetXMLNode( psRoot, "BoundingBox" ); if (psBoundingBox == NULL) return NULL; const char* pszMinX = CPLGetXMLValue(psBoundingBox, "minx", NULL); const char* pszMinY = CPLGetXMLValue(psBoundingBox, "miny", NULL); const char* pszMaxX = CPLGetXMLValue(psBoundingBox, "maxx", NULL); const char* pszMaxY = CPLGetXMLValue(psBoundingBox, "maxy", NULL); if (pszMinX == NULL || pszMinY == NULL || pszMaxX == NULL || pszMaxY == NULL) return NULL; double dfMinX = CPLAtofM(pszMinX); double dfMinY = CPLAtofM(pszMinY); double dfMaxX = CPLAtofM(pszMaxX); double dfMaxY = CPLAtofM(pszMaxY); if (dfMaxY <= dfMinY || dfMaxX <= dfMinX) return NULL; CPLXMLNode* psTileFormat = CPLGetXMLNode( psRoot, "TileFormat" ); if (psTileFormat == NULL) return NULL; const char* pszTileWidth = CPLGetXMLValue(psTileFormat, "width", NULL); const char* pszTileHeight = CPLGetXMLValue(psTileFormat, "height", NULL); const char* pszTileFormat = CPLGetXMLValue(psTileFormat, "extension", NULL); if (pszTileWidth == NULL || pszTileHeight == NULL || pszTileFormat == NULL) return NULL; int nTileWidth = atoi(pszTileWidth); int nTileHeight = atoi(pszTileHeight); if (nTileWidth < 128 || nTileHeight < 128) return NULL; CPLXMLNode* psIter = psTileSets->psChild; int nLevelCount = 0; double dfPixelSize = 0; for(; psIter != NULL; psIter = psIter->psNext) { if (psIter->eType == CXT_Element && EQUAL(psIter->pszValue, "TileSet")) { const char* pszOrder = CPLGetXMLValue(psIter, "order", NULL); if (pszOrder == NULL) { CPLDebug("WMS", "Cannot find order attribute"); return NULL; } if (atoi(pszOrder) != nLevelCount) { CPLDebug("WMS", "Expected order=%d, got %s", nLevelCount, pszOrder); return NULL; } const char* pszHref = CPLGetXMLValue(psIter, "href", NULL); if (nLevelCount == 0 && pszHref != NULL) { if (bCanChangeURL && strlen(pszHref) > 10 && strcmp(pszHref + strlen(pszHref) - strlen("/0"), "/0") == 0) { osURL = pszHref; osURL.resize(strlen(pszHref) - strlen("/0")); osURL += "/${z}/${x}/${y}.${format}"; } } const char* pszUnitsPerPixel = CPLGetXMLValue(psIter, "units-per-pixel", NULL); if (pszUnitsPerPixel == NULL) return NULL; dfPixelSize = CPLAtofM(pszUnitsPerPixel); nLevelCount++; } } if (nLevelCount == 0 || osURL.size() == 0) return NULL; int nXSize = 0; int nYSize = 0; while(nLevelCount > 0) { GIntBig nXSizeBig = (GIntBig)((dfMaxX - dfMinX) / dfPixelSize + 0.5); GIntBig nYSizeBig = (GIntBig)((dfMaxY - dfMinY) / dfPixelSize + 0.5); if (nXSizeBig < INT_MAX && nYSizeBig < INT_MAX) { nXSize = (int)nXSizeBig; nYSize = (int)nYSizeBig; break; } CPLDebug("WMS", "Dropping one overview level so raster size fits into 32bit..."); dfPixelSize *= 2; nLevelCount --; } char* pszEscapedURL = CPLEscapeString(osURL.c_str(), -1, CPLES_XML); CPLString osXML = CPLSPrintf( "<GDAL_WMS>\n" " <Service name=\"TMS\">\n" " <ServerUrl>%s</ServerUrl>\n" " <Format>%s</Format>\n" " </Service>\n" " <DataWindow>\n" " <UpperLeftX>%s</UpperLeftX>\n" " <UpperLeftY>%s</UpperLeftY>\n" " <LowerRightX>%s</LowerRightX>\n" " <LowerRightY>%s</LowerRightY>\n" " <TileLevel>%d</TileLevel>\n" " <SizeX>%d</SizeX>\n" " <SizeY>%d</SizeY>\n" " </DataWindow>\n" " <Projection>%s</Projection>\n" " <BlockSizeX>%d</BlockSizeX>\n" " <BlockSizeY>%d</BlockSizeY>\n" " <BandsCount>%d</BandsCount>\n" "</GDAL_WMS>\n", pszEscapedURL, pszTileFormat, pszMinX, pszMaxY, pszMaxX, pszMinY, nLevelCount - 1, nXSize, nYSize, pszSRS, nTileWidth, nTileHeight, 3); CPLDebug("WMS", "Opening TMS :\n%s", osXML.c_str()); CPLFree(pszEscapedURL); return CPLParseXMLString(osXML); }
NITFDES *NITFDESAccess( NITFFile *psFile, int iSegment ) { NITFDES *psDES; char *pachHeader; NITFSegmentInfo *psSegInfo; char szDESID[26]; int nOffset; int bHasDESOFLW; int nDESSHL; /* -------------------------------------------------------------------- */ /* Verify segment, and return existing DES accessor if there */ /* is one. */ /* -------------------------------------------------------------------- */ if( iSegment < 0 || iSegment >= psFile->nSegmentCount ) return NULL; psSegInfo = psFile->pasSegmentInfo + iSegment; if( !EQUAL(psSegInfo->szSegmentType,"DE") ) return NULL; if( psSegInfo->hAccess != NULL ) return (NITFDES *) psSegInfo->hAccess; /* -------------------------------------------------------------------- */ /* Read the DES subheader. */ /* -------------------------------------------------------------------- */ if (psSegInfo->nSegmentHeaderSize < 200) { CPLError(CE_Failure, CPLE_AppDefined, "DES header too small"); return NULL; } pachHeader = (char*) VSI_MALLOC_VERBOSE(psSegInfo->nSegmentHeaderSize); if (pachHeader == NULL) { return NULL; } retry: if( VSIFSeekL( psFile->fp, psSegInfo->nSegmentHeaderStart, SEEK_SET ) != 0 || VSIFReadL( pachHeader, 1, psSegInfo->nSegmentHeaderSize, psFile->fp ) != psSegInfo->nSegmentHeaderSize ) { CPLError( CE_Failure, CPLE_FileIO, "Failed to read %u byte DES subheader from " CPL_FRMT_GUIB ".", psSegInfo->nSegmentHeaderSize, psSegInfo->nSegmentHeaderStart ); CPLFree(pachHeader); return NULL; } if (!STARTS_WITH_CI(pachHeader, "DE")) { if (STARTS_WITH_CI(pachHeader + 4, "DERegistered")) { /* BAO_46_Ed1/rpf/conc/concz10/000fz010.ona and cie are buggy */ CPLDebug("NITF", "Patching nSegmentHeaderStart and nSegmentStart for DE segment %d", iSegment); psSegInfo->nSegmentHeaderStart += 4; psSegInfo->nSegmentStart += 4; goto retry; } CPLError(CE_Failure, CPLE_AppDefined, "Invalid segment prefix for DE segment %d", iSegment); CPLFree(pachHeader); return NULL; } /* -------------------------------------------------------------------- */ /* Initialize DES object. */ /* -------------------------------------------------------------------- */ psDES = (NITFDES *) CPLCalloc(sizeof(NITFDES),1); psDES->psFile = psFile; psDES->iSegment = iSegment; psDES->pachHeader = pachHeader; psSegInfo->hAccess = psDES; /* -------------------------------------------------------------------- */ /* Collect a variety of information as metadata. */ /* -------------------------------------------------------------------- */ #define GetMD( length, name ) \ do { NITFExtractMetadata( &(psDES->papszMetadata), pachHeader, \ nOffset, length, \ "NITF_" #name ); \ nOffset += length; } while(0) nOffset = 2; GetMD( 25, DESID ); GetMD( 2, DESVER ); GetMD( 1, DECLAS ); GetMD( 2, DESCLSY ); GetMD( 11, DESCODE ); GetMD( 2, DESCTLH ); GetMD( 20, DESREL ); GetMD( 2, DESDCTP ); GetMD( 8, DESDCDT ); GetMD( 4, DESDCXM ); GetMD( 1, DESDG ); GetMD( 8, DESDGDT ); GetMD( 43, DESCLTX ); GetMD( 1, DESCATP ); GetMD( 40, DESCAUT ); GetMD( 1, DESCRSN ); GetMD( 8, DESSRDT ); GetMD( 15, DESCTLN ); /* Load DESID */ NITFGetField( szDESID, pachHeader, 2, 25); /* For NITF < 02.10, we cannot rely on DESID=TRE_OVERFLOW to detect */ /* if DESOFLW and DESITEM are present. So if the next 4 bytes are non */ /* numeric, we'll assume that DESOFLW is there */ bHasDESOFLW = STARTS_WITH_CI(szDESID, "TRE_OVERFLOW") || (!((pachHeader[nOffset+0] >= '0' && pachHeader[nOffset+0] <= '9') && (pachHeader[nOffset+1] >= '0' && pachHeader[nOffset+1] <= '9') && (pachHeader[nOffset+2] >= '0' && pachHeader[nOffset+2] <= '9') && (pachHeader[nOffset+3] >= '0' && pachHeader[nOffset+3] <= '9'))); if (bHasDESOFLW) { if ((int)psSegInfo->nSegmentHeaderSize < nOffset + 6 + 3 ) { CPLError(CE_Failure, CPLE_AppDefined, "DES header too small"); NITFDESDeaccess(psDES); return NULL; } GetMD( 6, DESOFLW ); GetMD( 3, DESITEM ); } if ((int)psSegInfo->nSegmentHeaderSize < nOffset + 4 ) { CPLError(CE_Failure, CPLE_AppDefined, "DES header too small"); NITFDESDeaccess(psDES); return NULL; } GetMD( 4, DESSHL ); nDESSHL = atoi(CSLFetchNameValue( psDES->papszMetadata, "NITF_DESSHL" ) ); if (nDESSHL < 0) { CPLError(CE_Failure, CPLE_AppDefined, "Invalid value for DESSHL"); NITFDESDeaccess(psDES); return NULL; } if ( (int)psSegInfo->nSegmentHeaderSize < nOffset + nDESSHL) { CPLError(CE_Failure, CPLE_AppDefined, "DES header too small"); NITFDESDeaccess(psDES); return NULL; } if (STARTS_WITH_CI(szDESID, "CSSHPA DES")) { if ( nDESSHL != 62 && nDESSHL != 80) { CPLError(CE_Failure, CPLE_AppDefined, "Invalid DESSHL for CSSHPA DES"); NITFDESDeaccess(psDES); return NULL; } GetMD( 25, SHAPE_USE ); GetMD( 10, SHAPE_CLASS ); if (nDESSHL == 80) GetMD( 18, CC_SOURCE ); GetMD( 3, SHAPE1_NAME ); GetMD( 6, SHAPE1_START ); GetMD( 3, SHAPE2_NAME ); GetMD( 6, SHAPE2_START ); GetMD( 3, SHAPE3_NAME ); GetMD( 6, SHAPE3_START ); } else if (STARTS_WITH_CI(szDESID, "XML_DATA_CONTENT")) { /* TODO : handle nDESSHL = 0005 and 0283 */ if (nDESSHL >= 5) { GetMD( 5, DESCRC ); if (nDESSHL >= 283) { GetMD( 8, DESSHFT ); GetMD( 20, DESSHDT ); GetMD( 40, DESSHRP ); GetMD( 60, DESSHSI ); GetMD( 10, DESSHSV ); GetMD( 20, DESSHSD ); GetMD( 120, DESSHTN ); if (nDESSHL >= 773) { GetMD( 125, DESSHLPG ); GetMD( 25, DESSHLPT ); GetMD( 20, DESSHLI ); GetMD( 120, DESSHLIN ); GetMD( 200, DESSHABS ); } } } } else if (STARTS_WITH_CI(szDESID, "CSATTA DES") && nDESSHL == 52) { GetMD( 12, ATT_TYPE ); GetMD( 14, DT_ATT ); GetMD( 8, DATE_ATT ); GetMD( 13, T0_ATT ); GetMD( 5, NUM_ATT ); } else if (nDESSHL > 0) GetMD( nDESSHL, DESSHF ); if ((int)psSegInfo->nSegmentHeaderSize > nOffset) { char* pszEscapedDESDATA = CPLEscapeString( pachHeader + nOffset, (int)psSegInfo->nSegmentHeaderSize - nOffset, CPLES_BackslashQuotable ); psDES->papszMetadata = CSLSetNameValue( psDES->papszMetadata, "NITF_DESDATA", pszEscapedDESDATA ); CPLFree(pszEscapedDESDATA); } else { #define TEN_MEGABYTES 10485760 if (psSegInfo->nSegmentSize > TEN_MEGABYTES) { const char* pszOffset = CPLSPrintf(CPL_FRMT_GUIB, psFile->pasSegmentInfo[iSegment].nSegmentStart); const char* pszSize = CPLSPrintf(CPL_FRMT_GUIB, psFile->pasSegmentInfo[iSegment].nSegmentSize); psDES->papszMetadata = CSLSetNameValue( psDES->papszMetadata, "NITF_DESDATA_OFFSET", pszOffset ); psDES->papszMetadata = CSLSetNameValue( psDES->papszMetadata, "NITF_DESDATA_LENGTH", pszSize); } else { char* pachData = (char*)VSI_MALLOC_VERBOSE((size_t)psSegInfo->nSegmentSize); if (pachData == NULL ) { /* nothing */ } else if( VSIFSeekL( psFile->fp, psSegInfo->nSegmentStart, SEEK_SET ) != 0 || VSIFReadL( pachData, 1, (size_t)psSegInfo->nSegmentSize, psFile->fp ) != psSegInfo->nSegmentSize ) { CPLDebug("NITF", "Failed to read " CPL_FRMT_GUIB" bytes DES data from " CPL_FRMT_GUIB ".", psSegInfo->nSegmentSize, psSegInfo->nSegmentStart ); } else { char* pszEscapedDESDATA = CPLEscapeString( pachData, (int)psSegInfo->nSegmentSize, CPLES_BackslashQuotable ); psDES->papszMetadata = CSLSetNameValue( psDES->papszMetadata, "NITF_DESDATA", pszEscapedDESDATA ); CPLFree(pszEscapedDESDATA); } CPLFree(pachData); } #ifdef notdef /* Disabled because might generate a huge amount of elements */ if (STARTS_WITH_CI(szDESID, "CSATTA DES")) { int nNumAtt = atoi(CSLFetchNameValueDef(psDES->papszMetadata, "NITF_NUM_ATT", "0")); if (nNumAtt * 8 * 4 == psSegInfo->nSegmentSize) { int nMDSize = CSLCount(psDES->papszMetadata); char** papszMD = (char**)VSIRealloc(psDES->papszMetadata, (nMDSize + nNumAtt * 4 + 1) * sizeof(char*)); if (papszMD) { int i, j; const GByte* pachDataIter = pachData; psDES->papszMetadata = papszMD; for(i=0;i<nNumAtt;i++) { char szAttrNameValue[64+1+256+1]; double dfVal; for(j=0;j<4;j++) { memcpy(&dfVal, pachDataIter, 8); CPL_MSBPTR64(&dfVal); pachDataIter += 8; CPLsprintf(szAttrNameValue, "NITF_ATT_Q%d_%d=%.16g", j+1, i, dfVal); papszMD[nMDSize + i * 4 + j] = CPLStrdup(szAttrNameValue); } } papszMD[nMDSize + nNumAtt * 4] = NULL; } } } #endif } return psDES; }
static int WFS_ExprDumpAsOGCFilter(CPLString& osFilter, const swq_expr_node* poExpr, int bExpectBinary, ExprDumpFilterOptions* psOptions) { if( poExpr->eNodeType == SNT_COLUMN ) { if (bExpectBinary) return FALSE; /* Special fields not understood by server */ if (EQUAL(poExpr->string_value, "gml_id") || EQUAL(poExpr->string_value, "FID") || EQUAL(poExpr->string_value, "OGR_GEOMETRY") || EQUAL(poExpr->string_value, "OGR_GEOM_WKT") || EQUAL(poExpr->string_value, "OGR_GEOM_AREA") || EQUAL(poExpr->string_value, "OGR_STYLE")) { CPLDebug("WFS", "Attribute refers to a OGR special field. Cannot use server-side filtering"); return FALSE; } const char* pszFieldname = NULL; int nIndex; int bSameTable = psOptions->poFDefn != NULL && ( poExpr->table_name == NULL || EQUAL(poExpr->table_name, psOptions->poFDefn->GetName()) ); if( bSameTable ) { if( (nIndex = psOptions->poFDefn->GetFieldIndex(poExpr->string_value)) >= 0 ) { pszFieldname = psOptions->poFDefn->GetFieldDefn(nIndex)->GetNameRef(); } else if( (nIndex = psOptions->poFDefn->GetGeomFieldIndex(poExpr->string_value)) >= 0 ) { pszFieldname = psOptions->poFDefn->GetGeomFieldDefn(nIndex)->GetNameRef(); } } else if( psOptions->poDS != NULL ) { OGRLayer* poLayer = psOptions->poDS->GetLayerByName(poExpr->table_name); if( poLayer ) { OGRFeatureDefn* poFDefn = poLayer->GetLayerDefn(); if( (nIndex = poFDefn->GetFieldIndex(poExpr->string_value)) >= 0 ) { pszFieldname = CPLSPrintf("%s/%s", poLayer->GetName(), poFDefn->GetFieldDefn(nIndex)->GetNameRef()); } else if( (nIndex = poFDefn->GetGeomFieldIndex(poExpr->string_value)) >= 0 ) { pszFieldname = CPLSPrintf("%s/%s", poLayer->GetName(), poFDefn->GetGeomFieldDefn(nIndex)->GetNameRef()); } } } if( psOptions->poFDefn == NULL && psOptions->poDS == NULL ) pszFieldname = poExpr->string_value; if( pszFieldname == NULL ) { if( poExpr->table_name != NULL ) CPLDebug("WFS", "Field \"%s\".\"%s\" unknown. Cannot use server-side filtering", poExpr->table_name, poExpr->string_value); else CPLDebug("WFS", "Field \"%s\" unknown. Cannot use server-side filtering", poExpr->string_value); return FALSE; } if (psOptions->nVersion >= 200) osFilter += CPLSPrintf("<%sValueReference>", psOptions->pszNSPrefix); else osFilter += CPLSPrintf("<%sPropertyName>", psOptions->pszNSPrefix); char* pszFieldnameXML = CPLEscapeString(pszFieldname, -1, CPLES_XML); osFilter += pszFieldnameXML; CPLFree(pszFieldnameXML); if (psOptions->nVersion >= 200) osFilter += CPLSPrintf("</%sValueReference>", psOptions->pszNSPrefix); else osFilter += CPLSPrintf("</%sPropertyName>", psOptions->pszNSPrefix); return TRUE; } if( poExpr->eNodeType == SNT_CONSTANT ) { if (bExpectBinary) return FALSE; osFilter += CPLSPrintf("<%sLiteral>", psOptions->pszNSPrefix); if( !WFS_ExprDumpRawLitteral(osFilter, poExpr) ) return FALSE; osFilter += CPLSPrintf("</%sLiteral>", psOptions->pszNSPrefix); return TRUE; } if( poExpr->eNodeType != SNT_OPERATION ) return FALSE; /* shouldn't happen */ if( poExpr->nOperation == SWQ_NOT ) { osFilter += CPLSPrintf("<%sNot>", psOptions->pszNSPrefix); if (!WFS_ExprDumpAsOGCFilter(osFilter, poExpr->papoSubExpr[0], TRUE, psOptions)) return FALSE; osFilter += CPLSPrintf("</%sNot>", psOptions->pszNSPrefix); return TRUE; } if( poExpr->nOperation == SWQ_LIKE ) { CPLString osVal; char ch; char firstCh = 0; int i; if (psOptions->nVersion == 100) osFilter += CPLSPrintf("<%sPropertyIsLike wildCard='*' singleChar='_' escape='!'>", psOptions->pszNSPrefix); else osFilter += CPLSPrintf("<%sPropertyIsLike wildCard='*' singleChar='_' escapeChar='!'>", psOptions->pszNSPrefix); if (!WFS_ExprDumpAsOGCFilter(osFilter, poExpr->papoSubExpr[0], FALSE, psOptions)) return FALSE; if (poExpr->papoSubExpr[1]->eNodeType != SNT_CONSTANT && poExpr->papoSubExpr[1]->field_type != SWQ_STRING) return FALSE; osFilter += CPLSPrintf("<%sLiteral>", psOptions->pszNSPrefix); /* Escape value according to above special characters */ /* For URL compatibility reason, we remap the OGR SQL '%' wildchard into '*' */ i = 0; ch = poExpr->papoSubExpr[1]->string_value[i]; if (ch == '\'' || ch == '"') { firstCh = ch; i ++; } for(;(ch = poExpr->papoSubExpr[1]->string_value[i]) != '\0';i++) { if (ch == '%') osVal += "*"; else if (ch == '!') osVal += "!!"; else if (ch == '*') osVal += "!*"; else if (ch == firstCh && poExpr->papoSubExpr[1]->string_value[i + 1] == 0) break; else { char ach[2]; ach[0] = ch; ach[1] = 0; osVal += ach; } } char* pszXML = CPLEscapeString(osVal, -1, CPLES_XML); osFilter += pszXML; CPLFree(pszXML); osFilter += CPLSPrintf("</%sLiteral>", psOptions->pszNSPrefix); osFilter += CPLSPrintf("</%sPropertyIsLike>", psOptions->pszNSPrefix); return TRUE; } if( poExpr->nOperation == SWQ_ISNULL ) { osFilter += CPLSPrintf("<%sPropertyIsNull>", psOptions->pszNSPrefix); if (!WFS_ExprDumpAsOGCFilter(osFilter, poExpr->papoSubExpr[0], FALSE, psOptions)) return FALSE; osFilter += CPLSPrintf("</%sPropertyIsNull>", psOptions->pszNSPrefix); psOptions->bOutNeedsNullCheck = TRUE; return TRUE; } if( poExpr->nOperation == SWQ_EQ || poExpr->nOperation == SWQ_NE || poExpr->nOperation == SWQ_LE || poExpr->nOperation == SWQ_LT || poExpr->nOperation == SWQ_GE || poExpr->nOperation == SWQ_GT ) { int nOperation = poExpr->nOperation; int bAddClosingNot = FALSE; if (!psOptions->bPropertyIsNotEqualToSupported && nOperation == SWQ_NE) { osFilter += CPLSPrintf("<%sNot>", psOptions->pszNSPrefix); nOperation = SWQ_EQ; bAddClosingNot = TRUE; } const char* pszName = NULL; switch(nOperation) { case SWQ_EQ: pszName = "PropertyIsEqualTo"; break; case SWQ_NE: pszName = "PropertyIsNotEqualTo"; break; case SWQ_LE: pszName = "PropertyIsLessThanOrEqualTo"; break; case SWQ_LT: pszName = "PropertyIsLessThan"; break; case SWQ_GE: pszName = "PropertyIsGreaterThanOrEqualTo"; break; case SWQ_GT: pszName = "PropertyIsGreaterThan"; break; default: break; } osFilter += "<"; osFilter += psOptions->pszNSPrefix; osFilter += pszName; osFilter += ">"; if (!WFS_ExprDumpAsOGCFilter(osFilter, poExpr->papoSubExpr[0], FALSE, psOptions)) return FALSE; if (!WFS_ExprDumpAsOGCFilter(osFilter, poExpr->papoSubExpr[1], FALSE, psOptions)) return FALSE; osFilter += "</"; osFilter += psOptions->pszNSPrefix; osFilter += pszName; osFilter += ">"; if (bAddClosingNot) osFilter += CPLSPrintf("</%sNot>", psOptions->pszNSPrefix); return TRUE; } if( poExpr->nOperation == SWQ_AND || poExpr->nOperation == SWQ_OR ) { const char* pszName = (poExpr->nOperation == SWQ_AND) ? "And" : "Or"; osFilter += "<"; osFilter += psOptions->pszNSPrefix; osFilter += pszName; osFilter += ">"; if (!WFS_ExprDumpAsOGCFilter(osFilter, poExpr->papoSubExpr[0], TRUE, psOptions)) return FALSE; if (!WFS_ExprDumpAsOGCFilter(osFilter, poExpr->papoSubExpr[1], TRUE, psOptions)) return FALSE; osFilter += "</"; osFilter += psOptions->pszNSPrefix; osFilter += pszName; osFilter += ">"; return TRUE; } if( poExpr->nOperation == SWQ_CUSTOM_FUNC && EQUAL(poExpr->string_value, "ST_MakeEnvelope") ) { OGRSpatialReference oSRS; const char* pszSRSName = WFS_ExprGetSRSName( poExpr, 4, psOptions, oSRS ); int bAxisSwap = FALSE; osFilter += "<gml:Envelope"; if( pszSRSName ) { osFilter += " srsName=\""; osFilter += pszSRSName; osFilter += "\""; if( oSRS.EPSGTreatsAsLatLong() || oSRS.EPSGTreatsAsNorthingEasting() ) bAxisSwap = TRUE; } osFilter += ">"; osFilter += "<gml:lowerCorner>"; if (!WFS_ExprDumpRawLitteral(osFilter, poExpr->papoSubExpr[(bAxisSwap) ? 1 : 0])) return FALSE; osFilter += " "; if (!WFS_ExprDumpRawLitteral(osFilter, poExpr->papoSubExpr[(bAxisSwap) ? 0 : 1])) return FALSE; osFilter += "</gml:lowerCorner>"; osFilter += "<gml:upperCorner>"; if (!WFS_ExprDumpRawLitteral(osFilter, poExpr->papoSubExpr[(bAxisSwap) ? 3 : 2])) return FALSE; osFilter += " "; if (!WFS_ExprDumpRawLitteral(osFilter, poExpr->papoSubExpr[(bAxisSwap) ? 2 : 3])) return FALSE; osFilter += "</gml:upperCorner>"; osFilter += "</gml:Envelope>"; return TRUE; } if( poExpr->nOperation == SWQ_CUSTOM_FUNC && EQUAL(poExpr->string_value, "ST_GeomFromText") ) { OGRSpatialReference oSRS; const char* pszSRSName = WFS_ExprGetSRSName( poExpr, 1, psOptions, oSRS ); OGRGeometry* poGeom = NULL; char* pszWKT = (char*)poExpr->papoSubExpr[0]->string_value; OGRGeometryFactory::createFromWkt(&pszWKT, NULL, &poGeom); char** papszOptions = NULL; papszOptions = CSLSetNameValue(papszOptions, "FORMAT", "GML3"); if( pszSRSName != NULL ) { if( oSRS.EPSGTreatsAsLatLong() || oSRS.EPSGTreatsAsNorthingEasting() ) { OGR_SRSNode *poGEOGCS = oSRS.GetAttrNode( "GEOGCS" ); if( poGEOGCS != NULL ) poGEOGCS->StripNodes( "AXIS" ); OGR_SRSNode *poPROJCS = oSRS.GetAttrNode( "PROJCS" ); if (poPROJCS != NULL && oSRS.EPSGTreatsAsNorthingEasting()) poPROJCS->StripNodes( "AXIS" ); } if( EQUALN(pszSRSName, "urn:ogc:def:crs:EPSG::", strlen("urn:ogc:def:crs:EPSG::")) ) papszOptions = CSLSetNameValue(papszOptions, "GML3_LONGSRS", "YES"); else papszOptions = CSLSetNameValue(papszOptions, "GML3_LONGSRS", "NO"); poGeom->assignSpatialReference(&oSRS); } papszOptions = CSLSetNameValue(papszOptions, "GMLID", CPLSPrintf("id%d", psOptions->nUniqueGeomGMLId ++)); char* pszGML = OGR_G_ExportToGMLEx( (OGRGeometryH)poGeom, papszOptions ); osFilter += pszGML; CSLDestroy(papszOptions); delete poGeom; CPLFree(pszGML); return TRUE; } if( poExpr->nOperation == SWQ_CUSTOM_FUNC ) { const char* pszName = EQUAL(poExpr->string_value, "ST_Equals") ? "Equals" : EQUAL(poExpr->string_value, "ST_Disjoint") ? "Disjoint" : EQUAL(poExpr->string_value, "ST_Touches") ? "Touches" : EQUAL(poExpr->string_value, "ST_Contains") ? "Contains" : EQUAL(poExpr->string_value, "ST_Intersects") ? "Intersects" : EQUAL(poExpr->string_value, "ST_Within") ? "Within" : EQUAL(poExpr->string_value, "ST_Crosses") ? "Crosses" : EQUAL(poExpr->string_value, "ST_Overlaps") ? "Overlaps" : EQUAL(poExpr->string_value, "ST_DWithin") ? "DWithin" : EQUAL(poExpr->string_value, "ST_Beyond") ? "Beyond" : NULL; if( pszName == NULL ) return FALSE; osFilter += "<"; osFilter += psOptions->pszNSPrefix; osFilter += pszName; osFilter += ">"; for(int i=0;i<2;i++) { if( i == 1 && poExpr->papoSubExpr[0]->eNodeType == SNT_COLUMN && poExpr->papoSubExpr[1]->eNodeType == SNT_OPERATION && poExpr->papoSubExpr[1]->nOperation == SWQ_CUSTOM_FUNC && (EQUAL(poExpr->papoSubExpr[1]->string_value, "ST_GeomFromText") || EQUAL(poExpr->papoSubExpr[1]->string_value, "ST_MakeEnvelope")) ) { int bSameTable = psOptions->poFDefn != NULL && ( poExpr->papoSubExpr[0]->table_name == NULL || EQUAL(poExpr->papoSubExpr[0]->table_name, psOptions->poFDefn->GetName()) ); if( bSameTable ) { int nIndex; if( (nIndex = psOptions->poFDefn->GetGeomFieldIndex(poExpr->papoSubExpr[0]->string_value)) >= 0 ) { psOptions->poSRS = psOptions->poFDefn->GetGeomFieldDefn(nIndex)->GetSpatialRef(); } } else if( psOptions->poDS != NULL ) { OGRLayer* poLayer = psOptions->poDS->GetLayerByName(poExpr->papoSubExpr[0]->table_name); if( poLayer ) { OGRFeatureDefn* poFDefn = poLayer->GetLayerDefn(); int nIndex; if( (nIndex = poFDefn->GetGeomFieldIndex(poExpr->papoSubExpr[0]->string_value)) >= 0 ) { psOptions->poSRS = poFDefn->GetGeomFieldDefn(nIndex)->GetSpatialRef(); } } } } int bRet = WFS_ExprDumpAsOGCFilter(osFilter, poExpr->papoSubExpr[i], FALSE, psOptions); psOptions->poSRS = NULL; if( !bRet ) return FALSE; } if( poExpr->nSubExprCount > 2 ) { osFilter += CPLSPrintf("<%sDistance unit=\"m\">", psOptions->pszNSPrefix); if (!WFS_ExprDumpRawLitteral(osFilter, poExpr->papoSubExpr[2]) ) return FALSE; osFilter += CPLSPrintf("</%sDistance>", psOptions->pszNSPrefix); } osFilter += "</"; osFilter += psOptions->pszNSPrefix; osFilter += pszName; osFilter += ">"; return TRUE; } return FALSE; }
static CPLXMLNode * GDALWMSDatasetGetConfigFromURL(GDALOpenInfo *poOpenInfo) { const char* pszBaseURL = poOpenInfo->pszFilename; if (EQUALN(pszBaseURL, "WMS:", 4)) pszBaseURL += 4; CPLString osLayer = CPLURLGetValue(pszBaseURL, "LAYERS"); CPLString osVersion = CPLURLGetValue(pszBaseURL, "VERSION"); CPLString osSRS = CPLURLGetValue(pszBaseURL, "SRS"); CPLString osCRS = CPLURLGetValue(pszBaseURL, "CRS"); CPLString osBBOX = CPLURLGetValue(pszBaseURL, "BBOX"); CPLString osFormat = CPLURLGetValue(pszBaseURL, "FORMAT"); CPLString osTransparent = CPLURLGetValue(pszBaseURL, "TRANSPARENT"); /* GDAL specific extensions to alter the default settings */ CPLString osOverviewCount = CPLURLGetValue(pszBaseURL, "OVERVIEWCOUNT"); CPLString osTileSize = CPLURLGetValue(pszBaseURL, "TILESIZE"); CPLString osMinResolution = CPLURLGetValue(pszBaseURL, "MINRESOLUTION"); CPLString osBBOXOrder = CPLURLGetValue(pszBaseURL, "BBOXORDER"); CPLString osBaseURL = pszBaseURL; /* Remove all keywords to get base URL */ osBaseURL = CPLURLAddKVP(osBaseURL, "VERSION", NULL); osBaseURL = CPLURLAddKVP(osBaseURL, "REQUEST", NULL); osBaseURL = CPLURLAddKVP(osBaseURL, "LAYERS", NULL); osBaseURL = CPLURLAddKVP(osBaseURL, "SRS", NULL); osBaseURL = CPLURLAddKVP(osBaseURL, "CRS", NULL); osBaseURL = CPLURLAddKVP(osBaseURL, "BBOX", NULL); osBaseURL = CPLURLAddKVP(osBaseURL, "FORMAT", NULL); osBaseURL = CPLURLAddKVP(osBaseURL, "TRANSPARENT", NULL); osBaseURL = CPLURLAddKVP(osBaseURL, "STYLES", NULL); osBaseURL = CPLURLAddKVP(osBaseURL, "WIDTH", NULL); osBaseURL = CPLURLAddKVP(osBaseURL, "HEIGHT", NULL); osBaseURL = CPLURLAddKVP(osBaseURL, "OVERVIEWCOUNT", NULL); osBaseURL = CPLURLAddKVP(osBaseURL, "TILESIZE", NULL); osBaseURL = CPLURLAddKVP(osBaseURL, "MINRESOLUTION", NULL); osBaseURL = CPLURLAddKVP(osBaseURL, "BBOXORDER", NULL); if (osBaseURL.size() > 0 && osBaseURL[osBaseURL.size() - 1] == '&') osBaseURL.resize(osBaseURL.size() - 1); if (osVersion.size() == 0) osVersion = "1.1.1"; CPLString osSRSTag; CPLString osSRSValue; if(VersionStringToInt(osVersion.c_str())>= VersionStringToInt("1.3.0")) { if (osSRS.size()) { CPLError(CE_Warning, CPLE_AppDefined, "WMS version 1.3 and above expects CRS however SRS was set instead."); } osSRSValue = osCRS; osSRSTag = "CRS"; } else { if (osCRS.size()) { CPLError(CE_Warning, CPLE_AppDefined, "WMS version 1.1.1 and below expects SRS however CRS was set instead."); } osSRSValue = osSRS; osSRSTag = "SRS"; } if (osSRSValue.size() == 0) osSRSValue = "EPSG:4326"; if (osBBOX.size() == 0) { if (osBBOXOrder.compare("yxYX") == 0) osBBOX = "-90,-180,90,180"; else osBBOX = "-180,-90,180,90"; } char** papszTokens = CSLTokenizeStringComplex(osBBOX, ",", 0, 0); if (CSLCount(papszTokens) != 4) { CSLDestroy(papszTokens); return NULL; } const char* pszMinX = papszTokens[0]; const char* pszMinY = papszTokens[1]; const char* pszMaxX = papszTokens[2]; const char* pszMaxY = papszTokens[3]; if (osBBOXOrder.compare("yxYX") == 0) { std::swap(pszMinX, pszMinY); std::swap(pszMaxX, pszMaxY); } double dfMinX = CPLAtofM(pszMinX); double dfMinY = CPLAtofM(pszMinY); double dfMaxX = CPLAtofM(pszMaxX); double dfMaxY = CPLAtofM(pszMaxY); if (dfMaxY <= dfMinY || dfMaxX <= dfMinX) { CSLDestroy(papszTokens); return NULL; } int nTileSize = atoi(osTileSize); if (nTileSize <= 128 || nTileSize > 2048) nTileSize = 1024; int nXSize, nYSize; int nOverviewCount = (osOverviewCount.size()) ? atoi(osOverviewCount) : 20; if (osMinResolution.size() != 0) { double dfMinResolution = CPLAtofM(osMinResolution); while (nOverviewCount > 20) { nOverviewCount --; dfMinResolution *= 2; } nXSize = (int) ((dfMaxX - dfMinX) / dfMinResolution + 0.5); nYSize = (int) ((dfMaxY - dfMinY) / dfMinResolution + 0.5); } else { double dfRatio = (dfMaxX - dfMinX) / (dfMaxY - dfMinY); if (dfRatio > 1) { nXSize = nTileSize; nYSize = (int) (nXSize / dfRatio); } else { nYSize = nTileSize; nXSize = (int) (nYSize * dfRatio); } if (nOverviewCount < 0 || nOverviewCount > 20) nOverviewCount = 20; nXSize = nXSize * (1 << nOverviewCount); nYSize = nYSize * (1 << nOverviewCount); } int bTransparent = osTransparent.size() ? CSLTestBoolean(osTransparent) : FALSE; if (osFormat.size() == 0) { if (!bTransparent) { osFormat = "image/jpeg"; } else { osFormat = "image/png"; } } char* pszEscapedURL = CPLEscapeString(osBaseURL.c_str(), -1, CPLES_XML); char* pszEscapedLayerURL = CPLEscapeString(osLayer.c_str(), -1, CPLES_URL); char* pszEscapedLayerXML = CPLEscapeString(pszEscapedLayerURL, -1, CPLES_XML); CPLString osXML = CPLSPrintf( "<GDAL_WMS>\n" " <Service name=\"WMS\">\n" " <Version>%s</Version>\n" " <ServerUrl>%s</ServerUrl>\n" " <Layers>%s</Layers>\n" " <%s>%s</%s>\n" " <ImageFormat>%s</ImageFormat>\n" " <Transparent>%s</Transparent>\n" " <BBoxOrder>%s</BBoxOrder>\n" " </Service>\n" " <DataWindow>\n" " <UpperLeftX>%s</UpperLeftX>\n" " <UpperLeftY>%s</UpperLeftY>\n" " <LowerRightX>%s</LowerRightX>\n" " <LowerRightY>%s</LowerRightY>\n" " <SizeX>%d</SizeX>\n" " <SizeY>%d</SizeY>\n" " </DataWindow>\n" " <BandsCount>%d</BandsCount>\n" " <BlockSizeX>%d</BlockSizeX>\n" " <BlockSizeY>%d</BlockSizeY>\n" " <OverviewCount>%d</OverviewCount>\n" "</GDAL_WMS>\n", osVersion.c_str(), pszEscapedURL, pszEscapedLayerXML, osSRSTag.c_str(), osSRSValue.c_str(), osSRSTag.c_str(), osFormat.c_str(), (bTransparent) ? "TRUE" : "FALSE", (osBBOXOrder.size()) ? osBBOXOrder.c_str() : "xyXY", pszMinX, pszMaxY, pszMaxX, pszMinY, nXSize, nYSize, (bTransparent) ? 4 : 3, nTileSize, nTileSize, nOverviewCount); CPLFree(pszEscapedURL); CPLFree(pszEscapedLayerURL); CPLFree(pszEscapedLayerXML); CSLDestroy(papszTokens); CPLDebug("WMS", "Opening WMS :\n%s", osXML.c_str()); return CPLParseXMLString(osXML); }
static int WFS_ExprDumpAsOGCFilter(CPLString& osFilter, const Expr* expr, int bExpectBinary, ExprDumpFilterOptions* psOptions) { switch(expr->eType) { case TOKEN_VAR_NAME: { if (bExpectBinary) return FALSE; /* Special fields not understood by server */ if (EQUAL(expr->pszVal, "gml_id") || EQUAL(expr->pszVal, "FID") || EQUAL(expr->pszVal, "OGR_GEOMETRY") || EQUAL(expr->pszVal, "OGR_GEOM_WKT") || EQUAL(expr->pszVal, "OGR_GEOM_AREA") || EQUAL(expr->pszVal, "OGR_STYLE")) { CPLDebug("WFS", "Attribute refers to a OGR special field. Cannot use server-side filtering"); return FALSE; } const char* pszFieldname; CPLString osVal; if (expr->pszVal[0] == '\'' || expr->pszVal[0] == '"') { osVal = expr->pszVal + 1; osVal.resize(osVal.size() - 1); pszFieldname = osVal.c_str(); } else pszFieldname = expr->pszVal; if (psOptions->poFDefn->GetFieldIndex(pszFieldname) == -1) { CPLDebug("WFS", "Field '%s' unknown. Cannot use server-side filtering", pszFieldname); return FALSE; } if (psOptions->nVersion >= 200) osFilter += "<ValueReference>"; else osFilter += "<PropertyName>"; char* pszFieldnameXML = CPLEscapeString(pszFieldname, -1, CPLES_XML); osFilter += pszFieldnameXML; CPLFree(pszFieldnameXML); if (psOptions->nVersion >= 200) osFilter += "</ValueReference>"; else osFilter += "</PropertyName>"; break; } case TOKEN_LITERAL: { if (bExpectBinary) return FALSE; const char* pszLiteral; CPLString osVal; if (expr->pszVal[0] == '\'' || expr->pszVal[0] == '"') { osVal = expr->pszVal + 1; osVal.resize(osVal.size() - 1); pszLiteral = osVal.c_str(); } else pszLiteral = expr->pszVal; osFilter += "<Literal>"; char* pszLiteralXML = CPLEscapeString(pszLiteral, -1, CPLES_XML); osFilter += pszLiteralXML; CPLFree(pszLiteralXML); osFilter += "</Literal>"; break; } case TOKEN_NOT: osFilter += "<Not>"; if (!WFS_ExprDumpAsOGCFilter(osFilter, expr->expr1, TRUE, psOptions)) return FALSE; osFilter += "</Not>"; break; case TOKEN_LIKE: { CPLString osVal; char ch; char firstCh = 0; int i; if (psOptions->nVersion == 100) osFilter += "<PropertyIsLike wildCard='*' singleChar='_' escape='!'>"; else osFilter += "<PropertyIsLike wildCard='*' singleChar='_' escapeChar='!'>"; if (!WFS_ExprDumpAsOGCFilter(osFilter, expr->expr1, FALSE, psOptions)) return FALSE; if (expr->expr2->eType != TOKEN_LITERAL) return FALSE; osFilter += "<Literal>"; /* Escape value according to above special characters */ /* For URL compatibility reason, we remap the OGR SQL '%' wildchard into '*' */ i = 0; ch = expr->expr2->pszVal[i]; if (ch == '\'' || ch == '"') { firstCh = ch; i ++; } for(; (ch = expr->expr2->pszVal[i]) != '\0'; i++) { if (ch == '%') osVal += "*"; else if (ch == '!') osVal += "!!"; else if (ch == '*') osVal += "!*"; else if (ch == firstCh && expr->expr2->pszVal[i + 1] == 0) break; else { char ach[2]; ach[0] = ch; ach[1] = 0; osVal += ach; } } osFilter += osVal; osFilter += "</Literal>"; osFilter += "</PropertyIsLike>"; break; } case TOKEN_EQUAL: case TOKEN_NOT_EQUAL: case TOKEN_LESSER_OR_EQUAL: case TOKEN_LESSER: case TOKEN_GREATER_OR_EQUAL: case TOKEN_GREATER: { if (expr->eType == TOKEN_EQUAL && expr->expr2->eType == TOKEN_LITERAL && EQUAL(expr->expr2->pszVal, "NULL")) { osFilter += "<PropertyIsNull>"; if (!WFS_ExprDumpAsOGCFilter(osFilter, expr->expr1, FALSE, psOptions)) return FALSE; osFilter += "</PropertyIsNull>"; psOptions->bOutNeedsNullCheck = TRUE; break; } if (expr->eType == TOKEN_NOT_EQUAL && expr->expr2->eType == TOKEN_LITERAL && EQUAL(expr->expr2->pszVal, "NULL")) { osFilter += "<Not><PropertyIsNull>"; if (!WFS_ExprDumpAsOGCFilter(osFilter, expr->expr1, FALSE, psOptions)) return FALSE; osFilter += "</PropertyIsNull></Not>"; psOptions->bOutNeedsNullCheck = TRUE; break; } TokenType eType = expr->eType; int bAddClosingNot = FALSE; if (!psOptions->bPropertyIsNotEqualToSupported && eType == TOKEN_NOT_EQUAL) { osFilter += "<Not>"; eType = TOKEN_EQUAL; bAddClosingNot = TRUE; } const char* pszName = NULL; switch(eType) { case TOKEN_EQUAL: pszName = "PropertyIsEqualTo"; break; case TOKEN_NOT_EQUAL: pszName = "PropertyIsNotEqualTo"; break; case TOKEN_LESSER_OR_EQUAL: pszName = "PropertyIsLessThanOrEqualTo"; break; case TOKEN_LESSER: pszName = "PropertyIsLessThan"; break; case TOKEN_GREATER_OR_EQUAL: pszName = "PropertyIsGreaterThanOrEqualTo"; break; case TOKEN_GREATER: pszName = "PropertyIsGreaterThan"; break; default: break; } osFilter += "<"; osFilter += pszName; osFilter += ">"; if (!WFS_ExprDumpAsOGCFilter(osFilter, expr->expr1, FALSE, psOptions)) return FALSE; if (!WFS_ExprDumpAsOGCFilter(osFilter, expr->expr2, FALSE, psOptions)) return FALSE; osFilter += "</"; osFilter += pszName; osFilter += ">"; if (bAddClosingNot) osFilter += "</Not>"; break; } case TOKEN_AND: case TOKEN_OR: { const char* pszName = (expr->eType == TOKEN_AND) ? "And" : "Or"; osFilter += "<"; osFilter += pszName; osFilter += ">"; if (!WFS_ExprDumpAsOGCFilter(osFilter, expr->expr1, TRUE, psOptions)) return FALSE; if (!WFS_ExprDumpAsOGCFilter(osFilter, expr->expr2, TRUE, psOptions)) return FALSE; osFilter += "</"; osFilter += pszName; osFilter += ">"; break; } default: return FALSE; } return TRUE; }
/* * Init() */ bool OGRNGWDataset::Init(int nOpenFlagsIn) { // NOTE: Skip check API version at that moment. We expected API v3. // Get resource details. CPLJSONDocument oResourceDetailsReq; char **papszHTTPOptions = GetHeaders(); bool bResult = oResourceDetailsReq.LoadUrl( NGWAPI::GetResource( osUrl, osResourceId ), papszHTTPOptions ); CPLDebug("NGW", "Get resource %s details %s", osResourceId.c_str(), bResult ? "success" : "failed"); if( bResult ) { CPLJSONObject oRoot = oResourceDetailsReq.GetRoot(); if( oRoot.IsValid() ) { std::string osResourceType = oRoot.GetString("resource/cls"); FillMetadata( oRoot ); if( osResourceType == "resource_group" ) { // Check feature paging. FillCapabilities( papszHTTPOptions ); if( oRoot.GetBool( "resource/children", false ) ) { // Get child resources. bResult = FillResources( papszHTTPOptions, nOpenFlagsIn ); } } else if( (osResourceType == "vector_layer" || osResourceType == "postgis_layer") ) { // Cehck feature paging. FillCapabilities( papszHTTPOptions ); // Add vector layer. AddLayer( oRoot, papszHTTPOptions, nOpenFlagsIn ); } else if( osResourceType == "mapserver_style" || osResourceType == "qgis_vector_style" || osResourceType == "raster_style" || osResourceType == "wmsclient_layer" ) { // GetExtent from parent. OGREnvelope stExtent; std::string osParentId = oRoot.GetString("resource/parent/id"); bool bExtentResult = NGWAPI::GetExtent(osUrl, osParentId, papszHTTPOptions, 3857, stExtent); if( !bExtentResult ) { // Set full extent for EPSG:3857. stExtent.MinX = -20037508.34; stExtent.MaxX = 20037508.34; stExtent.MinY = -20037508.34; stExtent.MaxY = 20037508.34; } CPLDebug("NGW", "Raster extent is: %f, %f, %f, %f", stExtent.MinX, stExtent.MinY, stExtent.MaxX, stExtent.MaxY); int nEPSG = 3857; // Get parent details. We can skip this as default SRS in NGW is 3857. if( osResourceType == "wmsclient_layer" ) { nEPSG = oRoot.GetInteger("wmsclient_layer/srs/id", nEPSG); } else { CPLJSONDocument oResourceReq; bResult = oResourceReq.LoadUrl( NGWAPI::GetResource( osUrl, osResourceId ), papszHTTPOptions ); if( bResult ) { CPLJSONObject oParentRoot = oResourceReq.GetRoot(); if( osResourceType == "mapserver_style" || osResourceType == "qgis_vector_style" ) { nEPSG = oParentRoot.GetInteger("vector_layer/srs/id", nEPSG); } else if( osResourceType == "raster_style") { nEPSG = oParentRoot.GetInteger("raster_layer/srs/id", nEPSG); } } } // Create raster dataset. std::string osRasterUrl = NGWAPI::GetTMS(osUrl, osResourceId); char* pszRasterUrl = CPLEscapeString(osRasterUrl.c_str(), -1, CPLES_XML); const char *pszConnStr = CPLSPrintf("<GDAL_WMS><Service name=\"TMS\">" "<ServerUrl>%s</ServerUrl></Service><DataWindow>" "<UpperLeftX>-20037508.34</UpperLeftX><UpperLeftY>20037508.34</UpperLeftY>" "<LowerRightX>20037508.34</LowerRightX><LowerRightY>-20037508.34</LowerRightY>" "<TileLevel>%d</TileLevel><TileCountX>1</TileCountX>" "<TileCountY>1</TileCountY><YOrigin>top</YOrigin></DataWindow>" "<Projection>EPSG:%d</Projection><BlockSizeX>256</BlockSizeX>" "<BlockSizeY>256</BlockSizeY><BandsCount>%d</BandsCount>" "<Cache><Type>file</Type><Expires>%d</Expires><MaxSize>%d</MaxSize>" "</Cache><ZeroBlockHttpCodes>204,404</ZeroBlockHttpCodes></GDAL_WMS>", pszRasterUrl, 22, // NOTE: We have no limit in zoom levels. nEPSG, // NOTE: Default SRS is EPSG:3857. 4, nCacheExpires, nCacheMaxSize); CPLFree( pszRasterUrl ); poRasterDS = reinterpret_cast<GDALDataset*>(GDALOpenEx(pszConnStr, GDAL_OF_READONLY | GDAL_OF_RASTER | GDAL_OF_INTERNAL, nullptr, nullptr, nullptr)); if( poRasterDS ) { bResult = true; nRasterXSize = poRasterDS->GetRasterXSize(); nRasterYSize = poRasterDS->GetRasterYSize(); for( int iBand = 1; iBand <= poRasterDS->GetRasterCount(); iBand++ ) { SetBand( iBand, new NGWWrapperRasterBand( poRasterDS->GetRasterBand( iBand )) ); } // Set pixel limits. bool bHasTransform = false; double geoTransform[6] = { 0.0 }; double invGeoTransform[6] = { 0.0 }; if(poRasterDS->GetGeoTransform(geoTransform) == CE_None) { bHasTransform = GDALInvGeoTransform(geoTransform, invGeoTransform) == TRUE; } if(bHasTransform) { GDALApplyGeoTransform(invGeoTransform, stExtent.MinX, stExtent.MinY, &stPixelExtent.MinX, &stPixelExtent.MaxY); GDALApplyGeoTransform(invGeoTransform, stExtent.MaxX, stExtent.MaxY, &stPixelExtent.MaxX, &stPixelExtent.MinY); CPLDebug("NGW", "Raster extent in px is: %f, %f, %f, %f", stPixelExtent.MinX, stPixelExtent.MinY, stPixelExtent.MaxX, stPixelExtent.MaxY); } else { stPixelExtent.MinX = 0.0; stPixelExtent.MinY = 0.0; stPixelExtent.MaxX = std::numeric_limits<double>::max(); stPixelExtent.MaxY = std::numeric_limits<double>::max(); } } else { bResult = false; } } else if( osResourceType == "raster_layer" ) //FIXME: Do we need this check? && nOpenFlagsIn & GDAL_OF_RASTER ) { AddRaster( oRoot, papszHTTPOptions ); } else { bResult = false; } // TODO: Add support for baselayers, webmap, wfsserver_service, wmsserver_service. } } CSLDestroy( papszHTTPOptions ); return bResult; }
json_object* OGRAmigoCloudDataSource::RunSQL(const char* pszUnescapedSQL) { CPLString osSQL; osSQL = "/users/0/projects/" + CPLString(pszProjectId) + "/sql"; /* -------------------------------------------------------------------- */ /* Provide the API Key */ /* -------------------------------------------------------------------- */ if( !osAPIKey.empty() ) { osSQL += "?token=" + osAPIKey; } osSQL += "&query="; char * pszEscaped = CPLEscapeString( pszUnescapedSQL, -1, CPLES_URL ); std::string escaped = pszEscaped; CPLFree( pszEscaped ); osSQL += escaped; /* -------------------------------------------------------------------- */ /* Collection the header options and execute request. */ /* -------------------------------------------------------------------- */ std::string pszAPIURL = GetAPIURL(); char** papszOptions = nullptr; papszOptions = CSLAddString(papszOptions, GetUserAgentOption().c_str()); pszAPIURL += osSQL; CPLHTTPResult * psResult = CPLHTTPFetch( pszAPIURL.c_str(), papszOptions); CSLDestroy(papszOptions); if( psResult == nullptr ) return nullptr; /* -------------------------------------------------------------------- */ /* Check for some error conditions and report. HTML Messages */ /* are transformed info failure. */ /* -------------------------------------------------------------------- */ if (psResult->pszContentType && strncmp(psResult->pszContentType, "text/html", 9) == 0) { CPLDebug( "AMIGOCLOUD", "RunSQL HTML Response:%s", psResult->pabyData ); CPLError(CE_Failure, CPLE_AppDefined, "HTML error page returned by server"); CPLHTTPDestroyResult(psResult); return nullptr; } if (psResult->pszErrBuf != nullptr && psResult->pabyData != nullptr ) { CPLError( CE_Failure, CPLE_AppDefined, "GET Response: %s", psResult->pabyData ); } else if (psResult->nStatus != 0) { CPLDebug( "AMIGOCLOUD", "RunGET Error Status:%d", psResult->nStatus ); } if( psResult->pabyData == nullptr ) { CPLHTTPDestroyResult(psResult); return nullptr; } CPLDebug( "AMIGOCLOUD", "RunSQL Response:%s", psResult->pabyData ); json_object* poObj = nullptr; const char* pszText = reinterpret_cast<const char*>(psResult->pabyData); if( !OGRJSonParse(pszText, &poObj, true) ) { CPLHTTPDestroyResult(psResult); return nullptr; } CPLHTTPDestroyResult(psResult); if( poObj != nullptr ) { if( json_object_get_type(poObj) == json_type_object ) { json_object* poError = CPL_json_object_object_get(poObj, "error"); if( poError != nullptr && json_object_get_type(poError) == json_type_array && json_object_array_length(poError) > 0 ) { poError = json_object_array_get_idx(poError, 0); if( poError != nullptr && json_object_get_type(poError) == json_type_string ) { CPLError(CE_Failure, CPLE_AppDefined, "Error returned by server : %s", json_object_get_string(poError)); json_object_put(poObj); return nullptr; } } } else { json_object_put(poObj); return nullptr; } } return poObj; }
OGRLayer *OGRCouchDBDataSource::ICreateLayer( const char *pszNameIn, OGRSpatialReference *poSpatialRef, OGRwkbGeometryType eGType, char ** papszOptions ) { if( !bReadWrite ) { CPLError(CE_Failure, CPLE_AppDefined, "Operation not available in read-only mode"); return NULL; } /* -------------------------------------------------------------------- */ /* Do we already have this layer? If so, should we blow it */ /* away? */ /* -------------------------------------------------------------------- */ for( int iLayer = 0; iLayer < nLayers; iLayer++ ) { if( EQUAL(pszNameIn,papoLayers[iLayer]->GetName()) ) { if( CSLFetchNameValue( papszOptions, "OVERWRITE" ) != NULL && !EQUAL(CSLFetchNameValue(papszOptions,"OVERWRITE"),"NO") ) { DeleteLayer( pszNameIn ); break; } else { CPLError( CE_Failure, CPLE_AppDefined, "Layer %s already exists, CreateLayer failed.\n" "Use the layer creation option OVERWRITE=YES to " "replace it.", pszNameIn ); return NULL; } } } char* pszEscapedName = CPLEscapeString(pszNameIn, -1, CPLES_URL); CPLString osEscapedName = pszEscapedName; CPLFree(pszEscapedName); /* -------------------------------------------------------------------- */ /* Create "database" */ /* -------------------------------------------------------------------- */ CPLString osURI; osURI = "/"; osURI += osEscapedName; json_object* poAnswerObj = PUT(osURI, NULL); if (poAnswerObj == NULL) return NULL; if( !IsOK(poAnswerObj, "Layer creation failed") ) { json_object_put(poAnswerObj); return NULL; } json_object_put(poAnswerObj); /* -------------------------------------------------------------------- */ /* Create "spatial index" */ /* -------------------------------------------------------------------- */ int nUpdateSeq = 0; if (eGType != wkbNone) { osURI = "/"; osURI += osEscapedName; osURI += "/_design/ogr_spatial"; CPLString osContent("{ \"spatial\": { \"spatial\" : \"function(doc) { if (doc.geometry && doc.geometry.coordinates && doc.geometry.coordinates.length != 0) { emit(doc.geometry, null); } } \" } }"); poAnswerObj = PUT(osURI, osContent); if( IsOK(poAnswerObj, "Spatial index creation failed") ) nUpdateSeq ++; json_object_put(poAnswerObj); } /* -------------------------------------------------------------------- */ /* Create validation function */ /* -------------------------------------------------------------------- */ const char* pszUpdatePermissions = CSLFetchNameValueDef(papszOptions, "UPDATE_PERMISSIONS", "LOGGED_USER"); CPLString osValidation; if (EQUAL(pszUpdatePermissions, "LOGGED_USER")) { osValidation = "{\"validate_doc_update\": \"function(new_doc, old_doc, userCtx) { if(!userCtx.name) { throw({forbidden: \\\"Please log in first.\\\"}); } }\" }"; } else if (EQUAL(pszUpdatePermissions, "ALL")) { osValidation = "{\"validate_doc_update\": \"function(new_doc, old_doc, userCtx) { }\" }"; } else if (EQUAL(pszUpdatePermissions, "ADMIN")) { osValidation = "{\"validate_doc_update\": \"function(new_doc, old_doc, userCtx) {if (userCtx.roles.indexOf('_admin') === -1) { throw({forbidden: \\\"No changes allowed except by admin.\\\"}); } }\" }"; } else if (STARTS_WITH(pszUpdatePermissions, "function(")) { osValidation = "{\"validate_doc_update\": \""; osValidation += pszUpdatePermissions; osValidation += "\"}"; } if (!osValidation.empty() ) { osURI = "/"; osURI += osEscapedName; osURI += "/_design/ogr_validation"; poAnswerObj = PUT(osURI, osValidation); if( IsOK(poAnswerObj, "Validation function creation failed") ) nUpdateSeq ++; json_object_put(poAnswerObj); } const bool bGeoJSONDocument = CPLTestBool(CSLFetchNameValueDef(papszOptions, "GEOJSON", "TRUE")); int nCoordPrecision = atoi(CSLFetchNameValueDef(papszOptions, "COORDINATE_PRECISION", "-1")); OGRCouchDBTableLayer* poLayer = new OGRCouchDBTableLayer(this, pszNameIn); if (nCoordPrecision != -1) poLayer->SetCoordinatePrecision(nCoordPrecision); poLayer->SetInfoAfterCreation(eGType, poSpatialRef, nUpdateSeq, bGeoJSONDocument); papoLayers = (OGRLayer**) CPLRealloc(papoLayers, (nLayers + 1) * sizeof(OGRLayer*)); papoLayers[nLayers ++] = poLayer; return poLayer; }
const char *VRTSourcedRasterBand::GetMetadataItem( const char * pszName, const char * pszDomain ) { /* ==================================================================== */ /* LocationInfo handling. */ /* ==================================================================== */ if( pszDomain != NULL && EQUAL(pszDomain,"LocationInfo") && (EQUALN(pszName,"Pixel_",6) || EQUALN(pszName,"GeoPixel_",9)) ) { int iPixel, iLine; /* -------------------------------------------------------------------- */ /* What pixel are we aiming at? */ /* -------------------------------------------------------------------- */ if( EQUALN(pszName,"Pixel_",6) ) { if( sscanf( pszName+6, "%d_%d", &iPixel, &iLine ) != 2 ) return NULL; } else if( EQUALN(pszName,"GeoPixel_",9) ) { double adfGeoTransform[6]; double adfInvGeoTransform[6]; double dfGeoX, dfGeoY; if( sscanf( pszName+9, "%lf_%lf", &dfGeoX, &dfGeoY ) != 2 ) return NULL; if( GetDataset() == NULL ) return NULL; if( GetDataset()->GetGeoTransform( adfGeoTransform ) != CE_None ) return NULL; if( !GDALInvGeoTransform( adfGeoTransform, adfInvGeoTransform ) ) return NULL; iPixel = (int) floor( adfInvGeoTransform[0] + adfInvGeoTransform[1] * dfGeoX + adfInvGeoTransform[2] * dfGeoY ); iLine = (int) floor( adfInvGeoTransform[3] + adfInvGeoTransform[4] * dfGeoX + adfInvGeoTransform[5] * dfGeoY ); } else return NULL; if( iPixel < 0 || iLine < 0 || iPixel >= GetXSize() || iLine >= GetYSize() ) return NULL; /* -------------------------------------------------------------------- */ /* Find the file(s) at this location. */ /* -------------------------------------------------------------------- */ char **papszFileList = NULL; int nListMaxSize = 0, nListSize = 0; CPLHashSet* hSetFiles = CPLHashSetNew(CPLHashSetHashStr, CPLHashSetEqualStr, NULL); for( int iSource = 0; iSource < nSources; iSource++ ) { int nReqXOff, nReqYOff, nReqXSize, nReqYSize; int nOutXOff, nOutYOff, nOutXSize, nOutYSize; if (!papoSources[iSource]->IsSimpleSource()) continue; VRTSimpleSource *poSrc = (VRTSimpleSource *) papoSources[iSource]; if( !poSrc->GetSrcDstWindow( iPixel, iLine, 1, 1, 1, 1, &nReqXOff, &nReqYOff, &nReqXSize, &nReqYSize, &nOutXOff, &nOutYOff, &nOutXSize, &nOutYSize ) ) continue; poSrc->GetFileList( &papszFileList, &nListSize, &nListMaxSize, hSetFiles ); } /* -------------------------------------------------------------------- */ /* Format into XML. */ /* -------------------------------------------------------------------- */ int i; osLastLocationInfo = "<LocationInfo>"; for( i = 0; i < nListSize; i++ ) { osLastLocationInfo += "<File>"; char* pszXMLEscaped = CPLEscapeString(papszFileList[i], -1, CPLES_XML); osLastLocationInfo += pszXMLEscaped; CPLFree(pszXMLEscaped); osLastLocationInfo += "</File>"; } osLastLocationInfo += "</LocationInfo>"; CSLDestroy( papszFileList ); CPLHashSetDestroy( hSetFiles ); return osLastLocationInfo.c_str(); } /* ==================================================================== */ /* Other domains. */ /* ==================================================================== */ else return GDALRasterBand::GetMetadataItem( pszName, pszDomain ); }
OGRFeatureDefn *OGRMySQLTableLayer::ReadTableDefinition( const char *pszTable ) { MYSQL_RES *hResult; CPLString osCommand; /* -------------------------------------------------------------------- */ /* Fire off commands to get back the schema of the table. */ /* -------------------------------------------------------------------- */ osCommand.Printf("DESCRIBE `%s`", pszTable ); pszGeomColumnTable = CPLStrdup(pszTable); if( mysql_query( poDS->GetConn(), osCommand ) ) { poDS->ReportError( "DESCRIBE Failed" ); return NULL; } hResult = mysql_store_result( poDS->GetConn() ); if( hResult == NULL ) { poDS->ReportError( "mysql_store_result() failed on DESCRIBE result." ); return NULL; } /* -------------------------------------------------------------------- */ /* Parse the returned table information. */ /* -------------------------------------------------------------------- */ OGRFeatureDefn *poDefn = new OGRFeatureDefn( pszTable ); char **papszRow; OGRwkbGeometryType eForcedGeomType = wkbUnknown; int bGeomColumnNotNullable = FALSE; poDefn->Reference(); while( (papszRow = mysql_fetch_row( hResult )) != NULL ) { const char *pszType; OGRFieldDefn oField( papszRow[0], OFTString); int nLenType; pszType = papszRow[1]; if( pszType == NULL ) continue; nLenType = (int)strlen(pszType); if( EQUAL(pszType,"varbinary") || (nLenType>=4 && EQUAL(pszType+nLenType-4,"blob"))) { oField.SetType( OFTBinary ); } else if( EQUAL(pszType,"varchar") || (nLenType>=4 && EQUAL(pszType+nLenType-4,"enum")) || (nLenType>=3 && EQUAL(pszType+nLenType-3,"set")) ) { oField.SetType( OFTString ); } else if( STARTS_WITH_CI(pszType, "char") ) { oField.SetType( OFTString ); char ** papszTokens; papszTokens = CSLTokenizeString2(pszType,"(),",0); if (CSLCount(papszTokens) >= 2) { /* width is the second */ oField.SetWidth(atoi(papszTokens[1])); } CSLDestroy( papszTokens ); oField.SetType( OFTString ); } if(nLenType>=4 && EQUAL(pszType+nLenType-4,"text")) { oField.SetType( OFTString ); } else if( STARTS_WITH_CI(pszType,"varchar") ) { /* pszType is usually in the form "varchar(15)" so we'll split it up and get the width and precision */ oField.SetType( OFTString ); char ** papszTokens; papszTokens = CSLTokenizeString2(pszType,"(),",0); if (CSLCount(papszTokens) >= 2) { /* width is the second */ oField.SetWidth(atoi(papszTokens[1])); } CSLDestroy( papszTokens ); oField.SetType( OFTString ); } else if( STARTS_WITH_CI(pszType, "int") ) { oField.SetType( OFTInteger ); } else if( STARTS_WITH_CI(pszType, "tinyint") ) { oField.SetType( OFTInteger ); } else if( STARTS_WITH_CI(pszType, "smallint") ) { oField.SetType( OFTInteger ); } else if( STARTS_WITH_CI(pszType, "mediumint") ) { oField.SetType( OFTInteger ); } else if( STARTS_WITH_CI(pszType, "bigint") ) { oField.SetType( OFTInteger64 ); } else if( STARTS_WITH_CI(pszType, "decimal") ) { /* pszType is usually in the form "decimal(15,2)" so we'll split it up and get the width and precision */ oField.SetType( OFTReal ); char ** papszTokens; papszTokens = CSLTokenizeString2(pszType,"(),",0); if (CSLCount(papszTokens) >= 3) { /* width is the second and precision is the third */ oField.SetWidth(atoi(papszTokens[1])); oField.SetPrecision(atoi(papszTokens[2])); } CSLDestroy( papszTokens ); } else if( STARTS_WITH_CI(pszType, "float") ) { oField.SetType( OFTReal ); } else if( EQUAL(pszType,"double") ) { oField.SetType( OFTReal ); } else if( STARTS_WITH_CI(pszType, "double") ) { // double can also be double(15,2) // so we'll handle this case here after // we check for just a regular double // without a width and precision specified char ** papszTokens=NULL; papszTokens = CSLTokenizeString2(pszType,"(),",0); if (CSLCount(papszTokens) >= 3) { /* width is the second and precision is the third */ oField.SetWidth(atoi(papszTokens[1])); oField.SetPrecision(atoi(papszTokens[2])); } CSLDestroy( papszTokens ); oField.SetType( OFTReal ); } else if( EQUAL(pszType,"decimal") ) { oField.SetType( OFTReal ); } else if( EQUAL(pszType, "date") ) { oField.SetType( OFTDate ); } else if( EQUAL(pszType, "time") ) { oField.SetType( OFTTime ); } else if( EQUAL(pszType, "datetime") || EQUAL(pszType, "timestamp") ) { oField.SetType( OFTDateTime ); } else if( EQUAL(pszType, "year") ) { oField.SetType( OFTString ); oField.SetWidth( 10 ); } else if( EQUAL(pszType, "geometry") || OGRFromOGCGeomType(pszType) != wkbUnknown) { if (pszGeomColumn == NULL) { pszGeomColumn = CPLStrdup(papszRow[0]); eForcedGeomType = OGRFromOGCGeomType(pszType); bGeomColumnNotNullable = ( papszRow[2] != NULL && EQUAL(papszRow[2], "NO") ); } else { CPLDebug("MYSQL", "Ignoring %s as geometry column. Another one(%s) has already been found before", papszRow[0], pszGeomColumn); } continue; } // Is this an integer primary key field? if( !bHasFid && papszRow[3] != NULL && EQUAL(papszRow[3],"PRI") && (oField.GetType() == OFTInteger || oField.GetType() == OFTInteger64) ) { bHasFid = TRUE; pszFIDColumn = CPLStrdup(oField.GetNameRef()); if( oField.GetType() == OFTInteger64 ) SetMetadataItem(OLMD_FID64, "YES"); continue; } // Is not nullable ? if( papszRow[2] != NULL && EQUAL(papszRow[2], "NO") ) oField.SetNullable(FALSE); // Has default ? const char* pszDefault = papszRow[4]; if( pszDefault != NULL ) { if( !EQUAL(pszDefault, "NULL") && !STARTS_WITH_CI(pszDefault, "CURRENT_") && pszDefault[0] != '(' && pszDefault[0] != '\'' && CPLGetValueType(pszDefault) == CPL_VALUE_STRING ) { int nYear, nMonth, nDay, nHour, nMinute; float fSecond; if( oField.GetType() == OFTDateTime && sscanf(pszDefault, "%d-%d-%d %d:%d:%f", &nYear, &nMonth, &nDay, &nHour, &nMinute, &fSecond) == 6 ) { oField.SetDefault(CPLSPrintf("'%04d/%02d/%02d %02d:%02d:%02d'", nYear, nMonth, nDay, nHour, nMinute, (int)(fSecond+0.5))); } else { CPLString osDefault("'"); char* pszTmp = CPLEscapeString(pszDefault, -1, CPLES_SQL); osDefault += pszTmp; CPLFree(pszTmp); osDefault += "'"; oField.SetDefault(osDefault); } } else { oField.SetDefault(pszDefault); } } poDefn->AddFieldDefn( &oField ); } // set to none for now... if we have a geometry column it will be set layer. poDefn->SetGeomType( wkbNone ); if( hResult != NULL ) { mysql_free_result( hResult ); hResultSet = NULL; } if( bHasFid ) CPLDebug( "MySQL", "table %s has FID column %s.", pszTable, pszFIDColumn ); else CPLDebug( "MySQL", "table %s has no FID column, FIDs will not be reliable!", pszTable ); if (pszGeomColumn) { char* pszType=NULL; // set to unknown first poDefn->SetGeomType( wkbUnknown ); osCommand = "SELECT type, coord_dimension FROM geometry_columns WHERE f_table_name='"; osCommand += pszTable; osCommand += "'"; hResult = NULL; if( !mysql_query( poDS->GetConn(), osCommand ) ) hResult = mysql_store_result( poDS->GetConn() ); papszRow = NULL; if( hResult != NULL ) papszRow = mysql_fetch_row( hResult ); if( papszRow != NULL && papszRow[0] != NULL ) { pszType = papszRow[0]; OGRwkbGeometryType l_nGeomType = OGRFromOGCGeomType(pszType); if( papszRow[1] != NULL && atoi(papszRow[1]) == 3 ) l_nGeomType = wkbSetZ(l_nGeomType); poDefn->SetGeomType( l_nGeomType ); } else if (eForcedGeomType != wkbUnknown) poDefn->SetGeomType(eForcedGeomType); if( bGeomColumnNotNullable ) poDefn->GetGeomFieldDefn(0)->SetNullable(FALSE); if( hResult != NULL ) mysql_free_result( hResult ); //Free our query results for finding type. hResult = NULL; } // Fetch the SRID for this table now nSRSId = FetchSRSId(); return poDefn; }
OGRLayer* OGRCouchDBDataSource::OpenDatabase(const char* pszLayerName) { CPLString osTableName; CPLString osEscapedName; if (pszLayerName) { osTableName = pszLayerName; char* pszEscapedName = CPLEscapeString(pszLayerName, -1, CPLES_URL); osEscapedName = pszEscapedName; CPLFree(pszEscapedName); } else { char* pszURL = CPLStrdup(osURL); char* pszLastSlash = strrchr(pszURL, '/'); if (pszLastSlash) { osEscapedName = pszLastSlash + 1; char* l_pszName = CPLUnescapeString(osEscapedName, NULL, CPLES_URL); osTableName = l_pszName; CPLFree(l_pszName); *pszLastSlash = 0; } osURL = pszURL; CPLFree(pszURL); pszURL = NULL; if (pszLastSlash == NULL) return NULL; } CPLString osURI("/"); osURI += osEscapedName; json_object* poAnswerObj = GET(osURI); if (poAnswerObj == NULL) return NULL; if ( !json_object_is_type(poAnswerObj, json_type_object) || CPL_json_object_object_get(poAnswerObj, "db_name") == NULL ) { IsError(poAnswerObj, "Database opening failed"); json_object_put(poAnswerObj); return NULL; } OGRCouchDBTableLayer* poLayer = new OGRCouchDBTableLayer(this, osTableName); if ( CPL_json_object_object_get(poAnswerObj, "update_seq") != NULL ) { int nUpdateSeq = json_object_get_int(CPL_json_object_object_get(poAnswerObj, "update_seq")); poLayer->SetUpdateSeq(nUpdateSeq); } json_object_put(poAnswerObj); papoLayers = (OGRLayer**) CPLRealloc(papoLayers, (nLayers + 1) * sizeof(OGRLayer*)); papoLayers[nLayers ++] = poLayer; return poLayer; }
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( !bHasFieldNames ) { bHasFieldNames = TRUE; bNeedSeekEnd = FALSE; for(int iFile=0;iFile<((bCreateCSVT) ? 2 : 1);iFile++) { VSILFILE* fpCSVT = NULL; if (bCreateCSVT && iFile == 0) { char* pszDirName = CPLStrdup(CPLGetDirname(pszFilename)); char* pszBaseName = CPLStrdup(CPLGetBasename(pszFilename)); fpCSVT = VSIFOpenL(CPLFormFilename(pszDirName, pszBaseName, ".csvt"), "wb"); CPLFree(pszDirName); CPLFree(pszBaseName); } else { if( strncmp(pszFilename, "/vsistdout/", 11) == 0 || strncmp(pszFilename, "/vsizip/", 8) == 0 ) fpCSV = VSIFOpenL( pszFilename, "wb" ); else fpCSV = VSIFOpenL( pszFilename, "w+b" ); if( fpCSV == NULL ) { CPLError( CE_Failure, CPLE_OpenFailed, "Failed to create %s:\n%s", pszFilename, VSIStrerror( errno ) ); return NULL; } } if (eGeometryFormat == OGR_CSV_GEOM_AS_WKT) { if (fpCSV) VSIFPrintfL( fpCSV, "%s", "WKT"); if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", "String"); if (poFeatureDefn->GetFieldCount() > 0) { if (fpCSV) VSIFPrintfL( fpCSV, "%c", chDelimiter ); if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", ","); } } else if (eGeometryFormat == OGR_CSV_GEOM_AS_XYZ) { if (fpCSV) VSIFPrintfL( fpCSV, "X%cY%cZ", chDelimiter, chDelimiter); if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", "Real,Real,Real"); if (poFeatureDefn->GetFieldCount() > 0) { if (fpCSV) VSIFPrintfL( fpCSV, "%c", chDelimiter ); if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", ","); } } else if (eGeometryFormat == OGR_CSV_GEOM_AS_XY) { if (fpCSV) VSIFPrintfL( fpCSV, "X%cY", chDelimiter); if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", "Real,Real"); if (poFeatureDefn->GetFieldCount() > 0) { if (fpCSV) VSIFPrintfL( fpCSV, "%c", chDelimiter ); if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", ","); } } else if (eGeometryFormat == OGR_CSV_GEOM_AS_YX) { if (fpCSV) VSIFPrintfL( fpCSV, "Y%cX", chDelimiter); if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", "Real,Real"); if (poFeatureDefn->GetFieldCount() > 0) { if (fpCSV) VSIFPrintfL( fpCSV, "%c", chDelimiter ); if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", ","); } } for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ ) { char *pszEscaped; if( iField > 0 ) { if (fpCSV) VSIFPrintfL( fpCSV, "%c", chDelimiter ); if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", ","); } pszEscaped = CPLEscapeString( poFeatureDefn->GetFieldDefn(iField)->GetNameRef(), -1, CPLES_CSV ); if (fpCSV) VSIFPrintfL( fpCSV, "%s", pszEscaped ); CPLFree( pszEscaped ); if (fpCSVT) { switch( poFeatureDefn->GetFieldDefn(iField)->GetType() ) { case OFTInteger: VSIFPrintfL( fpCSVT, "%s", "Integer"); break; case OFTReal: VSIFPrintfL( fpCSVT, "%s", "Real"); break; case OFTDate: VSIFPrintfL( fpCSVT, "%s", "Date"); break; case OFTTime: VSIFPrintfL( fpCSVT, "%s", "Time"); break; case OFTDateTime: VSIFPrintfL( fpCSVT, "%s", "DateTime"); break; default: VSIFPrintfL( fpCSVT, "%s", "String"); break; } int nWidth = poFeatureDefn->GetFieldDefn(iField)->GetWidth(); int nPrecision = poFeatureDefn->GetFieldDefn(iField)->GetPrecision(); if (nWidth != 0) { if (nPrecision != 0) VSIFPrintfL( fpCSVT, "(%d.%d)", nWidth, nPrecision); else VSIFPrintfL( fpCSVT, "(%d)", nWidth); } } } if( bUseCRLF ) { if (fpCSV) VSIFPutcL( 13, fpCSV ); if (fpCSVT) VSIFPutcL( 13, fpCSVT ); } if (fpCSV) VSIFPutcL( '\n', fpCSV ); if (fpCSVT) VSIFPutcL( '\n', fpCSVT ); if (fpCSVT) VSIFCloseL(fpCSVT); } } 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. */ /* -------------------------------------------------------------------- */ for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ ) { char *pszEscaped; if( iField > 0 ) VSIFPrintfL( fpCSV, "%c", chDelimiter ); pszEscaped = CPLEscapeString( poNewFeature->GetFieldAsString(iField), -1, CPLES_CSV ); if (poFeatureDefn->GetFieldDefn(iField)->GetType() == OFTReal) { /* Use point as decimal separator */ char* pszComma = strchr(pszEscaped, ','); if (pszComma) *pszComma = '.'; } VSIFWriteL( pszEscaped, 1, strlen(pszEscaped), fpCSV ); CPLFree( pszEscaped ); } if( bUseCRLF ) VSIFPutcL( 13, fpCSV ); VSIFPutcL( '\n', fpCSV ); return OGRERR_NONE; }
int main( int nArgc, char ** papszArgv ) { NITFFile *psFile; int iSegment, iFile; char szTemp[100]; int bDisplayTRE = FALSE; int bExtractSHP = FALSE, bExtractSHPInMem = FALSE; if( nArgc < 2 ) { printf( "Usage: nitfdump [-tre] [-extractshp | -extractshpinmem] <nitf_filename>*\n" ); exit( 1 ); } for( iFile = 1; iFile < nArgc; iFile++ ) { if ( EQUAL(papszArgv[iFile], "-tre") ) bDisplayTRE = TRUE; else if ( EQUAL(papszArgv[iFile], "-extractshp") ) bExtractSHP = TRUE; else if ( EQUAL(papszArgv[iFile], "-extractshpinmem") ) { bExtractSHP = TRUE; bExtractSHPInMem = TRUE; } } /* ==================================================================== */ /* Loop over all files. */ /* ==================================================================== */ for( iFile = 1; iFile < nArgc; iFile++ ) { int bHasFoundLocationTable = FALSE; if ( EQUAL(papszArgv[iFile], "-tre") ) continue; if ( EQUAL(papszArgv[iFile], "-extractshp") ) continue; if ( EQUAL(papszArgv[iFile], "-extractshpinmem") ) continue; /* -------------------------------------------------------------------- */ /* Open the file. */ /* -------------------------------------------------------------------- */ psFile = NITFOpen( papszArgv[iFile], FALSE ); if( psFile == NULL ) exit( 2 ); printf( "Dump for %s\n", papszArgv[iFile] ); /* -------------------------------------------------------------------- */ /* Dump first TRE list. */ /* -------------------------------------------------------------------- */ if( psFile->pachTRE != NULL ) { int nTREBytes = psFile->nTREBytes; const char *pszTREData = psFile->pachTRE; printf( "File TREs:" ); while( nTREBytes > 10 ) { int nThisTRESize = atoi(NITFGetField(szTemp, pszTREData, 6, 5 )); if (nThisTRESize < 0 || nThisTRESize > nTREBytes - 11) { NITFGetField(szTemp, pszTREData, 0, 6 ); printf(" Invalid size (%d) for TRE %s", nThisTRESize, szTemp); break; } printf( " %6.6s(%d)", pszTREData, nThisTRESize ); pszTREData += nThisTRESize + 11; nTREBytes -= (nThisTRESize + 11); } printf( "\n" ); if (bDisplayTRE) { nTREBytes = psFile->nTREBytes; pszTREData = psFile->pachTRE; while( nTREBytes > 10 ) { char *pszEscaped; int nThisTRESize = atoi(NITFGetField(szTemp, pszTREData, 6, 5 )); if (nThisTRESize < 0 || nThisTRESize > nTREBytes - 11) { break; } pszEscaped = CPLEscapeString( pszTREData + 11, nThisTRESize, CPLES_BackslashQuotable ); printf( "TRE '%6.6s' : %s\n", pszTREData, pszEscaped); CPLFree(pszEscaped); pszTREData += nThisTRESize + 11; nTREBytes -= (nThisTRESize + 11); } } } /* -------------------------------------------------------------------- */ /* Dump Metadata */ /* -------------------------------------------------------------------- */ DumpMetadata( "File Metadata:", " ", psFile->papszMetadata ); /* -------------------------------------------------------------------- */ /* Dump general info about segments. */ /* -------------------------------------------------------------------- */ NITFCollectAttachments( psFile ); NITFReconcileAttachments( psFile ); for( iSegment = 0; iSegment < psFile->nSegmentCount; iSegment++ ) { NITFSegmentInfo *psSegInfo = psFile->pasSegmentInfo + iSegment; printf( "Segment %d (Type=%s):\n", iSegment + 1, psSegInfo->szSegmentType ); printf( " HeaderStart=" CPL_FRMT_GUIB ", HeaderSize=%u, DataStart=" CPL_FRMT_GUIB ", DataSize=" CPL_FRMT_GUIB "\n", psSegInfo->nSegmentHeaderStart, psSegInfo->nSegmentHeaderSize, psSegInfo->nSegmentStart, psSegInfo->nSegmentSize ); printf( " DLVL=%d, ALVL=%d, LOC=C%d,R%d, CCS=C%d,R%d\n", psSegInfo->nDLVL, psSegInfo->nALVL, psSegInfo->nLOC_C, psSegInfo->nLOC_R, psSegInfo->nCCS_C, psSegInfo->nCCS_R ); printf( "\n" ); } /* -------------------------------------------------------------------- */ /* Report details of images. */ /* -------------------------------------------------------------------- */ for( iSegment = 0; iSegment < psFile->nSegmentCount; iSegment++ ) { NITFSegmentInfo *psSegInfo = psFile->pasSegmentInfo + iSegment; NITFImage *psImage; NITFRPC00BInfo sRPCInfo; int iBand; char **papszMD; if( !EQUAL(psSegInfo->szSegmentType,"IM") ) continue; psImage = NITFImageAccess( psFile, iSegment ); if( psImage == NULL ) { printf( "NITFAccessImage(%d) failed!\n", iSegment ); continue; } printf( "Image Segment %d, %dPx%dLx%dB x %dbits:\n", iSegment + 1, psImage->nCols, psImage->nRows, psImage->nBands, psImage->nBitsPerSample ); printf( " PVTYPE=%s, IREP=%s, ICAT=%s, IMODE=%c, IC=%s, COMRAT=%s, ICORDS=%c\n", psImage->szPVType, psImage->szIREP, psImage->szICAT, psImage->chIMODE, psImage->szIC, psImage->szCOMRAT, psImage->chICORDS ); if( psImage->chICORDS != ' ' ) { printf( " UL=(%.15g,%.15g), UR=(%.15g,%.15g) Center=%d\n LL=(%.15g,%.15g), LR=(%.15g,%.15g)\n", psImage->dfULX, psImage->dfULY, psImage->dfURX, psImage->dfURY, psImage->bIsBoxCenterOfPixel, psImage->dfLLX, psImage->dfLLY, psImage->dfLRX, psImage->dfLRY ); } printf( " IDLVL=%d, IALVL=%d, ILOC R=%d,C=%d, IMAG=%s\n", psImage->nIDLVL, psImage->nIALVL, psImage->nILOCRow, psImage->nILOCColumn, psImage->szIMAG ); printf( " %d x %d blocks of size %d x %d\n", psImage->nBlocksPerRow, psImage->nBlocksPerColumn, psImage->nBlockWidth, psImage->nBlockHeight ); if( psImage->pachTRE != NULL ) { int nTREBytes = psImage->nTREBytes; const char *pszTREData = psImage->pachTRE; printf( " Image TREs:" ); while( nTREBytes > 10 ) { int nThisTRESize = atoi(NITFGetField(szTemp, pszTREData, 6, 5 )); if (nThisTRESize < 0 || nThisTRESize > nTREBytes - 11) { NITFGetField(szTemp, pszTREData, 0, 6 ); printf(" Invalid size (%d) for TRE %s", nThisTRESize, szTemp); break; } printf( " %6.6s(%d)", pszTREData, nThisTRESize ); pszTREData += nThisTRESize + 11; nTREBytes -= (nThisTRESize + 11); } printf( "\n" ); if (bDisplayTRE) { nTREBytes = psImage->nTREBytes; pszTREData = psImage->pachTRE; while( nTREBytes > 10 ) { char *pszEscaped; int nThisTRESize = atoi(NITFGetField(szTemp, pszTREData, 6, 5 )); if (nThisTRESize < 0 || nThisTRESize > nTREBytes - 11) { break; } pszEscaped = CPLEscapeString( pszTREData + 11, nThisTRESize, CPLES_BackslashQuotable ); printf( " TRE '%6.6s' : %s\n", pszTREData, pszEscaped); CPLFree(pszEscaped); pszTREData += nThisTRESize + 11; nTREBytes -= (nThisTRESize + 11); } } } /* Report info from location table, if found. */ if( psImage->nLocCount > 0 ) { int i; bHasFoundLocationTable = TRUE; printf( " Location Table\n" ); for( i = 0; i < psImage->nLocCount; i++ ) { printf( " LocName=%s, LocId=%d, Offset=%d, Size=%d\n", GetLocationNameFromId(psImage->pasLocations[i].nLocId), psImage->pasLocations[i].nLocId, psImage->pasLocations[i].nLocOffset, psImage->pasLocations[i].nLocSize ); } printf( "\n" ); } if( strlen(psImage->pszComments) > 0 ) printf( " Comments:\n%s\n", psImage->pszComments ); for( iBand = 0; iBand < psImage->nBands; iBand++ ) { NITFBandInfo *psBandInfo = psImage->pasBandInfo + iBand; printf( " Band %d: IREPBAND=%s, ISUBCAT=%s, %d LUT entries.\n", iBand + 1, psBandInfo->szIREPBAND, psBandInfo->szISUBCAT, psBandInfo->nSignificantLUTEntries ); } if( NITFReadRPC00B( psImage, &sRPCInfo ) ) { DumpRPC( psImage, &sRPCInfo ); } papszMD = NITFReadUSE00A( psImage ); if( papszMD != NULL ) { DumpMetadata( " USE00A TRE:", " ", papszMD ); CSLDestroy( papszMD ); } papszMD = NITFReadBLOCKA( psImage ); if( papszMD != NULL ) { DumpMetadata( " BLOCKA TRE:", " ", papszMD ); CSLDestroy( papszMD ); } papszMD = NITFReadSTDIDC( psImage ); if( papszMD != NULL ) { DumpMetadata( " STDIDC TRE:", " ", papszMD ); CSLDestroy( papszMD ); } DumpMetadata( " Image Metadata:", " ", psImage->papszMetadata ); printf("\n"); } /* ==================================================================== */ /* Report details of graphic segments. */ /* ==================================================================== */ for( iSegment = 0; iSegment < psFile->nSegmentCount; iSegment++ ) { NITFSegmentInfo *psSegInfo = psFile->pasSegmentInfo + iSegment; char achSubheader[298]; int nSTYPEOffset; if( !EQUAL(psSegInfo->szSegmentType,"GR") && !EQUAL(psSegInfo->szSegmentType,"SY") ) continue; /* -------------------------------------------------------------------- */ /* Load the graphic subheader. */ /* -------------------------------------------------------------------- */ if( VSIFSeekL( psFile->fp, psSegInfo->nSegmentHeaderStart, SEEK_SET ) != 0 || VSIFReadL( achSubheader, 1, sizeof(achSubheader), psFile->fp ) < 258 ) { CPLError( CE_Warning, CPLE_FileIO, "Failed to read graphic subheader at " CPL_FRMT_GUIB ".", psSegInfo->nSegmentHeaderStart ); continue; } // NITF 2.0. (also works for NITF 2.1) nSTYPEOffset = 200; if( STARTS_WITH_CI(achSubheader+193, "999998") ) nSTYPEOffset += 40; /* -------------------------------------------------------------------- */ /* Report some standard info. */ /* -------------------------------------------------------------------- */ printf( "Graphic Segment %d, type=%2.2s, sfmt=%c, sid=%10.10s\n", iSegment + 1, achSubheader + 0, achSubheader[nSTYPEOffset], achSubheader + 2 ); printf( " sname=%20.20s\n", achSubheader + 12 ); printf("\n"); } /* ==================================================================== */ /* Report details of text segments. */ /* ==================================================================== */ for( iSegment = 0; iSegment < psFile->nSegmentCount; iSegment++ ) { char *pabyHeaderData; char *pabyTextData; NITFSegmentInfo *psSegment = psFile->pasSegmentInfo + iSegment; if( !EQUAL(psSegment->szSegmentType,"TX") ) continue; printf( "Text Segment %d\n", iSegment + 1); /* -------------------------------------------------------------------- */ /* Load the text header */ /* -------------------------------------------------------------------- */ /* Allocate one extra byte for the NULL terminating character */ pabyHeaderData = (char *) CPLCalloc(1, (size_t) psSegment->nSegmentHeaderSize + 1); if (VSIFSeekL(psFile->fp, psSegment->nSegmentHeaderStart, SEEK_SET) != 0 || VSIFReadL(pabyHeaderData, 1, (size_t) psSegment->nSegmentHeaderSize, psFile->fp) != psSegment->nSegmentHeaderSize) { CPLError( CE_Warning, CPLE_FileIO, "Failed to read %d bytes of text header data at " CPL_FRMT_GUIB ".", psSegment->nSegmentHeaderSize, psSegment->nSegmentHeaderStart); CPLFree(pabyHeaderData); continue; } printf(" Header : %s\n", pabyHeaderData); CPLFree(pabyHeaderData); /* -------------------------------------------------------------------- */ /* Load the raw TEXT data itself. */ /* -------------------------------------------------------------------- */ /* Allocate one extra byte for the NULL terminating character */ pabyTextData = (char *) CPLCalloc(1,(size_t)psSegment->nSegmentSize+1); if( VSIFSeekL( psFile->fp, psSegment->nSegmentStart, SEEK_SET ) != 0 || VSIFReadL( pabyTextData, 1, (size_t)psSegment->nSegmentSize, psFile->fp ) != psSegment->nSegmentSize ) { CPLError( CE_Warning, CPLE_FileIO, "Failed to read " CPL_FRMT_GUIB " bytes of text data at " CPL_FRMT_GUIB ".", psSegment->nSegmentSize, psSegment->nSegmentStart ); CPLFree( pabyTextData ); continue; } printf(" Data : %s\n", pabyTextData); printf("\n"); CPLFree( pabyTextData ); } /* -------------------------------------------------------------------- */ /* Report details of DES. */ /* -------------------------------------------------------------------- */ for( iSegment = 0; iSegment < psFile->nSegmentCount; iSegment++ ) { NITFSegmentInfo *psSegInfo = psFile->pasSegmentInfo + iSegment; NITFDES *psDES; int nOffset = 0; char szTREName[7]; int nThisTRESize; int nRPFDESOffset = -1; if( !EQUAL(psSegInfo->szSegmentType,"DE") ) continue; psDES = NITFDESAccess( psFile, iSegment ); if( psDES == NULL ) { printf( "NITFDESAccess(%d) failed!\n", iSegment ); continue; } printf( "DE Segment %d:\n", iSegment + 1 ); printf( " Segment TREs:" ); nOffset = 0; while (NITFDESGetTRE( psDES, nOffset, szTREName, NULL, &nThisTRESize)) { printf( " %6.6s(%d)", szTREName, nThisTRESize ); if (strcmp(szTREName, "RPFDES") == 0) nRPFDESOffset = nOffset + 11; nOffset += 11 + nThisTRESize; } printf( "\n" ); if (bDisplayTRE) { char* pabyTREData = NULL; nOffset = 0; while (NITFDESGetTRE( psDES, nOffset, szTREName, &pabyTREData, &nThisTRESize)) { char* pszEscaped = CPLEscapeString( pabyTREData, nThisTRESize, CPLES_BackslashQuotable ); printf( " TRE '%6.6s' : %s\n", szTREName, pszEscaped); CPLFree(pszEscaped); nOffset += 11 + nThisTRESize; NITFDESFreeTREData(pabyTREData); } } /* Report info from location table, if found. */ if( !bHasFoundLocationTable && nRPFDESOffset >= 0 ) { int i; int nLocCount = 0; NITFLocation* pasLocations; VSIFSeekL(psFile->fp, psSegInfo->nSegmentStart + nRPFDESOffset, SEEK_SET); pasLocations = NITFReadRPFLocationTable(psFile->fp, &nLocCount); if (pasLocations) { printf( " Location Table\n" ); for( i = 0; i < nLocCount; i++ ) { printf( " LocName=%s, LocId=%d, Offset=%d, Size=%d\n", GetLocationNameFromId(pasLocations[i].nLocId), pasLocations[i].nLocId, pasLocations[i].nLocOffset, pasLocations[i].nLocSize ); } CPLFree(pasLocations); printf( "\n" ); } } DumpMetadata( " DES Metadata:", " ", psDES->papszMetadata ); if ( bExtractSHP && CSLFetchNameValue(psDES->papszMetadata, "NITF_SHAPE_USE") != NULL ) { char szFilename[32]; char szRadix[32]; if (bExtractSHPInMem) snprintf(szRadix, sizeof(szRadix), "/vsimem/nitf_segment_%d", iSegment + 1); else snprintf(szRadix, sizeof(szRadix), "nitf_segment_%d", iSegment + 1); if (NITFDESExtractShapefile(psDES, szRadix)) { OGRDataSourceH hDS; OGRRegisterAll(); snprintf(szFilename, sizeof(szFilename), "%s.SHP", szRadix); hDS = OGROpen(szFilename, FALSE, NULL); if (hDS) { int nGeom = 0; OGRLayerH hLayer = OGR_DS_GetLayer(hDS, 0); if (hLayer) { OGRFeatureH hFeat; printf("\n"); while ( (hFeat = OGR_L_GetNextFeature(hLayer)) != NULL ) { OGRGeometryH hGeom = OGR_F_GetGeometryRef(hFeat); if (hGeom) { char* pszWKT = NULL; OGR_G_ExportToWkt(hGeom, &pszWKT); if (pszWKT) printf(" Geometry %d : %s\n", nGeom ++, pszWKT); CPLFree(pszWKT); } OGR_F_Destroy(hFeat); } } OGR_DS_Destroy(hDS); } } if (bExtractSHPInMem) { snprintf(szFilename, sizeof(szFilename), "%s.SHP", szRadix); VSIUnlink(szFilename); snprintf(szFilename, sizeof(szFilename), "%s.SHX", szRadix); VSIUnlink(szFilename); snprintf(szFilename, sizeof(szFilename), "%s.DBF", szRadix); VSIUnlink(szFilename); } } } /* -------------------------------------------------------------------- */ /* Close. */ /* -------------------------------------------------------------------- */ NITFClose( psFile ); } CPLFinderClean(); CPLCleanupTLS(); VSICleanupFileManager(); OGRCleanupAll(); exit( 0 ); }
GDALDataset *GDALWMSDataset::Open(GDALOpenInfo *poOpenInfo) { CPLXMLNode *config = NULL; CPLErr ret = CE_None; const char* pszFilename = poOpenInfo->pszFilename; const char* pabyHeader = (const char *) poOpenInfo->pabyHeader; if (poOpenInfo->nHeaderBytes == 0 && EQUALN(pszFilename, "<GDAL_WMS>", 10)) { config = CPLParseXMLString(pszFilename); } else if (poOpenInfo->nHeaderBytes >= 10 && EQUALN(pabyHeader, "<GDAL_WMS>", 10)) { config = CPLParseXMLFile(pszFilename); } else if (poOpenInfo->nHeaderBytes == 0 && (EQUALN(pszFilename, "WMS:http", 8) || EQUALN(pszFilename, "http", 4)) && strstr(pszFilename, "/MapServer?f=json") != NULL) { if (EQUALN(pszFilename, "WMS:http", 8)) pszFilename += 4; CPLString osURL(pszFilename); if (strstr(pszFilename, "&pretty=true") == NULL) osURL += "&pretty=true"; CPLHTTPResult *psResult = CPLHTTPFetch(osURL.c_str(), NULL); if (psResult == NULL) return NULL; if (psResult->pabyData == NULL) { CPLHTTPDestroyResult(psResult); return NULL; } config = GDALWMSDatasetGetConfigFromArcGISJSON(osURL, (const char*)psResult->pabyData); CPLHTTPDestroyResult(psResult); } else if (poOpenInfo->nHeaderBytes == 0 && (EQUALN(pszFilename, "WMS:", 4) || CPLString(pszFilename).ifind("SERVICE=WMS") != std::string::npos)) { CPLString osLayers = CPLURLGetValue(pszFilename, "LAYERS"); CPLString osRequest = CPLURLGetValue(pszFilename, "REQUEST"); if (osLayers.size() != 0) config = GDALWMSDatasetGetConfigFromURL(poOpenInfo); else if (EQUAL(osRequest, "GetTileService")) return GDALWMSMetaDataset::DownloadGetTileService(poOpenInfo); else return GDALWMSMetaDataset::DownloadGetCapabilities(poOpenInfo); } else if (poOpenInfo->nHeaderBytes != 0 && (strstr(pabyHeader, "<WMT_MS_Capabilities") != NULL || strstr(pabyHeader, "<WMS_Capabilities") != NULL || strstr(pabyHeader, "<!DOCTYPE WMT_MS_Capabilities") != NULL)) { CPLXMLNode* psXML = CPLParseXMLFile(pszFilename); if (psXML == NULL) return NULL; GDALDataset* poRet = GDALWMSMetaDataset::AnalyzeGetCapabilities(psXML); CPLDestroyXMLNode( psXML ); return poRet; } else if (poOpenInfo->nHeaderBytes != 0 && strstr(pabyHeader, "<WMS_Tile_Service") != NULL) { CPLXMLNode* psXML = CPLParseXMLFile(pszFilename); if (psXML == NULL) return NULL; GDALDataset* poRet = GDALWMSMetaDataset::AnalyzeGetTileService(psXML); CPLDestroyXMLNode( psXML ); return poRet; } else if (poOpenInfo->nHeaderBytes != 0 && strstr(pabyHeader, "<TileMap version=\"1.0.0\"") != NULL) { CPLXMLNode* psXML = CPLParseXMLFile(pszFilename); if (psXML == NULL) return NULL; config = GDALWMSDatasetGetConfigFromTileMap(psXML); CPLDestroyXMLNode( psXML ); } else if (poOpenInfo->nHeaderBytes != 0 && strstr(pabyHeader, "<Services") != NULL && strstr(pabyHeader, "<TileMapService version=\"1.0") != NULL) { CPLXMLNode* psXML = CPLParseXMLFile(pszFilename); if (psXML == NULL) return NULL; CPLXMLNode* psRoot = CPLGetXMLNode( psXML, "=Services" ); GDALDataset* poRet = NULL; if (psRoot) { CPLXMLNode* psTileMapService = CPLGetXMLNode(psRoot, "TileMapService"); if (psTileMapService) { const char* pszHref = CPLGetXMLValue(psTileMapService, "href", NULL); if (pszHref) { poRet = (GDALDataset*) GDALOpen(pszHref, GA_ReadOnly); } } } CPLDestroyXMLNode( psXML ); return poRet; } else if (poOpenInfo->nHeaderBytes != 0 && strstr(pabyHeader, "<TileMapService version=\"1.0.0\"") != NULL) { CPLXMLNode* psXML = CPLParseXMLFile(pszFilename); if (psXML == NULL) return NULL; GDALDataset* poRet = GDALWMSMetaDataset::AnalyzeTileMapService(psXML); CPLDestroyXMLNode( psXML ); return poRet; } else if (poOpenInfo->nHeaderBytes == 0 && EQUALN(pszFilename, "AGS:", 4)) { return NULL; } else if (poOpenInfo->nHeaderBytes == 0 && EQUALN(pszFilename, "IIP:", 4)) { CPLString osURL(pszFilename + 4); osURL += "&obj=Basic-Info"; CPLHTTPResult *psResult = CPLHTTPFetch(osURL.c_str(), NULL); if (psResult == NULL) return NULL; if (psResult->pabyData == NULL) { CPLHTTPDestroyResult(psResult); return NULL; } int nXSize, nYSize; const char* pszMaxSize = strstr((const char*)psResult->pabyData, "Max-size:"); const char* pszResolutionNumber = strstr((const char*)psResult->pabyData, "Resolution-number:"); if( pszMaxSize && sscanf(pszMaxSize + strlen("Max-size:"), "%d %d", &nXSize, &nYSize) == 2 && pszResolutionNumber ) { int nResolutions = atoi(pszResolutionNumber + strlen("Resolution-number:")); char* pszEscapedURL = CPLEscapeString(pszFilename + 4, -1, CPLES_XML); CPLString osXML = CPLSPrintf( "<GDAL_WMS>" " <Service name=\"IIP\">" " <ServerUrl>%s</ServerUrl>" " </Service>" " <DataWindow>" " <SizeX>%d</SizeX>" " <SizeY>%d</SizeY>" " <TileLevel>%d</TileLevel>" " </DataWindow>" " <BlockSizeX>256</BlockSizeX>" " <BlockSizeY>256</BlockSizeY>" " <BandsCount>3</BandsCount>" " <Cache />" "</GDAL_WMS>", pszEscapedURL, nXSize, nYSize, nResolutions - 1); config = CPLParseXMLString(osXML); CPLFree(pszEscapedURL); } CPLHTTPDestroyResult(psResult); } else return NULL; if (config == NULL) return NULL; /* -------------------------------------------------------------------- */ /* Confirm the requested access is supported. */ /* -------------------------------------------------------------------- */ if( poOpenInfo->eAccess == GA_Update ) { CPLDestroyXMLNode(config); CPLError( CE_Failure, CPLE_NotSupported, "The WMS poDriver does not support update access to existing" " datasets.\n" ); return NULL; } GDALWMSDataset *ds = new GDALWMSDataset(); ret = ds->Initialize(config); if (ret != CE_None) { delete ds; ds = NULL; } CPLDestroyXMLNode(config); /* -------------------------------------------------------------------- */ /* Initialize any PAM information. */ /* -------------------------------------------------------------------- */ if (ds != NULL) { ds->SetMetadataItem( "INTERLEAVE", "PIXEL", "IMAGE_STRUCTURE" ); ds->SetDescription( poOpenInfo->pszFilename ); ds->TryLoadXML(); } return ds; }