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; }