OGRBoolean OGRPolygon::Equals( OGRGeometry * poOther ) const
{
OGRPolygon *poOPoly = (OGRPolygon *) poOther;
if( poOPoly == this )
return TRUE;
if( poOther->getGeometryType() != getGeometryType() )
return FALSE;
if( getNumInteriorRings() != poOPoly->getNumInteriorRings() )
return FALSE;
if( getExteriorRing() == NULL && poOPoly->getExteriorRing() == NULL )
/* ok */;
else if( getExteriorRing() == NULL || poOPoly->getExteriorRing() == NULL )
return FALSE;
else if( !getExteriorRing()->Equals( poOPoly->getExteriorRing() ) )
return FALSE;
// we should eventually test the SRS.
for( int iRing = 0; iRing < getNumInteriorRings(); iRing++ )
{
if( !getInteriorRing(iRing)->Equals(poOPoly->getInteriorRing(iRing)) )
return FALSE;
}
return TRUE;
}
bool is_valid_polygon(const OGRGeometry* geometry) {
if (geometry && geometry->getGeometryType() == wkbPolygon) {
const auto polygon = static_cast<const OGRPolygon*>(geometry);
return (polygon->getExteriorRing()->getNumPoints() > 3) && (polygon->getNumInteriorRings() == 0) && geometry->IsValid();
}
return false;
}
double OGRPolygon::get_Area() const
{
double dfArea = 0.0;
if( getExteriorRing() != NULL )
{
int iRing;
dfArea = getExteriorRing()->get_Area();
for( iRing = 0; iRing < getNumInteriorRings(); iRing++ )
dfArea -= getInteriorRing( iRing )->get_Area();
}
return dfArea;
}
OGRErr OGRPolygon::exportToWkt( char ** ppszDstText,
OGRwkbVariant eWkbVariant ) const
{
bool bMustWriteComma = false;
/* -------------------------------------------------------------------- */
/* If we have no valid exterior ring, return POLYGON EMPTY. */
/* -------------------------------------------------------------------- */
if( getExteriorRing() == NULL ||
getExteriorRing()->IsEmpty() )
{
if( eWkbVariant == wkbVariantIso )
{
if( (flags & OGR_G_3D) && (flags & OGR_G_MEASURED) )
*ppszDstText = CPLStrdup((CPLString(getGeometryName()) + " ZM EMPTY").c_str());
else if( flags & OGR_G_MEASURED )
*ppszDstText = CPLStrdup((CPLString(getGeometryName()) + " M EMPTY").c_str());
else if( flags & OGR_G_3D )
*ppszDstText = CPLStrdup((CPLString(getGeometryName()) + " Z EMPTY").c_str());
else
*ppszDstText = CPLStrdup((CPLString(getGeometryName()) + " EMPTY").c_str());
}
else
*ppszDstText = CPLStrdup((CPLString(getGeometryName()) + " EMPTY").c_str());
return OGRERR_NONE;
}
/* -------------------------------------------------------------------- */
/* Build a list of strings containing the stuff for each ring. */
/* -------------------------------------------------------------------- */
char **papszRings =
static_cast<char **>(CPLCalloc(sizeof(char *), oCC.nCurveCount));
size_t nCumulativeLength = 0;
size_t nNonEmptyRings = 0;
size_t *pnRingBeginning =
static_cast<size_t *>(CPLCalloc(sizeof(size_t), oCC.nCurveCount));
OGRErr eErr;
for( int iRing = 0; iRing < oCC.nCurveCount; iRing++ )
{
OGRLinearRing* poLR = (OGRLinearRing*) oCC.papoCurves[iRing];
//poLR->setFlags( getFlags() );
poLR->set3D(Is3D());
poLR->setMeasured(IsMeasured());
if( poLR->getNumPoints() == 0 )
{
papszRings[iRing] = NULL;
continue;
}
eErr = poLR->exportToWkt( &(papszRings[iRing]), eWkbVariant );
if( eErr != OGRERR_NONE )
goto error;
if( STARTS_WITH_CI(papszRings[iRing], "LINEARRING ZM (") )
pnRingBeginning[iRing] = 14;
else if( STARTS_WITH_CI(papszRings[iRing], "LINEARRING M (") )
pnRingBeginning[iRing] = 13;
else if( STARTS_WITH_CI(papszRings[iRing], "LINEARRING Z (") )
pnRingBeginning[iRing] = 13;
else if( STARTS_WITH_CI(papszRings[iRing], "LINEARRING (") )
pnRingBeginning[iRing] = 11;
else
{
CPLAssert(false);
}
nCumulativeLength += strlen(papszRings[iRing] + pnRingBeginning[iRing]);
nNonEmptyRings++;
}
/* -------------------------------------------------------------------- */
/* Allocate exactly the right amount of space for the */
/* aggregated string. */
/* -------------------------------------------------------------------- */
*ppszDstText = (char *) VSI_MALLOC_VERBOSE(
nCumulativeLength + nNonEmptyRings + strlen(getGeometryName()) + strlen(" ZM ()") + 1);
if( *ppszDstText == NULL )
{
eErr = OGRERR_NOT_ENOUGH_MEMORY;
goto error;
}
/* -------------------------------------------------------------------- */
/* Build up the string, freeing temporary strings as we go. */
/* -------------------------------------------------------------------- */
if( eWkbVariant == wkbVariantIso )
{
if( (flags & OGR_G_3D) && (flags & OGR_G_MEASURED) )
strcpy( *ppszDstText, (CPLString(getGeometryName()) + " ZM (").c_str() );
else if( flags & OGR_G_MEASURED )
strcpy( *ppszDstText, (CPLString(getGeometryName()) + " M (").c_str() );
else if( flags & OGR_G_3D )
strcpy( *ppszDstText, (CPLString(getGeometryName()) + " Z (").c_str() );
else
strcpy( *ppszDstText, (CPLString(getGeometryName()) + " (").c_str() );
}
else
strcpy( *ppszDstText, (CPLString(getGeometryName()) + " (").c_str() );
nCumulativeLength = strlen(*ppszDstText);
for( int iRing = 0; iRing < oCC.nCurveCount; iRing++ )
{
if( papszRings[iRing] == NULL )
{
CPLDebug( "OGR",
"OGRPolygon::exportToWkt() - skipping empty ring.");
continue;
}
if( bMustWriteComma )
(*ppszDstText)[nCumulativeLength++] = ',';
bMustWriteComma = true;
size_t nRingLen = strlen(papszRings[iRing] + pnRingBeginning[iRing]);
memcpy( *ppszDstText + nCumulativeLength,
papszRings[iRing] + pnRingBeginning[iRing],
nRingLen );
nCumulativeLength += nRingLen;
VSIFree( papszRings[iRing] );
}
(*ppszDstText)[nCumulativeLength++] = ')';
(*ppszDstText)[nCumulativeLength] = '\0';
CPLFree( papszRings );
CPLFree( pnRingBeginning );
return OGRERR_NONE;
error:
for( int iRing = 0; iRing < oCC.nCurveCount; iRing++ )
CPLFree(papszRings[iRing]);
CPLFree(papszRings);
return eErr;
}
Geometry*
Polygon::convexHull() const
{
return getExteriorRing()->convexHull();
}
OGRErr OGRPolygon::exportToWkt( char ** ppszDstText ) const
{
char **papszRings;
int iRing, nCumulativeLength = 0, nNonEmptyRings = 0;
OGRErr eErr;
int bMustWriteComma = FALSE;
/* -------------------------------------------------------------------- */
/* If we have no valid exterior ring, return POLYGON EMPTY. */
/* -------------------------------------------------------------------- */
if (getExteriorRing() == NULL ||
getExteriorRing()->IsEmpty())
{
*ppszDstText = CPLStrdup("POLYGON EMPTY");
return OGRERR_NONE;
}
/* -------------------------------------------------------------------- */
/* Build a list of strings containing the stuff for each ring. */
/* -------------------------------------------------------------------- */
papszRings = (char **) CPLCalloc(sizeof(char *),nRingCount);
for( iRing = 0; iRing < nRingCount; iRing++ )
{
papoRings[iRing]->setCoordinateDimension( getCoordinateDimension() );
if( papoRings[iRing]->getNumPoints() == 0 )
{
papszRings[iRing] = NULL;
continue;
}
eErr = papoRings[iRing]->exportToWkt( &(papszRings[iRing]) );
if( eErr != OGRERR_NONE )
goto error;
CPLAssert( EQUALN(papszRings[iRing],"LINEARRING (", 12) );
nCumulativeLength += strlen(papszRings[iRing] + 11);
nNonEmptyRings++;
}
/* -------------------------------------------------------------------- */
/* Allocate exactly the right amount of space for the */
/* aggregated string. */
/* -------------------------------------------------------------------- */
*ppszDstText = (char *) VSIMalloc(nCumulativeLength + nNonEmptyRings + 11);
if( *ppszDstText == NULL )
{
eErr = OGRERR_NOT_ENOUGH_MEMORY;
goto error;
}
/* -------------------------------------------------------------------- */
/* Build up the string, freeing temporary strings as we go. */
/* -------------------------------------------------------------------- */
strcpy( *ppszDstText, "POLYGON (" );
nCumulativeLength = strlen(*ppszDstText);
for( iRing = 0; iRing < nRingCount; iRing++ )
{
if( papszRings[iRing] == NULL )
{
CPLDebug( "OGR", "OGRPolygon::exportToWkt() - skipping empty ring.");
continue;
}
if( bMustWriteComma )
(*ppszDstText)[nCumulativeLength++] = ',';
bMustWriteComma = TRUE;
int nRingLen = strlen(papszRings[iRing] + 11);
memcpy( *ppszDstText + nCumulativeLength, papszRings[iRing] + 11, nRingLen );
nCumulativeLength += nRingLen;
VSIFree( papszRings[iRing] );
}
(*ppszDstText)[nCumulativeLength++] = ')';
(*ppszDstText)[nCumulativeLength] = '\0';
CPLFree( papszRings );
return OGRERR_NONE;
error:
for( iRing = 0; iRing < nRingCount; iRing++ )
CPLFree(papszRings[iRing]);
CPLFree(papszRings);
return eErr;
}