自学教程：C++ CPLAtof函数代码示例

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

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

intPamParseHistogram( 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);}