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;
}
