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 OGRLineString::importFromWkt( char ** ppszInput )
{
char szToken[OGR_WKT_TOKEN_MAX];
const char *pszInput = *ppszInput;
if( paoPoints != NULL )
{
nPointCount = 0;
CPLFree( paoPoints );
paoPoints = NULL;
CPLFree( padfZ );
padfZ = NULL;
}
/* -------------------------------------------------------------------- */
/* Read and verify the ``LINESTRING'' keyword token. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
if( !EQUAL(szToken,getGeometryName()) )
return OGRERR_CORRUPT_DATA;
/* -------------------------------------------------------------------- */
/* Read the point list which should consist of exactly one point. */
/* -------------------------------------------------------------------- */
int nMaxPoint = 0;
nPointCount = 0;
pszInput = OGRWktReadPoints( pszInput, &paoPoints, &padfZ, &nMaxPoint,
&nPointCount );
if( pszInput == NULL )
return OGRERR_CORRUPT_DATA;
*ppszInput = (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 OGRPolygon::importFromWkt( char ** ppszInput )
{
char szToken[OGR_WKT_TOKEN_MAX];
const char *pszInput = *ppszInput;
int iRing;
/* -------------------------------------------------------------------- */
/* Clear existing rings. */
/* -------------------------------------------------------------------- */
if( nRingCount > 0 )
{
for( iRing = 0; iRing < nRingCount; iRing++ )
delete papoRings[iRing];
nRingCount = 0;
CPLFree( papoRings );
}
/* -------------------------------------------------------------------- */
/* Read and verify the ``POLYGON'' keyword token. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
if( !EQUAL(szToken,"POLYGON") )
return OGRERR_CORRUPT_DATA;
/* -------------------------------------------------------------------- */
/* The next character should be a ( indicating the start of the */
/* list of rings. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
if( szToken[0] != '(' )
return OGRERR_CORRUPT_DATA;
/* ==================================================================== */
/* Read each ring 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, nMaxRings = 0;
double *padfZ = NULL;
do
{
int nPoints = 0;
/* -------------------------------------------------------------------- */
/* Read points for one ring from input. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadPoints( pszInput, &paoPoints, &padfZ, &nMaxPoints,
&nPoints );
if( pszInput == NULL )
{
CPLFree( paoPoints );
return OGRERR_CORRUPT_DATA;
}
/* -------------------------------------------------------------------- */
/* Do we need to grow the ring array? */
/* -------------------------------------------------------------------- */
if( nRingCount == nMaxRings )
{
nMaxRings = nMaxRings * 2 + 1;
papoRings = (OGRLinearRing **)
CPLRealloc(papoRings, nMaxRings * sizeof(OGRLinearRing*));
}
/* -------------------------------------------------------------------- */
/* Create the new ring, and assign to ring list. */
/* -------------------------------------------------------------------- */
papoRings[nRingCount] = new OGRLinearRing();
papoRings[nRingCount]->setPoints( nPoints, paoPoints, padfZ );
nRingCount++;
/* -------------------------------------------------------------------- */
/* Read the delimeter following the ring. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
} while( szToken[0] == ',' );
/* -------------------------------------------------------------------- */
/* freak if we don't get a closing bracket. */
/* -------------------------------------------------------------------- */
CPLFree( paoPoints );
CPLFree( padfZ );
if( szToken[0] != ')' )
return OGRERR_CORRUPT_DATA;
*ppszInput = (char *) 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 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 )
{
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 OGRPolygon::importFromWKTListOnly( char ** ppszInput,
int bHasZ, int bHasM,
OGRRawPoint*& paoPoints,
int& nMaxPoints,
double*& padfZ )
{
char szToken[OGR_WKT_TOKEN_MAX] = {};
const char *pszInput = *ppszInput;
// Skip first '('.
pszInput = OGRWktReadToken( pszInput, szToken );
if( EQUAL(szToken, "EMPTY") )
{
*ppszInput = (char*) pszInput;
return OGRERR_NONE;
}
if( !EQUAL(szToken, "(") )
return OGRERR_CORRUPT_DATA;
/* ==================================================================== */
/* Read each ring in turn. Note that we try to reuse the same */
/* point list buffer from ring to ring to cut down on */
/* allocate/deallocate overhead. */
/* ==================================================================== */
int nMaxRings = 0;
double *padfM = NULL;
do
{
const char* pszNext = OGRWktReadToken( pszInput, szToken );
if( EQUAL(szToken, "EMPTY") )
{
/* -------------------------------------------------------------------- */
/* Do we need to grow the ring array? */
/* -------------------------------------------------------------------- */
if( oCC.nCurveCount == nMaxRings )
{
nMaxRings = nMaxRings * 2 + 1;
oCC.papoCurves = static_cast<OGRCurve **>(
CPLRealloc(oCC.papoCurves,
nMaxRings * sizeof(OGRLinearRing*)));
}
oCC.papoCurves[oCC.nCurveCount] = new OGRLinearRing();
oCC.nCurveCount++;
pszInput = OGRWktReadToken( pszNext, szToken );
if( !EQUAL(szToken, ",") )
break;
continue;
}
/* -------------------------------------------------------------------- */
/* Read points for one ring from input. */
/* -------------------------------------------------------------------- */
int nPoints = 0;
int flagsFromInput = flags;
if( flagsFromInput == 0 )
{
// Flags was not set, this is not called by us.
if( bHasM )
flagsFromInput |= OGR_G_MEASURED;
if( bHasZ )
flagsFromInput |= OGR_G_3D;
}
pszInput = OGRWktReadPointsM( pszInput, &paoPoints, &padfZ, &padfM,
&flagsFromInput,
&nMaxPoints, &nPoints );
if( pszInput == NULL || nPoints == 0 )
{
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;
}
/* -------------------------------------------------------------------- */
/* Do we need to grow the ring array? */
/* -------------------------------------------------------------------- */
if( oCC.nCurveCount == nMaxRings )
{
nMaxRings = nMaxRings * 2 + 1;
oCC.papoCurves = static_cast<OGRCurve **>(
CPLRealloc(oCC.papoCurves, nMaxRings * sizeof(OGRLinearRing*)));
}
/* -------------------------------------------------------------------- */
/* Create the new ring, and assign to ring list. */
/* -------------------------------------------------------------------- */
OGRLinearRing* poLR = new OGRLinearRing();
oCC.papoCurves[oCC.nCurveCount] = poLR;
if( bHasM && bHasZ )
poLR->setPoints(nPoints, paoPoints, padfZ, padfM);
else if( bHasM )
poLR->setPointsM(nPoints, paoPoints, padfM);
else if( bHasZ )
poLR->setPoints(nPoints, paoPoints, padfZ);
else
poLR->setPoints(nPoints, paoPoints);
oCC.nCurveCount++;
/* -------------------------------------------------------------------- */
/* Read the delimiter following the ring. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
} while( szToken[0] == ',' );
CPLFree( padfM );
/* -------------------------------------------------------------------- */
/* freak if we don't get a closing bracket. */
/* -------------------------------------------------------------------- */
if( szToken[0] != ')' )
return OGRERR_CORRUPT_DATA;
*ppszInput = const_cast<char *>(pszInput);
return OGRERR_NONE;
}
OGRErr OGRGeometryFactory::createFromWkt(char **ppszData,
OGRSpatialReference * poSR,
OGRGeometry **ppoReturn )
{
OGRErr eErr;
char szToken[OGR_WKT_TOKEN_MAX];
char *pszInput = *ppszData;
OGRGeometry *poGeom;
*ppoReturn = NULL;
/* -------------------------------------------------------------------- */
/* Get the first token, which should be the geometry type. */
/* -------------------------------------------------------------------- */
if( OGRWktReadToken( pszInput, szToken ) == NULL )
return OGRERR_CORRUPT_DATA;
/* -------------------------------------------------------------------- */
/* Instantiate a geometry of the appropriate type. */
/* -------------------------------------------------------------------- */
if( EQUAL(szToken,"POINT") )
{
poGeom = new OGRPoint();
}
else if( EQUAL(szToken,"LINESTRING") )
{
poGeom = new OGRLineString();
}
else if( EQUAL(szToken,"POLYGON") )
{
poGeom = new OGRPolygon();
}
else if( EQUAL(szToken,"GEOMETRYCOLLECTION") )
{
poGeom = new OGRGeometryCollection();
}
else if( EQUAL(szToken,"MULTIPOLYGON") )
{
poGeom = new OGRMultiPolygon();
}
else if( EQUAL(szToken,"MULTIPOINT") )
{
poGeom = new OGRMultiPoint();
}
else if( EQUAL(szToken,"MULTILINESTRING") )
{
poGeom = new OGRMultiLineString();
}
else
{
return OGRERR_UNSUPPORTED_GEOMETRY_TYPE;
}
/* -------------------------------------------------------------------- */
/* Do the import. */
/* -------------------------------------------------------------------- */
eErr = poGeom->importFromWkt( &pszInput );
/* -------------------------------------------------------------------- */
/* Assign spatial reference system. */
/* -------------------------------------------------------------------- */
if( eErr == OGRERR_NONE )
{
poGeom->assignSpatialReference( poSR );
*ppoReturn = poGeom;
*ppszData = pszInput;
}
else
{
delete poGeom;
}
return eErr;
}
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 OGRLineString::importFromWkt( char ** ppszInput )
{
char szToken[OGR_WKT_TOKEN_MAX];
const char *pszInput = *ppszInput;
if( paoPoints != NULL )
{
nPointCount = 0;
CPLFree( paoPoints );
paoPoints = NULL;
CPLFree( padfZ );
padfZ = NULL;
}
/* -------------------------------------------------------------------- */
/* Read and verify the ``LINESTRING'' keyword token. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
if( !EQUAL(szToken,getGeometryName()) )
return OGRERR_CORRUPT_DATA;
/* -------------------------------------------------------------------- */
/* Check for EMPTY ... but treat like a point at 0,0. */
/* -------------------------------------------------------------------- */
const char *pszPreScan;
pszPreScan = OGRWktReadToken( pszInput, szToken );
if( !EQUAL(szToken,"(") )
return OGRERR_CORRUPT_DATA;
pszPreScan = OGRWktReadToken( pszPreScan, szToken );
if( EQUAL(szToken,"EMPTY") )
{
pszPreScan = OGRWktReadToken( pszPreScan, szToken );
*ppszInput = (char *) pszPreScan;
if( !EQUAL(szToken,")") )
return OGRERR_CORRUPT_DATA;
else
return OGRERR_NONE;
}
/* -------------------------------------------------------------------- */
/* Read the point list. */
/* -------------------------------------------------------------------- */
int nMaxPoint = 0;
nPointCount = 0;
pszInput = OGRWktReadPoints( pszInput, &paoPoints, &padfZ, &nMaxPoint,
&nPointCount );
if( pszInput == NULL )
return OGRERR_CORRUPT_DATA;
*ppszInput = (char *) pszInput;
return OGRERR_NONE;
}
const char * OGRWktReadPoints( const char * pszInput,
OGRRawPoint ** ppaoPoints, double **ppadfZ,
int * pnMaxPoints,
int * pnPointsRead )
{
const char *pszOrigInput = pszInput;
*pnPointsRead = 0;
if( pszInput == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Eat any leading white space. */
/* -------------------------------------------------------------------- */
while( *pszInput == ' ' || *pszInput == '\t' )
pszInput++;
/* -------------------------------------------------------------------- */
/* If this isn't an opening bracket then we have a problem! */
/* -------------------------------------------------------------------- */
if( *pszInput != '(' )
{
CPLDebug( "OGR",
"Expected '(', but got %s in OGRWktReadPoints().\n",
pszInput );
return pszInput;
}
pszInput++;
/* ==================================================================== */
/* This loop reads a single point. It will continue till we */
/* run out of well formed points, or a closing bracket is */
/* encountered. */
/* ==================================================================== */
char szDelim[OGR_WKT_TOKEN_MAX];
do {
/* -------------------------------------------------------------------- */
/* Read the X and Y values, verify they are numeric. */
/* -------------------------------------------------------------------- */
char szTokenX[OGR_WKT_TOKEN_MAX];
char szTokenY[OGR_WKT_TOKEN_MAX];
pszInput = OGRWktReadToken( pszInput, szTokenX );
pszInput = OGRWktReadToken( pszInput, szTokenY );
if( (!isdigit(szTokenX[0]) && szTokenX[0] != '-' && szTokenX[0] != '.' )
|| (!isdigit(szTokenY[0]) && szTokenY[0] != '-' && szTokenY[0] != '.') )
return NULL;
/* -------------------------------------------------------------------- */
/* Do we need to grow the point list to hold this point? */
/* -------------------------------------------------------------------- */
if( *pnPointsRead == *pnMaxPoints )
{
*pnMaxPoints = *pnMaxPoints * 2 + 10;
*ppaoPoints = (OGRRawPoint *)
CPLRealloc(*ppaoPoints, sizeof(OGRRawPoint) * *pnMaxPoints);
if( *ppadfZ != NULL )
{
*ppadfZ = (double *)
CPLRealloc(*ppadfZ, sizeof(double) * *pnMaxPoints);
}
}
/* -------------------------------------------------------------------- */
/* Add point to list. */
/* -------------------------------------------------------------------- */
(*ppaoPoints)[*pnPointsRead].x = CPLAtof(szTokenX);
(*ppaoPoints)[*pnPointsRead].y = CPLAtof(szTokenY);
/* -------------------------------------------------------------------- */
/* Do we have a Z coordinate? */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szDelim );
if( isdigit(szDelim[0]) || szDelim[0] == '-' || szDelim[0] == '.' )
{
if( *ppadfZ == NULL )
{
*ppadfZ = (double *) CPLCalloc(sizeof(double),*pnMaxPoints);
}
(*ppadfZ)[*pnPointsRead] = CPLAtof(szDelim);
pszInput = OGRWktReadToken( pszInput, szDelim );
}
(*pnPointsRead)++;
/* -------------------------------------------------------------------- */
/* Do we have a M coordinate? */
/* If we do, just skip it. */
/* -------------------------------------------------------------------- */
if( isdigit(szDelim[0]) || szDelim[0] == '-' || szDelim[0] == '.' )
{
pszInput = OGRWktReadToken( pszInput, szDelim );
}
/* -------------------------------------------------------------------- */
/* Read next delimeter ... it should be a comma if there are */
/* more points. */
/* -------------------------------------------------------------------- */
if( szDelim[0] != ')' && szDelim[0] != ',' )
{
CPLDebug( "OGR",
"Corrupt input in OGRWktReadPoints()\n"
"Got `%s' when expecting `,' or `)', near `%s' in %s.\n",
szDelim, pszInput, pszOrigInput );
return NULL;
}
} while( szDelim[0] == ',' );
return pszInput;
}
OGRErr OGRPoint::importFromWkt( char ** ppszInput )
{
char szToken[OGR_WKT_TOKEN_MAX];
const char *pszInput = *ppszInput;
/* -------------------------------------------------------------------- */
/* Read and verify the ``POINT'' keyword token. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
if( !EQUAL(szToken,"POINT") )
return OGRERR_CORRUPT_DATA;
/* -------------------------------------------------------------------- */
/* Check for EMPTY ... but treat like a point at 0,0. */
/* -------------------------------------------------------------------- */
const char *pszPreScan;
pszPreScan = OGRWktReadToken( pszInput, szToken );
if( EQUAL(szToken,"EMPTY") )
{
*ppszInput = (char *) pszInput;
empty();
return OGRERR_NONE;
}
if( !EQUAL(szToken,"(") )
return OGRERR_CORRUPT_DATA;
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;
}
}
/* -------------------------------------------------------------------- */
/* Read the point list which should consist of exactly one point. */
/* -------------------------------------------------------------------- */
OGRRawPoint *poPoints = NULL;
double *padfZ = NULL;
int nMaxPoint = 0, nPoints = 0;
pszInput = OGRWktReadPoints( pszInput, &poPoints, &padfZ,
&nMaxPoint, &nPoints );
if( pszInput == NULL || nPoints != 1 )
return OGRERR_CORRUPT_DATA;
x = poPoints[0].x;
y = poPoints[0].y;
CPLFree( poPoints );
if( padfZ != NULL )
{
z = padfZ[0];
nCoordDimension = 3;
CPLFree( padfZ );
}
else
nCoordDimension = 2;
*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 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 OGRPoint::importFromWkt( char ** ppszInput )
{
char szToken[OGR_WKT_TOKEN_MAX];
const char *pszInput = *ppszInput;
/* -------------------------------------------------------------------- */
/* Read and verify the ``POINT'' keyword token. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
if( !EQUAL(szToken,"POINT") )
return OGRERR_CORRUPT_DATA;
/* -------------------------------------------------------------------- */
/* Check for EMPTY ... but treat like a point at 0,0. */
/* -------------------------------------------------------------------- */
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 POINT(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;
}
}
}
/* -------------------------------------------------------------------- */
/* Read the point list which should consist of exactly one point. */
/* -------------------------------------------------------------------- */
OGRRawPoint *poPoints = NULL;
double *padfZ = NULL;
int nMaxPoint = 0, nPoints = 0;
pszInput = OGRWktReadPoints( pszInput, &poPoints, &padfZ,
&nMaxPoint, &nPoints );
if( pszInput == NULL || nPoints != 1 )
{
CPLFree( poPoints );
CPLFree( padfZ );
return OGRERR_CORRUPT_DATA;
}
x = poPoints[0].x;
y = poPoints[0].y;
CPLFree( poPoints );
if( padfZ != NULL )
{
/* If there's a 3rd value, and it is not a POINT M, */
/* then assume it is the Z */
if ((!(bHasM && !bHasZ)))
{
z = padfZ[0];
nCoordDimension = 3;
}
else
nCoordDimension = 2;
CPLFree( padfZ );
}
else if ( bHasZ )
{
/* In theory we should have a z coordinate for POINT Z */
/* oh well, let be tolerant */
nCoordDimension = 3;
}
else
nCoordDimension = 2;
*ppszInput = (char *) pszInput;
return OGRERR_NONE;
}
OGRErr OGRPolygon::importFromWkt( char ** ppszInput )
{
char szToken[OGR_WKT_TOKEN_MAX];
const char *pszInput = *ppszInput;
int iRing;
/* -------------------------------------------------------------------- */
/* Clear existing rings. */
/* -------------------------------------------------------------------- */
if( nRingCount > 0 )
{
for( iRing = 0; iRing < nRingCount; iRing++ )
delete papoRings[iRing];
nRingCount = 0;
CPLFree( papoRings );
}
/* -------------------------------------------------------------------- */
/* Read and verify the ``POLYGON'' keyword token. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
if( !EQUAL(szToken,"POLYGON") )
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 POLYGON(EMPTY) */
pszPreScan = OGRWktReadToken( pszPreScan, szToken );
if( EQUAL(szToken,"EMPTY") )
{
pszPreScan = OGRWktReadToken( pszPreScan, szToken );
if( EQUAL(szToken,",") )
{
/* This is OK according to SFSQL SPEC. */
}
else if( !EQUAL(szToken,")") )
return OGRERR_CORRUPT_DATA;
else
{
*ppszInput = (char *) pszPreScan;
empty();
return OGRERR_NONE;
}
}
}
/* Skip first '(' */
pszInput = OGRWktReadToken( pszInput, szToken );
/* ==================================================================== */
/* Read each ring 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, nMaxRings = 0;
double *padfZ = NULL;
nCoordDimension = 2;
do
{
int nPoints = 0;
const char* pszNext = OGRWktReadToken( pszInput, szToken );
if (EQUAL(szToken,"EMPTY"))
{
/* -------------------------------------------------------------------- */
/* Do we need to grow the ring array? */
/* -------------------------------------------------------------------- */
if( nRingCount == nMaxRings )
{
nMaxRings = nMaxRings * 2 + 1;
papoRings = (OGRLinearRing **)
CPLRealloc(papoRings, nMaxRings * sizeof(OGRLinearRing*));
}
papoRings[nRingCount] = new OGRLinearRing();
nRingCount++;
pszInput = OGRWktReadToken( pszNext, szToken );
if ( !EQUAL(szToken, ",") )
break;
continue;
}
/* -------------------------------------------------------------------- */
/* Read points for one ring from input. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadPoints( pszInput, &paoPoints, &padfZ, &nMaxPoints,
&nPoints );
if( pszInput == NULL || nPoints == 0 )
{
CPLFree( paoPoints );
return OGRERR_CORRUPT_DATA;
}
/* -------------------------------------------------------------------- */
/* Do we need to grow the ring array? */
/* -------------------------------------------------------------------- */
if( nRingCount == nMaxRings )
{
nMaxRings = nMaxRings * 2 + 1;
papoRings = (OGRLinearRing **)
CPLRealloc(papoRings, nMaxRings * sizeof(OGRLinearRing*));
}
/* -------------------------------------------------------------------- */
/* Create the new ring, and assign to ring list. */
/* -------------------------------------------------------------------- */
papoRings[nRingCount] = new OGRLinearRing();
/* Ignore Z array when we have a POLYGON M */
if (bHasM && !bHasZ)
papoRings[nRingCount]->setPoints( nPoints, paoPoints, NULL );
else
papoRings[nRingCount]->setPoints( nPoints, paoPoints, padfZ );
nRingCount++;
if( padfZ && !(bHasM && !bHasZ) )
nCoordDimension = 3;
/* -------------------------------------------------------------------- */
/* Read the delimeter following the ring. */
/* -------------------------------------------------------------------- */
pszInput = OGRWktReadToken( pszInput, szToken );
} while( szToken[0] == ',' );
/* -------------------------------------------------------------------- */
/* freak if we don't get a closing bracket. */
/* -------------------------------------------------------------------- */
CPLFree( paoPoints );
CPLFree( padfZ );
if( szToken[0] != ')' )
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;
}