int OGR_L_Dereference( OGRLayerH hLayer )
{
VALIDATE_POINTER1( hLayer, "OGR_L_Dereference", 0 );
return ((OGRLayer *) hLayer)->Dereference();
}
/**
* \brief Make a copy of a color table.
*
* This function is the same as the C++ method GDALColorTable::Clone()
*/
GDALColorTableH CPL_STDCALL GDALCloneColorTable( GDALColorTableH hTable )
{
VALIDATE_POINTER1( hTable, "GDALCloneColorTable", NULL );
return (GDALColorTableH) ((GDALColorTable *) hTable)->Clone();
}
int GDALTPSTransform( void *pTransformArg, int bDstToSrc,
int nPointCount,
double *x, double *y,
CPL_UNUSED double *z,
int *panSuccess )
{
VALIDATE_POINTER1( pTransformArg, "GDALTPSTransform", 0 );
int i;
TPSTransformInfo *psInfo = (TPSTransformInfo *) pTransformArg;
for( i = 0; i < nPointCount; i++ )
{
double xy_out[2];
if( bDstToSrc )
{
psInfo->poReverse->get_point( x[i], y[i], xy_out );
x[i] = xy_out[0];
y[i] = xy_out[1];
}
else
{
psInfo->poForward->get_point( x[i], y[i], xy_out );
x[i] = xy_out[0];
y[i] = xy_out[1];
}
panSuccess[i] = TRUE;
}
return TRUE;
}
double OGR_G_Length( OGRGeometryH hGeom )
{
VALIDATE_POINTER1( hGeom, "OGR_G_GetLength", 0 );
double dfLength;
OGRwkbGeometryType eType = wkbFlatten(((OGRGeometry *) hGeom)->getGeometryType());
if( OGR_GT_IsCurve(eType) )
{
dfLength = ((OGRCurve *) hGeom)->get_Length();
}
else if( OGR_GT_IsSubClassOf(eType, wkbMultiCurve) ||
eType == wkbGeometryCollection )
{
dfLength = ((OGRGeometryCollection *) hGeom)->get_Length();
}
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"OGR_G_Length() called against a non-curve geometry type." );
dfLength = 0.0;
}
return dfLength;
}
/**
* \brief Import coordinate system from XML format (GML only currently).
*
* This function is the same as OGRSpatialReference::importFromXML().
*/
OGRErr OSRImportFromXML(OGRSpatialReferenceH hSRS, const char *pszXML)
{
VALIDATE_POINTER1(hSRS, "OSRImportFromXML", CE_Failure);
return ((OGRSpatialReference*) hSRS)->importFromXML(pszXML);
}
static
void* GDALCreateSimilarGCPTransformer( void *hTransformArg, double dfRatioX, double dfRatioY )
{
int i = 0;
GDAL_GCP *pasGCPList = NULL;
GCPTransformInfo *psInfo = (GCPTransformInfo *) hTransformArg;
VALIDATE_POINTER1( hTransformArg, "GDALCreateSimilarGCPTransformer", NULL );
if( dfRatioX == 1.0 && dfRatioY == 1.0 )
{
/* We can just use a ref count, since using the source transformation */
/* is thread-safe */
CPLAtomicInc(&(psInfo->nRefCount));
}
else
{
pasGCPList = GDALDuplicateGCPs( psInfo->nGCPCount, psInfo->pasGCPList );
for(i=0;i<psInfo->nGCPCount;i++)
{
pasGCPList[i].dfGCPPixel /= dfRatioX;
pasGCPList[i].dfGCPLine /= dfRatioY;
}
/* As remove_outliers modifies the provided GCPs we don't need to reapply it */
psInfo = (GCPTransformInfo *) GDALCreateGCPTransformer(
psInfo->nGCPCount, pasGCPList, psInfo->nOrder, psInfo->bReversed );
GDALDeinitGCPs( psInfo->nGCPCount, pasGCPList );
CPLFree( pasGCPList );
}
return psInfo;
}
int OGR_G_GetPoints( OGRGeometryH hGeom,
void* pabyX, int nXStride,
void* pabyY, int nYStride,
void* pabyZ, int nZStride)
{
VALIDATE_POINTER1( hGeom, "OGR_G_GetPoints", 0 );
switch( wkbFlatten(((OGRGeometry *) hGeom)->getGeometryType()) )
{
case wkbPoint:
{
if (pabyX) *((double*)pabyX) = ((OGRPoint *)hGeom)->getX();
if (pabyY) *((double*)pabyY) = ((OGRPoint *)hGeom)->getY();
if (pabyZ) *((double*)pabyZ) = ((OGRPoint *)hGeom)->getZ();
return 1;
}
break;
case wkbLineString:
case wkbCircularString:
{
OGRLineString* poLS = (OGRLineString *) hGeom;
poLS->getPoints(pabyX, nXStride, pabyY, nYStride, pabyZ, nZStride);
return poLS->getNumPoints();
}
break;
default:
CPLError(CE_Failure, CPLE_NotSupported, "Incompatible geometry for operation");
return 0;
break;
}
}
OGRErr OGR_L_SetNextByIndex( OGRLayerH hLayer, long nIndex )
{
VALIDATE_POINTER1( hLayer, "OGR_L_SetNextByIndex", OGRERR_INVALID_HANDLE );
return ((OGRLayer *)hLayer)->SetNextByIndex( nIndex );
}
OGRFeatureH OGR_L_GetNextFeature( OGRLayerH hLayer )
{
VALIDATE_POINTER1( hLayer, "OGR_L_GetNextFeature", NULL );
return (OGRFeatureH) ((OGRLayer *)hLayer)->GetNextFeature();
}
OGRErr OGR_L_SetAttributeFilter( OGRLayerH hLayer, const char *pszQuery )
{
VALIDATE_POINTER1( hLayer, "OGR_L_SetAttributeFilter", OGRERR_INVALID_HANDLE );
return ((OGRLayer *) hLayer)->SetAttributeFilter( pszQuery );
}
OGRFeatureH OGR_L_GetFeature( OGRLayerH hLayer, long nFeatureId )
{
VALIDATE_POINTER1( hLayer, "OGR_L_GetFeature", NULL );
return (OGRFeatureH) ((OGRLayer *)hLayer)->GetFeature( nFeatureId );
}
OGRErr OGR_L_GetExtent( OGRLayerH hLayer, OGREnvelope *psExtent, int bForce )
{
VALIDATE_POINTER1( hLayer, "OGR_L_GetExtent", OGRERR_INVALID_HANDLE );
return ((OGRLayer *) hLayer)->GetExtent( psExtent, bForce );
}
int OGR_L_GetFeatureCount( OGRLayerH hLayer, int bForce )
{
VALIDATE_POINTER1( hLayer, "OGR_L_GetFeature", 0 );
return ((OGRLayer *) hLayer)->GetFeatureCount(bForce);
}
int OGR_L_GetRefCount( OGRLayerH hLayer )
{
VALIDATE_POINTER1( hLayer, "OGR_L_GetRefCount", 0 );
return ((OGRLayer *) hLayer)->GetRefCount();
}
const char *OGR_L_GetGeometryColumn( OGRLayerH hLayer )
{
VALIDATE_POINTER1( hLayer, "OGR_L_GetGeometryColumn", NULL );
return ((OGRLayer *) hLayer)->GetGeometryColumn();
}
OGRErr OGR_L_RollbackTransaction( OGRLayerH hLayer )
{
VALIDATE_POINTER1( hLayer, "OGR_L_RollbackTransaction", OGRERR_INVALID_HANDLE );
return ((OGRLayer *)hLayer)->RollbackTransaction();
}
OGRStyleTableH OGR_L_GetStyleTable( OGRLayerH hLayer )
{
VALIDATE_POINTER1( hLayer, "OGR_L_GetStyleTable", NULL );
return (OGRStyleTableH) ((OGRLayer *) hLayer)->GetStyleTable( );
}
OGRFeatureDefnH OGR_L_GetLayerDefn( OGRLayerH hLayer )
{
VALIDATE_POINTER1( hLayer, "OGR_L_GetLayerDefn", NULL );
return (OGRFeatureDefnH) ((OGRLayer *)hLayer)->GetLayerDefn();
}
double OGR_G_GetZ( OGRGeometryH hGeom, int i )
{
VALIDATE_POINTER1( hGeom, "OGR_G_GetZ", 0 );
switch( wkbFlatten(((OGRGeometry *) hGeom)->getGeometryType()) )
{
case wkbPoint:
{
if( i == 0 )
return ((OGRPoint *) hGeom)->getZ();
else
{
CPLError(CE_Failure, CPLE_NotSupported, "Only i == 0 is supported");
return 0.0;
}
}
case wkbLineString:
case wkbCircularString:
{
OGRLineString* poLS = (OGRLineString *) hGeom;
if (i < 0 || i >= poLS->getNumPoints())
{
CPLError(CE_Failure, CPLE_NotSupported, "Index out of bounds");
return 0.0;
}
return poLS->getZ( i );
}
default:
CPLError(CE_Failure, CPLE_NotSupported, "Incompatible geometry for operation");
return 0.0;
}
}
OGRSpatialReferenceH OGR_L_GetSpatialRef( OGRLayerH hLayer )
{
VALIDATE_POINTER1( hLayer, "OGR_L_GetSpatialRef", NULL );
return (OGRSpatialReferenceH) ((OGRLayer *) hLayer)->GetSpatialRef();
}
OGRGeometryH OGR_G_GetGeometryRef( OGRGeometryH hGeom, int iSubGeom )
{
VALIDATE_POINTER1( hGeom, "OGR_G_GetGeometryRef", NULL );
OGRwkbGeometryType eType = wkbFlatten(((OGRGeometry *) hGeom)->getGeometryType());
if( OGR_GT_IsSubClassOf(eType, wkbCurvePolygon) )
{
if( iSubGeom == 0 )
return (OGRGeometryH)
((OGRCurvePolygon *)hGeom)->getExteriorRingCurve();
else
return (OGRGeometryH)
((OGRCurvePolygon *)hGeom)->getInteriorRingCurve(iSubGeom-1);
}
else if( OGR_GT_IsSubClassOf(eType, wkbCompoundCurve) )
return (OGRGeometryH) ((OGRCompoundCurve *)hGeom)->getCurve(iSubGeom);
else if( OGR_GT_IsSubClassOf(eType, wkbGeometryCollection) )
return (OGRGeometryH) ((OGRGeometryCollection *)hGeom)->getGeometryRef( iSubGeom );
else
{
CPLError(CE_Failure, CPLE_NotSupported, "Incompatible geometry for operation");
return 0;
}
}
OGRGeometryH OGR_L_GetSpatialFilter( OGRLayerH hLayer )
{
VALIDATE_POINTER1( hLayer, "OGR_L_GetSpatialFilter", NULL );
return (OGRGeometryH) ((OGRLayer *) hLayer)->GetSpatialFilter();
}
double OGR_G_Area( OGRGeometryH hGeom )
{
VALIDATE_POINTER1( hGeom, "OGR_G_Area", 0 );
double dfArea;
OGRwkbGeometryType eType = wkbFlatten(((OGRGeometry *) hGeom)->getGeometryType());
if( OGR_GT_IsSurface(eType) )
{
dfArea = ((OGRSurface *) hGeom)->get_Area();
}
else if( OGR_GT_IsCurve(eType) )
{
dfArea = ((OGRCurve *) hGeom)->get_Area();
}
else if( OGR_GT_IsSubClassOf(eType, wkbMultiSurface) ||
eType == wkbGeometryCollection )
{
dfArea = ((OGRGeometryCollection *) hGeom)->get_Area();
}
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"OGR_G_Area() called against non-surface geometry type." );
dfArea = 0.0;
}
return dfArea;
}
OGRErr OGR_L_SyncToDisk( OGRLayerH hDS )
{
VALIDATE_POINTER1( hDS, "OGR_L_SyncToDisk", OGRERR_INVALID_HANDLE );
return ((OGRLayer *) hDS)->SyncToDisk();
}
/**
* \brief Validate SRS tokens.
*
* This function is the same as the C++ method OGRSpatialReference::Validate().
*/
OGRErr OSRValidate( OGRSpatialReferenceH hSRS )
{
VALIDATE_POINTER1( hSRS, "OSRValidate", OGRERR_FAILURE );
return ((OGRSpatialReference *) hSRS)->Validate();
}
OGRErr OGR_L_DeleteFeature( OGRLayerH hDS, long nFID )
{
VALIDATE_POINTER1( hDS, "OGR_L_DeleteFeature", OGRERR_INVALID_HANDLE );
return ((OGRLayer *) hDS)->DeleteFeature( nFID );
}
/**
* \brief Get number of color entries in table.
*
* This function is the same as the C++ method GDALColorTable::GetColorEntryCount()
*/
int CPL_STDCALL GDALGetColorEntryCount( GDALColorTableH hTable )
{
VALIDATE_POINTER1( hTable, "GDALGetColorEntryCount", 0 );
return ((GDALColorTable *) hTable)->GetColorEntryCount();
}
GIntBig OGR_L_GetFeaturesRead( OGRLayerH hLayer )
{
VALIDATE_POINTER1( hLayer, "OGR_L_GetFeaturesRead", 0 );
return ((OGRLayer *) hLayer)->GetFeaturesRead();
}
CPLXMLNode *GDALSerializeTPSTransformer( void *pTransformArg )
{
VALIDATE_POINTER1( pTransformArg, "GDALSerializeTPSTransformer", NULL );
CPLXMLNode *psTree;
TPSTransformInfo *psInfo = static_cast<TPSTransformInfo *>(pTransformArg);
psTree = CPLCreateXMLNode( NULL, CXT_Element, "TPSTransformer" );
/* -------------------------------------------------------------------- */
/* Serialize bReversed. */
/* -------------------------------------------------------------------- */
CPLCreateXMLElementAndValue(
psTree, "Reversed",
CPLString().Printf( "%d", psInfo->bReversed ) );
/* -------------------------------------------------------------------- */
/* Attach GCP List. */
/* -------------------------------------------------------------------- */
if( psInfo->nGCPCount > 0 )
{
GDALSerializeGCPListToXML( psTree,
psInfo->pasGCPList,
psInfo->nGCPCount,
NULL );
}
return psTree;
}
OGRErr OGR_L_SetIgnoredFields( OGRLayerH hLayer, const char **papszFields )
{
VALIDATE_POINTER1( hLayer, "OGR_L_SetIgnoredFields", NULL );
return ((OGRLayer *) hLayer)->SetIgnoredFields( papszFields );
}
