OGRErr OGRMultiPoint::importFromWkt_Bracketed( char ** ppszInput )
{
char szToken[OGR_WKT_TOKEN_MAX];
const char *pszInput = *ppszInput;
OGRErr eErr = OGRERR_NONE;
/* -------------------------------------------------------------------- */
/* Skip MULTIPOINT keyword. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
/* -------------------------------------------------------------------- */
/* Read points till we get to the closing bracket. */
/* -------------------------------------------------------------------- */
int nMaxPoint = 0;
int nPointCount = 0;
OGRRawPoint *paoPoints = NULL;
double *padfZ = NULL;
while( (pszInput = OGRWktReadToken( pszInput, szToken ))
&& (EQUAL(szToken,"(") || EQUAL(szToken,",")) )
{
OGRGeometry *poGeom;
pszInput = OGRWktReadPoints( pszInput, &paoPoints, &padfZ, &nMaxPoint,
&nPointCount );
if( pszInput == NULL || nPointCount != 1 )
return OGRERR_CORRUPT_DATA;
if( padfZ )
poGeom = new OGRPoint( paoPoints[0].x,
paoPoints[0].y,
padfZ[0] );
else
poGeom = new OGRPoint( paoPoints[0].x,
paoPoints[0].y );
eErr = addGeometryDirectly( poGeom );
if( eErr != OGRERR_NONE )
return eErr;
}
/* -------------------------------------------------------------------- */
/* Cleanup. */
/* -------------------------------------------------------------------- */
OGRFree( paoPoints );
if( padfZ )
OGRFree( padfZ );
if( !EQUAL(szToken,")") )
return OGRERR_CORRUPT_DATA;
*ppszInput = (char *) pszInput;
return OGRERR_NONE;
}
OGRErr OGRGeometryCollection::addGeometry( const OGRGeometry * poNewGeom )
{
OGRGeometry *poClone = poNewGeom->clone();
OGRErr eErr;
eErr = addGeometryDirectly( poClone );
if( eErr != OGRERR_NONE )
delete poClone;
return eErr;
}
OGRErr OGRMultiPoint::importFromWkt( char ** ppszInput )
{
char szToken[OGR_WKT_TOKEN_MAX];
const char *pszInput = *ppszInput;
int iGeom;
OGRErr eErr = OGRERR_NONE;
/* -------------------------------------------------------------------- */
/* Clear existing Geoms. */
/* -------------------------------------------------------------------- */
empty();
/* -------------------------------------------------------------------- */
/* Read and verify the type keyword, and ensure it matches the */
/* actual type of this container. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
if( !EQUAL(szToken,getGeometryName()) )
return OGRERR_CORRUPT_DATA;
/* -------------------------------------------------------------------- */
/* Skip past first bracket for checking purposes, but don't */
/* alter pszInput. */
/* -------------------------------------------------------------------- */
const char *pszPreScan = pszInput;
// skip white space.
while( *pszPreScan == ' ' || *pszPreScan == '\t' )
pszPreScan++;
// Skip outer bracket.
if( *pszPreScan != '(' )
return OGRERR_CORRUPT_DATA;
pszPreScan++;
/* -------------------------------------------------------------------- */
/* If the next token is EMPTY, then verify that we have proper */
/* EMPTY format will a trailing closing bracket. */
/* -------------------------------------------------------------------- */
OGRWktReadToken( pszPreScan, szToken );
if( EQUAL(szToken,"EMPTY") )
{
pszInput = OGRWktReadToken( pszPreScan, szToken );
pszInput = OGRWktReadToken( pszInput, szToken );
*ppszInput = (char *) pszInput;
if( !EQUAL(szToken,")") )
return OGRERR_CORRUPT_DATA;
else
return OGRERR_NONE;
}
/* -------------------------------------------------------------------- */
/* Check for inner bracket indicating the improper bracketed */
/* format which we still want to support. */
/* -------------------------------------------------------------------- */
// skip white space.
while( *pszPreScan == ' ' || *pszPreScan == '\t' )
pszPreScan++;
// Do we have an inner bracket?
if( *pszPreScan == '(' )
return importFromWkt_Bracketed( ppszInput );
/* -------------------------------------------------------------------- */
/* Read the point list which should consist of exactly one point. */
/* -------------------------------------------------------------------- */
int nMaxPoint = 0;
int nPointCount = 0;
OGRRawPoint *paoPoints = NULL;
double *padfZ = NULL;
pszInput = OGRWktReadPoints( pszInput, &paoPoints, &padfZ, &nMaxPoint,
&nPointCount );
if( pszInput == NULL )
return OGRERR_CORRUPT_DATA;
/* -------------------------------------------------------------------- */
/* Transform raw points into point objects. */
/* -------------------------------------------------------------------- */
for( iGeom = 0; iGeom < nPointCount && eErr == OGRERR_NONE; iGeom++ )
{
OGRGeometry *poGeom;
if( padfZ )
poGeom = new OGRPoint( paoPoints[iGeom].x,
paoPoints[iGeom].y,
padfZ[iGeom] );
else
poGeom = new OGRPoint( paoPoints[iGeom].x,
paoPoints[iGeom].y );
eErr = addGeometryDirectly( poGeom );
}
OGRFree( paoPoints );
if( padfZ )
OGRFree( padfZ );
if( eErr != OGRERR_NONE )
return eErr;
*ppszInput = (char *) pszInput;
return OGRERR_NONE;
}
OGRErr OGRMultiSurface::importFromWkt( char ** ppszInput )
{
int bHasZ = FALSE;
int bHasM = FALSE;
bool bIsEmpty = false;
OGRErr eErr = importPreambuleFromWkt(ppszInput, &bHasZ, &bHasM, &bIsEmpty);
flags = 0;
if( eErr != OGRERR_NONE )
return eErr;
if( bHasZ ) flags |= OGR_G_3D;
if( bHasM ) flags |= OGR_G_MEASURED;
if( bIsEmpty )
return OGRERR_NONE;
char szToken[OGR_WKT_TOKEN_MAX] = {};
const char *pszInput = *ppszInput;
eErr = OGRERR_NONE;
// Skip first '('.
pszInput = OGRWktReadToken( pszInput, szToken );
/* ==================================================================== */
/* Read each surface in turn. Note that we try to reuse the same */
/* point list buffer from ring to ring to cut down on */
/* allocate/deallocate overhead. */
/* ==================================================================== */
OGRRawPoint *paoPoints = NULL;
int nMaxPoints = 0;
double *padfZ = NULL;
do
{
/* -------------------------------------------------------------------- */
/* Get the first token, which should be the geometry type. */
/* -------------------------------------------------------------------- */
const char* pszInputBefore = pszInput;
pszInput = OGRWktReadToken( pszInput, szToken );
OGRSurface* poSurface = NULL;
/* -------------------------------------------------------------------- */
/* Do the import. */
/* -------------------------------------------------------------------- */
if( EQUAL(szToken, "(") )
{
OGRPolygon *poPolygon = new OGRPolygon();
poSurface = poPolygon;
pszInput = pszInputBefore;
eErr = poPolygon->importFromWKTListOnly(
const_cast<char **>(&pszInput), bHasZ, bHasM,
paoPoints, nMaxPoints, padfZ );
}
else if( EQUAL(szToken, "EMPTY") )
{
poSurface = new OGRPolygon();
}
// We accept POLYGON() but this is an extension to the BNF, also
// accepted by PostGIS.
else if( EQUAL(szToken, "POLYGON") ||
EQUAL(szToken, "CURVEPOLYGON") )
{
OGRGeometry* poGeom = NULL;
pszInput = pszInputBefore;
eErr = OGRGeometryFactory::createFromWkt(
const_cast<char **>(&pszInput), NULL, &poGeom );
poSurface = dynamic_cast<OGRSurface*>(poGeom);
if( poSurface == NULL )
{
delete poGeom;
eErr = OGRERR_CORRUPT_DATA;
break;
}
}
else
{
CPLError(CE_Failure, CPLE_AppDefined,
"Unexpected token : %s", szToken);
eErr = OGRERR_CORRUPT_DATA;
break;
}
if( eErr == OGRERR_NONE )
eErr = addGeometryDirectly( poSurface );
if( eErr != OGRERR_NONE )
{
delete poSurface;
break;
}
/* -------------------------------------------------------------------- */
/* Read the delimiter following the surface. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
} while( szToken[0] == ',' && eErr == OGRERR_NONE );
CPLFree( paoPoints );
CPLFree( padfZ );
/* -------------------------------------------------------------------- */
/* freak if we don't get a closing bracket. */
/* -------------------------------------------------------------------- */
if( eErr != OGRERR_NONE )
return eErr;
if( szToken[0] != ')' )
return OGRERR_CORRUPT_DATA;
*ppszInput = const_cast<char *>(pszInput);
return OGRERR_NONE;
}
OGRErr OGRGeometryCollection::importFromWkt( char ** ppszInput )
{
char szToken[OGR_WKT_TOKEN_MAX];
const char *pszInput = *ppszInput;
int iGeom;
/* -------------------------------------------------------------------- */
/* Clear existing Geoms. */
/* -------------------------------------------------------------------- */
if( nGeomCount > 0 )
{
for( iGeom = 0; iGeom < nGeomCount; iGeom++ )
delete papoGeoms[iGeom];
nGeomCount = 0;
CPLFree( papoGeoms );
}
/* -------------------------------------------------------------------- */
/* Read and verify the type keyword, and ensure it matches the */
/* actual type of this container. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
if( !EQUAL(szToken,getGeometryName()) )
return OGRERR_CORRUPT_DATA;
/* -------------------------------------------------------------------- */
/* The next character should be a ( indicating the start of the */
/* list of objects. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
if( szToken[0] != '(' )
return OGRERR_CORRUPT_DATA;
/* -------------------------------------------------------------------- */
/* If the next token is EMPTY, then verify that we have proper */
/* EMPTY format will a trailing closing bracket. */
/* -------------------------------------------------------------------- */
OGRWktReadToken( pszInput, szToken );
if( EQUAL(szToken,"EMPTY") )
{
pszInput = OGRWktReadToken( pszInput, szToken );
pszInput = OGRWktReadToken( pszInput, szToken );
*ppszInput = (char *) pszInput;
if( !EQUAL(szToken,")") )
return OGRERR_CORRUPT_DATA;
else
return OGRERR_NONE;
}
/* ==================================================================== */
/* Read each subgeometry in turn. */
/* ==================================================================== */
do
{
OGRGeometry *poGeom = NULL;
OGRErr eErr;
eErr = OGRGeometryFactory::createFromWkt( (char **) &pszInput,
NULL, &poGeom );
if( eErr != OGRERR_NONE )
return eErr;
addGeometryDirectly( poGeom );
/* -------------------------------------------------------------------- */
/* Read the delimeter following the ring. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
} while( szToken[0] == ',' );
/* -------------------------------------------------------------------- */
/* freak if we don't get a closing bracket. */
/* -------------------------------------------------------------------- */
if( szToken[0] != ')' )
return OGRERR_CORRUPT_DATA;
*ppszInput = (char *) pszInput;
return OGRERR_NONE;
}
OGRErr OGRMultiLineString::importFromWkt( char ** ppszInput )
{
char szToken[OGR_WKT_TOKEN_MAX];
const char *pszInput = *ppszInput;
OGRErr eErr;
/* -------------------------------------------------------------------- */
/* Clear existing rings. */
/* -------------------------------------------------------------------- */
empty();
/* -------------------------------------------------------------------- */
/* Read and verify the ``MULTILINESTRING'' keyword token. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
if( !EQUAL(szToken,getGeometryName()) )
return OGRERR_CORRUPT_DATA;
/* -------------------------------------------------------------------- */
/* The next character should be a ( indicating the start of the */
/* list of linestrings. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
if( EQUAL(szToken,"EMPTY") )
{
*ppszInput = (char *) pszInput;
return OGRERR_NONE;
}
if( szToken[0] != '(' )
return OGRERR_CORRUPT_DATA;
/* -------------------------------------------------------------------- */
/* If the next token is EMPTY, then verify that we have proper */
/* EMPTY format will a trailing closing bracket. */
/* -------------------------------------------------------------------- */
OGRWktReadToken( pszInput, szToken );
if( EQUAL(szToken,"EMPTY") )
{
pszInput = OGRWktReadToken( pszInput, szToken );
pszInput = OGRWktReadToken( pszInput, szToken );
*ppszInput = (char *) pszInput;
if( !EQUAL(szToken,")") )
return OGRERR_CORRUPT_DATA;
else
return OGRERR_NONE;
}
/* ==================================================================== */
/* Read each line in turn. Note that we try to reuse the same */
/* point list buffer from ring to ring to cut down on */
/* allocate/deallocate overhead. */
/* ==================================================================== */
OGRRawPoint *paoPoints = NULL;
int nMaxPoints = 0;
double *padfZ = NULL;
do
{
int nPoints = 0;
/* -------------------------------------------------------------------- */
/* Read points for one line from input. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadPoints( pszInput, &paoPoints, &padfZ, &nMaxPoints,
&nPoints );
if( pszInput == NULL )
{
eErr = OGRERR_CORRUPT_DATA;
break;
}
/* -------------------------------------------------------------------- */
/* Create the new line, and add to collection. */
/* -------------------------------------------------------------------- */
OGRLineString *poLine;
poLine = new OGRLineString();
poLine->setPoints( nPoints, paoPoints, padfZ );
eErr = addGeometryDirectly( poLine );
/* -------------------------------------------------------------------- */
/* Read the delimeter following the ring. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
} while( szToken[0] == ',' && eErr == OGRERR_NONE );
/* -------------------------------------------------------------------- */
/* freak if we don't get a closing bracket. */
/* -------------------------------------------------------------------- */
CPLFree( paoPoints );
CPLFree( padfZ );
if( eErr != OGRERR_NONE )
return eErr;
if( szToken[0] != ')' )
return OGRERR_CORRUPT_DATA;
*ppszInput = (char *) pszInput;
return OGRERR_NONE;
}
OGRErr OGRGeometryCollection::importFromWktInternal( const char ** ppszInput,
int nRecLevel )
{
// Arbitrary value, but certainly large enough for reasonable usages.
if( nRecLevel == 32 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Too many recursion levels (%d) while parsing WKT geometry.",
nRecLevel );
return OGRERR_CORRUPT_DATA;
}
int bHasZ = FALSE;
int bHasM = FALSE;
bool bIsEmpty = false;
OGRErr eErr = importPreambleFromWkt(ppszInput, &bHasZ, &bHasM, &bIsEmpty);
if( eErr != OGRERR_NONE )
return eErr;
if( bHasZ ) flags |= OGR_G_3D;
if( bHasM ) flags |= OGR_G_MEASURED;
if( bIsEmpty )
return OGRERR_NONE;
char szToken[OGR_WKT_TOKEN_MAX] = {};
const char *pszInput = *ppszInput;
// Skip first '('.
pszInput = OGRWktReadToken( pszInput, szToken );
/* ==================================================================== */
/* Read each subgeometry in turn. */
/* ==================================================================== */
do
{
OGRGeometry *poGeom = nullptr;
/* -------------------------------------------------------------------- */
/* Get the first token, which should be the geometry type. */
/* -------------------------------------------------------------------- */
OGRWktReadToken( pszInput, szToken );
/* -------------------------------------------------------------------- */
/* Do the import. */
/* -------------------------------------------------------------------- */
if( STARTS_WITH_CI(szToken, "GEOMETRYCOLLECTION") )
{
OGRGeometryCollection* poGC = new OGRGeometryCollection();
poGeom = poGC;
eErr = poGC->importFromWktInternal( &pszInput,
nRecLevel + 1 );
}
else
eErr = OGRGeometryFactory::createFromWkt( &pszInput,
nullptr, &poGeom );
if( eErr == OGRERR_NONE )
{
// If this has M, but not Z, it is an error if poGeom does
// not have M.
if( !Is3D() && IsMeasured() && !poGeom->IsMeasured() )
eErr = OGRERR_CORRUPT_DATA;
else
eErr = addGeometryDirectly( poGeom );
}
if( eErr != OGRERR_NONE )
{
delete poGeom;
return eErr;
}
/* -------------------------------------------------------------------- */
/* Read the delimiter following the ring. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
} while( szToken[0] == ',' );
/* -------------------------------------------------------------------- */
/* freak if we don't get a closing bracket. */
/* -------------------------------------------------------------------- */
if( szToken[0] != ')' )
return OGRERR_CORRUPT_DATA;
*ppszInput = pszInput;
return OGRERR_NONE;
}
OGRErr OGRGeometryCollection::importFromWkt( char ** ppszInput )
{
char szToken[OGR_WKT_TOKEN_MAX];
const char *pszInput = *ppszInput;
/* -------------------------------------------------------------------- */
/* Clear existing Geoms. */
/* -------------------------------------------------------------------- */
empty();
/* -------------------------------------------------------------------- */
/* Read and verify the type keyword, and ensure it matches the */
/* actual type of this container. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
if( !EQUAL(szToken,getGeometryName()) )
return OGRERR_CORRUPT_DATA;
/* -------------------------------------------------------------------- */
/* Check for EMPTY ... */
/* -------------------------------------------------------------------- */
const char *pszPreScan;
int bHasZ = FALSE, bHasM = FALSE;
pszPreScan = OGRWktReadToken( pszInput, szToken );
if( EQUAL(szToken,"EMPTY") )
{
*ppszInput = (char *) pszPreScan;
empty();
return OGRERR_NONE;
}
/* -------------------------------------------------------------------- */
/* Check for Z, M or ZM. Will ignore the Measure */
/* -------------------------------------------------------------------- */
else if( EQUAL(szToken,"Z") )
{
bHasZ = TRUE;
}
else if( EQUAL(szToken,"M") )
{
bHasM = TRUE;
}
else if( EQUAL(szToken,"ZM") )
{
bHasZ = TRUE;
bHasM = TRUE;
}
if (bHasZ || bHasM)
{
pszInput = pszPreScan;
pszPreScan = OGRWktReadToken( pszInput, szToken );
if( EQUAL(szToken,"EMPTY") )
{
*ppszInput = (char *) pszPreScan;
empty();
/* FIXME?: In theory we should store the dimension and M presence */
/* if we want to allow round-trip with ExportToWKT v1.2 */
return OGRERR_NONE;
}
}
if( !EQUAL(szToken,"(") )
return OGRERR_CORRUPT_DATA;
if ( !bHasZ && !bHasM )
{
/* Test for old-style GEOMETRYCOLLECTION(EMPTY) */
pszPreScan = OGRWktReadToken( pszPreScan, szToken );
if( EQUAL(szToken,"EMPTY") )
{
pszInput = OGRWktReadToken( pszPreScan, szToken );
if( !EQUAL(szToken,")") )
return OGRERR_CORRUPT_DATA;
else
{
*ppszInput = (char *) pszInput;
empty();
return OGRERR_NONE;
}
}
}
/* Skip first '(' */
pszInput = OGRWktReadToken( pszInput, szToken );
/* ==================================================================== */
/* Read each subgeometry in turn. */
/* ==================================================================== */
do
{
OGRGeometry *poGeom = NULL;
OGRErr eErr;
eErr = OGRGeometryFactory::createFromWkt( (char **) &pszInput,
NULL, &poGeom );
if( eErr != OGRERR_NONE )
return eErr;
addGeometryDirectly( poGeom );
/* -------------------------------------------------------------------- */
/* Read the delimeter following the ring. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
} while( szToken[0] == ',' );
/* -------------------------------------------------------------------- */
/* freak if we don't get a closing bracket. */
/* -------------------------------------------------------------------- */
if( szToken[0] != ')' )
return OGRERR_CORRUPT_DATA;
*ppszInput = (char *) pszInput;
return OGRERR_NONE;
}
OGRErr OGRGeometryCollection::importFromWktInternal( char ** ppszInput, int nRecLevel )
{
char szToken[OGR_WKT_TOKEN_MAX];
const char *pszInput = *ppszInput;
/* Arbitrary value, but certainly large enough for reasonable usages ! */
if( nRecLevel == 32 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Too many recursiong level (%d) while parsing WKT geometry.",
nRecLevel );
return OGRERR_CORRUPT_DATA;
}
/* -------------------------------------------------------------------- */
/* Clear existing Geoms. */
/* -------------------------------------------------------------------- */
empty();
/* -------------------------------------------------------------------- */
/* Read and verify the type keyword, and ensure it matches the */
/* actual type of this container. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
if( !EQUAL(szToken,getGeometryName()) )
return OGRERR_CORRUPT_DATA;
/* -------------------------------------------------------------------- */
/* Check for EMPTY ... */
/* -------------------------------------------------------------------- */
const char *pszPreScan;
int bHasZ = FALSE, bHasM = FALSE;
pszPreScan = OGRWktReadToken( pszInput, szToken );
if( EQUAL(szToken,"EMPTY") )
{
*ppszInput = (char *) pszPreScan;
empty();
return OGRERR_NONE;
}
/* -------------------------------------------------------------------- */
/* Check for Z, M or ZM. Will ignore the Measure */
/* -------------------------------------------------------------------- */
else if( EQUAL(szToken,"Z") )
{
bHasZ = TRUE;
}
else if( EQUAL(szToken,"M") )
{
bHasM = TRUE;
}
else if( EQUAL(szToken,"ZM") )
{
bHasZ = TRUE;
bHasM = TRUE;
}
if (bHasZ || bHasM)
{
pszInput = pszPreScan;
pszPreScan = OGRWktReadToken( pszInput, szToken );
if( EQUAL(szToken,"EMPTY") )
{
*ppszInput = (char *) pszPreScan;
empty();
/* FIXME?: In theory we should store the dimension and M presence */
/* if we want to allow round-trip with ExportToWKT v1.2 */
return OGRERR_NONE;
}
}
if( !EQUAL(szToken,"(") )
return OGRERR_CORRUPT_DATA;
if ( !bHasZ && !bHasM )
{
/* Test for old-style GEOMETRYCOLLECTION(EMPTY) */
pszPreScan = OGRWktReadToken( pszPreScan, szToken );
if( EQUAL(szToken,"EMPTY") )
{
pszInput = OGRWktReadToken( pszPreScan, szToken );
if( !EQUAL(szToken,")") )
return OGRERR_CORRUPT_DATA;
else
{
*ppszInput = (char *) pszInput;
empty();
return OGRERR_NONE;
}
}
}
/* Skip first '(' */
pszInput = OGRWktReadToken( pszInput, szToken );
/* ==================================================================== */
/* Read each subgeometry in turn. */
/* ==================================================================== */
do
{
OGRGeometry *poGeom = NULL;
OGRErr eErr;
/* -------------------------------------------------------------------- */
/* Get the first token, which should be the geometry type. */
/* -------------------------------------------------------------------- */
if( OGRWktReadToken( pszInput, szToken ) == NULL )
return OGRERR_CORRUPT_DATA;
/* -------------------------------------------------------------------- */
/* Do the import. */
/* -------------------------------------------------------------------- */
if (EQUAL(szToken,"GEOMETRYCOLLECTION"))
{
poGeom = new OGRGeometryCollection();
eErr = ((OGRGeometryCollection*)poGeom)->
importFromWktInternal( (char **) &pszInput, nRecLevel + 1 );
}
else
eErr = OGRGeometryFactory::createFromWkt( (char **) &pszInput,
NULL, &poGeom );
if( eErr != OGRERR_NONE )
return eErr;
addGeometryDirectly( poGeom );
/* -------------------------------------------------------------------- */
/* Read the delimeter following the ring. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
} while( szToken[0] == ',' );
/* -------------------------------------------------------------------- */
/* freak if we don't get a closing bracket. */
/* -------------------------------------------------------------------- */
if( szToken[0] != ')' )
return OGRERR_CORRUPT_DATA;
*ppszInput = (char *) pszInput;
return OGRERR_NONE;
}
OGRErr OGRMultiPoint::importFromWkt_Bracketed( char ** ppszInput,
int bHasM, int bHasZ )
{
/* -------------------------------------------------------------------- */
/* Skip MULTIPOINT keyword. */
/* -------------------------------------------------------------------- */
char szToken[OGR_WKT_TOKEN_MAX] = {};
const char *pszInput = *ppszInput;
pszInput = OGRWktReadToken( pszInput, szToken );
if( bHasZ || bHasM )
{
// Skip Z, M or ZM.
pszInput = OGRWktReadToken( pszInput, szToken );
}
/* -------------------------------------------------------------------- */
/* Read points till we get to the closing bracket. */
/* -------------------------------------------------------------------- */
OGRRawPoint *paoPoints = NULL;
double *padfZ = NULL;
double *padfM = NULL;
while( (pszInput = OGRWktReadToken( pszInput, szToken )) != NULL
&& (EQUAL(szToken, "(") || EQUAL(szToken, ",")) )
{
const char* pszNext = OGRWktReadToken( pszInput, szToken );
if( EQUAL(szToken, "EMPTY") )
{
OGRPoint *poGeom = new OGRPoint(0.0, 0.0);
poGeom->empty();
const OGRErr eErr = addGeometryDirectly( poGeom );
if( eErr != OGRERR_NONE )
{
CPLFree( paoPoints );
delete poGeom;
return eErr;
}
pszInput = pszNext;
continue;
}
int flagsFromInput = flags;
int nMaxPoint = 0;
int nPointCount = 0;
pszInput = OGRWktReadPointsM( pszInput, &paoPoints, &padfZ, &padfM,
&flagsFromInput,
&nMaxPoint, &nPointCount );
if( pszInput == NULL || nPointCount != 1 )
{
CPLFree( paoPoints );
CPLFree( padfZ );
CPLFree( padfM );
return OGRERR_CORRUPT_DATA;
}
if( (flagsFromInput & OGR_G_3D) && !(flags & OGR_G_3D) )
{
flags |= OGR_G_3D;
bHasZ = TRUE;
}
if( (flagsFromInput & OGR_G_MEASURED) && !(flags & OGR_G_MEASURED) )
{
flags |= OGR_G_MEASURED;
bHasM = TRUE;
}
OGRPoint *poPoint = new OGRPoint(paoPoints[0].x, paoPoints[0].y);
if( bHasM )
{
if( padfM != NULL )
poPoint->setM(padfM[0]);
else
poPoint->setM(0.0);
}
if( bHasZ )
{
if( padfZ != NULL )
poPoint->setZ(padfZ[0]);
else
poPoint->setZ(0.0);
}
const OGRErr eErr = addGeometryDirectly( poPoint );
if( eErr != OGRERR_NONE )
{
CPLFree( paoPoints );
CPLFree( padfZ );
CPLFree( padfM );
delete poPoint;
return eErr;
}
}
/* -------------------------------------------------------------------- */
/* Cleanup. */
/* -------------------------------------------------------------------- */
CPLFree( paoPoints );
CPLFree( padfZ );
CPLFree( padfM );
if( !EQUAL(szToken, ")") )
return OGRERR_CORRUPT_DATA;
*ppszInput = const_cast<char *>(pszInput);
return OGRERR_NONE;
}
OGRErr OGRMultiPoint::importFromWkt( char ** ppszInput )
{
const char *pszInputBefore = *ppszInput;
int bHasZ = FALSE;
int bHasM = FALSE;
bool bIsEmpty = false;
OGRErr eErr = importPreambuleFromWkt(ppszInput, &bHasZ, &bHasM, &bIsEmpty);
flags = 0;
if( eErr != OGRERR_NONE )
return eErr;
if( bHasZ ) flags |= OGR_G_3D;
if( bHasM ) flags |= OGR_G_MEASURED;
if( bIsEmpty )
return OGRERR_NONE;
char szToken[OGR_WKT_TOKEN_MAX] = {};
const char *pszInput = *ppszInput;
eErr = OGRERR_NONE;
const char* pszPreScan = OGRWktReadToken( pszInput, szToken );
OGRWktReadToken( pszPreScan, szToken );
// Do we have an inner bracket?
if( EQUAL(szToken,"(") || EQUAL(szToken, "EMPTY") )
{
*ppszInput = const_cast<char *>(pszInputBefore);
return importFromWkt_Bracketed( ppszInput, bHasM, bHasZ );
}
if( bHasZ || bHasM )
{
return OGRERR_CORRUPT_DATA;
}
/* -------------------------------------------------------------------- */
/* Read the point list which should consist of exactly one point. */
/* -------------------------------------------------------------------- */
OGRRawPoint *paoPoints = NULL;
double *padfZ = NULL;
double *padfM = NULL;
int flagsFromInput = flags;
int nMaxPoint = 0;
int nPointCount = 0;
pszInput = OGRWktReadPointsM( pszInput, &paoPoints, &padfZ, &padfM,
&flagsFromInput,
&nMaxPoint, &nPointCount );
if( pszInput == NULL )
{
CPLFree( paoPoints );
CPLFree( padfZ );
CPLFree( padfM );
return OGRERR_CORRUPT_DATA;
}
if( (flagsFromInput & OGR_G_3D) && !(flags & OGR_G_3D) )
{
flags |= OGR_G_3D;
bHasZ = TRUE;
}
if( (flagsFromInput & OGR_G_MEASURED) && !(flags & OGR_G_MEASURED) )
{
flags |= OGR_G_MEASURED;
bHasM = TRUE;
}
/* -------------------------------------------------------------------- */
/* Transform raw points into point objects. */
/* -------------------------------------------------------------------- */
for( int iGeom = 0; iGeom < nPointCount && eErr == OGRERR_NONE; iGeom++ )
{
OGRPoint *poPoint =
new OGRPoint(paoPoints[iGeom].x, paoPoints[iGeom].y);
if( bHasM )
{
if( padfM != NULL )
poPoint->setM(padfM[iGeom]);
else
poPoint->setM(0.0);
}
if( bHasZ )
{
if( padfZ != NULL )
poPoint->setZ(padfZ[iGeom]);
else
poPoint->setZ(0.0);
}
eErr = addGeometryDirectly( poPoint );
if( eErr != OGRERR_NONE )
{
CPLFree( paoPoints );
CPLFree( padfZ );
CPLFree( padfM );
delete poPoint;
return eErr;
}
}
CPLFree( paoPoints );
CPLFree( padfZ );
CPLFree( padfM );
if( eErr != OGRERR_NONE )
return eErr;
*ppszInput = const_cast<char *>(pszInput);
return OGRERR_NONE;
}
OGRErr OGRMultiPoint::importFromWkt_Bracketed( char ** ppszInput, int bHasM, int bHasZ )
{
char szToken[OGR_WKT_TOKEN_MAX];
const char *pszInput = *ppszInput;
OGRErr eErr = OGRERR_NONE;
/* -------------------------------------------------------------------- */
/* Skip MULTIPOINT keyword. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
if (bHasZ || bHasM)
{
/* Skip Z, M or ZM */
pszInput = OGRWktReadToken( pszInput, szToken );
}
/* -------------------------------------------------------------------- */
/* Read points till we get to the closing bracket. */
/* -------------------------------------------------------------------- */
int nMaxPoint = 0;
int nPointCount = 0;
OGRRawPoint *paoPoints = NULL;
double *padfZ = NULL;
while( (pszInput = OGRWktReadToken( pszInput, szToken )) != NULL
&& (EQUAL(szToken,"(") || EQUAL(szToken,",")) )
{
OGRGeometry *poGeom;
const char* pszNext = OGRWktReadToken( pszInput, szToken );
if (EQUAL(szToken,"EMPTY"))
{
poGeom = new OGRPoint(0,0);
poGeom->empty();
eErr = addGeometryDirectly( poGeom );
if( eErr != OGRERR_NONE )
return eErr;
pszInput = pszNext;
continue;
}
pszInput = OGRWktReadPoints( pszInput, &paoPoints, &padfZ, &nMaxPoint,
&nPointCount );
if( pszInput == NULL || nPointCount != 1 )
{
OGRFree( paoPoints );
OGRFree( padfZ );
return OGRERR_CORRUPT_DATA;
}
/* Ignore Z array when we have a MULTIPOINT M */
if( padfZ && !(bHasM && !bHasZ))
poGeom = new OGRPoint( paoPoints[0].x,
paoPoints[0].y,
padfZ[0] );
else
poGeom = new OGRPoint( paoPoints[0].x,
paoPoints[0].y );
eErr = addGeometryDirectly( poGeom );
if( eErr != OGRERR_NONE )
return eErr;
}
/* -------------------------------------------------------------------- */
/* Cleanup. */
/* -------------------------------------------------------------------- */
OGRFree( paoPoints );
if( padfZ )
OGRFree( padfZ );
if( !EQUAL(szToken,")") )
return OGRERR_CORRUPT_DATA;
*ppszInput = (char *) pszInput;
return OGRERR_NONE;
}
OGRErr OGRMultiPoint::importFromWkt( char ** ppszInput )
{
const char *pszInputBefore = *ppszInput;
int bHasZ = FALSE, bHasM = FALSE;
OGRErr eErr = importPreambuleFromWkt(ppszInput, &bHasZ, &bHasM);
if( eErr >= 0 )
return eErr;
char szToken[OGR_WKT_TOKEN_MAX];
const char *pszInput = *ppszInput;
int iGeom;
eErr = OGRERR_NONE;
const char* pszPreScan = OGRWktReadToken( pszInput, szToken );
OGRWktReadToken( pszPreScan, szToken );
// Do we have an inner bracket?
if (EQUAL(szToken,"(") || EQUAL(szToken, "EMPTY") )
{
*ppszInput = (char*) pszInputBefore;
return importFromWkt_Bracketed( ppszInput, bHasM, bHasZ );
}
if (bHasZ || bHasM)
{
return OGRERR_CORRUPT_DATA;
}
/* -------------------------------------------------------------------- */
/* Read the point list which should consist of exactly one point. */
/* -------------------------------------------------------------------- */
int nMaxPoint = 0;
int nPointCount = 0;
OGRRawPoint *paoPoints = NULL;
double *padfZ = NULL;
pszInput = OGRWktReadPoints( pszInput, &paoPoints, &padfZ, &nMaxPoint,
&nPointCount );
if( pszInput == NULL )
{
OGRFree( paoPoints );
OGRFree( padfZ );
return OGRERR_CORRUPT_DATA;
}
/* -------------------------------------------------------------------- */
/* Transform raw points into point objects. */
/* -------------------------------------------------------------------- */
for( iGeom = 0; iGeom < nPointCount && eErr == OGRERR_NONE; iGeom++ )
{
OGRGeometry *poGeom;
if( padfZ )
poGeom = new OGRPoint( paoPoints[iGeom].x,
paoPoints[iGeom].y,
padfZ[iGeom] );
else
poGeom = new OGRPoint( paoPoints[iGeom].x,
paoPoints[iGeom].y );
eErr = addGeometryDirectly( poGeom );
}
OGRFree( paoPoints );
if( padfZ )
OGRFree( padfZ );
if( eErr != OGRERR_NONE )
return eErr;
*ppszInput = (char *) pszInput;
return OGRERR_NONE;
}