本文整理汇总了C++中CPLDebug函数的典型用法代码示例。如果您正苦于以下问题:C++ CPLDebug函数的具体用法?C++ CPLDebug怎么用?C++ CPLDebug使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了CPLDebug函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: while
int ILI1Reader::ReadTable(CPL_UNUSED const char *layername) {
char **tokens = NULL;
int ret = TRUE;
int warned = FALSE;
int geomIdx = -1;
OGRFeatureDefn *featureDef = curLayer->GetLayerDefn();
OGRFeature *feature = NULL;
bool bFeatureAdded = false;
while (ret && (tokens = ReadParseLine()) != NULL)
{
const char *firsttok = CSLGetField(tokens, 0);
if (EQUAL(firsttok, "OBJE"))
{
if (featureDef->GetFieldCount() == 0)
{
CPLError( CE_Warning, CPLE_AppDefined,
"No field definition found for table: %s",
featureDef->GetName() );
// Model not read - use heuristics.
for( int fIndex=1; fIndex<CSLCount(tokens); fIndex++ )
{
char szFieldName[32];
snprintf(szFieldName, sizeof(szFieldName), "Field%02d", fIndex);
OGRFieldDefn oFieldDefn(szFieldName, OFTString);
featureDef->AddFieldDefn(&oFieldDefn);
}
}
//start new feature
if( !bFeatureAdded )
delete feature;
feature = new OGRFeature(featureDef);
for( int fIndex=1, fieldno = 0;
fIndex<CSLCount(tokens) && fieldno < featureDef->GetFieldCount();
fIndex++, fieldno++ )
{
if (!(tokens[fIndex][0] == codeUndefined && tokens[fIndex][1] == '\0')) {
#ifdef DEBUG_VERBOSE
CPLDebug( "READ TABLE OGR_ILI", "Setting Field %d (Type %d): %s",
fieldno, featureDef->GetFieldDefn(fieldno)->GetType(),
tokens[fIndex] );
#endif
if (featureDef->GetFieldDefn(fieldno)->GetType() == OFTString) {
// Interlis 1 encoding is ISO 8859-1 (Latin1) -> Recode to UTF-8
char* pszRecoded = CPLRecode(
tokens[fIndex], CPL_ENC_ISO8859_1, CPL_ENC_UTF8);
// Replace space marks
for( char* pszString = pszRecoded;
*pszString != '\0';
pszString++ ) {
if (*pszString == codeBlank) *pszString = ' ';
}
feature->SetField(fieldno, pszRecoded);
CPLFree(pszRecoded);
} else {
feature->SetField(fieldno, tokens[fIndex]);
}
if (featureDef->GetFieldDefn(fieldno)->GetType() == OFTReal
&& fieldno > 0
&& featureDef->GetFieldDefn(fieldno-1)->GetType() == OFTReal) {
// Check for Point geometry (Coord type).
// If there is no ili model read,
// we have no chance to detect the
// geometry column.
CPLString geomfldname
= featureDef->GetFieldDefn(fieldno)->GetNameRef();
// Check if name ends with _1.
if (geomfldname.size() >= 2 && geomfldname[geomfldname.size()-2]
== '_') {
geomfldname = geomfldname.substr(0, geomfldname.size()-2);
geomIdx = featureDef->GetGeomFieldIndex(geomfldname.c_str());
if (geomIdx == -1)
{
CPLError( CE_Warning, CPLE_AppDefined,
"No matching definition for field '%s' of "
"table %s found",
geomfldname.c_str(), featureDef->GetName() );
}
} else {
geomIdx = -1;
}
if (geomIdx >= 0) {
if (featureDef->GetGeomFieldDefn(geomIdx)->GetType() ==
wkbPoint) {
// Add Point geometry.
OGRPoint *ogrPoint = new OGRPoint(
CPLAtof(tokens[fIndex-1]), CPLAtof(tokens[fIndex]));
feature->SetGeomFieldDirectly(geomIdx, ogrPoint);
} else if (featureDef->GetGeomFieldDefn(geomIdx)->GetType() ==
wkbPoint25D && fieldno > 1 &&
featureDef->GetFieldDefn(fieldno-2)->GetType() ==
OFTReal) {
// Add 3D Point geometry.
OGRPoint *ogrPoint = new OGRPoint(
CPLAtof(tokens[fIndex-2]), CPLAtof(tokens[fIndex-1]),
CPLAtof(tokens[fIndex]) );
feature->SetGeomFieldDirectly(geomIdx, ogrPoint);
}
//.........这里部分代码省略.........
示例2: CPLAssert
OGRErr OGRSpatialReference::exportToPanorama( long *piProjSys, long *piDatum,
long *piEllips, long *piZone,
double *padfPrjParams ) const
{
CPLAssert( padfPrjParams );
const char *pszProjection = GetAttrValue("PROJECTION");
/* -------------------------------------------------------------------- */
/* Fill all projection parameters with zero. */
/* -------------------------------------------------------------------- */
int i;
*piDatum = 0L;
*piEllips = 0L;
*piZone = 0L;
for ( i = 0; i < 7; i++ )
padfPrjParams[i] = 0.0;
/* ==================================================================== */
/* Handle the projection definition. */
/* ==================================================================== */
if( IsLocal() )
*piProjSys = PAN_PROJ_NONE;
else if( pszProjection == NULL )
{
#ifdef DEBUG
CPLDebug( "OSR_Panorama",
"Empty projection definition, considered as Geographic" );
#endif
*piProjSys = PAN_PROJ_NONE;
}
else if( EQUAL(pszProjection, SRS_PT_MERCATOR_1SP) )
{
*piProjSys = PAN_PROJ_MERCAT;
padfPrjParams[3] =
TO_RADIANS * GetNormProjParm( SRS_PP_CENTRAL_MERIDIAN, 0.0 );
padfPrjParams[0] =
TO_RADIANS * GetNormProjParm( SRS_PP_LATITUDE_OF_ORIGIN, 0.0 );
padfPrjParams[4] = GetNormProjParm( SRS_PP_SCALE_FACTOR, 1.0 );
padfPrjParams[5] = GetNormProjParm( SRS_PP_FALSE_EASTING, 0.0 );
padfPrjParams[6] = GetNormProjParm( SRS_PP_FALSE_NORTHING, 0.0 );
}
else if( EQUAL(pszProjection, SRS_PT_POLAR_STEREOGRAPHIC) )
{
*piProjSys = PAN_PROJ_PS;
padfPrjParams[3] =
TO_RADIANS * GetNormProjParm( SRS_PP_CENTRAL_MERIDIAN, 0.0 );
padfPrjParams[2] =
TO_RADIANS * GetNormProjParm( SRS_PP_LATITUDE_OF_ORIGIN, 0.0 );
padfPrjParams[4] = GetNormProjParm( SRS_PP_SCALE_FACTOR, 1.0 );
padfPrjParams[5] = GetNormProjParm( SRS_PP_FALSE_EASTING, 0.0 );
padfPrjParams[6] = GetNormProjParm( SRS_PP_FALSE_NORTHING, 0.0 );
}
else if( EQUAL(pszProjection, SRS_PT_POLYCONIC) )
{
*piProjSys = PAN_PROJ_POLYC;
padfPrjParams[3] =
TO_RADIANS * GetNormProjParm( SRS_PP_CENTRAL_MERIDIAN, 0.0 );
padfPrjParams[2] =
TO_RADIANS * GetNormProjParm( SRS_PP_LATITUDE_OF_ORIGIN, 0.0 );
padfPrjParams[5] = GetNormProjParm( SRS_PP_FALSE_EASTING, 0.0 );
padfPrjParams[6] = GetNormProjParm( SRS_PP_FALSE_NORTHING, 0.0 );
}
else if( EQUAL(pszProjection, SRS_PT_EQUIDISTANT_CONIC) )
{
*piProjSys = PAN_PROJ_EC;
padfPrjParams[0] =
TO_RADIANS * GetNormProjParm( SRS_PP_STANDARD_PARALLEL_1, 0.0 );
padfPrjParams[1] =
TO_RADIANS * GetNormProjParm( SRS_PP_STANDARD_PARALLEL_2, 0.0 );
padfPrjParams[3] =
TO_RADIANS * GetNormProjParm( SRS_PP_CENTRAL_MERIDIAN, 0.0 );
padfPrjParams[2] =
TO_RADIANS * GetNormProjParm( SRS_PP_LATITUDE_OF_ORIGIN, 0.0 );
padfPrjParams[5] = GetNormProjParm( SRS_PP_FALSE_EASTING, 0.0 );
padfPrjParams[6] = GetNormProjParm( SRS_PP_FALSE_NORTHING, 0.0 );
}
else if( EQUAL(pszProjection, SRS_PT_LAMBERT_CONFORMAL_CONIC_2SP) )
{
*piProjSys = PAN_PROJ_LCC;
padfPrjParams[0] =
TO_RADIANS * GetNormProjParm( SRS_PP_STANDARD_PARALLEL_1, 0.0 );
padfPrjParams[1] =
TO_RADIANS * GetNormProjParm( SRS_PP_STANDARD_PARALLEL_2, 0.0 );
padfPrjParams[3] =
TO_RADIANS * GetNormProjParm( SRS_PP_CENTRAL_MERIDIAN, 0.0 );
padfPrjParams[2] =
TO_RADIANS * GetNormProjParm( SRS_PP_LATITUDE_OF_ORIGIN, 0.0 );
padfPrjParams[5] = GetNormProjParm( SRS_PP_FALSE_EASTING, 0.0 );
padfPrjParams[6] = GetNormProjParm( SRS_PP_FALSE_NORTHING, 0.0 );
}
//.........这里部分代码省略.........
示例3: RPCInverseTransformPoint
static void
RPCInverseTransformPoint( GDALRPCTransformInfo *psTransform,
double dfPixel, double dfLine, double dfHeight,
double *pdfLong, double *pdfLat )
{
double dfResultX, dfResultY;
int iIter;
GDALRPCInfo *psRPC = &(psTransform->sRPC);
/* -------------------------------------------------------------------- */
/* Compute an initial approximation based on linear */
/* interpolation from our reference point. */
/* -------------------------------------------------------------------- */
dfResultX = psTransform->adfPLToLatLongGeoTransform[0]
+ psTransform->adfPLToLatLongGeoTransform[1] * dfPixel
+ psTransform->adfPLToLatLongGeoTransform[2] * dfLine;
dfResultY = psTransform->adfPLToLatLongGeoTransform[3]
+ psTransform->adfPLToLatLongGeoTransform[4] * dfPixel
+ psTransform->adfPLToLatLongGeoTransform[5] * dfLine;
/* -------------------------------------------------------------------- */
/* Now iterate, trying to find a closer LL location that will */
/* back transform to the indicated pixel and line. */
/* -------------------------------------------------------------------- */
double dfPixelDeltaX=0.0, dfPixelDeltaY=0.0;
for( iIter = 0; iIter < 10; iIter++ )
{
double dfBackPixel, dfBackLine;
RPCTransformPoint( psRPC, dfResultX, dfResultY, dfHeight,
&dfBackPixel, &dfBackLine );
dfPixelDeltaX = dfBackPixel - dfPixel;
dfPixelDeltaY = dfBackLine - dfLine;
dfResultX = dfResultX
- dfPixelDeltaX * psTransform->adfPLToLatLongGeoTransform[1]
- dfPixelDeltaY * psTransform->adfPLToLatLongGeoTransform[2];
dfResultY = dfResultY
- dfPixelDeltaX * psTransform->adfPLToLatLongGeoTransform[4]
- dfPixelDeltaY * psTransform->adfPLToLatLongGeoTransform[5];
if( ABS(dfPixelDeltaX) < psTransform->dfPixErrThreshold
&& ABS(dfPixelDeltaY) < psTransform->dfPixErrThreshold )
{
iIter = -1;
//CPLDebug( "RPC", "Converged!" );
break;
}
}
if( iIter != -1 )
CPLDebug( "RPC", "Iterations %d: Got: %g,%g Offset=%g,%g",
iIter,
dfResultX, dfResultY,
dfPixelDeltaX, dfPixelDeltaY );
*pdfLong = dfResultX;
*pdfLat = dfResultY;
}
示例4: CPLFree
CPLErr OGRMSSQLSpatialTableLayer::Initialize( const char *pszSchema,
const char *pszLayerName,
const char *pszGeomCol,
int nCoordDimension,
int nSRId,
OGRwkbGeometryType eType )
{
CPLODBCSession *poSession = poDS->GetSession();
CPLFree( pszFIDColumn );
pszFIDColumn = NULL;
/* -------------------------------------------------------------------- */
/* Parse out schema name if present in layer. We assume a */
/* schema is provided if there is a dot in the name, and that */
/* it is in the form <schema>.<tablename> */
/* -------------------------------------------------------------------- */
const char *pszDot = strstr(pszLayerName,".");
if( pszDot != NULL )
{
pszTableName = CPLStrdup(pszDot + 1);
pszSchemaName = CPLStrdup(pszLayerName);
pszSchemaName[pszDot - pszLayerName] = '\0';
}
else
{
pszTableName = CPLStrdup(pszLayerName);
pszSchemaName = CPLStrdup(pszSchema);
}
/* -------------------------------------------------------------------- */
/* Do we have a simple primary key? */
/* -------------------------------------------------------------------- */
CPLODBCStatement oGetKey( poSession );
if( oGetKey.GetPrimaryKeys( pszTableName, poDS->GetCatalog(), pszSchemaName )
&& oGetKey.Fetch() )
{
pszFIDColumn = CPLStrdup(oGetKey.GetColData( 3 ));
if( oGetKey.Fetch() ) // more than one field in key!
{
CPLFree( pszFIDColumn );
pszFIDColumn = NULL;
CPLDebug( "OGR_MSSQLSpatial", "Table %s has multiple primary key fields, "
"ignoring them all.", pszTableName );
}
}
/* -------------------------------------------------------------------- */
/* Have we been provided a geometry column? */
/* -------------------------------------------------------------------- */
CPLFree( pszGeomColumn );
if( pszGeomCol == NULL )
pszGeomColumn = NULL;
else
pszGeomColumn = CPLStrdup( pszGeomCol );
/* -------------------------------------------------------------------- */
/* Get the column definitions for this table. */
/* -------------------------------------------------------------------- */
CPLODBCStatement oGetCol( poSession );
CPLErr eErr;
if( !oGetCol.GetColumns( pszTableName, poDS->GetCatalog(), pszSchemaName ) )
return CE_Failure;
eErr = BuildFeatureDefn( pszLayerName, &oGetCol );
if( eErr != CE_None )
return eErr;
poFeatureDefn->SetGeomType(eType);
if( poFeatureDefn->GetFieldCount() == 0 &&
pszFIDColumn == NULL && pszGeomColumn == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"No column definitions found for table '%s', layer not usable.",
pszLayerName );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* If we got a geometry column, does it exist? Is it binary? */
/* -------------------------------------------------------------------- */
if( pszGeomColumn != NULL )
{
int iColumn = oGetCol.GetColId( pszGeomColumn );
if( iColumn < 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Column %s requested for geometry, but it does not exist.",
pszGeomColumn );
CPLFree( pszGeomColumn );
pszGeomColumn = NULL;
}
else
{
//.........这里部分代码省略.........
示例5: CPLDebug
GvData *gv_shapes_from_ogr_layer(void *ogr_layer)
{
CPLDebug( "OpenEV", "gv_shapes_from_ogr_layer() called, "
"but OGR not configured" );
return NULL;
}
示例6: AcquireMutex
size_t VSICurlStreamingHandle::Read( void *pBuffer, size_t nSize, size_t nMemb )
{
GByte* pabyBuffer = (GByte*)pBuffer;
size_t nBufferRequestSize = nSize * nMemb;
if (nBufferRequestSize == 0)
return 0;
size_t nRemaining = nBufferRequestSize;
AcquireMutex();
int bHastComputedFileSizeLocal = bHastComputedFileSize;
vsi_l_offset fileSizeLocal = fileSize;
ReleaseMutex();
if (bHastComputedFileSizeLocal && curOffset >= fileSizeLocal)
{
CPLDebug("VSICURL", "Read attempt beyond end of file");
bEOF = TRUE;
}
if (bEOF)
return 0;
if (curOffset < nRingBufferFileOffset)
PutRingBufferInCache();
if (ENABLE_DEBUG)
CPLDebug("VSICURL", "Read [" CPL_FRMT_GUIB ", " CPL_FRMT_GUIB "[ in %s",
curOffset, curOffset + nBufferRequestSize, pszURL);
#ifdef notdef
if( pCachedData != NULL && nCachedSize >= 1024 &&
nRecomputedChecksumOfFirst1024Bytes == 0 )
{
for(size_t i = 0; i < 1024 / sizeof(int); i ++)
{
int nVal;
memcpy(&nVal, pCachedData + i * sizeof(int), sizeof(int));
nRecomputedChecksumOfFirst1024Bytes += nVal;
}
if( bHastComputedFileSizeLocal )
{
poFS->AcquireMutex();
CachedFileProp* cachedFileProp = poFS->GetCachedFileProp(pszURL);
if( cachedFileProp->nChecksumOfFirst1024Bytes == 0 )
{
cachedFileProp->nChecksumOfFirst1024Bytes = nRecomputedChecksumOfFirst1024Bytes;
}
else if( nRecomputedChecksumOfFirst1024Bytes != cachedFileProp->nChecksumOfFirst1024Bytes )
{
CPLDebug("VSICURL", "Invalidating previously cached file size. First bytes of file have changed!");
AcquireMutex();
bHastComputedFileSize = FALSE;
cachedFileProp->bHastComputedFileSize = FALSE;
cachedFileProp->nChecksumOfFirst1024Bytes = 0;
ReleaseMutex();
}
poFS->ReleaseMutex();
}
}
#endif
/* Can we use the cache ? */
if( pCachedData != NULL && curOffset < nCachedSize )
{
size_t nSz = MIN(nRemaining, (size_t)(nCachedSize - curOffset));
if (ENABLE_DEBUG)
CPLDebug("VSICURL", "Using cache for [%d, %d[ in %s",
(int)curOffset, (int)(curOffset + nSz), pszURL);
memcpy(pabyBuffer, pCachedData + curOffset, nSz);
pabyBuffer += nSz;
curOffset += nSz;
nRemaining -= nSz;
}
/* Is the request partially covered by the cache and going beyond file size ? */
if ( pCachedData != NULL && bHastComputedFileSizeLocal &&
curOffset <= nCachedSize &&
curOffset + nRemaining > fileSizeLocal &&
fileSize == nCachedSize )
{
size_t nSz = (size_t) (nCachedSize - curOffset);
if (ENABLE_DEBUG && nSz != 0)
CPLDebug("VSICURL", "Using cache for [%d, %d[ in %s",
(int)curOffset, (int)(curOffset + nSz), pszURL);
memcpy(pabyBuffer, pCachedData + curOffset, nSz);
pabyBuffer += nSz;
curOffset += nSz;
nRemaining -= nSz;
bEOF = TRUE;
}
/* Has a Seek() being done since the last Read() ? */
if (!bEOF && nRemaining > 0 && curOffset != nRingBufferFileOffset)
{
/* Backward seek : we need to restart the download from the start */
if (curOffset < nRingBufferFileOffset)
StopDownload();
StartDownload();
//.........这里部分代码省略.........
示例7: CPLDebug
int VSICurlStreamingHandle::ReceivedBytes(GByte *buffer, size_t count, size_t nmemb)
{
size_t nSize = count * nmemb;
nBodySize += nSize;
if (ENABLE_DEBUG)
CPLDebug("VSICURL", "Receiving %d bytes...", (int)nSize);
if( bHasCandidateFileSize && bCanTrustCandidateFileSize && !bHastComputedFileSize )
{
poFS->AcquireMutex();
CachedFileProp* cachedFileProp = poFS->GetCachedFileProp(pszURL);
cachedFileProp->fileSize = fileSize = nCandidateFileSize;
cachedFileProp->bHastComputedFileSize = bHastComputedFileSize = TRUE;
if (ENABLE_DEBUG)
CPLDebug("VSICURL", "File size = " CPL_FRMT_GUIB, fileSize);
poFS->ReleaseMutex();
}
AcquireMutex();
if (eExists == EXIST_UNKNOWN)
{
poFS->AcquireMutex();
CachedFileProp* cachedFileProp = poFS->GetCachedFileProp(pszURL);
cachedFileProp->eExists = eExists = EXIST_YES;
poFS->ReleaseMutex();
}
else if (eExists == EXIST_NO)
{
ReleaseMutex();
return 0;
}
while(TRUE)
{
size_t nFree = oRingBuffer.GetCapacity() - oRingBuffer.GetSize();
if (nSize <= nFree)
{
oRingBuffer.Write(buffer, nSize);
/* Signal to the consumer that we have added bytes to the buffer */
CPLCondSignal(hCondProducer);
if (bAskDownloadEnd)
{
if (ENABLE_DEBUG)
CPLDebug("VSICURL", "Download interruption asked");
ReleaseMutex();
return 0;
}
break;
}
else
{
oRingBuffer.Write(buffer, nFree);
buffer += nFree;
nSize -= nFree;
/* Signal to the consumer that we have added bytes to the buffer */
CPLCondSignal(hCondProducer);
if (ENABLE_DEBUG)
CPLDebug("VSICURL", "Waiting for reader to consume some bytes...");
while(oRingBuffer.GetSize() == oRingBuffer.GetCapacity() && !bAskDownloadEnd)
{
CPLCondWait(hCondConsumer, hRingBufferMutex);
}
if (bAskDownloadEnd)
{
if (ENABLE_DEBUG)
CPLDebug("VSICURL", "Download interruption asked");
ReleaseMutex();
return 0;
}
}
}
ReleaseMutex();
return nmemb;
}
示例8: strstr
//.........这里部分代码省略.........
/*********** Grab SEMI-MAJOR ************/
semi_major =
atof(poDS->GetKeyword( "QUBE.IMAGE_MAP_PROJECTION.A_AXIS_RADIUS")) * 1000.0;
/*********** Grab semi-minor ************/
semi_minor =
atof(poDS->GetKeyword( "QUBE.IMAGE_MAP_PROJECTION.C_AXIS_RADIUS")) * 1000.0;
/*********** Grab CENTER_LAT ************/
center_lat =
atof(poDS->GetKeyword( "QUBE.IMAGE_MAP_PROJECTION.CENTER_LATITUDE"));
/*********** Grab CENTER_LON ************/
center_lon =
atof(poDS->GetKeyword( "QUBE.IMAGE_MAP_PROJECTION.CENTER_LONGITUDE"));
/*********** Grab 1st std parallel ************/
first_std_parallel =
atof(poDS->GetKeyword( "QUBE.IMAGE_MAP_PROJECTION.FIRST_STANDARD_PARALLEL"));
/*********** Grab 2nd std parallel ************/
second_std_parallel =
atof(poDS->GetKeyword( "QUBE.IMAGE_MAP_PROJECTION.SECOND_STANDARD_PARALLEL"));
/*** grab PROJECTION_LATITUDE_TYPE = "PLANETOCENTRIC" ****/
// Need to further study how ocentric/ographic will effect the gdal library.
// So far we will use this fact to define a sphere or ellipse for some projections
// Frank - may need to talk this over
char bIsGeographic = TRUE;
value = poDS->GetKeyword("CUBE.IMAGE_MAP_PROJECTION.PROJECTION_LATITUDE_TYPE");
if (EQUAL( value, "\"PLANETOCENTRIC\"" ))
bIsGeographic = FALSE;
CPLDebug("ISIS2","using projection %s", map_proj_name.c_str() );
//Set oSRS projection and parameters
if ((EQUAL( map_proj_name, "EQUIRECTANGULAR_CYLINDRICAL" )) ||
(EQUAL( map_proj_name, "EQUIRECTANGULAR" )) ||
(EQUAL( map_proj_name, "SIMPLE_CYLINDRICAL" )) ) {
oSRS.OGRSpatialReference::SetEquirectangular2 ( 0.0, center_lon, center_lat, 0, 0 );
} else if (EQUAL( map_proj_name, "ORTHOGRAPHIC" )) {
oSRS.OGRSpatialReference::SetOrthographic ( center_lat, center_lon, 0, 0 );
} else if ((EQUAL( map_proj_name, "SINUSOIDAL" )) ||
(EQUAL( map_proj_name, "SINUSOIDAL_EQUAL-AREA" ))) {
oSRS.OGRSpatialReference::SetSinusoidal ( center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "MERCATOR" )) {
oSRS.OGRSpatialReference::SetMercator ( center_lat, center_lon, 1, 0, 0 );
} else if (EQUAL( map_proj_name, "POLAR_STEREOGRAPHIC" )) {
oSRS.OGRSpatialReference::SetPS ( center_lat, center_lon, 1, 0, 0 );
} else if (EQUAL( map_proj_name, "TRANSVERSE_MERCATOR" )) {
oSRS.OGRSpatialReference::SetTM ( center_lat, center_lon, 1, 0, 0 );
} else if (EQUAL( map_proj_name, "LAMBERT_CONFORMAL_CONIC" )) {
oSRS.OGRSpatialReference::SetLCC ( first_std_parallel, second_std_parallel, center_lat, center_lon, 0, 0 );
} else {
CPLDebug( "ISIS2",
"Dataset projection %s is not supported. Continuing...",
map_proj_name.c_str() );
bProjectionSet = FALSE;
}
if (bProjectionSet) {
//Create projection name, i.e. MERCATOR MARS and set as ProjCS keyword
CPLString proj_target_name = map_proj_name + " " + target_name;
oSRS.SetProjCS(proj_target_name); //set ProjCS keyword
//The geographic/geocentric name will be the same basic name as the body name
示例9: CPLStrdup
int OGRSVGDataSource::Open( const char * pszFilename )
{
#ifdef HAVE_EXPAT
pszName = CPLStrdup( pszFilename );
/* -------------------------------------------------------------------- */
/* Try to open the file. */
/* -------------------------------------------------------------------- */
CPLString osFilename(pszFilename);
if (EQUAL(CPLGetExtension(pszFilename), "svgz") &&
strstr(pszFilename, "/vsigzip/") == NULL)
{
osFilename = CPLString("/vsigzip/") + pszFilename;
pszFilename = osFilename.c_str();
}
VSILFILE* fp = VSIFOpenL(pszFilename, "r");
if (fp == NULL)
return FALSE;
eValidity = SVG_VALIDITY_UNKNOWN;
XML_Parser oParser = OGRCreateExpatXMLParser();
oCurrentParser = oParser;
XML_SetUserData(oParser, this);
XML_SetElementHandler(oParser, ::startElementValidateCbk, NULL);
XML_SetCharacterDataHandler(oParser, ::dataHandlerValidateCbk);
char aBuf[BUFSIZ];
int nDone;
unsigned int nLen;
int nCount = 0;
/* Begin to parse the file and look for the <svg> element */
/* It *MUST* be the first element of an XML file */
/* So once we have read the first element, we know if we can */
/* handle the file or not with that driver */
do
{
nDataHandlerCounter = 0;
nLen = (unsigned int) VSIFReadL( aBuf, 1, sizeof(aBuf), fp );
nDone = VSIFEofL(fp);
if (XML_Parse(oParser, aBuf, nLen, nDone) == XML_STATUS_ERROR)
{
if (nLen <= BUFSIZ-1)
aBuf[nLen] = 0;
else
aBuf[BUFSIZ-1] = 0;
if (strstr(aBuf, "<?xml") && strstr(aBuf, "<svg"))
{
CPLError(CE_Failure, CPLE_AppDefined,
"XML parsing of SVG file failed : %s at line %d, column %d",
XML_ErrorString(XML_GetErrorCode(oParser)),
(int)XML_GetCurrentLineNumber(oParser),
(int)XML_GetCurrentColumnNumber(oParser));
}
eValidity = SVG_VALIDITY_INVALID;
break;
}
if (eValidity == SVG_VALIDITY_INVALID)
{
break;
}
else if (eValidity == SVG_VALIDITY_VALID)
{
break;
}
else
{
/* After reading 50 * BUFSIZE bytes, and not finding whether the file */
/* is SVG or not, we give up and fail silently */
nCount ++;
if (nCount == 50)
break;
}
} while (!nDone && nLen > 0 );
XML_ParserFree(oParser);
VSIFCloseL(fp);
if (eValidity == SVG_VALIDITY_VALID)
{
if (bIsCloudmade)
{
nLayers = 3;
papoLayers =(OGRSVGLayer **) CPLRealloc(papoLayers,
nLayers * sizeof(OGRSVGLayer*));
papoLayers[0] = new OGRSVGLayer( pszFilename, "points", SVG_POINTS, this );
papoLayers[1] = new OGRSVGLayer( pszFilename, "lines", SVG_LINES, this );
papoLayers[2] = new OGRSVGLayer( pszFilename, "polygons", SVG_POLYGONS, this );
}
else
{
CPLDebug("SVG",
"%s seems to be a SVG file, but not a Cloudmade vector one.",
pszFilename);
}
}
//.........这里部分代码省略.........
示例10: atoi
//.........这里部分代码省略.........
double dfEndAngle;
double dfRotation;
double dfRatio;
int bCounterClockwise = FALSE;
if( poDS->ReadValue(szLineBuf,sizeof(szLineBuf)) == 10 )
dfCenterX = atof(szLineBuf);
else
break;
if( poDS->ReadValue(szLineBuf,sizeof(szLineBuf)) == 20 )
dfCenterY = atof(szLineBuf);
else
break;
if( poDS->ReadValue(szLineBuf,sizeof(szLineBuf)) == 11 )
dfMajorX = atof(szLineBuf);
else
break;
if( poDS->ReadValue(szLineBuf,sizeof(szLineBuf)) == 21 )
dfMajorY = atof(szLineBuf);
else
break;
if( poDS->ReadValue(szLineBuf,sizeof(szLineBuf)) == 40 )
dfRatio = atof(szLineBuf) / 100.0;
else
break;
if( poDS->ReadValue(szLineBuf,sizeof(szLineBuf)) == 50 )
dfStartAngle = -1 * atof(szLineBuf);
else
break;
if( poDS->ReadValue(szLineBuf,sizeof(szLineBuf)) == 51 )
dfEndAngle = -1 * atof(szLineBuf);
else
break;
if( (nCode = poDS->ReadValue(szLineBuf,sizeof(szLineBuf))) == 73 )
bCounterClockwise = atoi(szLineBuf);
else if (nCode >= 0)
poDS->UnreadValue();
if( bCounterClockwise )
{
double dfTemp = dfStartAngle;
dfStartAngle = dfEndAngle;
dfEndAngle = dfTemp;
}
if( dfStartAngle > dfEndAngle )
dfEndAngle += 360.0;
dfMajorRadius = sqrt( dfMajorX * dfMajorX + dfMajorY * dfMajorY );
dfMinorRadius = dfMajorRadius * dfRatio;
dfRotation = -1 * atan2( dfMajorY, dfMajorX ) * 180 / PI;
OGRGeometry *poArc = OGRGeometryFactory::approximateArcAngles(
dfCenterX, dfCenterY, 0.0,
dfMajorRadius, dfMinorRadius, dfRotation,
dfStartAngle, dfEndAngle, 0.0 );
poArc->flattenTo2D();
poGC->addGeometryDirectly( poArc );
}
else
{
CPLDebug( "DXF", "Unsupported HATCH boundary line type:%d",
nEdgeType );
return OGRERR_UNSUPPORTED_OPERATION;
}
}
/* -------------------------------------------------------------------- */
/* 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;
}
示例11: CPLMalloc
static GDALDataset *OGRSEGYDriverOpen( GDALOpenInfo* poOpenInfo )
{
if( poOpenInfo->eAccess == GA_Update ||
poOpenInfo->fpL == NULL ||
!poOpenInfo->TryToIngest(3200+400) ||
poOpenInfo->nHeaderBytes < 3200+400 )
{
return NULL;
}
if( STARTS_WITH_CI((const char*)poOpenInfo->pabyHeader, "%PDF"))
{
return NULL;
}
// --------------------------------------------------------------------
// Try to decode the header encoded as EBCDIC and then ASCII
// --------------------------------------------------------------------
int i, j, k;
const GByte* pabyTextHeader = poOpenInfo->pabyHeader;
GByte* pabyASCIITextHeader = (GByte*) CPLMalloc(3200 + 40 + 1);
for( k=0; k<2; k++)
{
for( i=0, j=0;i<3200;i++)
{
GByte chASCII = (k == 0) ? EBCDICToASCII[pabyTextHeader[i]] :
pabyTextHeader[i];
if (chASCII < 32 && chASCII != '\t' &&
chASCII != '\n' && chASCII != '\r')
{
break;
}
pabyASCIITextHeader[j++] = chASCII;
if (chASCII != '\n' && ((i + 1) % 80) == 0)
pabyASCIITextHeader[j++] = '\n';
}
pabyASCIITextHeader[j] = '\0';
if (i == 3200)
break;
if (k == 1)
{
CPLFree(pabyASCIITextHeader);
return NULL;
}
}
CPLDebug("SIGY", "Header = \n%s", pabyASCIITextHeader);
CPLFree(pabyASCIITextHeader);
pabyASCIITextHeader = NULL;
// --------------------------------------------------------------------
// Read the next 400 bytes, where the Binary File Header is
// located
// --------------------------------------------------------------------
const GByte* abyFileHeader = poOpenInfo->pabyHeader + 3200;
// --------------------------------------------------------------------
// First check that this binary header is not EBCDIC nor ASCII
// --------------------------------------------------------------------
for( k=0;k<2;k++ )
{
for( i=0;i<400;i++)
{
GByte chASCII = (k == 0) ? abyFileHeader[i] :
EBCDICToASCII[abyFileHeader[i]];
/* A translated 0 value, when source value is not 0, means an invalid */
/* EBCDIC value. Bail out also for control characters */
if (chASCII < 32 && chASCII != '\t' &&
chASCII != '\n' && chASCII != '\r')
{
break;
}
}
if (i == 400)
{
CPLFree(pabyASCIITextHeader);
return NULL;
}
}
OGRSEGYDataSource *poDS = new OGRSEGYDataSource();
if( !poDS->Open( poOpenInfo->pszFilename, (const char*)pabyASCIITextHeader ) )
{
CPLFree(pabyASCIITextHeader);
delete poDS;
poDS = NULL;
}
CPLFree(pabyASCIITextHeader);
return poDS;
}
示例12: osSQL
json_object* OGRCARTODBDataSource::RunSQL(const char* pszUnescapedSQL)
{
CPLString osSQL("POSTFIELDS=q=");
/* Do post escaping */
for(int i=0;pszUnescapedSQL[i] != 0;i++)
{
const int ch = ((unsigned char*)pszUnescapedSQL)[i];
if (ch != '&' && ch >= 32 && ch < 128)
osSQL += (char)ch;
else
osSQL += CPLSPrintf("%%%02X", ch);
}
/* -------------------------------------------------------------------- */
/* Provide the API Key */
/* -------------------------------------------------------------------- */
if( osAPIKey.size() )
{
osSQL += "&api_key=";
osSQL += osAPIKey;
}
/* -------------------------------------------------------------------- */
/* Collection the header options and execute request. */
/* -------------------------------------------------------------------- */
const char* pszAPIURL = GetAPIURL();
char** papszOptions = CSLAddString(
strncmp(pszAPIURL, "/vsimem/", strlen("/vsimem/")) != 0 ? AddHTTPOptions(): NULL, osSQL);
CPLHTTPResult * psResult = CPLHTTPFetch( GetAPIURL(), papszOptions);
CSLDestroy(papszOptions);
/* -------------------------------------------------------------------- */
/* Check for some error conditions and report. HTML Messages */
/* are transformed info failure. */
/* -------------------------------------------------------------------- */
if (psResult && psResult->pszContentType &&
strncmp(psResult->pszContentType, "text/html", 9) == 0)
{
CPLDebug( "CARTODB", "RunSQL HTML Response:%s", psResult->pabyData );
CPLError(CE_Failure, CPLE_AppDefined,
"HTML error page returned by server");
CPLHTTPDestroyResult(psResult);
return NULL;
}
if (psResult && psResult->pszErrBuf != NULL)
{
CPLDebug( "CARTODB", "RunSQL Error Message:%s", psResult->pszErrBuf );
}
else if (psResult && psResult->nStatus != 0)
{
CPLDebug( "CARTODB", "RunSQL Error Status:%d", psResult->nStatus );
}
if( psResult->pabyData == NULL )
{
CPLHTTPDestroyResult(psResult);
return NULL;
}
if( strlen((const char*)psResult->pabyData) < 1000 )
CPLDebug( "CARTODB", "RunSQL Response:%s", psResult->pabyData );
json_tokener* jstok = NULL;
json_object* poObj = NULL;
jstok = json_tokener_new();
poObj = json_tokener_parse_ex(jstok, (const char*) psResult->pabyData, -1);
if( jstok->err != json_tokener_success)
{
CPLError( CE_Failure, CPLE_AppDefined,
"JSON parsing error: %s (at offset %d)",
json_tokener_error_desc(jstok->err), jstok->char_offset);
json_tokener_free(jstok);
CPLHTTPDestroyResult(psResult);
return NULL;
}
json_tokener_free(jstok);
CPLHTTPDestroyResult(psResult);
if( poObj != NULL )
{
if( json_object_get_type(poObj) == json_type_object )
{
json_object* poError = json_object_object_get(poObj, "error");
if( poError != NULL && json_object_get_type(poError) == json_type_array &&
json_object_array_length(poError) > 0 )
{
poError = json_object_array_get_idx(poError, 0);
if( poError != NULL && json_object_get_type(poError) == json_type_string )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Error returned by server : %s", json_object_get_string(poError));
json_object_put(poObj);
return NULL;
}
}
}
else
{
//.........这里部分代码省略.........
示例13: CPLDebug
OGRBoolean OGRLinearRing::isPointInRing(const OGRPoint* poPoint, int bTestEnvelope) const
{
if ( NULL == poPoint )
{
CPLDebug( "OGR", "OGRLinearRing::isPointInRing(const OGRPoint* poPoint) - passed point is NULL!" );
return 0;
}
const int iNumPoints = getNumPoints();
// Simple validation
if ( iNumPoints < 4 )
return 0;
const double dfTestX = poPoint->getX();
const double dfTestY = poPoint->getY();
// Fast test if point is inside extent of the ring
if (bTestEnvelope)
{
OGREnvelope extent;
getEnvelope(&extent);
if ( !( dfTestX >= extent.MinX && dfTestX <= extent.MaxX
&& dfTestY >= extent.MinY && dfTestY <= extent.MaxY ) )
{
return 0;
}
}
// For every point p in ring,
// test if ray starting from given point crosses segment (p - 1, p)
int iNumCrossings = 0;
double prev_diff_x = getX(0) - dfTestX;
double prev_diff_y = getY(0) - dfTestY;
for ( int iPoint = 1; iPoint < iNumPoints; iPoint++ )
{
const double x1 = getX(iPoint) - dfTestX;
const double y1 = getY(iPoint) - dfTestY;
const double x2 = prev_diff_x;
const double y2 = prev_diff_y;
if( ( ( y1 > 0 ) && ( y2 <= 0 ) ) || ( ( y2 > 0 ) && ( y1 <= 0 ) ) )
{
// Check if ray intersects with segment of the ring
const double dfIntersection = ( x1 * y2 - x2 * y1 ) / (y2 - y1);
if ( 0.0 < dfIntersection )
{
// Count intersections
iNumCrossings++;
}
}
prev_diff_x = x1;
prev_diff_y = y1;
}
// If iNumCrossings number is even, given point is outside the ring,
// when the crossings number is odd, the point is inside the ring.
return ( ( iNumCrossings % 2 ) == 1 ? 1 : 0 );
}
示例14: CPLDebug
void ILI1Reader::ReadGeom( char **stgeom, int geomIdx, OGRwkbGeometryType eType,
OGRFeature *feature ) {
#ifdef DEBUG_VERBOSE
CPLDebug( "OGR_ILI",
"ILI1Reader::ReadGeom geomIdx: %d OGRGeometryType: %s",
geomIdx, OGRGeometryTypeToName(eType) );
#endif
if (eType == wkbNone)
{
CPLError( CE_Warning, CPLE_AppDefined,
"Calling ILI1Reader::ReadGeom with wkbNone" );
}
// Initialize geometry.
OGRCompoundCurve *ogrCurve = new OGRCompoundCurve();
OGRCurvePolygon *ogrPoly = NULL; //current polygon
OGRMultiCurve *ogrMultiLine = NULL; //current multi line
if (eType == wkbMultiCurve || eType == wkbMultiLineString)
{
ogrMultiLine = new OGRMultiCurve();
}
else if (eType == wkbPolygon || eType == wkbCurvePolygon)
{
ogrPoly = new OGRCurvePolygon();
}
OGRPoint ogrPoint; // Current point.
ogrPoint.setX(CPLAtof(stgeom[1])); ogrPoint.setY(CPLAtof(stgeom[2]));
OGRLineString *ogrLine = new OGRLineString();
ogrLine->addPoint(&ogrPoint);
// Parse geometry.
char **tokens = NULL;
bool end = false;
OGRCircularString *arc = NULL; //current arc
while (!end && (tokens = ReadParseLine()) != NULL)
{
const char *firsttok = CSLGetField(tokens, 0);
if (EQUAL(firsttok, "LIPT"))
{
ogrPoint.setX(CPLAtof(tokens[1])); ogrPoint.setY(CPLAtof(tokens[2]));
if (arc) {
arc->addPoint(&ogrPoint);
OGRErr error = ogrCurve->addCurveDirectly(arc);
if (error != OGRERR_NONE) {
CPLError(CE_Warning, CPLE_AppDefined, "Added geometry: %s", arc->exportToJson() );
}
arc = NULL;
}
ogrLine->addPoint(&ogrPoint);
}
else if (EQUAL(firsttok, "ARCP"))
{
//Finish line and start arc
if (ogrLine->getNumPoints() > 1) {
OGRErr error = ogrCurve->addCurveDirectly(ogrLine);
if (error != OGRERR_NONE) {
CPLError(CE_Warning, CPLE_AppDefined, "Added geometry: %s", ogrLine->exportToJson() );
}
ogrLine = new OGRLineString();
} else {
ogrLine->empty();
}
arc = new OGRCircularString();
arc->addPoint(&ogrPoint);
ogrPoint.setX(CPLAtof(tokens[1])); ogrPoint.setY(CPLAtof(tokens[2]));
arc->addPoint(&ogrPoint);
}
else if (EQUAL(firsttok, "ELIN"))
{
if (ogrLine->getNumPoints() > 1) { // Ignore single LIPT after ARCP
OGRErr error = ogrCurve->addCurveDirectly(ogrLine);
if (error != OGRERR_NONE) {
CPLError(CE_Warning, CPLE_AppDefined, "Added geometry: %s", ogrLine->exportToJson() );
}
ogrLine = NULL;
}
if (!ogrCurve->IsEmpty()) {
if (ogrMultiLine)
{
OGRErr error = ogrMultiLine->addGeometryDirectly(ogrCurve);
if (error != OGRERR_NONE) {
CPLError(CE_Warning, CPLE_AppDefined, "Added geometry: %s", ogrCurve->exportToJson() );
}
ogrCurve = NULL;
}
if (ogrPoly)
{
OGRErr error = ogrPoly->addRingDirectly(ogrCurve);
if (error != OGRERR_NONE) {
CPLError(CE_Warning, CPLE_AppDefined, "Added geometry: %s", ogrCurve->exportToJson() );
}
ogrCurve = NULL;
}
}
//.........这里部分代码省略.........
示例15: CPLError
int OGRGeoRSSDataSource::Open( const char * pszFilename, int bUpdateIn)
{
if (bUpdateIn)
{
CPLError(CE_Failure, CPLE_NotSupported,
"OGR/GeoRSS driver does not support opening a file in update mode");
return FALSE;
}
#ifdef HAVE_EXPAT
pszName = CPLStrdup( pszFilename );
/* -------------------------------------------------------------------- */
/* Try to open the file. */
/* -------------------------------------------------------------------- */
VSILFILE* fp = VSIFOpenL(pszFilename, "r");
if (fp == NULL)
return FALSE;
validity = GEORSS_VALIDITY_UNKNOWN;
XML_Parser oParser = OGRCreateExpatXMLParser();
XML_SetUserData(oParser, this);
XML_SetElementHandler(oParser, ::startElementValidateCbk, NULL);
XML_SetCharacterDataHandler(oParser, ::dataHandlerValidateCbk);
oCurrentParser = oParser;
char aBuf[BUFSIZ];
int nDone;
unsigned int nLen;
int nCount = 0;
/* Begin to parse the file and look for the <rss> or <feed> element */
/* It *MUST* be the first element of an XML file */
/* So once we have read the first element, we know if we can */
/* handle the file or not with that driver */
do
{
nDataHandlerCounter = 0;
nLen = (unsigned int) VSIFReadL( aBuf, 1, sizeof(aBuf), fp );
nDone = VSIFEofL(fp);
if (XML_Parse(oParser, aBuf, nLen, nDone) == XML_STATUS_ERROR)
{
if (nLen <= BUFSIZ-1)
aBuf[nLen] = 0;
else
aBuf[BUFSIZ-1] = 0;
if (strstr(aBuf, "<?xml") && (strstr(aBuf, "<rss") || strstr(aBuf, "<feed")))
{
CPLError(CE_Failure, CPLE_AppDefined,
"XML parsing of GeoRSS file failed : %s at line %d, column %d",
XML_ErrorString(XML_GetErrorCode(oParser)),
(int)XML_GetCurrentLineNumber(oParser),
(int)XML_GetCurrentColumnNumber(oParser));
}
validity = GEORSS_VALIDITY_INVALID;
break;
}
if (validity == GEORSS_VALIDITY_INVALID)
{
break;
}
else if (validity == GEORSS_VALIDITY_VALID)
{
break;
}
else
{
/* After reading 50 * BUFSIZ bytes, and not finding whether the file */
/* is GeoRSS or not, we give up and fail silently */
nCount ++;
if (nCount == 50)
break;
}
} while (!nDone && nLen > 0 );
XML_ParserFree(oParser);
VSIFCloseL(fp);
if (validity == GEORSS_VALIDITY_VALID)
{
CPLDebug("GeoRSS", "%s seems to be a GeoRSS file.", pszFilename);
nLayers = 1;
papoLayers = (OGRGeoRSSLayer **) CPLRealloc(papoLayers, nLayers * sizeof(OGRGeoRSSLayer*));
papoLayers[0] = new OGRGeoRSSLayer( pszName, "georss", this, NULL, FALSE );
}
return (validity == GEORSS_VALIDITY_VALID);
#else
char aBuf[256];
VSILFILE* fp = VSIFOpenL(pszFilename, "r");
if (fp)
{
unsigned int nLen = (unsigned int)VSIFReadL( aBuf, 1, 255, fp );
aBuf[nLen] = 0;
if (strstr(aBuf, "<?xml") && (strstr(aBuf, "<rss") || strstr(aBuf, "<feed")))
{
CPLError(CE_Failure, CPLE_NotSupported,
//.........这里部分代码省略.........