static int ParseXY( const char **ppszNext, double *padfXY )
{
int iStartY;
const char *pszNext = *ppszNext;
for( iStartY = 0; ; iStartY++ )
{
if( pszNext[iStartY] == '\0' )
return FALSE;
if( pszNext[iStartY] == ',' )
{
iStartY++;
break;
}
}
padfXY[0] = CPLAtof(pszNext);
padfXY[1] = CPLAtof(pszNext + iStartY);
int iEnd;
for( iEnd = iStartY;
pszNext[iEnd] != ')';
iEnd++ )
{
if( pszNext[iEnd] == '\0' )
return FALSE;
}
*ppszNext += iEnd;
return TRUE;
}
static int GetLatLon(const char* pszLat,
char chLatHemisphere,
const char* pszLon,
char chLonHemisphere,
int nSecLen,
double& dfLat, double& dfLon)
{
char szDeg[4] = { pszLat[0], pszLat[1], 0 };
char szMin[3] = { pszLat[3], pszLat[4], 0 };
char szSec[10];
memcpy(szSec, pszLat + 6, std::max((int)sizeof(szSec) - 1, nSecLen));
szSec[std::max((int)sizeof(szSec) - 1, nSecLen)] = 0;
dfLat = atoi(szDeg) + atoi(szMin) / 60. + CPLAtof(szSec) / 3600.;
if (chLatHemisphere == 'S')
dfLat = -dfLat;
szDeg[0] = pszLon[0];
szDeg[1] = pszLon[1];
szDeg[2] = pszLon[2];
szDeg[3] = 0;
szMin[0] = pszLon[4];
szMin[1] = pszLon[5];
szMin[2] = 0;
memcpy(szSec, pszLon + 7, std::max((int)sizeof(szSec) - 1, nSecLen));
szSec[std::max((int)sizeof(szSec) - 1, nSecLen)] = 0;
dfLon = atoi(szDeg) + atoi(szMin) / 60. + CPLAtof(szSec) / 3600.;
if (chLonHemisphere == ' ' || chLonHemisphere == 'W')
dfLon = -dfLon;
return TRUE;
}
OGRErr OGRESRIFeatureServiceLayer::GetExtent(OGREnvelope *psExtent, int bForce)
{
OGRErr eErr = OGRERR_FAILURE;
CPLString osNewURL = CPLURLAddKVP(poDS->GetURL(), "returnExtentOnly", "true");
osNewURL = CPLURLAddKVP(osNewURL, "f", "geojson");
CPLErrorReset();
CPLHTTPResult* pResult = CPLHTTPFetch( osNewURL, NULL );
if( pResult != NULL && pResult->nDataLen != 0 && CPLGetLastErrorNo() == 0 &&
pResult->nStatus == 0 )
{
const char* pszBBox = strstr((const char*)pResult->pabyData, "\"bbox\"");
if( pszBBox )
{
pszBBox = strstr(pszBBox, ":[");
if( pszBBox )
{
pszBBox+=2;
char** papszTokens = CSLTokenizeString2(pszBBox, ",", 0);
if( CSLCount(papszTokens) >= 4 )
{
psExtent->MinX = CPLAtof(papszTokens[0]);
psExtent->MinY = CPLAtof(papszTokens[1]);
psExtent->MaxX = CPLAtof(papszTokens[2]);
psExtent->MaxY = CPLAtof(papszTokens[3]);
eErr = OGRERR_NONE;
}
CSLDestroy(papszTokens);
}
}
}
CPLHTTPDestroyResult( pResult );
if( eErr == OGRERR_FAILURE )
eErr = OGRLayer::GetExtent(psExtent, bForce);
return eErr;
}
void OGROCIWritableLayer::ParseDIMINFO( const char *pszOptionName,
double *pdfMin,
double *pdfMax,
double *pdfRes )
{
const char *pszUserDIMINFO;
char **papszTokens;
pszUserDIMINFO = CSLFetchNameValue( papszOptions, pszOptionName );
if( pszUserDIMINFO == NULL )
return;
papszTokens =
CSLTokenizeStringComplex( pszUserDIMINFO, ",", FALSE, FALSE );
if( CSLCount(papszTokens) != 3 )
{
CSLDestroy( papszTokens );
CPLError( CE_Warning, CPLE_AppDefined,
"Ignoring %s, it does not contain three comma separated values.",
pszOptionName );
return;
}
*pdfMin = CPLAtof(papszTokens[0]);
*pdfMax = CPLAtof(papszTokens[1]);
*pdfRes = CPLAtof(papszTokens[2]);
CSLDestroy( papszTokens );
}
CPLErr TerragenDataset::SetProjection( const char * pszNewProjection )
{
// Terragen files aren't really georeferenced, but
// we should get the projection's linear units so
// that we can scale elevations correctly.
//m_dSCAL = 30.0; // default
OGRSpatialReference oSRS( pszNewProjection );
/* -------------------------------------------------------------------- */
/* Linear units. */
/* -------------------------------------------------------------------- */
m_bIsGeo = oSRS.IsGeographic() != FALSE;
if(m_bIsGeo)
{
// The caller is using degrees. We need to convert
// to meters, otherwise we can't derive a SCAL
// value to scale elevations with.
m_bIsGeo = true;
}
else
{
const double dfLinear = oSRS.GetLinearUnits();
if( approx_equal(dfLinear, 0.3048))
m_dMetersPerGroundUnit = 0.3048;
else if( approx_equal(dfLinear, CPLAtof(SRS_UL_US_FOOT_CONV)) )
m_dMetersPerGroundUnit = CPLAtof(SRS_UL_US_FOOT_CONV);
else
m_dMetersPerGroundUnit = 1.0;
}
return CE_None;
}
GBool MITABExtractCoordSysBounds( const char * pszCoordSys,
double &dXMin, double &dYMin,
double &dXMax, double &dYMax )
{
char **papszFields;
if( pszCoordSys == NULL )
return FALSE;
papszFields = CSLTokenizeStringComplex( pszCoordSys, " ,()", TRUE, FALSE );
int iBounds = CSLFindString( papszFields, "Bounds" );
if (iBounds >= 0 && iBounds + 4 < CSLCount(papszFields))
{
dXMin = CPLAtof(papszFields[++iBounds]);
dYMin = CPLAtof(papszFields[++iBounds]);
dXMax = CPLAtof(papszFields[++iBounds]);
dYMax = CPLAtof(papszFields[++iBounds]);
CSLDestroy( papszFields );
return TRUE;
}
CSLDestroy( papszFields );
return FALSE;
}
static bool ParseXY( const char **ppszNext, double *padfXY )
{
const char *pszNext = *ppszNext;
int iStartY = 0; // Used after for.
for( ; ; iStartY++ )
{
if( pszNext[iStartY] == '\0' )
return false;
if( pszNext[iStartY] == ',' )
{
iStartY++;
break;
}
}
padfXY[0] = CPLAtof(pszNext);
padfXY[1] = CPLAtof(pszNext + iStartY);
int iEnd = iStartY; // Used after for.
for( ; pszNext[iEnd] != ')'; iEnd++ )
{
if( pszNext[iEnd] == '\0' )
return false;
}
*ppszNext += iEnd;
return true;
}
static
Coordinate* ParseCoordinate(std::string const& text)
{
int pos = 0;
const char* pszStr = text.c_str();
Coordinate *psTmp = new Coordinate();
// X coordinate
psTmp->dfLongitude = CPLAtof(pszStr);
while(isNumberDigit(pszStr[pos++]));
// Y coordinate
if(pszStr[pos - 1] != ',')
{
delete psTmp;
return NULL;
}
psTmp->dfLatitude = CPLAtof(pszStr + pos);
while(isNumberDigit(pszStr[pos++]));
// Z coordinate
if(pszStr[pos - 1] != ',')
{
psTmp->bHasZ = FALSE;
psTmp->dfAltitude = 0;
return psTmp;
}
psTmp->bHasZ = TRUE;
psTmp->dfAltitude = CPLAtof(pszStr + pos);
return psTmp;
}
CPLErr PAuxDataset::GetGeoTransform( double * padfGeoTransform )
{
if( CSLFetchNameValue(papszAuxLines, "UpLeftX") != NULL
&& CSLFetchNameValue(papszAuxLines, "UpLeftY") != NULL
&& CSLFetchNameValue(papszAuxLines, "LoRightX") != NULL
&& CSLFetchNameValue(papszAuxLines, "LoRightY") != NULL )
{
const double dfUpLeftX = CPLAtof(CSLFetchNameValue(papszAuxLines, "UpLeftX" ));
const double dfUpLeftY = CPLAtof(CSLFetchNameValue(papszAuxLines, "UpLeftY" ));
const double dfLoRightX = CPLAtof(CSLFetchNameValue(papszAuxLines, "LoRightX" ));
const double dfLoRightY = CPLAtof(CSLFetchNameValue(papszAuxLines, "LoRightY" ));
padfGeoTransform[0] = dfUpLeftX;
padfGeoTransform[1] = (dfLoRightX - dfUpLeftX) / GetRasterXSize();
padfGeoTransform[2] = 0.0;
padfGeoTransform[3] = dfUpLeftY;
padfGeoTransform[4] = 0.0;
padfGeoTransform[5] = (dfLoRightY - dfUpLeftY) / GetRasterYSize();
return CE_None;
}
else
{
padfGeoTransform[0] = 0.0;
padfGeoTransform[1] = 1.0;
padfGeoTransform[2] = 0.0;
padfGeoTransform[3] = 0.0;
padfGeoTransform[4] = 0.0;
padfGeoTransform[5] = 1.0;
return CE_Failure;
}
}
int
PamParseHistogram( CPLXMLNode *psHistItem,
double *pdfMin, double *pdfMax,
int *pnBuckets, GUIntBig **ppanHistogram,
CPL_UNUSED int *pbIncludeOutOfRange,
CPL_UNUSED int *pbApproxOK )
{
if( psHistItem == NULL )
return FALSE;
*pdfMin = CPLAtof(CPLGetXMLValue( psHistItem, "HistMin", "0"));
*pdfMax = CPLAtof(CPLGetXMLValue( psHistItem, "HistMax", "1"));
*pnBuckets = atoi(CPLGetXMLValue( psHistItem, "BucketCount","2"));
if (*pnBuckets <= 0 || *pnBuckets > INT_MAX / 2)
return FALSE;
if( ppanHistogram == NULL )
return TRUE;
// Fetch the histogram and use it.
int iBucket;
const char *pszHistCounts = CPLGetXMLValue( psHistItem,
"HistCounts", "" );
/* Sanity check to test consistency of BucketCount and HistCounts */
if( strlen(pszHistCounts) < 2 * (size_t)(*pnBuckets) -1 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"HistCounts content isn't consistent with BucketCount value");
return FALSE;
}
*ppanHistogram = (GUIntBig *) VSICalloc(sizeof(GUIntBig),*pnBuckets);
if (*ppanHistogram == NULL)
{
CPLError(CE_Failure, CPLE_OutOfMemory,
"Cannot allocate memory for %d buckets", *pnBuckets);
return FALSE;
}
for( iBucket = 0; iBucket < *pnBuckets; iBucket++ )
{
(*ppanHistogram)[iBucket] = CPLAtoGIntBig(pszHistCounts);
// skip to next number.
while( *pszHistCounts != '\0' && *pszHistCounts != '|' )
pszHistCounts++;
if( *pszHistCounts == '|' )
pszHistCounts++;
}
return TRUE;
}
CPLErr HDF5ImageDataset::CreateODIMH5Projection()
{
const char* const pszProj4String = GetMetadataItem("where_projdef");
const char* const pszLL_lon = GetMetadataItem("where_LL_lon");
const char* const pszLL_lat = GetMetadataItem("where_LL_lat");
const char* const pszUR_lon = GetMetadataItem("where_UR_lon");
const char* const pszUR_lat = GetMetadataItem("where_UR_lat");
if( pszProj4String == NULL ||
pszLL_lon == NULL || pszLL_lat == NULL ||
pszUR_lon == NULL || pszUR_lat == NULL )
return CE_Failure;
if( oSRS.importFromProj4( pszProj4String ) != OGRERR_NONE )
return CE_Failure;
OGRSpatialReference oSRSWGS84;
oSRSWGS84.SetWellKnownGeogCS( "WGS84" );
OGRCoordinateTransformation* poCT =
OGRCreateCoordinateTransformation( &oSRSWGS84, &oSRS );
if( poCT == NULL )
return CE_Failure;
/* Reproject corners from long,lat WGS84 to the target SRS */
double dfLLX = CPLAtof(pszLL_lon);
double dfLLY = CPLAtof(pszLL_lat);
double dfURX = CPLAtof(pszUR_lon);
double dfURY = CPLAtof(pszUR_lat);
if( !poCT->Transform(1, &dfLLX, &dfLLY) ||
!poCT->Transform(1, &dfURX, &dfURY) )
{
delete poCT;
return CE_Failure;
}
delete poCT;
/* Compute the geotransform now */
const double dfPixelX = (dfURX - dfLLX) / nRasterXSize;
const double dfPixelY = (dfURY - dfLLY) / nRasterYSize;
bHasGeoTransform = true;
adfGeoTransform[0] = dfLLX;
adfGeoTransform[1] = dfPixelX;
adfGeoTransform[2] = 0;
adfGeoTransform[3] = dfURY;
adfGeoTransform[4] = 0;
adfGeoTransform[5] = -dfPixelY;
CPLFree( pszProjection );
oSRS.exportToWkt( &pszProjection );
return CE_None;
}
int GDALRasterBlock::FlushCacheBlock( int bDirtyBlocksOnly )
{
GDALRasterBlock *poTarget;
{
INITIALIZE_LOCK;
poTarget = poOldest;
while( poTarget != NULL )
{
if( !bDirtyBlocksOnly || poTarget->GetDirty() )
{
if( CPLAtomicCompareAndExchange(
&(poTarget->nLockCount), 0, -1) )
break;
}
poTarget = poTarget->poPrevious;
}
if( poTarget == NULL )
return FALSE;
if( bSleepsForBockCacheDebug )
CPLSleep(CPLAtof(
CPLGetConfigOption(
"GDAL_RB_FLUSHBLOCK_SLEEP_AFTER_DROP_LOCK", "0")));
poTarget->Detach_unlocked();
poTarget->GetBand()->UnreferenceBlock(poTarget);
}
if( bSleepsForBockCacheDebug )
CPLSleep(CPLAtof(
CPLGetConfigOption("GDAL_RB_FLUSHBLOCK_SLEEP_AFTER_RB_LOCK", "0")));
if( poTarget->GetDirty() )
{
const CPLErr eErr = poTarget->Write();
if( eErr != CE_None )
{
// Save the error for later reporting.
poTarget->GetBand()->SetFlushBlockErr(eErr);
}
}
VSIFree(poTarget->pData);
poTarget->pData = NULL;
poTarget->GetBand()->AddBlockToFreeList(poTarget);
return TRUE;
}
static int FORCE_CDECL swq_compare_real( const void *item1, const void *item2 )
{
double v1, v2;
v1 = CPLAtof(*((const char **) item1));
v2 = CPLAtof(*((const char **) item2));
if( v1 < v2 )
return -1;
else if( v1 == v2 )
return 0;
else
return 1;
}
std::vector<double>
OGRDXFWriterLayer::PrepareLineTypeDefinition( OGRStylePen *poPen )
{
/* -------------------------------------------------------------------- */
/* Fetch pattern. */
/* -------------------------------------------------------------------- */
GBool bDefault;
const char *pszPattern = poPen->Pattern( bDefault );
if( bDefault || strlen(pszPattern) == 0 )
return std::vector<double>();
/* -------------------------------------------------------------------- */
/* Split into pen up / pen down bits. */
/* -------------------------------------------------------------------- */
char **papszTokens = CSLTokenizeString(pszPattern);
std::vector<double> adfWeightTokens;
for( int i = 0; papszTokens != nullptr && papszTokens[i] != nullptr; i++ )
{
const char *pszToken = papszTokens[i];
CPLString osAmount;
CPLString osDXFEntry;
// Split amount and unit.
const char *pszUnit = pszToken; // Used after for.
for( ;
strchr( "0123456789.", *pszUnit) != nullptr;
pszUnit++ ) {}
osAmount.assign(pszToken,(int) (pszUnit-pszToken));
// If the unit is other than 'g' we really should be trying to
// do some type of transformation - but what to do? Pretty hard.
// Even entries are "pen down" represented as positive in DXF.
// "Pen up" entries (gaps) are represented as negative.
if( i%2 == 0 )
adfWeightTokens.push_back( CPLAtof( osAmount ) );
else
adfWeightTokens.push_back( -CPLAtof( osAmount ) );
}
CSLDestroy( papszTokens );
return adfWeightTokens;
}
int OPTGetParameterInfo( const char * pszProjectionMethod,
const char * pszParameterName,
char ** ppszUserName,
char ** ppszType,
double *pdfDefaultValue )
{
int i;
(void) pszProjectionMethod;
for( i = 0; papszParameterDefinitions[i] != NULL; i += 4 )
{
if( EQUAL(papszParameterDefinitions[i],pszParameterName) )
{
if( ppszUserName != NULL )
*ppszUserName = (char *)papszParameterDefinitions[i+1];
if( ppszType != NULL )
*ppszType = (char *)papszParameterDefinitions[i+2];
if( pdfDefaultValue != NULL )
*pdfDefaultValue = CPLAtof(papszParameterDefinitions[i+3]);
return TRUE;
}
}
return FALSE;
}
static void ParseLineString(OGRLineString* poLS,
const char* pszCoordinates)
{
char** papszTuples = CSLTokenizeString2(pszCoordinates, " ", 0);
for(int iTuple = 0; papszTuples && papszTuples[iTuple]; iTuple++)
{
char** papszTokens = CSLTokenizeString2(papszTuples[iTuple], ",", 0);
if (CSLCount(papszTokens) == 2)
poLS->addPoint(CPLAtof(papszTokens[0]), CPLAtof(papszTokens[1]));
else if (CSLCount(papszTokens) == 3)
poLS->addPoint(CPLAtof(papszTokens[0]), CPLAtof(papszTokens[1]),
CPLAtof(papszTokens[2]));
CSLDestroy(papszTokens);
}
CSLDestroy(papszTuples);
}
int GDALRasterBlock::TakeLock()
{
const int nLockVal = AddLock();
CPLAssert(nLockVal >= 0);
if( bSleepsForBockCacheDebug )
CPLSleep(CPLAtof(
CPLGetConfigOption("GDAL_RB_TRYGET_SLEEP_AFTER_TAKE_LOCK", "0")));
if( nLockVal == 0 )
{
#ifdef DEBUG
CPLDebug(
"GDAL",
"TakeLock(%p): Block(%d,%d,%p) is being evicted while trying to "
"reacquire it.",
reinterpret_cast<void *>(CPLGetPID()), nXOff, nYOff, poBand );
#endif
// The block is being evicted by GDALRasterBlock::Internalize()
// or FlushCacheBlock(), so wait for this to be done before trying
// again.
DropLock();
// wait for the block having been unreferenced
TAKE_LOCK;
return FALSE;
}
Touch();
return TRUE;
}
static double USGSDEMReadDoubleFromBuffer( Buffer* psBuffer, int nCharCount, int *pbSuccess = nullptr)
{
if (psBuffer->cur_index + nCharCount > psBuffer->buffer_size)
{
USGSDEMRefillBuffer(psBuffer);
if (psBuffer->cur_index + nCharCount > psBuffer->buffer_size)
{
if( pbSuccess ) *pbSuccess = FALSE;
return 0;
}
}
char* szPtr = psBuffer->buffer + psBuffer->cur_index;
char backupC = szPtr[nCharCount];
szPtr[nCharCount] = 0;
for( int i = 0; i < nCharCount; i++ )
{
if( szPtr[i] == 'D' )
szPtr[i] = 'E';
}
double dfVal = CPLAtof(szPtr);
szPtr[nCharCount] = backupC;
psBuffer->cur_index += nCharCount;
if( pbSuccess ) *pbSuccess = TRUE;
return dfVal;
}
COASPMetadataItem *COASPMetadataReader::GetNextItem()
{
COASPMetadataItem *poMetadata;
char **papszMDTokens;
char *pszItemName;
char *pszItemValue;
if (nCurrentItem >= nMetadataCount)
return NULL;
papszMDTokens = CSLTokenizeString2(papszMetadata[nCurrentItem], " ",
CSLT_HONOURSTRINGS );
pszItemName = papszMDTokens[0];
if (EQUALN(pszItemName, "georef_grid", 11)) {
double ndLat, ndLong;
int nPixels, nLines;
// georef_grid ( pixels lines ) ( lat long )
// 0 1 2 3 4 5 6 7 8
nPixels = atoi(papszMDTokens[2]);
nLines = atoi(papszMDTokens[3]);
ndLat = CPLAtof(papszMDTokens[6]);
ndLong = CPLAtof(papszMDTokens[7]);
poMetadata = new COASPMetadataGeorefGridItem(nCurrentItem, nPixels,
nLines, ndLat, ndLong);
}
else {
int nCount = CSLCount(papszMDTokens);
pszItemValue = strdup(papszMDTokens[1]);
for (int i = 2; i < nCount; i++) {
int nSize = strlen(papszMDTokens[i]);
pszItemValue = (char *)CPLRealloc(pszItemValue,
strlen(pszItemValue) + 1 + nSize);
sprintf(pszItemValue,"%s %s",pszItemValue,
papszMDTokens[i]);
}
poMetadata = new COASPMetadataItem(pszItemName,
pszItemValue);
free(pszItemValue);
}
free(pszItemName);
nCurrentItem++;
return poMetadata;
}
void *GDALDeserializeGCPTransformer( CPLXMLNode *psTree )
{
GDAL_GCP *pasGCPList = 0;
int nGCPCount = 0;
void *pResult = NULL;
int nReqOrder = 0;
int bReversed = 0;
int bRefine = 0;
int nMinimumGcps = 0;
double dfTolerance = 0.0;
/* -------------------------------------------------------------------- */
/* Check for GCPs. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psGCPList = CPLGetXMLNode( psTree, "GCPList" );
if( psGCPList != NULL )
{
GDALDeserializeGCPListFromXML( psGCPList,
&pasGCPList,
&nGCPCount,
NULL );
}
/* -------------------------------------------------------------------- */
/* Get other flags. */
/* -------------------------------------------------------------------- */
nReqOrder = atoi(CPLGetXMLValue(psTree,"Order","3"));
bReversed = atoi(CPLGetXMLValue(psTree,"Reversed","0"));
bRefine = atoi(CPLGetXMLValue(psTree,"Refine","0"));
nMinimumGcps = atoi(CPLGetXMLValue(psTree,"MinimumGcps","6"));
dfTolerance = CPLAtof(CPLGetXMLValue(psTree,"Tolerance","1.0"));
/* -------------------------------------------------------------------- */
/* Generate transformation. */
/* -------------------------------------------------------------------- */
if(bRefine)
{
pResult = GDALCreateGCPRefineTransformer( nGCPCount, pasGCPList, nReqOrder,
bReversed, dfTolerance, nMinimumGcps );
}
else
{
pResult = GDALCreateGCPTransformer( nGCPCount, pasGCPList, nReqOrder,
bReversed );
}
/* -------------------------------------------------------------------- */
/* Cleanup GCP copy. */
/* -------------------------------------------------------------------- */
GDALDeinitGCPs( nGCPCount, pasGCPList );
CPLFree( pasGCPList );
return pResult;
}
COASPMetadataItem *COASPMetadataReader::GetNextItem()
{
if (nCurrentItem >= nMetadataCount)
return NULL;
COASPMetadataItem *poMetadata;
char **papszMDTokens
= CSLTokenizeString2(papszMetadata[nCurrentItem], " ",
CSLT_HONOURSTRINGS );
char *pszItemName = papszMDTokens[0];
if (STARTS_WITH_CI(pszItemName, "georef_grid")) {
// georef_grid ( pixels lines ) ( lat long )
// 0 1 2 3 4 5 6 7 8
int nPixels = atoi(papszMDTokens[2]);
int nLines = atoi(papszMDTokens[3]);
double dfLat = CPLAtof(papszMDTokens[6]);
double dfLong = CPLAtof(papszMDTokens[7]);
poMetadata = new COASPMetadataGeorefGridItem(
nCurrentItem, nPixels, nLines, dfLat, dfLong);
}
else {
int nCount = CSLCount(papszMDTokens);
char *pszItemValue = CPLStrdup(papszMDTokens[1]);
for (int i = 2; i < nCount; i++) {
const size_t nSize = strlen(pszItemValue) + 1 + strlen(papszMDTokens[i]);
pszItemValue = (char *)CPLRealloc(pszItemValue, nSize);
snprintf(pszItemValue + strlen(pszItemValue),
nSize - strlen(pszItemValue), " %s",
papszMDTokens[i]);
}
poMetadata = new COASPMetadataItem(pszItemName,
pszItemValue);
CPLFree(pszItemValue);
}
CSLDestroy(papszMDTokens);
nCurrentItem++;
return poMetadata;
}
CPLErr VRTKernelFilteredSource::XMLInit( CPLXMLNode *psTree,
const char *pszVRTPath,
void* pUniqueHandle,
std::map<CPLString, GDALDataset*>& oMapSharedSources )
{
{
const CPLErr eErr = VRTFilteredSource::XMLInit( psTree, pszVRTPath,
pUniqueHandle,
oMapSharedSources );
if( eErr != CE_None )
return eErr;
}
const int nNewKernelSize = atoi(CPLGetXMLValue(psTree,"Kernel.Size","0"));
if( nNewKernelSize == 0 )
return CE_None;
char **papszCoefItems =
CSLTokenizeString( CPLGetXMLValue(psTree,"Kernel.Coefs","") );
const int nCoefs = CSLCount(papszCoefItems);
const bool bSquare = nCoefs == nNewKernelSize * nNewKernelSize;
const bool bSeparable = nCoefs == nNewKernelSize && nCoefs != 1;
if( !bSquare && !bSeparable )
{
CSLDestroy( papszCoefItems );
CPLError( CE_Failure, CPLE_AppDefined,
"Got wrong number of filter kernel coefficients (%s). "
"Expected %d or %d, got %d.",
CPLGetXMLValue(psTree,"Kernel.Coefs",""),
nNewKernelSize * nNewKernelSize, nNewKernelSize, nCoefs );
return CE_Failure;
}
double *padfNewCoefs = static_cast<double *>(
CPLMalloc( sizeof(double) * nCoefs ) );
for( int i = 0; i < nCoefs; i++ )
padfNewCoefs[i] = CPLAtof(papszCoefItems[i]);
const CPLErr eErr = SetKernel( nNewKernelSize, bSeparable, padfNewCoefs );
CPLFree( padfNewCoefs );
CSLDestroy( papszCoefItems );
SetNormalized( atoi(CPLGetXMLValue(psTree,"Kernel.normalized","0")) );
return eErr;
}
static int FORCE_CDECL swq_compare_real( const void *item1, const void *item2 )
{
double v1, v2;
const char* pszStr1 = *((const char **) item1);
const char* pszStr2 = *((const char **) item2);
if (pszStr1 == NULL)
return (pszStr2 == NULL) ? 0 : -1;
else if (pszStr2 == NULL)
return 1;
v1 = CPLAtof(pszStr1);
v2 = CPLAtof(pszStr2);
if( v1 < v2 )
return -1;
else if( v1 == v2 )
return 0;
else
return 1;
}
static double ERSDMS2Dec( const char *pszDMS )
{
char **papszTokens = CSLTokenizeStringComplex( pszDMS, ":", FALSE, FALSE );
if( CSLCount(papszTokens) != 3 )
{
return CPLAtof( pszDMS );
}
else
{
double dfResult = fabs(CPLAtof(papszTokens[0]))
+ CPLAtof(papszTokens[1]) / 60.0
+ CPLAtof(papszTokens[2]) / 3600.0;
if( CPLAtof(papszTokens[0]) < 0 )
dfResult *= -1;
CSLDestroy( papszTokens );
return dfResult;
}
}
int OGRElasticDataSource::Create(const char *pszFilename,
CPL_UNUSED char **papszOptions) {
this->pszName = CPLStrdup(pszFilename);
const char* pszMetaFile = CPLGetConfigOption("ES_META", NULL);
const char* pszWriteMap = CPLGetConfigOption("ES_WRITEMAP", NULL);;
this->bOverwrite = CSLTestBoolean(CPLGetConfigOption("ES_OVERWRITE", "0"));
this->nBulkUpload = (int) CPLAtof(CPLGetConfigOption("ES_BULK", "0"));
if (pszWriteMap != NULL) {
this->pszWriteMap = CPLStrdup(pszWriteMap);
}
// Read in the meta file from disk
if (pszMetaFile != NULL)
{
int fsize;
char *fdata;
FILE *fp;
fp = fopen(pszMetaFile, "rb");
if (fp != NULL) {
fseek(fp, 0, SEEK_END);
fsize = (int) ftell(fp);
fdata = (char *) malloc(fsize + 1);
fseek(fp, 0, SEEK_SET);
if (0 == fread(fdata, fsize, 1, fp)) {
CPLError(CE_Failure, CPLE_FileIO,
"OGRElasticDataSource::Create read failed.");
}
fdata[fsize] = 0;
this->pszMapping = fdata;
fclose(fp);
}
}
// Do a status check to ensure that the server is valid
CPLHTTPResult* psResult = CPLHTTPFetch(CPLSPrintf("%s/_status", pszFilename), NULL);
int bOK = (psResult != NULL && psResult->pszErrBuf == NULL);
if (!bOK)
{
CPLError(CE_Failure, CPLE_NoWriteAccess,
"Could not connect to server");
}
CPLHTTPDestroyResult(psResult);
return bOK;
}
int main( int argc, char ** argv )
{
if( argc != 5 )
{
printf( "Usage: stroke primary_axis secondary_axis axis_rotation angle\n" );
exit( 1 );
}
double dfX, dfY, dfPrimary, dfSecondary, dfAxisRotation, dfAngle;
dfPrimary = CPLAtof(argv[1]);
dfSecondary = CPLAtof(argv[2]);
dfAxisRotation = CPLAtof(argv[3]) / 180 * PI;
dfAngle = CPLAtof(argv[4]) / 180 * PI;
ComputePointOnArc2D( dfPrimary, dfSecondary, dfAxisRotation, dfAngle,
&dfX, &dfY );
printf( "X=%.2f, Y=%.2f\n", dfX, dfY );
exit( 0 );
}
CPLXMLNode *
PamFindMatchingHistogram( CPLXMLNode *psSavedHistograms,
double dfMin, double dfMax, int nBuckets,
int bIncludeOutOfRange, int bApproxOK )
{
if( psSavedHistograms == NULL )
return NULL;
CPLXMLNode *psXMLHist;
for( psXMLHist = psSavedHistograms->psChild;
psXMLHist != NULL; psXMLHist = psXMLHist->psNext )
{
if( psXMLHist->eType != CXT_Element
|| !EQUAL(psXMLHist->pszValue,"HistItem") )
continue;
double dfHistMin = CPLAtof(CPLGetXMLValue( psXMLHist, "HistMin", "0"));
double dfHistMax = CPLAtof(CPLGetXMLValue( psXMLHist, "HistMax", "0"));
if( !(ARE_REAL_EQUAL(dfHistMin, dfMin))
|| !(ARE_REAL_EQUAL(dfHistMax, dfMax))
|| atoi(CPLGetXMLValue( psXMLHist,
"BucketCount","0")) != nBuckets
|| !atoi(CPLGetXMLValue( psXMLHist,
"IncludeOutOfRange","0")) != !bIncludeOutOfRange
|| (!bApproxOK && atoi(CPLGetXMLValue( psXMLHist,
"Approximate","0"))) )
continue;
return psXMLHist;
}
return NULL;
}
static double DOQGetField( unsigned char *pabyData, int nBytes )
{
char szWork[128] = { '\0' };
strncpy( szWork, reinterpret_cast<const char *>( pabyData ), nBytes );
szWork[nBytes] = '\0';
for( int i = 0; i < nBytes; i++ )
{
if( szWork[i] == 'D' || szWork[i] == 'd' )
szWork[i] = 'E';
}
return CPLAtof(szWork);
}
double RDataset::ReadFloat()
{
if( bASCII )
{
return CPLAtof(ASCIIFGets());
}
double dfValue = 0.0;
if( VSIFReadL(&dfValue, 8, 1, fp) != 1 )
return -1;
CPL_MSBPTR64(&dfValue);
return dfValue;
}
static double DConvert( VSILFILE *fp, int nCharCount )
{
char szBuffer[100];
CPL_IGNORE_RET_VAL(VSIFReadL( szBuffer, nCharCount, 1, fp ));
szBuffer[nCharCount] = '\0';
for( int i = 0; i < nCharCount; i++ )
{
if( szBuffer[i] == 'D' )
szBuffer[i] = 'E';
}
return CPLAtof(szBuffer);
}