static bool CPLHasLibXMLBug()
{
if (bHasLibXMLBug >= 0)
return CPL_TO_BOOL(bHasLibXMLBug);
static const char szLibXMLBugTester[] =
"<schema targetNamespace=\"http://foo\" xmlns:foo=\"http://foo\" xmlns=\"http://www.w3.org/2001/XMLSchema\">"
"<simpleType name=\"t1\">"
"<list itemType=\"double\"/>"
"</simpleType>"
"<complexType name=\"t2\">"
"<simpleContent>"
"<extension base=\"foo:t1\"/>"
"</simpleContent>"
"</complexType>"
"<complexType name=\"t3\">"
"<simpleContent>"
"<restriction base=\"foo:t2\">"
"<length value=\"2\"/>"
"</restriction>"
"</simpleContent>"
"</complexType>"
"</schema>";
xmlSchemaParserCtxtPtr pSchemaParserCtxt;
xmlSchemaPtr pSchema;
pSchemaParserCtxt = xmlSchemaNewMemParserCtxt(szLibXMLBugTester, strlen(szLibXMLBugTester));
xmlSchemaSetParserErrors(pSchemaParserCtxt,
CPLHasLibXMLBugWarningCallback,
CPLHasLibXMLBugWarningCallback,
NULL);
pSchema = xmlSchemaParse(pSchemaParserCtxt);
xmlSchemaFreeParserCtxt(pSchemaParserCtxt);
bHasLibXMLBug = (pSchema == NULL);
if (pSchema)
xmlSchemaFree(pSchema);
if (bHasLibXMLBug)
{
CPLDebug("CPL",
"LibXML bug found (cf https://bugzilla.gnome.org/show_bug.cgi?id=630130). "
"Will try to workaround for GML schemas.");
}
return CPL_TO_BOOL(bHasLibXMLBug);
}
OGRFieldType GeoJSONStringPropertyToFieldType( json_object* poObject )
{
if( poObject == NULL ) { return OFTString; }
const char* pszStr = json_object_get_string( poObject );
OGRField sWrkField;
CPLPushErrorHandler(CPLQuietErrorHandler);
const bool bSuccess = CPL_TO_BOOL(OGRParseDate( pszStr, &sWrkField, 0 ));
CPLPopErrorHandler();
CPLErrorReset();
if( bSuccess )
{
const bool bHasDate =
strchr( pszStr, '/' ) != NULL ||
strchr( pszStr, '-' ) != NULL;
const bool bHasTime = strchr( pszStr, ':' ) != NULL;
if( bHasDate && bHasTime )
return OFTDateTime;
else if( bHasDate )
return OFTDate;
else
return OFTTime;
// TODO: What if both are false?
}
return OFTString;
}
static void AppendCoordinateList( OGRLineString *poLine,
char **ppszText, size_t *pnLength,
size_t *pnMaxLength )
{
char szCoordinate[256]= { 0 };
const bool b3D = CPL_TO_BOOL(wkbHasZ(poLine->getGeometryType()));
*pnLength += strlen(*ppszText + *pnLength);
_GrowBuffer( *pnLength + 20, ppszText, pnMaxLength );
strcat( *ppszText + *pnLength, "<coordinates>" );
*pnLength += strlen(*ppszText + *pnLength);
for( int iPoint = 0; iPoint < poLine->getNumPoints(); iPoint++ )
{
MakeKMLCoordinate( szCoordinate, sizeof(szCoordinate),
poLine->getX(iPoint),
poLine->getY(iPoint),
poLine->getZ(iPoint),
b3D );
_GrowBuffer( *pnLength + strlen(szCoordinate)+1,
ppszText, pnMaxLength );
if( iPoint != 0 )
strcat( *ppszText + *pnLength, " " );
strcat( *ppszText + *pnLength, szCoordinate );
*pnLength += strlen(*ppszText + *pnLength);
}
_GrowBuffer( *pnLength + 20, ppszText, pnMaxLength );
strcat( *ppszText + *pnLength, "</coordinates>" );
*pnLength += strlen(*ppszText + *pnLength);
}
VSILFILE *VSIFOpenExL( const char * pszFilename, const char * pszAccess, int bSetError )
{
VSIFilesystemHandler *poFSHandler =
VSIFileManager::GetHandler( pszFilename );
VSILFILE* fp = reinterpret_cast<VSILFILE *>(
poFSHandler->Open( pszFilename, pszAccess, CPL_TO_BOOL(bSetError) ) );
VSIDebug4( "VSIFOpenExL(%s,%s,%d) = %p", pszFilename, pszAccess, bSetError, fp );
return fp;
}
static void AppendCoordinateList( OGRLineString *poLine, VSILFILE* fp )
{
const bool b3D = CPL_TO_BOOL(wkbHasZ(poLine->getGeometryType()));
for( int iPoint = 0; iPoint < poLine->getNumPoints(); iPoint++ )
{
VSIFPrintfL(fp, "<COORD>");
VSIFPrintfL(fp, "<C1>%s</C1>", d2str(poLine->getX(iPoint)));
VSIFPrintfL(fp, "<C2>%s</C2>", d2str(poLine->getY(iPoint)));
if (b3D)
VSIFPrintfL(fp, "<C3>%s</C3>", d2str(poLine->getZ(iPoint)));
VSIFPrintfL(fp, "</COORD>\n");
}
}
static void AppendCoordinateList( OGRLineString *poLine,
OGRILI1DataSource *poDS )
{
const bool b3D = CPL_TO_BOOL(wkbHasZ(poLine->getGeometryType()));
for( int iPoint = 0; iPoint < poLine->getNumPoints(); iPoint++ )
{
if (iPoint == 0) VSIFPrintfL( poDS->GetTransferFile(), "STPT" );
else VSIFPrintfL( poDS->GetTransferFile(), "LIPT" );
VSIFPrintfL( poDS->GetTransferFile(), " %s",
d2str(poLine->getX(iPoint)) );
VSIFPrintfL( poDS->GetTransferFile(), " %s",
d2str(poLine->getY(iPoint)) );
if( b3D )
VSIFPrintfL( poDS->GetTransferFile(), " %s",
d2str(poLine->getZ(iPoint)) );
VSIFPrintfL( poDS->GetTransferFile(), "\n" );
}
VSIFPrintfL( poDS->GetTransferFile(), "ELIN\n" );
}
OGRLayer *OGRVRTDataSource::InstantiateLayer(
CPLXMLNode *psLTree,
const char *pszVRTDirectory,
int bUpdate,
int nRecLevel )
{
if( poLayerPool != nullptr && EQUAL(psLTree->pszValue,"OGRVRTLayer"))
{
PooledInitData *pData =
(PooledInitData *)CPLMalloc(sizeof(PooledInitData));
pData->poDS = this;
pData->psNode = psLTree;
pData->pszVRTDirectory = CPLStrdup(pszVRTDirectory);
pData->bUpdate = CPL_TO_BOOL(bUpdate);
return new OGRProxiedLayer(poLayerPool, OGRVRTOpenProxiedLayer,
OGRVRTFreeProxiedLayerUserData, pData);
}
return InstantiateLayerInternal(psLTree, pszVRTDirectory,
bUpdate, nRecLevel);
}
int OGRProj4CT::Transform( int nCount, double *x, double *y, double *z )
{
int *pabSuccess = (int *) CPLMalloc(sizeof(int) * nCount );
bool bOverallSuccess =
CPL_TO_BOOL(TransformEx( nCount, x, y, z, pabSuccess ));
for( int i = 0; i < nCount; i++ )
{
if( !pabSuccess[i] )
{
bOverallSuccess = false;
break;
}
}
CPLFree( pabSuccess );
return bOverallSuccess;
}
void GDALDefaultOverviews::Initialize( GDALDataset *poDSIn,
const char * pszBasename,
char **papszSiblingFiles,
int bNameIsOVR )
{
poDS = poDSIn;
/* -------------------------------------------------------------------- */
/* If we were already initialized, destroy the old overview */
/* file handle. */
/* -------------------------------------------------------------------- */
if( poODS != NULL )
{
GDALClose( poODS );
poODS = NULL;
CPLDebug(
"GDAL",
"GDALDefaultOverviews::Initialize() called twice - "
"this is odd and perhaps dangerous!" );
}
/* -------------------------------------------------------------------- */
/* Store the initialization information for later use in */
/* OverviewScan() */
/* -------------------------------------------------------------------- */
bCheckedForOverviews = FALSE;
CPLFree( pszInitName );
pszInitName = NULL;
if( pszBasename != NULL )
pszInitName = CPLStrdup(pszBasename);
bInitNameIsOVR = CPL_TO_BOOL(bNameIsOVR);
CSLDestroy( papszInitSiblingFiles );
papszInitSiblingFiles = NULL;
if( papszSiblingFiles != NULL )
papszInitSiblingFiles = CSLDuplicate(papszSiblingFiles);
}
OGRErr OGRLinearRing::transform( OGRCoordinateTransformation *poCT )
{
const bool bIsClosed = getNumPoints() > 2 && CPL_TO_BOOL(get_IsClosed());
OGRErr eErr = OGRLineString::transform(poCT);
if( bIsClosed && eErr == OGRERR_NONE && !get_IsClosed() )
{
CPLDebug("OGR", "Linearring is not closed after coordinate "
"transformation. Forcing last point to be identical to "
"first one");
// Force last point to be identical to first point.
// This is a safety belt in case the reprojection of the same coordinate
// isn't perfectly stable. This can for example happen in very rare cases
// when reprojecting a cutline with a RPC transform with a DEM that
// is a VRT whose sources are resampled...
OGRPoint oStartPoint;
StartPoint( &oStartPoint );
setPoint( getNumPoints()-1, &oStartPoint);
}
return eErr;
}
int OGRGmtDataSource::Open( const char *pszFilename, int bUpdateIn )
{
bUpdate = CPL_TO_BOOL( bUpdateIn );
OGRGmtLayer *poLayer = new OGRGmtLayer( pszFilename, bUpdate );
if( !poLayer->bValidFile )
{
delete poLayer;
return FALSE;
}
papoLayers = static_cast<OGRGmtLayer **>( CPLRealloc( papoLayers,
(nLayers + 1) *sizeof(OGRGmtLayer*)) );
papoLayers[nLayers] = poLayer;
nLayers ++;
CPLFree (pszName);
pszName = CPLStrdup( pszFilename );
return TRUE;
}
OGRDataSource *OGRGeoconceptDriver::Open( const char* pszFilename,
int bUpdate )
{
#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
/* -------------------------------------------------------------------- */
/* We will only consider .gxt and .txt files. */
/* -------------------------------------------------------------------- */
const char* pszExtension = CPLGetExtension(pszFilename);
if( !EQUAL(pszExtension,"gxt") && !EQUAL(pszExtension,"txt") )
{
return nullptr;
}
#endif
OGRGeoconceptDataSource *poDS = new OGRGeoconceptDataSource();
if( !poDS->Open( pszFilename, true, CPL_TO_BOOL(bUpdate) ) )
{
delete poDS;
return nullptr;
}
return poDS;
}
void OGRCloudantTableLayer::LoadMetadata()
{
if( bHasLoadedMetadata )
return;
bHasLoadedMetadata = true;
if (pszSpatialDDoc == nullptr)
GetSpatialView();
if( pszSpatialDDoc == nullptr )
return;
CPLString osURI("/");
osURI += osEscapedName;
osURI += "/";
osURI += pszSpatialDDoc;
json_object* poAnswerObj = poDS->GET(osURI);
if (poAnswerObj == nullptr)
return;
if ( !json_object_is_type(poAnswerObj, json_type_object) )
{
CPLError(CE_Failure, CPLE_AppDefined, "LoadMetadata() failed");
json_object_put(poAnswerObj);
return;
}
json_object* poRev = CPL_json_object_object_get(poAnswerObj, "_rev");
const char* pszRev = json_object_get_string(poRev);
if (pszRev)
osMetadataRev = pszRev;
json_object* poError = CPL_json_object_object_get(poAnswerObj, "error");
const char* pszError = json_object_get_string(poError);
if (pszError && strcmp(pszError, "not_found") == 0)
{
json_object_put(poAnswerObj);
return;
}
if (poDS->IsError(poAnswerObj, "LoadMetadata() failed"))
{
json_object_put(poAnswerObj);
return;
}
json_object* poJsonSRS = CPL_json_object_object_get(poAnswerObj, "srsid");
const char* pszSRS = json_object_get_string(poJsonSRS);
if (pszSRS != nullptr)
{
poSRS = new OGRSpatialReference();
if (poSRS->importFromURN(pszSRS) != OGRERR_NONE)
{
delete poSRS;
poSRS = nullptr;
}
}
json_object* poGeomType = CPL_json_object_object_get(poAnswerObj, "geomtype");
const char* pszGeomType = json_object_get_string(poGeomType);
if (pszGeomType)
{
if (EQUAL(pszGeomType, "NONE"))
{
eGeomType = wkbNone;
bExtentValid = true;
}
else
{
eGeomType = OGRFromOGCGeomType(pszGeomType);
json_object* poIs25D = CPL_json_object_object_get(poAnswerObj, "is_25D");
if (poIs25D && json_object_get_boolean(poIs25D))
eGeomType = wkbSetZ(eGeomType);
json_object* poExtent = CPL_json_object_object_get(poAnswerObj, "extent");
if (poExtent && json_object_get_type(poExtent) == json_type_object)
{
json_object* poBbox = CPL_json_object_object_get(poExtent, "bbox");
if (poBbox &&
json_object_get_type(poBbox) == json_type_array &&
json_object_array_length(poBbox) == 4 &&
OGRCloudantIsNumericObject(json_object_array_get_idx(poBbox, 0)) &&
OGRCloudantIsNumericObject(json_object_array_get_idx(poBbox, 1)) &&
OGRCloudantIsNumericObject(json_object_array_get_idx(poBbox, 2)) &&
OGRCloudantIsNumericObject(json_object_array_get_idx(poBbox, 3)))
{
dfMinX = json_object_get_double(json_object_array_get_idx(poBbox, 0));
dfMinY = json_object_get_double(json_object_array_get_idx(poBbox, 1));
dfMaxX = json_object_get_double(json_object_array_get_idx(poBbox, 2));
dfMaxY = json_object_get_double(json_object_array_get_idx(poBbox, 3));
bExtentValid = true;
bExtentSet = true;
}
}
}
}
json_object* poGeoJSON = CPL_json_object_object_get(poAnswerObj, "geojson_documents");
if (poGeoJSON && json_object_is_type(poGeoJSON, json_type_boolean))
bGeoJSONDocument = CPL_TO_BOOL(json_object_get_boolean(poGeoJSON));
json_object* poFields = CPL_json_object_object_get(poAnswerObj, "fields");
if (poFields && json_object_is_type(poFields, json_type_array))
{
poFeatureDefn = new OGRFeatureDefn( osName );
poFeatureDefn->Reference();
poFeatureDefn->SetGeomType(eGeomType);
if( poFeatureDefn->GetGeomFieldCount() != 0 )
poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(poSRS);
OGRFieldDefn oFieldId("_id", OFTString);
poFeatureDefn->AddFieldDefn(&oFieldId);
OGRFieldDefn oFieldRev("_rev", OFTString);
poFeatureDefn->AddFieldDefn(&oFieldRev);
int nFields = json_object_array_length(poFields);
for(int i=0;i<nFields;i++)
{
json_object* poField = json_object_array_get_idx(poFields, i);
if (poField && json_object_is_type(poField, json_type_object))
{
json_object* poName = CPL_json_object_object_get(poField, "name");
const char* pszName = json_object_get_string(poName);
if (pszName)
{
json_object* poType = CPL_json_object_object_get(poField, "type");
const char* pszType = json_object_get_string(poType);
OGRFieldType eType = OFTString;
if (pszType)
{
if (strcmp(pszType, "integer") == 0)
eType = OFTInteger;
else if (strcmp(pszType, "integerlist") == 0)
eType = OFTIntegerList;
else if (strcmp(pszType, "real") == 0)
eType = OFTReal;
else if (strcmp(pszType, "reallist") == 0)
eType = OFTRealList;
else if (strcmp(pszType, "string") == 0)
eType = OFTString;
else if (strcmp(pszType, "stringlist") == 0)
eType = OFTStringList;
}
OGRFieldDefn oField(pszName, eType);
poFeatureDefn->AddFieldDefn(&oField);
}
}
}
}
std::sort(aosIdsToFetch.begin(), aosIdsToFetch.end());
json_object_put(poAnswerObj);
return;
}
GDALDataset *FASTDataset::Open( GDALOpenInfo * poOpenInfo )
{
if( poOpenInfo->nHeaderBytes < 1024)
return NULL;
if( !EQUALN((const char *) poOpenInfo->pabyHeader + 52,
"ACQUISITION DATE =", 18)
&& !EQUALN((const char *) poOpenInfo->pabyHeader + 36,
"ACQUISITION DATE =", 18) )
return NULL;
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
FASTDataset *poDS = new FASTDataset();
poDS->fpHeader = VSIFOpenL(poOpenInfo->pszFilename, "rb");
if (poDS->fpHeader == NULL)
{
delete poDS;
return NULL;
}
poDS->pszFilename = poOpenInfo->pszFilename;
poDS->pszDirname = CPLStrdup( CPLGetDirname( poOpenInfo->pszFilename ) );
/* -------------------------------------------------------------------- */
/* Read the administrative record. */
/* -------------------------------------------------------------------- */
char *pszHeader =
static_cast<char *>( CPLMalloc( ADM_HEADER_SIZE + 1 ) );
size_t nBytesRead = 0;
if( VSIFSeekL( poDS->fpHeader, 0, SEEK_SET ) >= 0 )
nBytesRead = VSIFReadL( pszHeader, 1, ADM_HEADER_SIZE, poDS->fpHeader );
if ( nBytesRead < ADM_MIN_HEADER_SIZE )
{
CPLDebug( "FAST", "Header file too short. Reading failed" );
CPLFree(pszHeader);
delete poDS;
return NULL;
}
pszHeader[nBytesRead] = '\0';
// Read acquisition date
char *pszTemp = GetValue( pszHeader, ACQUISITION_DATE,
ACQUISITION_DATE_SIZE, TRUE );
if (pszTemp == NULL)
{
CPLDebug( "FAST", "Cannot get ACQUISITION_DATE, using empty value." );
pszTemp = CPLStrdup("");
}
poDS->SetMetadataItem( "ACQUISITION_DATE", pszTemp );
CPLFree( pszTemp );
// Read satellite name (will read the first one only)
pszTemp = GetValue( pszHeader, SATELLITE_NAME, SATELLITE_NAME_SIZE, TRUE );
if (pszTemp == NULL)
{
CPLDebug( "FAST", "Cannot get SATELLITE_NAME, using empty value." );
pszTemp = CPLStrdup( "" );
}
poDS->SetMetadataItem( "SATELLITE", pszTemp );
if ( STARTS_WITH_CI(pszTemp, "LANDSAT") )
poDS->iSatellite = LANDSAT;
// TODO(schwehr): Was this a bug that both are IRS?
// else if ( STARTS_WITH_CI(pszTemp, "IRS") )
// poDS->iSatellite = IRS;
else
poDS->iSatellite = IRS; // TODO(schwehr): Should this be FAST_UNKNOWN?
CPLFree( pszTemp );
// Read sensor name (will read the first one only)
pszTemp = GetValue( pszHeader, SENSOR_NAME, SENSOR_NAME_SIZE, TRUE );
if (pszTemp == NULL)
{
CPLDebug( "FAST", "Cannot get SENSOR_NAME, using empty value." );
pszTemp = CPLStrdup("");
}
poDS->SetMetadataItem( "SENSOR", pszTemp );
CPLFree( pszTemp );
// Read filenames
poDS->nBands = 0;
if (strstr( pszHeader, FILENAME ) == NULL)
{
if (strstr(pszHeader, "GENERATING AGENCY =EUROMAP"))
{
// If we don't find the FILENAME field, let's try with the Euromap
// PAN / LISS3 / WIFS IRS filename convention.
if ((EQUAL(poDS->GetMetadataItem("SATELLITE"), "IRS 1C") ||
EQUAL(poDS->GetMetadataItem("SATELLITE"), "IRS 1D")) &&
(EQUAL(poDS->GetMetadataItem("SENSOR"), "PAN") ||
EQUAL(poDS->GetMetadataItem("SENSOR"), "LISS3") ||
EQUAL(poDS->GetMetadataItem("SENSOR"), "WIFS")))
{
poDS->TryEuromap_IRS_1C_1D_ChannelNameConvention();
}
else if (EQUAL(poDS->GetMetadataItem("SATELLITE"), "CARTOSAT-1") &&
(EQUAL(poDS->GetMetadataItem("SENSOR"), "FORE") ||
EQUAL(poDS->GetMetadataItem("SENSOR"), "AFT")))
{
// See appendix F in
// http://www.euromap.de/download/p5fast_20050301.pdf
const CPLString osSuffix = CPLGetExtension( poDS->pszFilename );
const char *papszBasenames[] =
{ "BANDF", "bandf", "BANDA", "banda" };
for ( int i = 0; i < 4; i++ )
{
const CPLString osChannelFilename =
CPLFormFilename( poDS->pszDirname, papszBasenames[i],
osSuffix );
if( poDS->OpenChannel( osChannelFilename, 0 ) )
{
poDS->nBands = 1;
break;
}
}
}
else if( EQUAL(poDS->GetMetadataItem("SATELLITE"), "IRS P6") )
{
// If BANDS_PRESENT="2345", the file bands are "BAND2.DAT",
// "BAND3.DAT", etc.
pszTemp =
GetValue( pszHeader, BANDS_PRESENT, BANDS_PRESENT_SIZE,
TRUE );
if (pszTemp)
{
for( int i=0; pszTemp[i] != '\0'; i++ )
{
if( pszTemp[i] >= '2' && pszTemp[i] <= '5' )
{
if( poDS->FOpenChannel(
poDS->pszFilename,
poDS->nBands, pszTemp[i] - '0'))
poDS->nBands++;
}
}
CPLFree( pszTemp );
}
}
}
}
// If the previous lookup for band files didn't success, fallback to the
// standard way of finding them, either by the FILENAME field, either with
// the usual patterns like bandX.dat, etc.
if( !poDS->nBands )
{
pszTemp = pszHeader;
for ( int i = 0; i < 7; i++ )
{
char *pszFilename = NULL ;
if ( pszTemp )
pszTemp = strstr( pszTemp, FILENAME );
if ( pszTemp )
{
// Skip the parameter name
pszTemp += strlen(FILENAME);
// Skip whitespaces and equal signs
while ( *pszTemp == ' ' )
pszTemp++;
while ( *pszTemp == '=' )
pszTemp++;
pszFilename =
CPLScanString( pszTemp, FILENAME_SIZE, TRUE, FALSE );
}
else
pszTemp = NULL;
if ( poDS->FOpenChannel( pszFilename, poDS->nBands,
poDS->nBands + 1 ) )
poDS->nBands++;
if ( pszFilename )
CPLFree( pszFilename );
}
}
if ( !poDS->nBands )
{
CPLError( CE_Failure, CPLE_NotSupported,
"Failed to find and open band data files." );
CPLFree(pszHeader);
delete poDS;
return NULL;
}
// Read number of pixels/lines and bit depth
pszTemp = GetValue( pszHeader, PIXELS, PIXELS_SIZE, FALSE );
if ( pszTemp )
{
poDS->nRasterXSize = atoi( pszTemp );
CPLFree( pszTemp );
}
else
{
CPLDebug( "FAST", "Failed to find number of pixels in line." );
CPLFree(pszHeader);
delete poDS;
return NULL;
}
pszTemp = GetValue( pszHeader, LINES1, LINES_SIZE, FALSE );
if ( !pszTemp )
pszTemp = GetValue( pszHeader, LINES2, LINES_SIZE, FALSE );
if ( pszTemp )
{
poDS->nRasterYSize = atoi( pszTemp );
CPLFree( pszTemp );
}
else
{
CPLDebug( "FAST", "Failed to find number of lines in raster." );
CPLFree(pszHeader);
delete poDS;
return NULL;
}
if (!GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize))
{
CPLFree(pszHeader);
delete poDS;
return NULL;
}
pszTemp = GetValue( pszHeader, BITS_PER_PIXEL, BITS_PER_PIXEL_SIZE, FALSE );
if ( pszTemp )
{
switch( atoi(pszTemp) )
{
case 8:
default:
poDS->eDataType = GDT_Byte;
break;
// For a strange reason, some Euromap products declare 10 bits
// output, but are 16 bits.
case 10:
case 16:
poDS->eDataType = GDT_UInt16;
break;
}
CPLFree( pszTemp );
}
else
{
poDS->eDataType = GDT_Byte;
}
/* -------------------------------------------------------------------- */
/* Read radiometric record. */
/* -------------------------------------------------------------------- */
const char *pszFirst = NULL;
const char *pszSecond = NULL;
// Read gains and biases. This is a trick!
pszTemp = strstr( pszHeader, "BIASES" );// It may be "BIASES AND GAINS"
// or "GAINS AND BIASES"
const char* pszGains = strstr( pszHeader, "GAINS" );
if( pszTemp == NULL || pszGains == NULL )
{
CPLDebug( "FAST", "No BIASES and/or GAINS" );
CPLFree( pszHeader );
delete poDS;
return NULL;
}
if ( pszTemp > pszGains )
{
pszFirst = "GAIN%d";
pszSecond = "BIAS%d";
}
else
{
pszFirst = "BIAS%d";
pszSecond = "GAIN%d";
}
// Now search for the first number occurrence after that string.
for ( int i = 1; i <= poDS->nBands; i++ )
{
char *pszValue = NULL;
size_t nValueLen = VALUE_SIZE;
pszTemp = strpbrk( pszTemp, "-.0123456789" );
if ( pszTemp )
{
nValueLen = strspn( pszTemp, "+-.0123456789" );
pszValue =
CPLScanString( pszTemp, static_cast<int>(nValueLen),
TRUE, TRUE );
poDS->SetMetadataItem( CPLSPrintf(pszFirst, i ), pszValue );
CPLFree( pszValue );
}
pszTemp += nValueLen;
pszTemp = strpbrk( pszTemp, "-.0123456789" );
if ( pszTemp )
{
nValueLen = strspn( pszTemp, "+-.0123456789" );
pszValue =
CPLScanString( pszTemp, static_cast<int>(nValueLen),
TRUE, TRUE );
poDS->SetMetadataItem( CPLSPrintf(pszSecond, i ), pszValue );
CPLFree( pszValue );
}
pszTemp += nValueLen;
}
/* -------------------------------------------------------------------- */
/* Read geometric record. */
/* -------------------------------------------------------------------- */
// Coordinates of pixel's centers
double dfULX = 0.0;
double dfULY = 0.0;
double dfURX = 0.0;
double dfURY = 0.0;
double dfLLX = 0.0;
double dfLLY = 0.0;
double dfLRX = 0.0;
double dfLRY = 0.0;
// Read projection name
pszTemp = GetValue( pszHeader, PROJECTION_NAME,
PROJECTION_NAME_SIZE, FALSE );
long iProjSys = 0;
if ( pszTemp && !EQUAL( pszTemp, "" ) )
iProjSys = USGSMnemonicToCode( pszTemp );
else
iProjSys = 1L; // UTM by default
CPLFree( pszTemp );
// Read ellipsoid name
pszTemp = GetValue( pszHeader, ELLIPSOID_NAME, ELLIPSOID_NAME_SIZE, FALSE );
long iDatum = 0; // Clarke, 1866 (NAD1927) by default.
if ( pszTemp && !EQUAL( pszTemp, "" ) )
iDatum = USGSEllipsoidToCode( pszTemp );
CPLFree( pszTemp );
// Read zone number.
pszTemp = GetValue( pszHeader, ZONE_NUMBER, ZONE_NUMBER_SIZE, FALSE );
long iZone = 0;
if ( pszTemp && !EQUAL( pszTemp, "" ) )
iZone = atoi( pszTemp );
CPLFree( pszTemp );
// Read 15 USGS projection parameters
double adfProjParms[15] = { 0.0 };
pszTemp = strstr( pszHeader, USGS_PARAMETERS );
if ( pszTemp && !EQUAL( pszTemp, "" ) )
{
pszTemp += strlen( USGS_PARAMETERS );
for ( int i = 0; i < 15; i++ )
{
pszTemp = strpbrk( pszTemp, "-.0123456789" );
if ( pszTemp )
adfProjParms[i] = CPLScanDouble( pszTemp, VALUE_SIZE );
pszTemp = strpbrk( pszTemp, " \t" );
}
}
// Coordinates should follow the word "PROJECTION", otherwise we can
// be confused by other occurrences of the corner keywords.
char *pszGeomRecord = strstr( pszHeader, "PROJECTION" );
// Read corner coordinates
pszTemp = strstr( pszGeomRecord, CORNER_UPPER_LEFT );
if ( pszTemp && !EQUAL( pszTemp, "" ) )
{
pszTemp += strlen( CORNER_UPPER_LEFT ) + 28;
dfULX = CPLScanDouble( pszTemp, CORNER_VALUE_SIZE );
pszTemp += CORNER_VALUE_SIZE + 1;
dfULY = CPLScanDouble( pszTemp, CORNER_VALUE_SIZE );
}
pszTemp = strstr( pszGeomRecord, CORNER_UPPER_RIGHT );
if ( pszTemp && !EQUAL( pszTemp, "" ) )
{
pszTemp += strlen( CORNER_UPPER_RIGHT ) + 28;
dfURX = CPLScanDouble( pszTemp, CORNER_VALUE_SIZE );
pszTemp += CORNER_VALUE_SIZE + 1;
dfURY = CPLScanDouble( pszTemp, CORNER_VALUE_SIZE );
}
pszTemp = strstr( pszGeomRecord, CORNER_LOWER_LEFT );
if ( pszTemp && !EQUAL( pszTemp, "" ) )
{
pszTemp += strlen( CORNER_LOWER_LEFT ) + 28;
dfLLX = CPLScanDouble( pszTemp, CORNER_VALUE_SIZE );
pszTemp += CORNER_VALUE_SIZE + 1;
dfLLY = CPLScanDouble( pszTemp, CORNER_VALUE_SIZE );
}
pszTemp = strstr( pszGeomRecord, CORNER_LOWER_RIGHT );
if ( pszTemp && !EQUAL( pszTemp, "" ) )
{
pszTemp += strlen( CORNER_LOWER_RIGHT ) + 28;
dfLRX = CPLScanDouble( pszTemp, CORNER_VALUE_SIZE );
pszTemp += CORNER_VALUE_SIZE + 1;
dfLRY = CPLScanDouble( pszTemp, CORNER_VALUE_SIZE );
}
if ( dfULX != 0.0 && dfULY != 0.0
&& dfURX != 0.0 && dfURY != 0.0
&& dfLLX != 0.0 && dfLLY != 0.0
&& dfLRX != 0.0 && dfLRY != 0.0 )
{
// Strip out zone number from the easting values, if either
if ( dfULX >= 1000000.0 )
dfULX -= static_cast<double>( iZone ) * 1000000.0;
if ( dfURX >= 1000000.0 )
dfURX -= static_cast<double>( iZone ) * 1000000.0;
if ( dfLLX >= 1000000.0 )
dfLLX -= static_cast<double>( iZone ) * 1000000.0;
if ( dfLRX >= 1000000.0 )
dfLRX -= static_cast<double>( iZone ) * 1000000.0;
// In EOSAT FAST Rev C, the angles are in decimal degrees
// otherwise they are in packed DMS format.
const int bAnglesInPackedDMSFormat =
strstr( pszHeader, "REV C" ) == NULL;
// Create projection definition
OGRSpatialReference oSRS;
OGRErr eErr =
oSRS.importFromUSGS( iProjSys, iZone, adfProjParms, iDatum, bAnglesInPackedDMSFormat );
if ( eErr != OGRERR_NONE )
CPLDebug( "FAST", "Import projection from USGS failed: %d", eErr );
oSRS.SetLinearUnits( SRS_UL_METER, 1.0 );
// Read datum name
pszTemp = GetValue( pszHeader, DATUM_NAME, DATUM_NAME_SIZE, FALSE );
if ( pszTemp )
{
if ( EQUAL( pszTemp, "WGS84" ) )
oSRS.SetWellKnownGeogCS( "WGS84" );
else if ( EQUAL( pszTemp, "NAD27" ) )
oSRS.SetWellKnownGeogCS( "NAD27" );
else if ( EQUAL( pszTemp, "NAD83" ) )
oSRS.SetWellKnownGeogCS( "NAD83" );
CPLFree( pszTemp );
}
else
{
// Reasonable fallback
oSRS.SetWellKnownGeogCS( "WGS84" );
}
if ( poDS->pszProjection )
CPLFree( poDS->pszProjection );
eErr = oSRS.exportToWkt( &poDS->pszProjection );
if ( eErr != OGRERR_NONE )
CPLDebug("FAST", "Export projection to WKT USGS failed: %d", eErr);
// Generate GCPs
GDAL_GCP *pasGCPList
= static_cast<GDAL_GCP *>( CPLCalloc( sizeof( GDAL_GCP ), 4 ) );
GDALInitGCPs( 4, pasGCPList );
CPLFree(pasGCPList[0].pszId);
CPLFree(pasGCPList[1].pszId);
CPLFree(pasGCPList[2].pszId);
CPLFree(pasGCPList[3].pszId);
/* Let's order the GCP in TL, TR, BR, BL order to benefit from the */
/* GDALGCPsToGeoTransform optimization */
pasGCPList[0].pszId = CPLStrdup("UPPER_LEFT");
pasGCPList[0].dfGCPX = dfULX;
pasGCPList[0].dfGCPY = dfULY;
pasGCPList[0].dfGCPZ = 0.0;
pasGCPList[0].dfGCPPixel = 0.5;
pasGCPList[0].dfGCPLine = 0.5;
pasGCPList[1].pszId = CPLStrdup("UPPER_RIGHT");
pasGCPList[1].dfGCPX = dfURX;
pasGCPList[1].dfGCPY = dfURY;
pasGCPList[1].dfGCPZ = 0.0;
pasGCPList[1].dfGCPPixel = poDS->nRasterXSize-0.5;
pasGCPList[1].dfGCPLine = 0.5;
pasGCPList[2].pszId = CPLStrdup("LOWER_RIGHT");
pasGCPList[2].dfGCPX = dfLRX;
pasGCPList[2].dfGCPY = dfLRY;
pasGCPList[2].dfGCPZ = 0.0;
pasGCPList[2].dfGCPPixel = poDS->nRasterXSize-0.5;
pasGCPList[2].dfGCPLine = poDS->nRasterYSize-0.5;
pasGCPList[3].pszId = CPLStrdup("LOWER_LEFT");
pasGCPList[3].dfGCPX = dfLLX;
pasGCPList[3].dfGCPY = dfLLY;
pasGCPList[3].dfGCPZ = 0.0;
pasGCPList[3].dfGCPPixel = 0.5;
pasGCPList[3].dfGCPLine = poDS->nRasterYSize-0.5;
// Calculate transformation matrix, if accurate
const bool transform_ok
= CPL_TO_BOOL(
GDALGCPsToGeoTransform( 4, pasGCPList,
poDS->adfGeoTransform, 0 ) );
if( !transform_ok )
{
poDS->adfGeoTransform[0] = 0.0;
poDS->adfGeoTransform[1] = 1.0;
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = 0.0;
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = 1.0;
if ( poDS->pszProjection )
CPLFree( poDS->pszProjection );
poDS->pszProjection = CPLStrdup("");
}
GDALDeinitGCPs(4, pasGCPList);
CPLFree(pasGCPList);
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
const int nPixelOffset = GDALGetDataTypeSize(poDS->eDataType) / 8;
const int nLineOffset = poDS->nRasterXSize * nPixelOffset;
for( int i = 1; i <= poDS->nBands; i++ )
{
poDS->SetBand( i, new FASTRasterBand( poDS, i, poDS->fpChannels[i - 1],
0, nPixelOffset, nLineOffset, poDS->eDataType, TRUE));
}
CPLFree( pszHeader );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
// opens overviews.
poDS->oOvManager.Initialize(poDS, poDS->pszFilename);
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
delete poDS;
CPLError( CE_Failure, CPLE_NotSupported,
"The FAST driver does not support update access to existing"
" datasets." );
return NULL;
}
return poDS;
}
void GDALDefaultOverviews::OverviewScan()
{
if( bCheckedForOverviews || poDS == NULL )
return;
bCheckedForOverviews = true;
CPLDebug( "GDAL", "GDALDefaultOverviews::OverviewScan()" );
/* -------------------------------------------------------------------- */
/* Open overview dataset if it exists. */
/* -------------------------------------------------------------------- */
if( pszInitName == NULL )
pszInitName = CPLStrdup(poDS->GetDescription());
if( !EQUAL(pszInitName,":::VIRTUAL:::") &&
GDALCanFileAcceptSidecarFile(pszInitName) )
{
if( bInitNameIsOVR )
osOvrFilename = pszInitName;
else
osOvrFilename.Printf( "%s.ovr", pszInitName );
std::vector<char> achOvrFilename;
achOvrFilename.resize(osOvrFilename.size() + 1);
memcpy(&(achOvrFilename[0]),
osOvrFilename.c_str(),
osOvrFilename.size() + 1);
bool bExists = CPL_TO_BOOL(
CPLCheckForFile( &achOvrFilename[0], papszInitSiblingFiles ) );
osOvrFilename = &achOvrFilename[0];
#if !defined(WIN32)
if( !bInitNameIsOVR && !bExists && !papszInitSiblingFiles )
{
osOvrFilename.Printf( "%s.OVR", pszInitName );
memcpy(&(achOvrFilename[0]),
osOvrFilename.c_str(),
osOvrFilename.size() + 1);
bExists = CPL_TO_BOOL(
CPLCheckForFile( &achOvrFilename[0], papszInitSiblingFiles ) );
osOvrFilename = &achOvrFilename[0];
if( !bExists )
osOvrFilename.Printf( "%s.ovr", pszInitName );
}
#endif
if( bExists )
{
poODS = static_cast<GDALDataset *>( GDALOpenEx(
osOvrFilename,
GDAL_OF_RASTER |
(poDS->GetAccess() == GA_Update ? GDAL_OF_UPDATE : 0),
NULL, NULL, papszInitSiblingFiles ) );
}
}
/* -------------------------------------------------------------------- */
/* We didn't find that, so try and find a corresponding aux */
/* file. Check that we are the dependent file of the aux */
/* file. */
/* */
/* We only use the .aux file for overviews if they already have */
/* overviews existing, or if USE_RRD is set true. */
/* -------------------------------------------------------------------- */
if( !poODS && !EQUAL(pszInitName,":::VIRTUAL:::") &&
GDALCanFileAcceptSidecarFile(pszInitName) )
{
bool bTryFindAssociatedAuxFile = true;
if( papszInitSiblingFiles )
{
CPLString osAuxFilename = CPLResetExtension( pszInitName, "aux");
int iSibling = CSLFindString( papszInitSiblingFiles,
CPLGetFilename(osAuxFilename) );
if( iSibling < 0 )
{
osAuxFilename = pszInitName;
osAuxFilename += ".aux";
iSibling = CSLFindString( papszInitSiblingFiles,
CPLGetFilename(osAuxFilename) );
if( iSibling < 0 )
bTryFindAssociatedAuxFile = false;
}
}
if( bTryFindAssociatedAuxFile )
{
poODS = GDALFindAssociatedAuxFile( pszInitName, poDS->GetAccess(),
poDS );
}
if( poODS )
{
const bool bUseRRD = CPLTestBool(CPLGetConfigOption("USE_RRD","NO"));
bOvrIsAux = true;
if( GetOverviewCount(1) == 0 && !bUseRRD )
{
bOvrIsAux = false;
GDALClose( poODS );
poODS = NULL;
}
else
{
osOvrFilename = poODS->GetDescription();
}
}
}
/* -------------------------------------------------------------------- */
/* If we still don't have an overview, check to see if we have */
/* overview metadata referencing a remote (i.e. proxy) or local */
/* subdataset overview dataset. */
/* -------------------------------------------------------------------- */
if( poODS == NULL )
{
const char *pszProxyOvrFilename =
poDS->GetMetadataItem( "OVERVIEW_FILE", "OVERVIEWS" );
if( pszProxyOvrFilename != NULL )
{
if( STARTS_WITH_CI(pszProxyOvrFilename, ":::BASE:::") )
{
const CPLString osPath = CPLGetPath(poDS->GetDescription());
osOvrFilename =
CPLFormFilename( osPath, pszProxyOvrFilename+10, NULL );
}
else
{
osOvrFilename = pszProxyOvrFilename;
}
CPLPushErrorHandler(CPLQuietErrorHandler);
poODS = static_cast<GDALDataset *>(GDALOpen(osOvrFilename, poDS->GetAccess()));
CPLPopErrorHandler();
}
}
/* -------------------------------------------------------------------- */
/* If we have an overview dataset, then mark all the overviews */
/* with the base dataset Used later for finding overviews */
/* masks. Uggg. */
/* -------------------------------------------------------------------- */
if( poODS )
{
const int nOverviewCount = GetOverviewCount(1);
for( int iOver = 0; iOver < nOverviewCount; iOver++ )
{
GDALRasterBand * const poBand = GetOverview( 1, iOver );
GDALDataset * const poOverDS = poBand != NULL ?
poBand->GetDataset() : NULL;
if( poOverDS != NULL )
{
poOverDS->oOvManager.poBaseDS = poDS;
poOverDS->oOvManager.poDS = poOverDS;
}
}
}
}
OGRErr OGRDXFLayer::CollectPolylinePath( OGRGeometryCollection *poGC,
const double dfElevation )
{
int nCode = 0;
char szLineBuf[257];
DXFSmoothPolyline oSmoothPolyline;
double dfBulge = 0.0;
double dfX = 0.0;
double dfY = 0.0;
bool bHaveX = false;
bool bHaveY = false;
bool bIsClosed = false;
int nVertexCount = -1;
bool bHaveBulges = false;
/* -------------------------------------------------------------------- */
/* Read the boundary path type. */
/* -------------------------------------------------------------------- */
while( (nCode = poDS->ReadValue(szLineBuf,sizeof(szLineBuf))) > 0 )
{
if( nVertexCount > 0 && (int) oSmoothPolyline.size() == nVertexCount )
break;
switch( nCode )
{
case 93:
nVertexCount = atoi(szLineBuf);
break;
case 72:
bHaveBulges = CPL_TO_BOOL(atoi(szLineBuf));
break;
case 73:
bIsClosed = CPL_TO_BOOL(atoi(szLineBuf));
break;
case 10:
if( bHaveX && bHaveY )
{
oSmoothPolyline.AddPoint(dfX, dfY, dfElevation, dfBulge);
dfBulge = 0.0;
bHaveY = false;
}
dfX = CPLAtof(szLineBuf);
bHaveX = true;
break;
case 20:
if( bHaveX && bHaveY )
{
oSmoothPolyline.AddPoint( dfX, dfY, dfElevation, dfBulge );
dfBulge = 0.0;
bHaveX = false;
}
dfY = CPLAtof(szLineBuf);
bHaveY = true;
if( bHaveX && bHaveY && !bHaveBulges )
{
oSmoothPolyline.AddPoint( dfX, dfY, dfElevation, dfBulge );
dfBulge = 0.0;
bHaveX = false;
bHaveY = false;
}
break;
case 42:
dfBulge = CPLAtof(szLineBuf);
if( bHaveX && bHaveY )
{
oSmoothPolyline.AddPoint( dfX, dfY, dfElevation, dfBulge );
dfBulge = 0.0;
bHaveX = false;
bHaveY = false;
}
break;
default:
break;
}
}
if( nCode < 0 )
{
DXF_LAYER_READER_ERROR();
return OGRERR_FAILURE;
}
if( nCode != 10 && nCode != 20 && nCode != 42 )
poDS->UnreadValue();
if( bHaveX && bHaveY )
oSmoothPolyline.AddPoint(dfX, dfY, dfElevation, dfBulge);
if( bIsClosed )
oSmoothPolyline.Close();
if(oSmoothPolyline.IsEmpty())
{
return OGRERR_FAILURE;
}
poGC->addGeometryDirectly( oSmoothPolyline.Tesselate() );
/* -------------------------------------------------------------------- */
/* Skip through source boundary objects if present. */
/* -------------------------------------------------------------------- */
nCode = poDS->ReadValue(szLineBuf,sizeof(szLineBuf));
if( nCode != 97 )
{
if (nCode < 0)
return OGRERR_FAILURE;
poDS->UnreadValue();
}
else
{
int iObj, nObjCount = atoi(szLineBuf);
for( iObj = 0; iObj < nObjCount; iObj++ )
{
if (poDS->ReadValue( szLineBuf, sizeof(szLineBuf) ) < 0)
return OGRERR_FAILURE;
}
}
return OGRERR_NONE;
}
GDALDataset *PNMDataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Verify that this is a _raw_ ppm or pgm file. Note, we don't */
/* support ascii files, or pbm (1bit) files. */
/* -------------------------------------------------------------------- */
if( !Identify( poOpenInfo ) )
return nullptr;
/* -------------------------------------------------------------------- */
/* Parse out the tokens from the header. */
/* -------------------------------------------------------------------- */
const char *pszSrc = reinterpret_cast<char *>( poOpenInfo->pabyHeader );
char szToken[512] = { '\0' };
int iToken = 0;
int nWidth = -1;
int nHeight = -1;
int nMaxValue = -1;
int iIn = 2;
while( iIn < poOpenInfo->nHeaderBytes && iToken < 3 )
{
unsigned int iOut = 0;
szToken[0] = '\0';
while( iOut < sizeof(szToken) && iIn < poOpenInfo->nHeaderBytes )
{
if( pszSrc[iIn] == '#' )
{
while( iIn < poOpenInfo->nHeaderBytes - 1 &&
pszSrc[iIn] != 10 && pszSrc[iIn] != 13 )
iIn++;
}
if( iOut != 0 && isspace(static_cast<unsigned char>(pszSrc[iIn])) )
{
szToken[iOut] = '\0';
if( iToken == 0 )
nWidth = atoi(szToken);
else if( iToken == 1 )
nHeight = atoi(szToken);
else if( iToken == 2 )
nMaxValue = atoi(szToken);
iToken++;
iIn++;
break;
}
else if( !isspace(static_cast<unsigned char>(pszSrc[iIn])) )
{
szToken[iOut++] = pszSrc[iIn];
}
iIn++;
}
}
CPLDebug( "PNM", "PNM header contains: width=%d, height=%d, maxval=%d",
nWidth, nHeight, nMaxValue );
if( iToken != 3 || nWidth < 1 || nHeight < 1 || nMaxValue < 1 )
return nullptr;
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
PNMDataset *poDS = new PNMDataset();
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
poDS->nRasterXSize = nWidth;
poDS->nRasterYSize = nHeight;
// Borrow file pointer
poDS->fpImage = poOpenInfo->fpL;
poOpenInfo->fpL = nullptr;
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
#ifdef CPL_LSB
const bool bMSBFirst = false;
#else
const bool bMSBFirst = true;
#endif
GDALDataType eDataType = GDT_Unknown;
if ( nMaxValue < 256 )
eDataType = GDT_Byte;
else
eDataType = GDT_UInt16;
const int iPixelSize = GDALGetDataTypeSizeBytes( eDataType );
if( poOpenInfo->pabyHeader[1] == '5' )
{
if (nWidth > INT_MAX / iPixelSize)
{
CPLError( CE_Failure, CPLE_AppDefined,
"Int overflow occurred.");
delete poDS;
return nullptr;
}
poDS->SetBand(
1, new RawRasterBand( poDS, 1, poDS->fpImage, iIn, iPixelSize,
nWidth*iPixelSize, eDataType, bMSBFirst,
RawRasterBand::OwnFP::NO ) );
poDS->GetRasterBand(1)->SetColorInterpretation( GCI_GrayIndex );
}
else
{
if (nWidth > INT_MAX / (3 * iPixelSize))
{
CPLError( CE_Failure, CPLE_AppDefined,
"Int overflow occurred.");
delete poDS;
return nullptr;
}
poDS->SetBand(
1, new RawRasterBand( poDS, 1, poDS->fpImage, iIn, 3*iPixelSize,
nWidth*3*iPixelSize, eDataType, bMSBFirst,
RawRasterBand::OwnFP::NO ));
poDS->SetBand(
2, new RawRasterBand( poDS, 2, poDS->fpImage, iIn+iPixelSize,
3*iPixelSize, nWidth*3*iPixelSize,
eDataType, bMSBFirst,
RawRasterBand::OwnFP::NO ));
poDS->SetBand(
3, new RawRasterBand( poDS, 3, poDS->fpImage, iIn+2*iPixelSize,
3*iPixelSize, nWidth*3*iPixelSize,
eDataType, bMSBFirst,
RawRasterBand::OwnFP::NO ));
poDS->GetRasterBand(1)->SetColorInterpretation( GCI_RedBand );
poDS->GetRasterBand(2)->SetColorInterpretation( GCI_GreenBand );
poDS->GetRasterBand(3)->SetColorInterpretation( GCI_BlueBand );
}
/* -------------------------------------------------------------------- */
/* Check for world file. */
/* -------------------------------------------------------------------- */
poDS->bGeoTransformValid =
CPL_TO_BOOL(
GDALReadWorldFile( poOpenInfo->pszFilename, ".wld",
poDS->adfGeoTransform ) );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return poDS;
}
int OGRCouchDBDataSource::Open( const char * pszFilename, int bUpdateIn)
{
bool bHTTP =
STARTS_WITH(pszFilename, "http://") ||
STARTS_WITH(pszFilename, "https://");
if( !bHTTP && !STARTS_WITH_CI(pszFilename, "CouchDB:"))
return FALSE;
bReadWrite = CPL_TO_BOOL(bUpdateIn);
pszName = CPLStrdup( pszFilename );
if( bHTTP )
osURL = pszFilename;
else
osURL = pszFilename + 8;
if (!osURL.empty() && osURL.back() == '/')
osURL.resize(osURL.size() - 1);
const char* pszUserPwd = CPLGetConfigOption("COUCHDB_USERPWD", NULL);
if (pszUserPwd)
osUserPwd = pszUserPwd;
if ((strstr(osURL, "/_design/") && strstr(osURL, "/_view/")) ||
strstr(osURL, "/_all_docs"))
{
return OpenView() != NULL;
}
/* If passed with http://useraccount.knownprovider.com/database, do not */
/* try to issue /all_dbs, but directly open the database */
const char* pszKnowProvider = strstr(osURL, ".iriscouch.com/");
if (pszKnowProvider != NULL &&
strchr(pszKnowProvider + strlen(".iriscouch.com/"), '/' ) == NULL)
{
return OpenDatabase() != NULL;
}
pszKnowProvider = strstr(osURL, ".cloudant.com/");
if (pszKnowProvider != NULL &&
strchr(pszKnowProvider + strlen(".cloudant.com/"), '/' ) == NULL)
{
return OpenDatabase() != NULL;
}
/* Get list of tables */
json_object* poAnswerObj = GET("/_all_dbs");
if (poAnswerObj == NULL)
{
if (!STARTS_WITH_CI(pszFilename, "CouchDB:"))
CPLErrorReset();
return FALSE;
}
if ( !json_object_is_type(poAnswerObj, json_type_array) )
{
if ( json_object_is_type(poAnswerObj, json_type_object) )
{
json_object* poError = CPL_json_object_object_get(poAnswerObj, "error");
json_object* poReason = CPL_json_object_object_get(poAnswerObj, "reason");
const char* pszError = json_object_get_string(poError);
const char* pszReason = json_object_get_string(poReason);
if (pszError && pszReason && strcmp(pszError, "not_found") == 0 &&
strcmp(pszReason, "missing") == 0)
{
json_object_put(poAnswerObj);
poAnswerObj = NULL;
CPLErrorReset();
return OpenDatabase() != NULL;
}
}
if (poAnswerObj)
{
IsError(poAnswerObj, "Database listing failed");
json_object_put(poAnswerObj);
return FALSE;
}
}
int nTables = json_object_array_length(poAnswerObj);
for(int i=0;i<nTables;i++)
{
json_object* poAnswerObjDBName = json_object_array_get_idx(poAnswerObj, i);
if ( json_object_is_type(poAnswerObjDBName, json_type_string) )
{
const char* pszDBName = json_object_get_string(poAnswerObjDBName);
if ( strcmp(pszDBName, "_users") != 0 &&
strcmp(pszDBName, "_replicator") != 0 )
{
papoLayers = (OGRLayer**) CPLRealloc(papoLayers, (nLayers + 1) * sizeof(OGRLayer*));
papoLayers[nLayers ++] = new OGRCouchDBTableLayer(this, pszDBName);
}
}
}
json_object_put(poAnswerObj);
return TRUE;
}
int OGRSelafinDataSource::Open( const char * pszFilename, int bUpdateIn,
int bCreate )
{
// Check if a range is set and extract it and the filename.
const char *pszc = pszFilename;
if (*pszFilename==0) return FALSE;
while (*pszc) ++pszc;
if (*(pszc-1)==']') {
--pszc;
while (pszc!=pszFilename && *pszc!='[') pszc--;
if (pszc==pszFilename) return FALSE;
poRange.setRange(pszc);
}
pszName = CPLStrdup( pszFilename );
pszName[pszc-pszFilename]=0;
bUpdate = CPL_TO_BOOL(bUpdateIn);
if (bCreate && EQUAL(pszName, "/vsistdout/")) return TRUE;
/* For writable /vsizip/, do nothing more */
if (bCreate && STARTS_WITH(pszName, "/vsizip/")) return TRUE;
CPLString osFilename(pszName);
CPLString osBaseFilename = CPLGetFilename(pszName);
// Determine what sort of object this is.
VSIStatBufL sStatBuf;
if (VSIStatExL( osFilename, &sStatBuf, VSI_STAT_NATURE_FLAG ) != 0) return FALSE;
// Is this a single Selafin file?
if (VSI_ISREG(sStatBuf.st_mode)) return OpenTable( pszName );
// Is this a single a ZIP file with only a Selafin file inside ?
if( STARTS_WITH(osFilename, "/vsizip/") && VSI_ISREG(sStatBuf.st_mode) ) {
char** papszFiles = VSIReadDir(osFilename);
if (CSLCount(papszFiles) != 1) {
CSLDestroy(papszFiles);
return FALSE;
}
osFilename = CPLFormFilename(osFilename, papszFiles[0], nullptr);
CSLDestroy(papszFiles);
return OpenTable( osFilename );
}
#ifdef notdef
// Otherwise it has to be a directory.
if( !VSI_ISDIR(sStatBuf.st_mode) ) return FALSE;
// Scan through for entries which look like Selafin files
int nNotSelafinCount = 0, i;
char **papszNames = VSIReadDir( osFilename );
for( i = 0; papszNames != NULL && papszNames[i] != NULL; i++ ) {
CPLString oSubFilename = CPLFormFilename( osFilename, papszNames[i], NULL );
if( EQUAL(papszNames[i],".") || EQUAL(papszNames[i],"..") ) continue;
if( VSIStatL( oSubFilename, &sStatBuf ) != 0 || !VSI_ISREG(sStatBuf.st_mode) ) {
nNotSelafinCount++;
continue;
}
if( !OpenTable( oSubFilename ) ) {
CPLDebug("Selafin", "Cannot open %s", oSubFilename.c_str());
nNotSelafinCount++;
continue;
}
}
CSLDestroy( papszNames );
// We presume that this is indeed intended to be a Selafin datasource if over half the files were Selafin files.
return nNotSelafinCount < nLayers;
#else
return FALSE;
#endif
}
/**
* Runs an executable in another process (or fork the current process)
* and return immediately.
*
* This function launches an executable and returns immediately, while letting
* the sub-process to run asynchronously.
*
* It is implemented as CreateProcess() on Windows platforms, and fork()/exec()
* on other platforms.
*
* On Unix, a pointer of function can be provided to run in the child process,
* without exec()'ing a new executable.
*
* @param pfnMain the function to run in the child process (Unix only).
* @param papszArgv argument list of the executable to run. papszArgv[0] is the
* name of the executable.
* @param bCreateInputPipe set to TRUE to create a pipe for the child input stream.
* @param bCreateOutputPipe set to TRUE to create a pipe for the child output stream.
* @param bCreateErrorPipe set to TRUE to create a pipe for the child error stream.
*
* @return a handle, that must be freed with CPLSpawnAsyncFinish()
*
* @since GDAL 1.10.0
*/
CPLSpawnedProcess* CPLSpawnAsync(int (*pfnMain)(CPL_FILE_HANDLE, CPL_FILE_HANDLE),
const char * const papszArgv[],
int bCreateInputPipe,
int bCreateOutputPipe,
int bCreateErrorPipe,
CPL_UNUSED char** papszOptions)
{
int pipe_in[2] = { -1, -1 };
int pipe_out[2] = { -1, -1 };
int pipe_err[2] = { -1, -1 };
bool bDup2In = CPL_TO_BOOL(bCreateInputPipe);
bool bDup2Out = CPL_TO_BOOL(bCreateOutputPipe);
bool bDup2Err = CPL_TO_BOOL(bCreateErrorPipe);
if ((bCreateInputPipe && pipe(pipe_in)) ||
(bCreateOutputPipe && pipe(pipe_out)) ||
(bCreateErrorPipe && pipe(pipe_err)))
{
CPLError(CE_Failure, CPLE_AppDefined, "Could not create pipe");
return NULL;
}
char** papszArgvDup = CSLDuplicate( const_cast<char **>( papszArgv ) );
/* If we don't do any file actions, posix_spawnp() might be implemented */
/* efficiently as a vfork()/exec() pair (or if it is not available, we */
/* can use vfork()/exec()), so if the child is cooperative */
/* we pass the pipe handles as commandline arguments */
if( papszArgv != NULL )
{
for( int i=0; papszArgvDup[i] != NULL; i++ )
{
if( bCreateInputPipe && strcmp(papszArgvDup[i], "{pipe_in}") == 0 )
{
CPLFree(papszArgvDup[i]);
papszArgvDup[i] = CPLStrdup(CPLSPrintf("%d,%d",
pipe_in[IN_FOR_PARENT], pipe_in[OUT_FOR_PARENT]));
bDup2In = false;
}
else if( bCreateOutputPipe && strcmp(papszArgvDup[i], "{pipe_out}") == 0 )
{
CPLFree(papszArgvDup[i]);
papszArgvDup[i] = CPLStrdup(CPLSPrintf("%d,%d",
pipe_out[OUT_FOR_PARENT], pipe_out[IN_FOR_PARENT]));
bDup2Out = false;
}
else if( bCreateErrorPipe && strcmp(papszArgvDup[i], "{pipe_err}") == 0 )
{
CPLFree(papszArgvDup[i]);
papszArgvDup[i] = CPLStrdup(CPLSPrintf("%d,%d",
pipe_err[OUT_FOR_PARENT], pipe_err[IN_FOR_PARENT]));
bDup2Err = false;
}
}
}
#ifdef HAVE_POSIX_SPAWNP
if( papszArgv != NULL )
{
bool bHasActions = false;
posix_spawn_file_actions_t actions;
if( bDup2In )
{
if( !bHasActions ) posix_spawn_file_actions_init(&actions);
posix_spawn_file_actions_adddup2(&actions, pipe_in[IN_FOR_PARENT], fileno(stdin));
posix_spawn_file_actions_addclose(&actions, pipe_in[OUT_FOR_PARENT]);
bHasActions = true;
}
if( bDup2Out )
{
if( !bHasActions ) posix_spawn_file_actions_init(&actions);
posix_spawn_file_actions_adddup2(&actions, pipe_out[OUT_FOR_PARENT], fileno(stdout));
posix_spawn_file_actions_addclose(&actions, pipe_out[IN_FOR_PARENT]);
bHasActions = true;
}
if( bDup2Err )
{
if( !bHasActions ) posix_spawn_file_actions_init(&actions);
posix_spawn_file_actions_adddup2(&actions, pipe_err[OUT_FOR_PARENT], fileno(stderr));
posix_spawn_file_actions_addclose(&actions, pipe_err[IN_FOR_PARENT]);
bHasActions = true;
}
pid_t pid;
if( posix_spawnp(&pid, papszArgvDup[0],
bHasActions ? &actions : NULL,
NULL,
reinterpret_cast<char* const*>( papszArgvDup ),
environ) != 0 )
{
if( bHasActions )
posix_spawn_file_actions_destroy(&actions);
CPLError(CE_Failure, CPLE_AppDefined, "posix_spawnp() failed");
goto err;
}
CSLDestroy(papszArgvDup);
/* Close unused end of pipe */
if( bCreateInputPipe )
close(pipe_in[IN_FOR_PARENT]);
if( bCreateOutputPipe )
close(pipe_out[OUT_FOR_PARENT]);
if( bCreateErrorPipe )
close(pipe_err[OUT_FOR_PARENT]);
/* Ignore SIGPIPE */
#ifdef SIGPIPE
std::signal( SIGPIPE, SIG_IGN );
#endif
CPLSpawnedProcess *p = static_cast<CPLSpawnedProcess *>(
CPLMalloc( sizeof(CPLSpawnedProcess) ) );
if( bHasActions )
memcpy(&p->actions, &actions, sizeof(actions));
p->bFreeActions = bHasActions;
p->pid = pid;
p->fin = pipe_out[IN_FOR_PARENT];
p->fout = pipe_in[OUT_FOR_PARENT];
p->ferr = pipe_err[IN_FOR_PARENT];
return p;
}
#endif // #ifdef HAVE_POSIX_SPAWNP
pid_t pid;
#ifdef HAVE_VFORK
/* coverity[dead_error_line] */
if( papszArgv != NULL && !bDup2In && !bDup2Out && !bDup2Err )
{
/* Workaround clang static analyzer warning about unsafe use of vfork */
pid_t (*p_vfork)(void) = vfork;
pid = p_vfork();
}
else
#endif
pid = fork();
if (pid == 0)
{
/* Close unused end of pipe */
if( bDup2In )
close(pipe_in[OUT_FOR_PARENT]);
if( bDup2Out )
close(pipe_out[IN_FOR_PARENT]);
if( bDup2Err )
close(pipe_err[IN_FOR_PARENT]);
#ifndef HAVE_POSIX_SPAWNP
if( papszArgv != NULL )
{
if( bDup2In )
dup2(pipe_in[IN_FOR_PARENT], fileno(stdin));
if( bDup2Out )
dup2(pipe_out[OUT_FOR_PARENT], fileno(stdout));
if( bDup2Err )
dup2(pipe_err[OUT_FOR_PARENT], fileno(stderr));
execvp(papszArgvDup[0], (char* const*) papszArgvDup);
_exit(1);
}
else
#endif // HAVE_POSIX_SPAWNP
{
if( bCreateErrorPipe )
close(pipe_err[OUT_FOR_PARENT]);
int nRet = 0;
if (pfnMain != NULL)
nRet = pfnMain((bCreateInputPipe) ? pipe_in[IN_FOR_PARENT] : fileno(stdin),
(bCreateOutputPipe) ? pipe_out[OUT_FOR_PARENT] : fileno(stdout));
_exit(nRet);
}
}
else if( pid > 0 )
{
CSLDestroy(papszArgvDup);
/* Close unused end of pipe */
if( bCreateInputPipe )
close(pipe_in[IN_FOR_PARENT]);
if( bCreateOutputPipe )
close(pipe_out[OUT_FOR_PARENT]);
if( bCreateErrorPipe )
close(pipe_err[OUT_FOR_PARENT]);
/* Ignore SIGPIPE */
#ifdef SIGPIPE
std::signal( SIGPIPE, SIG_IGN );
#endif
CPLSpawnedProcess* p = static_cast<CPLSpawnedProcess *>(
CPLMalloc( sizeof(CPLSpawnedProcess) ) );
#ifdef HAVE_POSIX_SPAWNP
p->bFreeActions = FALSE;
#endif
p->pid = pid;
p->fin = pipe_out[IN_FOR_PARENT];
p->fout = pipe_in[OUT_FOR_PARENT];
p->ferr = pipe_err[IN_FOR_PARENT];
return p;
}
else
{
CPLError(CE_Failure, CPLE_AppDefined, "Fork failed");
goto err;
}
err:
CSLDestroy(papszArgvDup);
for( int i = 0; i < 2; i++ )
{
if (pipe_in[i] >= 0)
close(pipe_in[i]);
if (pipe_out[i] >= 0)
close(pipe_out[i]);
if (pipe_err[i] >= 0)
close(pipe_err[i]);
}
return NULL;
}
int OGRCSVDataSource::Open( const char * pszFilename, int bUpdateIn,
int bForceOpen, char** papszOpenOptionsIn )
{
pszName = CPLStrdup( pszFilename );
bUpdate = CPL_TO_BOOL(bUpdateIn);
if( bUpdate && bForceOpen && EQUAL(pszFilename, "/vsistdout/") )
return TRUE;
/* For writable /vsizip/, do nothing more */
if( bUpdate && bForceOpen && STARTS_WITH(pszFilename, "/vsizip/") )
return TRUE;
CPLString osFilename(pszFilename);
CPLString osBaseFilename = CPLGetFilename(pszFilename);
CPLString osExt = GetRealExtension(osFilename);
// pszFilename = NULL;
bool bIgnoreExtension = STARTS_WITH_CI(osFilename, "CSV:");
bool bUSGeonamesFile = false;
/* bool bGeonamesOrgFile = false; */
if (bIgnoreExtension)
{
osFilename = osFilename + 4;
}
// Those are *not* real .XLS files, but text file with tab as column
// separator.
if (EQUAL(osBaseFilename, "NfdcFacilities.xls") ||
EQUAL(osBaseFilename, "NfdcRunways.xls") ||
EQUAL(osBaseFilename, "NfdcRemarks.xls") ||
EQUAL(osBaseFilename, "NfdcSchedules.xls"))
{
if( bUpdate )
return FALSE;
bIgnoreExtension = true;
}
else if ((STARTS_WITH_CI(osBaseFilename, "NationalFile_") ||
STARTS_WITH_CI(osBaseFilename, "POP_PLACES_") ||
STARTS_WITH_CI(osBaseFilename, "HIST_FEATURES_") ||
STARTS_WITH_CI(osBaseFilename, "US_CONCISE_") ||
STARTS_WITH_CI(osBaseFilename, "AllNames_") ||
STARTS_WITH_CI(osBaseFilename, "Feature_Description_History_") ||
STARTS_WITH_CI(osBaseFilename, "ANTARCTICA_") ||
STARTS_WITH_CI(osBaseFilename, "GOVT_UNITS_") ||
STARTS_WITH_CI(osBaseFilename, "NationalFedCodes_") ||
STARTS_WITH_CI(osBaseFilename, "AllStates_") ||
STARTS_WITH_CI(osBaseFilename, "AllStatesFedCodes_") ||
( osBaseFilename.size() > 2 &&
STARTS_WITH_CI(osBaseFilename+2, "_Features_")) ||
( osBaseFilename.size() > 2 &&
STARTS_WITH_CI(osBaseFilename+2, "_FedCodes_"))) &&
(EQUAL(osExt, "txt") || EQUAL(osExt, "zip")) )
{
if( bUpdate )
return FALSE;
bIgnoreExtension = true;
bUSGeonamesFile = true;
if (EQUAL(osExt, "zip") &&
strstr(osFilename, "/vsizip/") == NULL )
{
osFilename = "/vsizip/" + osFilename;
}
}
else if (EQUAL(osBaseFilename, "allCountries.txt") ||
EQUAL(osBaseFilename, "allCountries.zip"))
{
if( bUpdate )
return FALSE;
bIgnoreExtension = true;
/* bGeonamesOrgFile = true; */
if (EQUAL(osExt, "zip") &&
strstr(osFilename, "/vsizip/") == NULL )
{
osFilename = "/vsizip/" + osFilename;
}
}
/* -------------------------------------------------------------------- */
/* Determine what sort of object this is. */
/* -------------------------------------------------------------------- */
VSIStatBufL sStatBuf;
if( VSIStatExL( osFilename, &sStatBuf, VSI_STAT_NATURE_FLAG ) != 0 )
return FALSE;
/* -------------------------------------------------------------------- */
/* Is this a single CSV file? */
/* -------------------------------------------------------------------- */
if( VSI_ISREG(sStatBuf.st_mode)
&& (bIgnoreExtension || EQUAL(osExt,"csv") || EQUAL(osExt,"tsv")) )
{
if (EQUAL(CPLGetFilename(osFilename), "NfdcFacilities.xls"))
{
return OpenTable( osFilename, papszOpenOptionsIn, "ARP");
}
else if (EQUAL(CPLGetFilename(osFilename), "NfdcRunways.xls"))
{
OpenTable( osFilename, papszOpenOptionsIn, "BaseEndPhysical");
OpenTable( osFilename, papszOpenOptionsIn, "BaseEndDisplaced");
OpenTable( osFilename, papszOpenOptionsIn, "ReciprocalEndPhysical");
OpenTable( osFilename, papszOpenOptionsIn,
"ReciprocalEndDisplaced");
return nLayers != 0;
}
else if (bUSGeonamesFile)
{
/* GNIS specific */
if (STARTS_WITH_CI(osBaseFilename, "NationalFedCodes_") ||
STARTS_WITH_CI(osBaseFilename, "AllStatesFedCodes_") ||
STARTS_WITH_CI(osBaseFilename, "ANTARCTICA_") ||
( osBaseFilename.size() > 2 &&
STARTS_WITH_CI(osBaseFilename+2, "_FedCodes_")))
{
OpenTable( osFilename, papszOpenOptionsIn, NULL, "PRIMARY");
}
else if (STARTS_WITH_CI(osBaseFilename, "GOVT_UNITS_") ||
STARTS_WITH_CI(osBaseFilename,
"Feature_Description_History_"))
{
OpenTable( osFilename, papszOpenOptionsIn, NULL, "");
}
else
{
OpenTable( osFilename, papszOpenOptionsIn, NULL, "PRIM");
OpenTable( osFilename, papszOpenOptionsIn, NULL, "SOURCE");
}
return nLayers != 0;
}
return OpenTable( osFilename, papszOpenOptionsIn );
}
/* -------------------------------------------------------------------- */
/* Is this a single a ZIP file with only a CSV file inside ? */
/* -------------------------------------------------------------------- */
if( STARTS_WITH(osFilename, "/vsizip/") &&
EQUAL(osExt, "zip") &&
VSI_ISREG(sStatBuf.st_mode) )
{
char** papszFiles = VSIReadDir(osFilename);
if (CSLCount(papszFiles) != 1 ||
!EQUAL(CPLGetExtension(papszFiles[0]), "CSV"))
{
CSLDestroy(papszFiles);
return FALSE;
}
osFilename = CPLFormFilename(osFilename, papszFiles[0], NULL);
CSLDestroy(papszFiles);
return OpenTable( osFilename, papszOpenOptionsIn );
}
/* -------------------------------------------------------------------- */
/* Otherwise it has to be a directory. */
/* -------------------------------------------------------------------- */
if( !VSI_ISDIR(sStatBuf.st_mode) )
return FALSE;
/* -------------------------------------------------------------------- */
/* Scan through for entries ending in .csv. */
/* -------------------------------------------------------------------- */
int nNotCSVCount = 0;
char **papszNames = VSIReadDir( osFilename );
for( int i = 0; papszNames != NULL && papszNames[i] != NULL; i++ )
{
CPLString oSubFilename =
CPLFormFilename( osFilename, papszNames[i], NULL );
if( EQUAL(papszNames[i],".") || EQUAL(papszNames[i],"..") )
continue;
if (EQUAL(CPLGetExtension(oSubFilename),"csvt"))
continue;
if( VSIStatL( oSubFilename, &sStatBuf ) != 0
|| !VSI_ISREG(sStatBuf.st_mode) )
{
nNotCSVCount++;
continue;
}
if (EQUAL(CPLGetExtension(oSubFilename),"csv"))
{
if( !OpenTable( oSubFilename, papszOpenOptionsIn ) )
{
CPLDebug("CSV", "Cannot open %s", oSubFilename.c_str());
nNotCSVCount++;
continue;
}
}
/* GNIS specific */
else if ( strlen(papszNames[i]) > 2 &&
STARTS_WITH_CI(papszNames[i]+2, "_Features_") &&
EQUAL(CPLGetExtension(papszNames[i]), "txt") )
{
bool bRet =
OpenTable( oSubFilename, papszOpenOptionsIn, NULL, "PRIM");
bRet |=
OpenTable( oSubFilename, papszOpenOptionsIn, NULL, "SOURCE");
if ( !bRet )
{
CPLDebug("CSV", "Cannot open %s", oSubFilename.c_str());
nNotCSVCount++;
continue;
}
}
/* GNIS specific */
else if ( strlen(papszNames[i]) > 2 &&
STARTS_WITH_CI(papszNames[i]+2, "_FedCodes_") &&
EQUAL(CPLGetExtension(papszNames[i]), "txt") )
{
if ( !OpenTable( oSubFilename, papszOpenOptionsIn,
NULL, "PRIMARY") )
{
CPLDebug("CSV", "Cannot open %s", oSubFilename.c_str());
nNotCSVCount++;
continue;
}
}
else
{
nNotCSVCount++;
continue;
}
}
CSLDestroy( papszNames );
/* -------------------------------------------------------------------- */
/* We presume that this is indeed intended to be a CSV */
/* datasource if over half the files were .csv files. */
/* -------------------------------------------------------------------- */
return bForceOpen || nNotCSVCount < nLayers;
}
int OGRProj4CT::InitializeNoLock( OGRSpatialReference * poSourceIn,
OGRSpatialReference * poTargetIn )
{
if( poSourceIn == NULL || poTargetIn == NULL )
return FALSE;
poSRSSource = poSourceIn->Clone();
poSRSTarget = poTargetIn->Clone();
bSourceLatLong = CPL_TO_BOOL(poSRSSource->IsGeographic());
bTargetLatLong = CPL_TO_BOOL(poSRSTarget->IsGeographic());
/* -------------------------------------------------------------------- */
/* Setup source and target translations to radians for lat/long */
/* systems. */
/* -------------------------------------------------------------------- */
dfSourceToRadians = DEG_TO_RAD;
bSourceWrap = false;
dfSourceWrapLong = 0.0;
if( bSourceLatLong )
{
OGR_SRSNode *poUNITS = poSRSSource->GetAttrNode( "GEOGCS|UNIT" );
if( poUNITS && poUNITS->GetChildCount() >= 2 )
{
dfSourceToRadians = CPLAtof(poUNITS->GetChild(1)->GetValue());
if( dfSourceToRadians == 0.0 )
dfSourceToRadians = DEG_TO_RAD;
}
}
dfTargetFromRadians = RAD_TO_DEG;
bTargetWrap = false;
dfTargetWrapLong = 0.0;
if( bTargetLatLong )
{
OGR_SRSNode *poUNITS = poSRSTarget->GetAttrNode( "GEOGCS|UNIT" );
if( poUNITS && poUNITS->GetChildCount() >= 2 )
{
double dfTargetToRadians = CPLAtof(poUNITS->GetChild(1)->GetValue());
if( dfTargetToRadians != 0.0 )
dfTargetFromRadians = 1 / dfTargetToRadians;
}
}
/* -------------------------------------------------------------------- */
/* Preliminary logic to setup wrapping. */
/* -------------------------------------------------------------------- */
if( CPLGetConfigOption( "CENTER_LONG", NULL ) != NULL )
{
bSourceWrap = true;
bTargetWrap = true;
dfSourceWrapLong = dfTargetWrapLong =
CPLAtof(CPLGetConfigOption( "CENTER_LONG", "" ));
CPLDebug( "OGRCT", "Wrap at %g.", dfSourceWrapLong );
}
const char *pszCENTER_LONG =
poSRSSource->GetExtension( "GEOGCS", "CENTER_LONG" );
if( pszCENTER_LONG != NULL )
{
dfSourceWrapLong = CPLAtof(pszCENTER_LONG);
bSourceWrap = true;
CPLDebug( "OGRCT", "Wrap source at %g.", dfSourceWrapLong );
}
pszCENTER_LONG = poSRSTarget->GetExtension( "GEOGCS", "CENTER_LONG" );
if( pszCENTER_LONG != NULL )
{
dfTargetWrapLong = CPLAtof(pszCENTER_LONG);
bTargetWrap = true;
CPLDebug( "OGRCT", "Wrap target at %g.", dfTargetWrapLong );
}
bCheckWithInvertProj =
CPLTestBool(CPLGetConfigOption( "CHECK_WITH_INVERT_PROJ", "NO" ));
// The threshold is experimental. Works well with the cases of ticket #2305.
if( bSourceLatLong )
dfThreshold = CPLAtof(CPLGetConfigOption( "THRESHOLD", ".1" ));
else
// 1 works well for most projections, except for +proj=aeqd that
// requires a tolerance of 10000.
dfThreshold = CPLAtof(CPLGetConfigOption( "THRESHOLD", "10000" ));
// OGRThreadSafety: The following variable is not a thread safety issue
// since the only issue is incrementing while accessing which at worse
// means debug output could be one "increment" late.
static int nDebugReportCount = 0;
char *pszSrcProj4Defn = NULL;
if( poSRSSource->exportToProj4( &pszSrcProj4Defn ) != OGRERR_NONE )
{
CPLFree( pszSrcProj4Defn );
return FALSE;
}
if( strlen(pszSrcProj4Defn) == 0 )
{
CPLFree( pszSrcProj4Defn );
CPLError( CE_Failure, CPLE_AppDefined,
"No PROJ.4 translation for source SRS, coordinate\n"
"transformation initialization has failed." );
return FALSE;
}
char *pszDstProj4Defn = NULL;
if( poSRSTarget->exportToProj4( &pszDstProj4Defn ) != OGRERR_NONE )
{
CPLFree( pszSrcProj4Defn );
CPLFree( pszDstProj4Defn );
return FALSE;
}
if( strlen(pszDstProj4Defn) == 0 )
{
CPLFree( pszSrcProj4Defn );
CPLFree( pszDstProj4Defn );
CPLError( CE_Failure, CPLE_AppDefined,
"No PROJ.4 translation for destination SRS, coordinate\n"
"transformation initialization has failed." );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Optimization to avoid useless nadgrids evaluation. */
/* For example when converting between WGS84 and WebMercator */
/* -------------------------------------------------------------------- */
if( pszSrcProj4Defn[strlen(pszSrcProj4Defn)-1] == ' ' )
pszSrcProj4Defn[strlen(pszSrcProj4Defn)-1] = 0;
if( pszDstProj4Defn[strlen(pszDstProj4Defn)-1] == ' ' )
pszDstProj4Defn[strlen(pszDstProj4Defn)-1] = 0;
char* pszNeedle = strstr(pszSrcProj4Defn, " ");
if( pszNeedle )
memmove(pszNeedle, pszNeedle + 1, strlen(pszNeedle + 1)+1);
pszNeedle = strstr(pszDstProj4Defn, " ");
if( pszNeedle )
memmove(pszNeedle, pszNeedle + 1, strlen(pszNeedle + 1)+1);
if( (strstr(pszSrcProj4Defn, "+datum=WGS84") != NULL ||
strstr(pszSrcProj4Defn, "+ellps=WGS84 +towgs84=0,0,0,0,0,0,0 ") != NULL) &&
strstr(pszDstProj4Defn, "+nadgrids=@null ") != NULL &&
strstr(pszDstProj4Defn, "+towgs84") == NULL )
{
char* pszDst = strstr(pszSrcProj4Defn, "+towgs84=0,0,0,0,0,0,0 ");
if( pszDst != NULL )
{
char *pszSrc = pszDst + strlen("+towgs84=0,0,0,0,0,0,0 ");
memmove(pszDst, pszSrc, strlen(pszSrc)+1);
}
else
{
memcpy(strstr(pszSrcProj4Defn, "+datum=WGS84"), "+ellps", 6);
}
pszDst = strstr(pszDstProj4Defn, "+nadgrids=@null ");
char *pszSrc = pszDst + strlen("+nadgrids=@null ");
memmove(pszDst, pszSrc, strlen(pszSrc)+1);
pszDst = strstr(pszDstProj4Defn, "+wktext ");
if( pszDst )
{
pszSrc = pszDst + strlen("+wktext ");
memmove(pszDst, pszSrc, strlen(pszSrc)+1);
}
//bWGS84ToWebMercator =
// strcmp(pszSrcProj4Defn, "+proj=longlat +ellps=WGS84 +no_defs") == 0 &&
// strcmp(pszDstProj4Defn, "+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +no_defs") == 0;
}
else
if( (strstr(pszDstProj4Defn, "+datum=WGS84") != NULL ||
strstr(pszDstProj4Defn, "+ellps=WGS84 +towgs84=0,0,0,0,0,0,0 ") != NULL) &&
strstr(pszSrcProj4Defn, "+nadgrids=@null ") != NULL &&
strstr(pszSrcProj4Defn, "+towgs84") == NULL )
{
char* pszDst = strstr(pszDstProj4Defn, "+towgs84=0,0,0,0,0,0,0 ");
if( pszDst != NULL)
{
char* pszSrc = pszDst + strlen("+towgs84=0,0,0,0,0,0,0 ");
memmove(pszDst, pszSrc, strlen(pszSrc)+1);
}
else
memcpy(strstr(pszDstProj4Defn, "+datum=WGS84"), "+ellps", 6);
pszDst = strstr(pszSrcProj4Defn, "+nadgrids=@null ");
char* pszSrc = pszDst + strlen("+nadgrids=@null ");
memmove(pszDst, pszSrc, strlen(pszSrc)+1);
pszDst = strstr(pszSrcProj4Defn, "+wktext ");
if( pszDst )
{
pszSrc = pszDst + strlen("+wktext ");
memmove(pszDst, pszSrc, strlen(pszSrc)+1);
}
bWebMercatorToWGS84 =
strcmp(pszDstProj4Defn,
"+proj=longlat +ellps=WGS84 +no_defs") == 0 &&
strcmp(pszSrcProj4Defn,
"+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 "
"+x_0=0.0 +y_0=0 +k=1.0 +units=m +no_defs") == 0;
}
/* -------------------------------------------------------------------- */
/* Establish PROJ.4 handle for source if projection. */
/* -------------------------------------------------------------------- */
if( !bWebMercatorToWGS84 )
{
if (pjctx)
psPJSource = pfn_pj_init_plus_ctx( pjctx, pszSrcProj4Defn );
else
psPJSource = pfn_pj_init_plus( pszSrcProj4Defn );
if( psPJSource == NULL )
{
if( pjctx != NULL)
{
int l_pj_errno = pfn_pj_ctx_get_errno(pjctx);
/* pfn_pj_strerrno not yet thread-safe in PROJ 4.8.0 */
CPLMutexHolderD(&hPROJMutex);
CPLError( CE_Failure, CPLE_NotSupported,
"Failed to initialize PROJ.4 with `%s'.\n%s",
pszSrcProj4Defn, pfn_pj_strerrno(l_pj_errno) );
}
else if( pfn_pj_get_errno_ref != NULL
&& pfn_pj_strerrno != NULL )
{
int *p_pj_errno = pfn_pj_get_errno_ref();
CPLError( CE_Failure, CPLE_NotSupported,
"Failed to initialize PROJ.4 with `%s'.\n%s",
pszSrcProj4Defn, pfn_pj_strerrno(*p_pj_errno) );
}
else
{
CPLError( CE_Failure, CPLE_NotSupported,
"Failed to initialize PROJ.4 with `%s'.\n",
pszSrcProj4Defn );
}
}
}
if( nDebugReportCount < 10 )
CPLDebug( "OGRCT", "Source: %s", pszSrcProj4Defn );
if( !bWebMercatorToWGS84 && psPJSource == NULL )
{
CPLFree( pszSrcProj4Defn );
CPLFree( pszDstProj4Defn );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Establish PROJ.4 handle for target if projection. */
/* -------------------------------------------------------------------- */
if( !bWebMercatorToWGS84 )
{
if (pjctx)
psPJTarget = pfn_pj_init_plus_ctx( pjctx, pszDstProj4Defn );
else
psPJTarget = pfn_pj_init_plus( pszDstProj4Defn );
if( psPJTarget == NULL )
CPLError( CE_Failure, CPLE_NotSupported,
"Failed to initialize PROJ.4 with `%s'.",
pszDstProj4Defn );
}
if( nDebugReportCount < 10 )
{
CPLDebug( "OGRCT", "Target: %s", pszDstProj4Defn );
nDebugReportCount++;
}
if( !bWebMercatorToWGS84 && psPJTarget == NULL )
{
CPLFree( pszSrcProj4Defn );
CPLFree( pszDstProj4Defn );
return FALSE;
}
/* Determine if we really have a transformation to do */
bIdentityTransform = strcmp(pszSrcProj4Defn, pszDstProj4Defn) == 0;
#if 0
/* In case of identity transform, under the following conditions, */
/* we can also avoid transforming from degrees <--> radians. */
if( bIdentityTransform && bSourceLatLong && !bSourceWrap &&
bTargetLatLong && !bTargetWrap &&
fabs(dfSourceToRadians * dfTargetFromRadians - 1.0) < 1e-10 )
{
// bSourceLatLong = false;
// bTargetLatLong = false;
}
#endif
CPLFree( pszSrcProj4Defn );
CPLFree( pszDstProj4Defn );
return TRUE;
}
bool OGRCSVDataSource::OpenTable( const char * pszFilename,
char** papszOpenOptionsIn,
const char* pszNfdcRunwaysGeomField,
const char* pszGeonamesGeomFieldPrefix)
{
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
VSILFILE *fp = NULL;
if( bUpdate )
fp = VSIFOpenL( pszFilename, "rb+" );
else
fp = VSIFOpenL( pszFilename, "rb" );
if( fp == NULL )
{
CPLError( CE_Warning, CPLE_OpenFailed,
"Failed to open %s, %s.",
pszFilename, VSIStrerror( errno ) );
return false;
}
if( !bUpdate && strstr(pszFilename, "/vsigzip/") == NULL &&
strstr(pszFilename, "/vsizip/") == NULL )
fp = reinterpret_cast<VSILFILE *>(
VSICreateBufferedReaderHandle(
reinterpret_cast<VSIVirtualHandle *>( fp ) ) );
CPLString osLayerName = CPLGetBasename(pszFilename);
CPLString osExt = CPLGetExtension(pszFilename);
if( STARTS_WITH(pszFilename, "/vsigzip/") && EQUAL(osExt, "gz") )
{
if( strlen(pszFilename) > 7
&& EQUAL(pszFilename + strlen(pszFilename) - 7, ".csv.gz") )
{
osLayerName = osLayerName.substr(0, osLayerName.size() - 4);
osExt = "csv";
}
else if( strlen(pszFilename) > 7
&& EQUAL(pszFilename + strlen(pszFilename) - 7, ".tsv.gz") )
{
osLayerName = osLayerName.substr(0, osLayerName.size() - 4);
osExt = "tsv";
}
}
/* -------------------------------------------------------------------- */
/* Read and parse a line. Did we get multiple fields? */
/* -------------------------------------------------------------------- */
const char* pszLine = CPLReadLineL( fp );
if (pszLine == NULL)
{
VSIFCloseL( fp );
return false;
}
char chDelimiter = CSVDetectSeperator(pszLine);
if( chDelimiter != '\t' && strchr(pszLine, '\t') != NULL )
{
// Force the delimiter to be TAB for a .tsv file that has a tabulation
// in its first line */
if( EQUAL(osExt, "tsv") )
{
chDelimiter = '\t';
}
else
{
for( int nDontHonourStrings = 0;
nDontHonourStrings <= 1;
nDontHonourStrings++ )
{
const bool bDontHonourStrings = CPL_TO_BOOL(nDontHonourStrings);
// Read the first 2 lines to see if they have the same number
// of fields, if using tabulation.
VSIRewindL( fp );
char** papszTokens = OGRCSVReadParseLineL( fp, '\t',
bDontHonourStrings );
int nTokens1 = CSLCount(papszTokens);
CSLDestroy(papszTokens);
papszTokens = OGRCSVReadParseLineL( fp, '\t',
bDontHonourStrings );
int nTokens2 = CSLCount(papszTokens);
CSLDestroy(papszTokens);
if( nTokens1 >= 2 && nTokens1 == nTokens2 )
{
chDelimiter = '\t';
break;
}
}
}
}
VSIRewindL( fp );
#if 0
const char *pszDelimiter = CSLFetchNameValueDef( papszOpenOptionsIn,
"SEPARATOR", "AUTO");
if( !EQUAL(pszDelimiter, "AUTO") )
{
if (EQUAL(pszDelimiter, "COMMA"))
chDelimiter = ',';
else if (EQUAL(pszDelimiter, "SEMICOLON"))
chDelimiter = ';';
else if (EQUAL(pszDelimiter, "TAB"))
chDelimiter = '\t';
else if (EQUAL(pszDelimiter, "SPACE"))
chDelimiter = ' ';
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"SEPARATOR=%s not understood, use one of COMMA, "
"SEMICOLON, SPACE or TAB.",
pszDelimiter );
}
}
#endif
/* GNIS specific */
if (pszGeonamesGeomFieldPrefix != NULL &&
strchr(pszLine, '|') != NULL)
chDelimiter = '|';
char **papszFields = OGRCSVReadParseLineL( fp, chDelimiter, false );
if( CSLCount(papszFields) < 2 )
{
VSIFCloseL( fp );
CSLDestroy( papszFields );
return false;
}
VSIRewindL( fp );
CSLDestroy( papszFields );
/* -------------------------------------------------------------------- */
/* Create a layer. */
/* -------------------------------------------------------------------- */
nLayers++;
papoLayers = static_cast<OGRLayer **>(
CPLRealloc( papoLayers, sizeof(void*) * nLayers ) );
if (pszNfdcRunwaysGeomField != NULL)
{
osLayerName += "_";
osLayerName += pszNfdcRunwaysGeomField;
}
else if (pszGeonamesGeomFieldPrefix != NULL &&
!EQUAL(pszGeonamesGeomFieldPrefix, ""))
{
osLayerName += "_";
osLayerName += pszGeonamesGeomFieldPrefix;
}
if (EQUAL(pszFilename, "/vsistdin/"))
osLayerName = "layer";
OGRCSVLayer* poCSVLayer =
new OGRCSVLayer( osLayerName, fp, pszFilename, FALSE, bUpdate,
chDelimiter );
poCSVLayer->BuildFeatureDefn( pszNfdcRunwaysGeomField,
pszGeonamesGeomFieldPrefix,
papszOpenOptionsIn );
OGRLayer* poLayer = poCSVLayer;
if( bUpdate )
{
poLayer = new OGRCSVEditableLayer(poCSVLayer, papszOpenOptionsIn);
}
papoLayers[nLayers-1] = poLayer;
return true;
}
CPLErr
VRTFilteredSource::RasterIO( GDALDataType eBandDataType,
int nXOff, int nYOff, int nXSize, int nYSize,
void *pData, int nBufXSize, int nBufYSize,
GDALDataType eBufType,
GSpacing nPixelSpace,
GSpacing nLineSpace,
GDALRasterIOExtraArg* psExtraArg )
{
/* -------------------------------------------------------------------- */
/* For now we don't support filtered access to non-full */
/* resolution requests. Just collect the data directly without */
/* any operator. */
/* -------------------------------------------------------------------- */
if( nBufXSize != nXSize || nBufYSize != nYSize )
{
return VRTComplexSource::RasterIO( eBandDataType,
nXOff, nYOff, nXSize, nYSize,
pData, nBufXSize, nBufYSize,
eBufType, nPixelSpace, nLineSpace,
psExtraArg );
}
// The window we will actually request from the source raster band.
double dfReqXOff = 0.0;
double dfReqYOff = 0.0;
double dfReqXSize = 0.0;
double dfReqYSize = 0.0;
int nReqXOff = 0;
int nReqYOff = 0;
int nReqXSize = 0;
int nReqYSize = 0;
// The window we will actual set _within_ the pData buffer.
int nOutXOff = 0;
int nOutYOff = 0;
int nOutXSize = 0;
int nOutYSize = 0;
if( !GetSrcDstWindow( nXOff, nYOff, nXSize, nYSize, nBufXSize, nBufYSize,
&dfReqXOff, &dfReqYOff, &dfReqXSize, &dfReqYSize,
&nReqXOff, &nReqYOff, &nReqXSize, &nReqYSize,
&nOutXOff, &nOutYOff, &nOutXSize, &nOutYSize ) )
return CE_None;
pData = reinterpret_cast<GByte *>( pData )
+ nPixelSpace * nOutXOff
+ nLineSpace * nOutYOff;
/* -------------------------------------------------------------------- */
/* Determine the data type we want to request. We try to match */
/* the source or destination request, and if both those fail we */
/* fallback to the first supported type at least as expressive */
/* as the request. */
/* -------------------------------------------------------------------- */
GDALDataType eOperDataType = GDT_Unknown;
if( IsTypeSupported( eBufType ) )
eOperDataType = eBufType;
if( eOperDataType == GDT_Unknown
&& IsTypeSupported( m_poRasterBand->GetRasterDataType() ) )
eOperDataType = m_poRasterBand->GetRasterDataType();
if( eOperDataType == GDT_Unknown )
{
for( int i = 0; i < m_nSupportedTypesCount; i++ )
{
if( GDALDataTypeUnion( m_aeSupportedTypes[i], eBufType )
== m_aeSupportedTypes[i] )
{
eOperDataType = m_aeSupportedTypes[i];
}
}
}
if( eOperDataType == GDT_Unknown )
{
eOperDataType = m_aeSupportedTypes[0];
for( int i = 1; i < m_nSupportedTypesCount; i++ )
{
if( GDALGetDataTypeSize( m_aeSupportedTypes[i] )
> GDALGetDataTypeSize( eOperDataType ) )
{
eOperDataType = m_aeSupportedTypes[i];
}
}
}
/* -------------------------------------------------------------------- */
/* Allocate the buffer of data into which our imagery will be */
/* read, with the extra edge pixels as well. This will be the */
/* source data fed into the filter. */
/* -------------------------------------------------------------------- */
if( nOutXSize > INT_MAX - 2 * m_nExtraEdgePixels ||
nOutYSize > INT_MAX - 2 * m_nExtraEdgePixels )
{
return CE_Failure;
}
const int nExtraXSize = nOutXSize + 2 * m_nExtraEdgePixels;
const int nExtraYSize = nOutYSize + 2 * m_nExtraEdgePixels;
GByte *pabyWorkData = static_cast<GByte *>(
VSI_MALLOC3_VERBOSE( nExtraXSize, nExtraYSize,
GDALGetDataTypeSizeBytes(eOperDataType)) );
if( pabyWorkData == nullptr )
{
return CE_Failure;
}
const GPtrDiff_t nPixelOffset = GDALGetDataTypeSizeBytes( eOperDataType );
const GPtrDiff_t nLineOffset = nPixelOffset * nExtraXSize;
memset( pabyWorkData, 0, nLineOffset * nExtraYSize );
/* -------------------------------------------------------------------- */
/* Allocate the output buffer in the same dimensions as the work */
/* buffer. This allows the filter process to write edge pixels */
/* if needed for two-pass (separable) filtering. */
/* -------------------------------------------------------------------- */
GByte *pabyOutData = static_cast<GByte *>(
VSI_MALLOC3_VERBOSE( nExtraXSize, nExtraYSize, nPixelOffset ) );
if( pabyOutData == nullptr )
{
CPLFree( pabyWorkData );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Figure out the extended window that we want to load. Note */
/* that we keep track of the file window as well as the amount */
/* we will need to edge fill past the edge of the source dataset. */
/* -------------------------------------------------------------------- */
int nFileXOff = nReqXOff - m_nExtraEdgePixels;
int nFileYOff = nReqYOff - m_nExtraEdgePixels;
int nFileXSize = nExtraXSize;
int nFileYSize = nExtraYSize;
int nTopFill = 0;
int nLeftFill = 0;
int nRightFill = 0;
int nBottomFill = 0;
if( nFileXOff < 0 )
{
nLeftFill = -nFileXOff;
nFileXOff = 0;
nFileXSize -= nLeftFill;
}
if( nFileYOff < 0 )
{
nTopFill = -nFileYOff;
nFileYOff = 0;
nFileYSize -= nTopFill;
}
if( nFileXOff + nFileXSize > m_poRasterBand->GetXSize() )
{
nRightFill = nFileXOff + nFileXSize - m_poRasterBand->GetXSize();
nFileXSize -= nRightFill;
}
if( nFileYOff + nFileYSize > m_poRasterBand->GetYSize() )
{
nBottomFill = nFileYOff + nFileYSize - m_poRasterBand->GetYSize();
nFileYSize -= nBottomFill;
}
/* -------------------------------------------------------------------- */
/* Load the data. */
/* -------------------------------------------------------------------- */
{
const bool bIsComplex = CPL_TO_BOOL( GDALDataTypeIsComplex(eOperDataType) );
const CPLErr eErr
= VRTComplexSource::RasterIOInternal<float>(
nFileXOff, nFileYOff, nFileXSize, nFileYSize,
pabyWorkData + nLineOffset * nTopFill + nPixelOffset * nLeftFill,
nFileXSize, nFileYSize, eOperDataType,
nPixelOffset, nLineOffset, psExtraArg,
bIsComplex ? GDT_CFloat32 : GDT_Float32 );
if( eErr != CE_None )
{
VSIFree( pabyWorkData );
VSIFree( pabyOutData );
return eErr;
}
}
/* -------------------------------------------------------------------- */
/* Fill in missing areas. Note that we replicate the edge */
/* valid values out. We don't using "mirroring" which might be */
/* more suitable for some times of filters. We also don't mark */
/* these pixels as "nodata" though perhaps we should. */
/* -------------------------------------------------------------------- */
if( nLeftFill != 0 || nRightFill != 0 )
{
for( int i = nTopFill; i < nExtraYSize - nBottomFill; i++ )
{
if( nLeftFill != 0 )
GDALCopyWords( pabyWorkData + nPixelOffset * nLeftFill
+ i * nLineOffset, eOperDataType, 0,
pabyWorkData + i * nLineOffset, eOperDataType,
static_cast<int>(nPixelOffset), nLeftFill );
if( nRightFill != 0 )
GDALCopyWords( pabyWorkData + i * nLineOffset
+ nPixelOffset * (nExtraXSize - nRightFill - 1),
eOperDataType, 0,
pabyWorkData + i * nLineOffset
+ nPixelOffset * (nExtraXSize - nRightFill),
eOperDataType,
static_cast<int>(nPixelOffset), nRightFill );
}
}
for( int i = 0; i < nTopFill; i++ )
{
memcpy( pabyWorkData + i * nLineOffset,
pabyWorkData + nTopFill * nLineOffset,
nLineOffset );
}
for( int i = nExtraYSize - nBottomFill; i < nExtraYSize; i++ )
{
memcpy( pabyWorkData + i * nLineOffset,
pabyWorkData + (nExtraYSize - nBottomFill - 1) * nLineOffset,
nLineOffset );
}
/* -------------------------------------------------------------------- */
/* Filter the data. */
/* -------------------------------------------------------------------- */
const CPLErr eErr = FilterData( nExtraXSize, nExtraYSize, eOperDataType,
pabyWorkData, pabyOutData );
VSIFree( pabyWorkData );
if( eErr != CE_None )
{
VSIFree( pabyOutData );
return eErr;
}
/* -------------------------------------------------------------------- */
/* Copy from work buffer to target buffer. */
/* -------------------------------------------------------------------- */
GByte *pabySrcRow =
pabyOutData + (nLineOffset + nPixelOffset) * m_nExtraEdgePixels;
GByte *pabyDstRow = reinterpret_cast<GByte *>( pData );
for( int i = 0; i < nOutYSize; i++,
pabySrcRow += nLineOffset, pabyDstRow += nLineSpace )
{
GDALCopyWords( pabySrcRow, eOperDataType, static_cast<int>(nPixelOffset),
pabyDstRow, eBufType, static_cast<int>(nPixelSpace),
nOutXSize );
}
VSIFree( pabyOutData );
return CE_None;
}
int OGRAmigoCloudDataSource::Open( const char * pszFilename,
char** papszOpenOptionsIn,
int bUpdateIn )
{
bReadWrite = CPL_TO_BOOL(bUpdateIn);
pszName = CPLStrdup( pszFilename );
pszProjectId = CPLStrdup(pszFilename + strlen("AMIGOCLOUD:"));
char* pchSpace = strchr(pszProjectId, ' ');
if( pchSpace )
*pchSpace = '\0';
if( pszProjectId[0] == 0 )
{
CPLError(CE_Failure, CPLE_AppDefined, "Missing project id");
return FALSE;
}
osAPIKey = CSLFetchNameValueDef(papszOpenOptionsIn, "AMIGOCLOUD_API_KEY",
CPLGetConfigOption("AMIGOCLOUD_API_KEY", ""));
if (osAPIKey.empty())
{
osAPIKey = OGRAMIGOCLOUDGetOptionValue(pszFilename, "AMIGOCLOUD_API_KEY");
}
if (osAPIKey.empty())
{
CPLError(CE_Failure, CPLE_AppDefined, "AMIGOCLOUD_API_KEY is not defined.\n");
return FALSE;
}
OGRLayer* poSchemaLayer = ExecuteSQLInternal("SELECT current_schema()");
if( poSchemaLayer )
{
OGRFeature* poFeat = poSchemaLayer->GetNextFeature();
if( poFeat )
{
if( poFeat->GetFieldCount() == 1 )
{
osCurrentSchema = poFeat->GetFieldAsString(0);
}
delete poFeat;
}
ReleaseResultSet(poSchemaLayer);
}
if( osCurrentSchema.empty() )
return FALSE;
CPLString osDatasets = OGRAMIGOCLOUDGetOptionValue(pszFilename, "datasets");
if (!osDatasets.empty())
{
char** papszTables = CSLTokenizeString2(osDatasets, ",", 0);
for(int i=0;papszTables && papszTables[i];i++)
{
papoLayers = (OGRAmigoCloudTableLayer**) CPLRealloc(
papoLayers, (nLayers + 1) * sizeof(OGRAmigoCloudTableLayer*));
papoLayers[nLayers ++] = new OGRAmigoCloudTableLayer(this, papszTables[i]);
}
CSLDestroy(papszTables);
// If OVERWRITE: YES, truncate the layer.
if( nLayers==1 &&
CPLFetchBool(papszOpenOptionsIn, "OVERWRITE", false) )
{
TruncateDataset(papoLayers[0]->GetTableName());
}
return TRUE;
} else {
// If 'datasets' word is in the filename, but no dataset id specified,
// print the list of available datasets
if(std::string(pszFilename).find("datasets") != std::string::npos)
ListDatasets();
}
return TRUE;
}
int OGRS57DataSource::Open( const char * pszFilename )
{
pszName = CPLStrdup( pszFilename );
/* -------------------------------------------------------------------- */
/* Setup reader options. */
/* -------------------------------------------------------------------- */
char **papszReaderOptions = NULL;
if( GetOption(S57O_LNAM_REFS) == NULL )
papszReaderOptions = CSLSetNameValue( papszReaderOptions,
S57O_LNAM_REFS, "ON" );
else
papszReaderOptions =
CSLSetNameValue( papszReaderOptions, S57O_LNAM_REFS,
GetOption(S57O_LNAM_REFS) );
if( GetOption(S57O_UPDATES) != NULL )
papszReaderOptions =
CSLSetNameValue( papszReaderOptions, S57O_UPDATES,
GetOption(S57O_UPDATES));
if( GetOption(S57O_SPLIT_MULTIPOINT) != NULL )
papszReaderOptions =
CSLSetNameValue( papszReaderOptions, S57O_SPLIT_MULTIPOINT,
GetOption(S57O_SPLIT_MULTIPOINT) );
if( GetOption(S57O_ADD_SOUNDG_DEPTH) != NULL )
papszReaderOptions =
CSLSetNameValue( papszReaderOptions, S57O_ADD_SOUNDG_DEPTH,
GetOption(S57O_ADD_SOUNDG_DEPTH));
if( GetOption(S57O_PRESERVE_EMPTY_NUMBERS) != NULL )
papszReaderOptions =
CSLSetNameValue( papszReaderOptions, S57O_PRESERVE_EMPTY_NUMBERS,
GetOption(S57O_PRESERVE_EMPTY_NUMBERS) );
if( GetOption(S57O_RETURN_PRIMITIVES) != NULL )
papszReaderOptions =
CSLSetNameValue( papszReaderOptions, S57O_RETURN_PRIMITIVES,
GetOption(S57O_RETURN_PRIMITIVES) );
if( GetOption(S57O_RETURN_LINKAGES) != NULL )
papszReaderOptions =
CSLSetNameValue( papszReaderOptions, S57O_RETURN_LINKAGES,
GetOption(S57O_RETURN_LINKAGES) );
if( GetOption(S57O_RETURN_DSID) != NULL )
papszReaderOptions =
CSLSetNameValue( papszReaderOptions, S57O_RETURN_DSID,
GetOption(S57O_RETURN_DSID) );
if( GetOption(S57O_RECODE_BY_DSSI) != NULL )
papszReaderOptions =
CSLSetNameValue( papszReaderOptions, S57O_RECODE_BY_DSSI,
GetOption(S57O_RECODE_BY_DSSI) );
S57Reader *poModule = new S57Reader( pszFilename );
int bRet = poModule->SetOptions( papszReaderOptions );
CSLDestroy( papszReaderOptions );
if( !bRet )
{
delete poModule;
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Try opening. */
/* */
/* Eventually this should check for catalogs, and if found */
/* instantiate a whole series of modules. */
/* -------------------------------------------------------------------- */
if( !poModule->Open( TRUE ) )
{
delete poModule;
return FALSE;
}
bool bSuccess = true;
nModules = 1;
papoModules = static_cast<S57Reader **>( CPLMalloc(sizeof(void*)) );
papoModules[0] = poModule;
/* -------------------------------------------------------------------- */
/* Add the header layers if they are called for. */
/* -------------------------------------------------------------------- */
if( GetOption( S57O_RETURN_DSID ) == NULL
|| CPLTestBool(GetOption( S57O_RETURN_DSID )) )
{
OGRFeatureDefn *poDefn = S57GenerateDSIDFeatureDefn();
AddLayer( new OGRS57Layer( this, poDefn ) );
}
/* -------------------------------------------------------------------- */
/* Add the primitive layers if they are called for. */
/* -------------------------------------------------------------------- */
if( GetOption( S57O_RETURN_PRIMITIVES ) != NULL )
{
OGRFeatureDefn *poDefn
= S57GenerateVectorPrimitiveFeatureDefn(
RCNM_VI, poModule->GetOptionFlags());
AddLayer( new OGRS57Layer( this, poDefn ) );
poDefn = S57GenerateVectorPrimitiveFeatureDefn(
RCNM_VC, poModule->GetOptionFlags());
AddLayer( new OGRS57Layer( this, poDefn ) );
poDefn = S57GenerateVectorPrimitiveFeatureDefn(
RCNM_VE, poModule->GetOptionFlags());
AddLayer( new OGRS57Layer( this, poDefn ) );
poDefn = S57GenerateVectorPrimitiveFeatureDefn(
RCNM_VF, poModule->GetOptionFlags());
AddLayer( new OGRS57Layer( this, poDefn ) );
}
/* -------------------------------------------------------------------- */
/* Initialize a layer for each type of geometry. Eventually */
/* we will do this by object class. */
/* -------------------------------------------------------------------- */
if( OGRS57Driver::GetS57Registrar() == NULL )
{
OGRFeatureDefn *poDefn
= S57GenerateGeomFeatureDefn( wkbPoint,
poModule->GetOptionFlags() );
AddLayer( new OGRS57Layer( this, poDefn ) );
poDefn = S57GenerateGeomFeatureDefn( wkbLineString,
poModule->GetOptionFlags() );
AddLayer( new OGRS57Layer( this, poDefn ) );
poDefn = S57GenerateGeomFeatureDefn( wkbPolygon,
poModule->GetOptionFlags() );
AddLayer( new OGRS57Layer( this, poDefn ) );
poDefn = S57GenerateGeomFeatureDefn( wkbNone,
poModule->GetOptionFlags() );
AddLayer( new OGRS57Layer( this, poDefn ) );
}
/* -------------------------------------------------------------------- */
/* Initialize a feature definition for each class that actually */
/* occurs in the dataset. */
/* -------------------------------------------------------------------- */
else
{
poClassContentExplorer =
new S57ClassContentExplorer( OGRS57Driver::GetS57Registrar() );
for( int iModule = 0; iModule < nModules; iModule++ )
papoModules[iModule]->SetClassBased(
OGRS57Driver::GetS57Registrar(), poClassContentExplorer );
std::vector<int> anClassCount;
for( int iModule = 0; iModule < nModules; iModule++ )
{
bSuccess &= CPL_TO_BOOL(
papoModules[iModule]->CollectClassList(anClassCount) );
}
bool bGeneric = false;
for( unsigned int iClass = 0; iClass < anClassCount.size(); iClass++ )
{
if( anClassCount[iClass] > 0 )
{
OGRFeatureDefn *poDefn =
S57GenerateObjectClassDefn( OGRS57Driver::GetS57Registrar(),
poClassContentExplorer,
iClass,
poModule->GetOptionFlags() );
if( poDefn != NULL )
AddLayer( new OGRS57Layer( this, poDefn,
anClassCount[iClass] ) );
else
{
bGeneric = true;
CPLDebug( "S57",
"Unable to find definition for OBJL=%d\n",
iClass );
}
}
}
if( bGeneric )
{
OGRFeatureDefn *poDefn
= S57GenerateGeomFeatureDefn( wkbUnknown,
poModule->GetOptionFlags() );
AddLayer( new OGRS57Layer( this, poDefn ) );
}
}
/* -------------------------------------------------------------------- */
/* Attach the layer definitions to each of the readers. */
/* -------------------------------------------------------------------- */
for( int iModule = 0; iModule < nModules; iModule++ )
{
for( int iLayer = 0; iLayer < nLayers; iLayer++ )
{
papoModules[iModule]->AddFeatureDefn(
papoLayers[iLayer]->GetLayerDefn() );
}
}
return bSuccess;
}
int OGRAmigoCloudDataSource::Open( const char * pszFilename,
char** papszOpenOptionsIn,
int bUpdateIn )
{
bReadWrite = CPL_TO_BOOL(bUpdateIn);
pszName = CPLStrdup( pszFilename );
if( CSLFetchNameValue(papszOpenOptionsIn, "PROJECTID") )
pszProjetctId = CPLStrdup(CSLFetchNameValue(papszOpenOptionsIn, "PROJECTID"));
else
{
pszProjetctId = CPLStrdup(pszFilename + strlen("AMIGOCLOUD:"));
char* pchSpace = strchr(pszProjetctId, ' ');
if( pchSpace )
*pchSpace = '\0';
if( pszProjetctId[0] == 0 )
{
CPLError(CE_Failure, CPLE_AppDefined, "Missing projetc id");
return FALSE;
}
}
osAPIKey = CSLFetchNameValueDef(papszOpenOptionsIn, "API_KEY",
CPLGetConfigOption("AMIGOCLOUD_API_KEY", ""));
CPLString osDatasets = OGRAMIGOCLOUDGetOptionValue(pszFilename, "datasets");
bUseHTTPS = CPLTestBool(CPLGetConfigOption("AMIGOCLOUD_HTTPS", "YES"));
OGRLayer* poSchemaLayer = ExecuteSQLInternal("SELECT current_schema()");
if( poSchemaLayer )
{
OGRFeature* poFeat = poSchemaLayer->GetNextFeature();
if( poFeat )
{
if( poFeat->GetFieldCount() == 1 )
{
osCurrentSchema = poFeat->GetFieldAsString(0);
}
delete poFeat;
}
ReleaseResultSet(poSchemaLayer);
}
if( osCurrentSchema.size() == 0 )
return FALSE;
if (osDatasets.size() != 0)
{
char** papszTables = CSLTokenizeString2(osDatasets, ",", 0);
for(int i=0;papszTables && papszTables[i];i++)
{
papoLayers = (OGRAmigoCloudTableLayer**) CPLRealloc(
papoLayers, (nLayers + 1) * sizeof(OGRAmigoCloudTableLayer*));
papoLayers[nLayers ++] = new OGRAmigoCloudTableLayer(this, papszTables[i]);
}
CSLDestroy(papszTables);
return TRUE;
}
return TRUE;
}
bool OGRShapeDataSource::Open( GDALOpenInfo* poOpenInfo,
bool bTestOpen, bool bForceSingleFileDataSource )
{
CPLAssert( nLayers == 0 );
const char * pszNewName = poOpenInfo->pszFilename;
const bool bUpdate = poOpenInfo->eAccess == GA_Update;
papszOpenOptions = CSLDuplicate( poOpenInfo->papszOpenOptions );
pszName = CPLStrdup( pszNewName );
bDSUpdate = bUpdate;
bSingleFileDataSource = CPL_TO_BOOL(bForceSingleFileDataSource);
/* -------------------------------------------------------------------- */
/* If bSingleFileDataSource is TRUE we don't try to do anything */
/* else. */
/* This is only utilized when the OGRShapeDriver::Create() */
/* method wants to create a stub OGRShapeDataSource for a */
/* single shapefile. The driver will take care of creating the */
/* file by calling ICreateLayer(). */
/* -------------------------------------------------------------------- */
if( bSingleFileDataSource )
return true;
/* -------------------------------------------------------------------- */
/* Is the given path a directory or a regular file? */
/* -------------------------------------------------------------------- */
if( !poOpenInfo->bStatOK )
{
if( !bTestOpen )
CPLError( CE_Failure, CPLE_AppDefined,
"%s is neither a file or directory, Shape access failed.",
pszNewName );
return false;
}
/* -------------------------------------------------------------------- */
/* Build a list of filenames we figure are Shape files. */
/* -------------------------------------------------------------------- */
if( !poOpenInfo->bIsDirectory )
{
if( !OpenFile( pszNewName, bUpdate ) )
{
if( !bTestOpen )
CPLError(
CE_Failure, CPLE_OpenFailed,
"Failed to open shapefile %s. "
"It may be corrupt or read-only file accessed in "
"update mode.",
pszNewName );
return false;
}
bSingleFileDataSource = true;
return true;
}
else
{
char **papszCandidates = VSIReadDir( pszNewName );
const int nCandidateCount = CSLCount( papszCandidates );
bool bMightBeOldCoverage = false;
std::set<CPLString> osLayerNameSet;
for( int iCan = 0; iCan < nCandidateCount; iCan++ )
{
const char *pszCandidate = papszCandidates[iCan];
const char *pszLayerName = CPLGetBasename(pszCandidate);
CPLString osLayerName(pszLayerName);
#ifdef WIN32
// On Windows, as filenames are case insensitive, a shapefile layer
// can be made of foo.shp and FOO.DBF, so to detect unique layer
// names, put them upper case in the unique set used for detection.
osLayerName.toupper();
#endif
if( EQUAL(pszCandidate,"ARC") )
bMightBeOldCoverage = true;
if( strlen(pszCandidate) < 4
|| !EQUAL(pszCandidate+strlen(pszCandidate)-4,".shp") )
continue;
char *pszFilename =
CPLStrdup(CPLFormFilename(pszNewName, pszCandidate, NULL));
osLayerNameSet.insert(osLayerName);
#ifdef IMMEDIATE_OPENING
if( !OpenFile( pszFilename, bUpdate )
&& !bTestOpen )
{
CPLError(
CE_Failure, CPLE_OpenFailed,
"Failed to open shapefile %s. "
"It may be corrupt or read-only file accessed in "
"update mode.",
pszFilename );
CPLFree( pszFilename );
CSLDestroy( papszCandidates );
return false;
}
#else
oVectorLayerName.push_back(pszFilename);
#endif
CPLFree( pszFilename );
}
// Try and .dbf files without apparent associated shapefiles.
for( int iCan = 0; iCan < nCandidateCount; iCan++ )
{
const char *pszCandidate = papszCandidates[iCan];
const char *pszLayerName = CPLGetBasename(pszCandidate);
CPLString osLayerName(pszLayerName);
#ifdef WIN32
osLayerName.toupper();
#endif
// We don't consume .dbf files in a directory that looks like
// an old style Arc/Info (for PC?) that unless we found at least
// some shapefiles. See Bug 493.
if( bMightBeOldCoverage && osLayerNameSet.size() == 0 )
continue;
if( strlen(pszCandidate) < 4
|| !EQUAL(pszCandidate+strlen(pszCandidate)-4, ".dbf") )
continue;
if( osLayerNameSet.find(osLayerName) != osLayerNameSet.end() )
continue;
// We don't want to access .dbf files with an associated .tab
// file, or it will never get recognised as a mapinfo dataset.
bool bFoundTAB = false;
for( int iCan2 = 0; iCan2 < nCandidateCount; iCan2++ )
{
const char *pszCandidate2 = papszCandidates[iCan2];
if( EQUALN(pszCandidate2, pszLayerName, strlen(pszLayerName))
&& EQUAL(pszCandidate2 + strlen(pszLayerName), ".tab") )
bFoundTAB = true;
}
if( bFoundTAB )
continue;
char *pszFilename =
CPLStrdup(CPLFormFilename(pszNewName, pszCandidate, NULL));
osLayerNameSet.insert(osLayerName);
#ifdef IMMEDIATE_OPENING
if( !OpenFile( pszFilename, bUpdate )
&& !bTestOpen )
{
CPLError(
CE_Failure, CPLE_OpenFailed,
"Failed to open dbf file %s. "
"It may be corrupt or read-only file accessed in "
"update mode.",
pszFilename );
CPLFree( pszFilename );
CSLDestroy( papszCandidates );
return false;
}
#else
oVectorLayerName.push_back(pszFilename);
#endif
CPLFree( pszFilename );
}
CSLDestroy( papszCandidates );
#ifdef IMMEDIATE_OPENING
const int nDirLayers = nLayers;
#else
const int nDirLayers = static_cast<int>(oVectorLayerName.size());
#endif
CPLErrorReset();
return nDirLayers > 0 || !bTestOpen;
}
}
OGRLayer * OGRCouchDBDataSource::ExecuteSQLStats( const char *pszSQLCommand )
{
swq_select sSelectInfo;
if( sSelectInfo.preparse( pszSQLCommand ) != CE_None )
{
return NULL;
}
if (sSelectInfo.table_count != 1)
{
return NULL;
}
swq_table_def *psTableDef = &sSelectInfo.table_defs[0];
if( psTableDef->data_source != NULL )
{
return NULL;
}
OGRCouchDBLayer* _poSrcLayer =
(OGRCouchDBLayer* )GetLayerByName( psTableDef->table_name );
if (_poSrcLayer == NULL)
{
return NULL;
}
if (_poSrcLayer->GetLayerType() != COUCHDB_TABLE_LAYER)
return NULL;
OGRCouchDBTableLayer* poSrcLayer = (OGRCouchDBTableLayer* ) _poSrcLayer;
int nFieldCount = poSrcLayer->GetLayerDefn()->GetFieldCount();
swq_field_list sFieldList;
memset( &sFieldList, 0, sizeof(sFieldList) );
sFieldList.table_count = sSelectInfo.table_count;
sFieldList.table_defs = sSelectInfo.table_defs;
sFieldList.count = 0;
sFieldList.names = static_cast<char **>(
CPLMalloc( sizeof(char *) * nFieldCount ));
sFieldList.types = static_cast<swq_field_type *>(
CPLMalloc( sizeof(swq_field_type) * nFieldCount ));
sFieldList.table_ids = static_cast<int *>(
CPLMalloc( sizeof(int) * nFieldCount ));
sFieldList.ids = static_cast<int *>(
CPLMalloc( sizeof(int) * nFieldCount ));
PointerAutoFree oHolderNames(sFieldList.names);
PointerAutoFree oHolderTypes(sFieldList.types);
PointerAutoFree oHolderTableIds(sFieldList.table_ids);
PointerAutoFree oHolderIds(sFieldList.ids);
for( int iField = 0;
iField < poSrcLayer->GetLayerDefn()->GetFieldCount();
iField++ )
{
OGRFieldDefn *poFDefn=poSrcLayer->GetLayerDefn()->GetFieldDefn(iField);
int iOutField = sFieldList.count++;
sFieldList.names[iOutField] = (char *) poFDefn->GetNameRef();
if( poFDefn->GetType() == OFTInteger )
sFieldList.types[iOutField] = SWQ_INTEGER;
else if( poFDefn->GetType() == OFTReal )
sFieldList.types[iOutField] = SWQ_FLOAT;
else if( poFDefn->GetType() == OFTString )
sFieldList.types[iOutField] = SWQ_STRING;
else
sFieldList.types[iOutField] = SWQ_OTHER;
sFieldList.table_ids[iOutField] = 0;
sFieldList.ids[iOutField] = iField;
}
CPLString osLastFieldName;
for( int iField = 0; iField < sSelectInfo.result_columns; iField++ )
{
swq_col_def *psColDef = sSelectInfo.column_defs + iField;
if (psColDef->field_name == NULL)
return NULL;
if (strcmp(psColDef->field_name, "*") != 0)
{
if (osLastFieldName.empty())
osLastFieldName = psColDef->field_name;
else if (strcmp(osLastFieldName, psColDef->field_name) != 0)
return NULL;
if (poSrcLayer->GetLayerDefn()->GetFieldIndex(psColDef->field_name) == -1)
return NULL;
}
if (!(psColDef->col_func == SWQCF_AVG ||
psColDef->col_func == SWQCF_MIN ||
psColDef->col_func == SWQCF_MAX ||
psColDef->col_func == SWQCF_COUNT ||
psColDef->col_func == SWQCF_SUM))
return NULL;
if (psColDef->distinct_flag) /* TODO: could perhaps be relaxed */
return NULL;
}
if (osLastFieldName.empty())
return NULL;
/* Normalize field name */
int nIndex = poSrcLayer->GetLayerDefn()->GetFieldIndex(osLastFieldName);
osLastFieldName = poSrcLayer->GetLayerDefn()->GetFieldDefn(nIndex)->GetNameRef();
/* -------------------------------------------------------------------- */
/* Finish the parse operation. */
/* -------------------------------------------------------------------- */
if( sSelectInfo.parse( &sFieldList, NULL ) != CE_None )
{
return NULL;
}
if (sSelectInfo.join_defs != NULL ||
sSelectInfo.where_expr != NULL ||
sSelectInfo.order_defs != NULL ||
sSelectInfo.query_mode != SWQM_SUMMARY_RECORD)
{
return NULL;
}
for( int iField = 0; iField < sSelectInfo.result_columns; iField++ )
{
swq_col_def *psColDef = sSelectInfo.column_defs + iField;
if (psColDef->field_index == -1)
{
if (psColDef->col_func == SWQCF_COUNT)
continue;
return NULL;
}
if (psColDef->field_type != SWQ_INTEGER &&
psColDef->field_type != SWQ_FLOAT)
{
return NULL;
}
}
const bool bFoundFilter = CPL_TO_BOOL(
poSrcLayer->HasFilterOnFieldOrCreateIfNecessary(osLastFieldName));
if( !bFoundFilter )
return NULL;
CPLString osURI = "/";
osURI += poSrcLayer->GetName();
osURI += "/_design/ogr_filter_";
osURI += osLastFieldName;
osURI += "/_view/filter?reduce=true";
json_object* poAnswerObj = GET(osURI);
json_object* poRows = NULL;
if (!(poAnswerObj != NULL &&
json_object_is_type(poAnswerObj, json_type_object) &&
(poRows = CPL_json_object_object_get(poAnswerObj, "rows")) != NULL &&
json_object_is_type(poRows, json_type_array)))
{
json_object_put(poAnswerObj);
return NULL;
}
int nLength = json_object_array_length(poRows);
if (nLength != 1)
{
json_object_put(poAnswerObj);
return NULL;
}
json_object* poRow = json_object_array_get_idx(poRows, 0);
if (!(poRow && json_object_is_type(poRow, json_type_object)))
{
json_object_put(poAnswerObj);
return NULL;
}
json_object* poValue = CPL_json_object_object_get(poRow, "value");
if (!(poValue != NULL && json_object_is_type(poValue, json_type_object)))
{
json_object_put(poAnswerObj);
return NULL;
}
json_object* poSum = CPL_json_object_object_get(poValue, "sum");
json_object* poCount = CPL_json_object_object_get(poValue, "count");
json_object* poMin = CPL_json_object_object_get(poValue, "min");
json_object* poMax = CPL_json_object_object_get(poValue, "max");
if (poSum != NULL && (json_object_is_type(poSum, json_type_int) ||
json_object_is_type(poSum, json_type_double)) &&
poCount != NULL && (json_object_is_type(poCount, json_type_int) ||
json_object_is_type(poCount, json_type_double)) &&
poMin != NULL && (json_object_is_type(poMin, json_type_int) ||
json_object_is_type(poMin, json_type_double)) &&
poMax != NULL && (json_object_is_type(poMax, json_type_int) ||
json_object_is_type(poMax, json_type_double)) )
{
double dfSum = json_object_get_double(poSum);
int nCount = json_object_get_int(poCount);
double dfMin = json_object_get_double(poMin);
double dfMax = json_object_get_double(poMax);
json_object_put(poAnswerObj);
//CPLDebug("CouchDB", "sum=%f, count=%d, min=%f, max=%f",
// dfSum, nCount, dfMin, dfMax);
OGRFeatureDefn* poFeatureDefn = new OGRFeatureDefn(poSrcLayer->GetName());
poFeatureDefn->Reference();
for( int iField = 0; iField < sSelectInfo.result_columns; iField++ )
{
swq_col_def *psColDef = sSelectInfo.column_defs + iField;
OGRFieldDefn oFDefn( "", OFTInteger );
if( psColDef->field_alias != NULL )
{
oFDefn.SetName(psColDef->field_alias);
}
else
{
const swq_operation *op = swq_op_registrar::GetOperator(
(swq_op) psColDef->col_func );
oFDefn.SetName( CPLSPrintf( "%s_%s",
op->pszName,
psColDef->field_name ) );
}
if( psColDef->col_func == SWQCF_COUNT )
oFDefn.SetType( OFTInteger );
else if (psColDef->field_type == SWQ_INTEGER)
oFDefn.SetType( OFTInteger );
else if (psColDef->field_type == SWQ_FLOAT)
oFDefn.SetType( OFTReal );
poFeatureDefn->AddFieldDefn(&oFDefn);
}
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
for( int iField = 0; iField < sSelectInfo.result_columns; iField++ )
{
swq_col_def *psColDef = sSelectInfo.column_defs + iField;
switch(psColDef->col_func)
{
case SWQCF_AVG:
if (nCount)
poFeature->SetField(iField, dfSum / nCount);
break;
case SWQCF_MIN:
poFeature->SetField(iField, dfMin);
break;
case SWQCF_MAX:
poFeature->SetField(iField, dfMax);
break;
case SWQCF_COUNT:
poFeature->SetField(iField, nCount);
break;
case SWQCF_SUM:
poFeature->SetField(iField, dfSum);
break;
default:
break;
}
}
poFeature->SetFID(0);
OGRCouchDBOneLineLayer* poAnswerLayer = new OGRCouchDBOneLineLayer();
poAnswerLayer->poFeatureDefn = poFeatureDefn;
poAnswerLayer->poFeature = poFeature;
return poAnswerLayer;
}
json_object_put(poAnswerObj);
return NULL;
}
int GDALDefaultOverviews::HaveMaskFile( char ** papszSiblingFiles,
const char *pszBasename )
{
/* -------------------------------------------------------------------- */
/* Have we already checked for masks? */
/* -------------------------------------------------------------------- */
if( bCheckedForMask )
return poMaskDS != NULL;
if( papszSiblingFiles == NULL )
papszSiblingFiles = papszInitSiblingFiles;
/* -------------------------------------------------------------------- */
/* Are we an overview? If so we need to find the corresponding */
/* overview in the base files mask file (if there is one). */
/* -------------------------------------------------------------------- */
if( poBaseDS != NULL && poBaseDS->oOvManager.HaveMaskFile() )
{
GDALRasterBand * const poBaseBand = poBaseDS->GetRasterBand(1);
GDALRasterBand * poBaseMask = poBaseBand != NULL ?
poBaseBand->GetMaskBand() : NULL;
const int nOverviewCount = poBaseMask != NULL ?
poBaseMask->GetOverviewCount() : 0;
for( int iOver = 0; iOver < nOverviewCount; iOver++ )
{
GDALRasterBand * const poOverBand =
poBaseMask->GetOverview( iOver );
if( poOverBand == NULL )
continue;
if( poOverBand->GetXSize() == poDS->GetRasterXSize()
&& poOverBand->GetYSize() == poDS->GetRasterYSize() )
{
poMaskDS = poOverBand->GetDataset();
break;
}
}
bCheckedForMask = true;
bOwnMaskDS = false;
CPLAssert( poMaskDS != poDS );
return poMaskDS != NULL;
}
/* -------------------------------------------------------------------- */
/* Are we even initialized? If not, we apparently don't want */
/* to support overviews and masks. */
/* -------------------------------------------------------------------- */
if( poDS == NULL )
return FALSE;
/* -------------------------------------------------------------------- */
/* Check for .msk file. */
/* -------------------------------------------------------------------- */
bCheckedForMask = true;
if( pszBasename == NULL )
pszBasename = poDS->GetDescription();
// Don't bother checking for masks of masks.
if( EQUAL(CPLGetExtension(pszBasename),"msk") )
return FALSE;
if( !GDALCanFileAcceptSidecarFile(pszBasename) )
return FALSE;
CPLString osMskFilename;
osMskFilename.Printf( "%s.msk", pszBasename );
std::vector<char> achMskFilename;
achMskFilename.resize(osMskFilename.size() + 1);
memcpy(&(achMskFilename[0]),
osMskFilename.c_str(),
osMskFilename.size() + 1);
bool bExists = CPL_TO_BOOL(
CPLCheckForFile( &achMskFilename[0],
papszSiblingFiles ) );
osMskFilename = &achMskFilename[0];
#if !defined(WIN32)
if( !bExists && !papszSiblingFiles )
{
osMskFilename.Printf( "%s.MSK", pszBasename );
memcpy(&(achMskFilename[0]),
osMskFilename.c_str(),
osMskFilename.size() + 1);
bExists = CPL_TO_BOOL(
CPLCheckForFile( &achMskFilename[0],
papszSiblingFiles ) );
osMskFilename = &achMskFilename[0];
}
#endif
if( !bExists )
return FALSE;
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
poMaskDS = static_cast<GDALDataset *>(
GDALOpenEx( osMskFilename,
GDAL_OF_RASTER |
(poDS->GetAccess() == GA_Update ? GDAL_OF_UPDATE : 0),
NULL, NULL, papszInitSiblingFiles ));
CPLAssert( poMaskDS != poDS );
if( poMaskDS == NULL )
return FALSE;
bOwnMaskDS = true;
return TRUE;
}
