OGRErr OGR_G_AddGeometryDirectly( OGRGeometryH hGeom,
OGRGeometryH hNewSubGeom )
{
VALIDATE_POINTER1( hGeom, "OGR_G_AddGeometryDirectly", OGRERR_UNSUPPORTED_OPERATION );
VALIDATE_POINTER1( hNewSubGeom, "OGR_G_AddGeometryDirectly", OGRERR_UNSUPPORTED_OPERATION );
OGRErr eErr = OGRERR_UNSUPPORTED_GEOMETRY_TYPE;
OGRwkbGeometryType eType = wkbFlatten(((OGRGeometry *) hGeom)->getGeometryType());
if( OGR_GT_IsSubClassOf(eType, wkbCurvePolygon) )
{
if( OGR_GT_IsCurve( wkbFlatten(((OGRGeometry *) hNewSubGeom)->getGeometryType()) ) )
eErr = ((OGRCurvePolygon *)hGeom)->addRingDirectly( (OGRCurve *) hNewSubGeom );
}
else if( OGR_GT_IsSubClassOf(eType, wkbCompoundCurve) )
{
if( OGR_GT_IsCurve( wkbFlatten(((OGRGeometry *) hNewSubGeom)->getGeometryType()) ) )
eErr = ((OGRCompoundCurve *)hGeom)->addCurveDirectly( (OGRCurve *) hNewSubGeom );
}
else if( OGR_GT_IsSubClassOf(eType, wkbGeometryCollection) )
{
eErr = ((OGRGeometryCollection *)hGeom)->addGeometryDirectly(
(OGRGeometry *) hNewSubGeom );
}
if( eErr != OGRERR_NONE )
delete (OGRGeometry*)hNewSubGeom;
return eErr;
}
OGRErr OGRCurveCollection::importBodyFromWkb( OGRGeometry* poGeom,
unsigned char * pabyData,
int nSize,
int nDataOffset,
int bAcceptCompoundCurve,
OGRErr (*pfnAddCurveDirectlyFromWkb)(OGRGeometry* poGeom, OGRCurve* poCurve),
OGRwkbVariant eWkbVariant )
{
/* -------------------------------------------------------------------- */
/* Get the Geoms. */
/* -------------------------------------------------------------------- */
int nIter = nCurveCount;
nCurveCount = 0;
for( int iGeom = 0; iGeom < nIter; iGeom++ )
{
OGRErr eErr;
OGRGeometry* poSubGeom = NULL;
/* Parses sub-geometry */
unsigned char* pabySubData = pabyData + nDataOffset;
if( nSize < 9 && nSize != -1 )
return OGRERR_NOT_ENOUGH_DATA;
OGRwkbGeometryType eSubGeomType;
OGRBoolean bIs3D;
if ( OGRReadWKBGeometryType( pabySubData, eWkbVariant, &eSubGeomType, &bIs3D ) != OGRERR_NONE )
return OGRERR_FAILURE;
if( (eSubGeomType != wkbCompoundCurve && OGR_GT_IsCurve(eSubGeomType)) ||
(bAcceptCompoundCurve && eSubGeomType == wkbCompoundCurve) )
{
eErr = OGRGeometryFactory::
createFromWkb( pabySubData, NULL,
&poSubGeom, nSize, eWkbVariant );
}
else
{
CPLDebug("OGR", "Cannot add geometry of type (%d) to geometry of type (%d)",
eSubGeomType, poGeom->getGeometryType());
return OGRERR_UNSUPPORTED_GEOMETRY_TYPE;
}
if( eErr == OGRERR_NONE )
eErr = pfnAddCurveDirectlyFromWkb(poGeom, (OGRCurve*)poSubGeom);
if( eErr != OGRERR_NONE )
{
delete poSubGeom;
return eErr;
}
int nSubGeomWkbSize = poSubGeom->WkbSize();
if( nSize != -1 )
nSize -= nSubGeomWkbSize;
nDataOffset += nSubGeomWkbSize;
}
return OGRERR_NONE;
}
double OGRGeometryCollection::get_Area() const
{
double dfArea = 0.0;
for( auto&& poSubGeom: *this )
{
OGRwkbGeometryType eType = wkbFlatten(poSubGeom->getGeometryType());
if( OGR_GT_IsSurface(eType) )
{
const OGRSurface *poSurface = poSubGeom->toSurface();
dfArea += poSurface->get_Area();
}
else if( OGR_GT_IsCurve(eType) )
{
const OGRCurve *poCurve = poSubGeom->toCurve();
dfArea += poCurve->get_Area();
}
else if( OGR_GT_IsSubClassOf(eType, wkbMultiSurface) ||
eType == wkbGeometryCollection )
{
dfArea += poSubGeom->toGeometryCollection()->get_Area();
}
}
return dfArea;
}
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;
}
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;
}
OGRGeometryH OGR_G_Value( OGRGeometryH hGeom, double dfDistance )
{
VALIDATE_POINTER1( hGeom, "OGR_G_Value", NULL );
if( OGR_GT_IsCurve(((OGRGeometry *) hGeom)->getGeometryType()) )
{
OGRPoint* p = new OGRPoint();
((OGRCurve *) hGeom)->Value(dfDistance, p);
return (OGRGeometryH)p;
}
else
{
return NULL;
}
}
int OGR_G_GetPointCount( OGRGeometryH hGeom )
{
VALIDATE_POINTER1( hGeom, "OGR_G_GetPointCount", 0 );
OGRwkbGeometryType eGType = wkbFlatten(((OGRGeometry *) hGeom)->getGeometryType());
if( eGType == wkbPoint )
return 1;
else if( OGR_GT_IsCurve(eGType) )
return ((OGRCurve *) hGeom)->getNumPoints();
else
{
// autotest/pymod/ogrtest.py calls this method on any geometry. So keep silent
//CPLError(CE_Failure, CPLE_NotSupported, "Incompatible geometry for operation");
return 0;
}
}
double OGRGeometryCollection::get_Length() const
{
double dfLength = 0.0;
for( int iGeom = 0; iGeom < nGeomCount; iGeom++ )
{
OGRGeometry* geom = papoGeoms[iGeom];
OGRwkbGeometryType eType = wkbFlatten(geom->getGeometryType());
if( OGR_GT_IsCurve(eType) )
{
dfLength += ((OGRCurve *) geom)->get_Length();
}
else if( OGR_GT_IsSubClassOf(eType, wkbMultiCurve) ||
eType == wkbGeometryCollection )
{
dfLength += ((OGRGeometryCollection *) geom)->get_Length();
}
}
return dfLength;
}
double OGRGeometryCollection::get_Length() const
{
double dfLength = 0.0;
for( auto&& poSubGeom: *this )
{
const OGRwkbGeometryType eType = wkbFlatten(poSubGeom->getGeometryType());
if( OGR_GT_IsCurve(eType) )
{
const OGRCurve *poCurve = poSubGeom->toCurve();
dfLength += poCurve->get_Length();
}
else if( OGR_GT_IsSubClassOf(eType, wkbMultiCurve) ||
eType == wkbGeometryCollection )
{
const OGRGeometryCollection *poColl = poSubGeom->toGeometryCollection();
dfLength += poColl->get_Length();
}
}
return dfLength;
}
OGRBoolean OGRMultiCurve::isCompatibleSubType(
OGRwkbGeometryType eGeomType ) const
{
return OGR_GT_IsCurve(eGeomType);
}