← Back to branch summary

~ubuntu-branches/debian/sid/gdal/sid

« back to all changes in this revision

Viewing changes to ogr/ogrmultipoint.cpp

  • Committer: Package Import Robot
  • Author(s): Francesco Paolo Lovergine
  • Date: 2012-05-07 15:04:42 UTC
  • mfrom: (5.5.16 experimental)
  • Revision ID: package-import@ubuntu.com-20120507150442-2eks97loeh6rq005
Tags: 1.9.0-1
* Ready for sid, starting transition.
* All symfiles updated to latest builds.
* Added dh_numpy call in debian/rules to depend on numpy ABI.
* Policy bumped to 3.9.3, no changes required.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ogr/ogrmultipoint.cpp
1
1
/******************************************************************************
2
 
 * $Id: ogrmultipoint.cpp 14336 2008-04-20 14:36:09Z rouault $
 
2
 * $Id: ogrmultipoint.cpp 21298 2010-12-20 10:58:34Z rouault $
3
3
 *
4
4
 * Project:  OpenGIS Simple Features Reference Implementation
5
5
 * Purpose:  The OGRMultiPoint class.
31
31
#include "ogr_p.h"
32
32
#include <assert.h>
33
33
 
34
 
CPL_CVSID("$Id: ogrmultipoint.cpp 14336 2008-04-20 14:36:09Z rouault $");
 
34
CPL_CVSID("$Id: ogrmultipoint.cpp 21298 2010-12-20 10:58:34Z rouault $");
35
35
 
36
36
/************************************************************************/
37
37
/*                           OGRMultiPoint()                            */
192
192
    if( !EQUAL(szToken,getGeometryName()) )
193
193
        return OGRERR_CORRUPT_DATA;
194
194
 
195
 
/* -------------------------------------------------------------------- */
196
 
/*      Skip past first bracket for checking purposes, but don't        */
197
 
/*      alter pszInput.                                                 */
198
 
/* -------------------------------------------------------------------- */
199
 
    const char *pszPreScan = pszInput;
200
 
 
201
 
    // skip white space. 
202
 
    while( *pszPreScan == ' ' || *pszPreScan == '\t' )
203
 
        pszPreScan++;
204
 
 
205
 
    // Handle the proper EMPTY syntax.
206
 
    if( EQUALN(pszPreScan,"EMPTY",5) )
207
 
    {
208
 
        *ppszInput = (char *) pszPreScan+5;
209
 
        return OGRERR_NONE;
210
 
    }
211
 
 
212
 
    // Skip outer bracket.
213
 
    if( *pszPreScan != '(' )
214
 
        return OGRERR_CORRUPT_DATA;
215
 
 
216
 
    pszPreScan++;
217
 
 
218
 
/* -------------------------------------------------------------------- */
219
 
/*      If the next token is EMPTY, then verify that we have proper     */
220
 
/*      EMPTY format will a trailing closing bracket.                   */
221
 
/* -------------------------------------------------------------------- */
222
 
    OGRWktReadToken( pszPreScan, szToken );
 
195
 
 
196
/* -------------------------------------------------------------------- */
 
197
/*      Check for EMPTY ...                                             */
 
198
/* -------------------------------------------------------------------- */
 
199
    const char *pszPreScan;
 
200
    int bHasZ = FALSE, bHasM = FALSE;
 
201
 
 
202
    pszPreScan = OGRWktReadToken( pszInput, szToken );
223
203
    if( EQUAL(szToken,"EMPTY") )
224
204
    {
225
 
        pszInput = OGRWktReadToken( pszPreScan, szToken );
226
 
        pszInput = OGRWktReadToken( pszInput, szToken );
227
 
        
228
 
        *ppszInput = (char *) pszInput;
229
 
 
230
 
        if( !EQUAL(szToken,")") )
231
 
            return OGRERR_CORRUPT_DATA;
232
 
        else
 
205
        *ppszInput = (char *) pszPreScan;
 
206
        empty();
 
207
        return OGRERR_NONE;
 
208
    }
 
209
 
 
210
/* -------------------------------------------------------------------- */
 
211
/*      Check for Z, M or ZM. Will ignore the Measure                   */
 
212
/* -------------------------------------------------------------------- */
 
213
    else if( EQUAL(szToken,"Z") )
 
214
    {
 
215
        bHasZ = TRUE;
 
216
    }
 
217
    else if( EQUAL(szToken,"M") )
 
218
    {
 
219
        bHasM = TRUE;
 
220
    }
 
221
    else if( EQUAL(szToken,"ZM") )
 
222
    {
 
223
        bHasZ = TRUE;
 
224
        bHasM = TRUE;
 
225
    }
 
226
 
 
227
    if (bHasZ || bHasM)
 
228
    {
 
229
        pszInput = pszPreScan;
 
230
        pszPreScan = OGRWktReadToken( pszInput, szToken );
 
231
        if( EQUAL(szToken,"EMPTY") )
 
232
        {
 
233
            *ppszInput = (char *) pszPreScan;
 
234
            empty();
 
235
            /* FIXME?: In theory we should store the dimension and M presence */
 
236
            /* if we want to allow round-trip with ExportToWKT v1.2 */
233
237
            return OGRERR_NONE;
234
 
    }
235
 
 
236
 
/* -------------------------------------------------------------------- */
237
 
/*      Check for inner bracket indicating the improper bracketed       */
238
 
/*      format which we still want to support.                          */
239
 
/* -------------------------------------------------------------------- */
240
 
    // skip white space.
241
 
    while( *pszPreScan == ' ' || *pszPreScan == '\t' )
242
 
        pszPreScan++;
 
238
        }
 
239
    }
 
240
 
 
241
    if( !EQUAL(szToken,"(") )
 
242
        return OGRERR_CORRUPT_DATA;
 
243
 
 
244
    if ( !bHasZ && !bHasM )
 
245
    {
 
246
        /* Test for old-style MULTIPOINT(EMPTY) */
 
247
        pszPreScan = OGRWktReadToken( pszPreScan, szToken );
 
248
        if( EQUAL(szToken,"EMPTY") )
 
249
        {
 
250
            pszPreScan = OGRWktReadToken( pszPreScan, szToken );
 
251
 
 
252
            if( EQUAL(szToken,",") )
 
253
            {
 
254
                /* This is OK according to SFSQL SPEC. */
 
255
            }
 
256
            else if( !EQUAL(szToken,")") )
 
257
                return OGRERR_CORRUPT_DATA;
 
258
            else
 
259
            {
 
260
                *ppszInput = (char *) pszPreScan;
 
261
                empty();
 
262
                return OGRERR_NONE;
 
263
            }
 
264
        }
 
265
    }
 
266
 
 
267
    pszPreScan = OGRWktReadToken( pszInput, szToken );
 
268
    OGRWktReadToken( pszPreScan, szToken );
243
269
 
244
270
    // Do we have an inner bracket? 
245
 
    if( *pszPreScan == '(' )
246
 
        return importFromWkt_Bracketed( ppszInput );
247
 
    
 
271
    if (EQUAL(szToken,"(") || EQUAL(szToken, "EMPTY") )
 
272
        return importFromWkt_Bracketed( ppszInput, bHasM, bHasZ );
 
273
 
 
274
    if (bHasZ || bHasM)
 
275
    {
 
276
        return OGRERR_CORRUPT_DATA;
 
277
    }
 
278
 
248
279
/* -------------------------------------------------------------------- */
249
280
/*      Read the point list which should consist of exactly one point.  */
250
281
/* -------------------------------------------------------------------- */
256
287
    pszInput = OGRWktReadPoints( pszInput, &paoPoints, &padfZ, &nMaxPoint,
257
288
                                 &nPointCount );
258
289
    if( pszInput == NULL )
 
290
    {
 
291
        OGRFree( paoPoints );
 
292
        OGRFree( padfZ );
259
293
        return OGRERR_CORRUPT_DATA;
 
294
    }
260
295
 
261
296
/* -------------------------------------------------------------------- */
262
297
/*      Transform raw points into point objects.                        */
297
332
/*      importFromWkt().                                                */
298
333
/************************************************************************/
299
334
 
300
 
OGRErr OGRMultiPoint::importFromWkt_Bracketed( char ** ppszInput )
 
335
OGRErr OGRMultiPoint::importFromWkt_Bracketed( char ** ppszInput, int bHasM, int bHasZ )
301
336
 
302
337
{
303
338
 
310
345
/* -------------------------------------------------------------------- */
311
346
    pszInput = OGRWktReadToken( pszInput, szToken );
312
347
 
 
348
    if (bHasZ || bHasM)
 
349
    {
 
350
        /* Skip Z, M or ZM */
 
351
        pszInput = OGRWktReadToken( pszInput, szToken );
 
352
    }
 
353
 
313
354
/* -------------------------------------------------------------------- */
314
355
/*      Read points till we get to the closing bracket.                 */
315
356
/* -------------------------------------------------------------------- */
318
359
    OGRRawPoint         *paoPoints = NULL;
319
360
    double              *padfZ = NULL;
320
361
 
321
 
    while( (pszInput = OGRWktReadToken( pszInput, szToken ))
 
362
    while( (pszInput = OGRWktReadToken( pszInput, szToken )) != NULL
322
363
           && (EQUAL(szToken,"(") || EQUAL(szToken,",")) )
323
364
    {
324
365
        OGRGeometry     *poGeom;
325
366
 
 
367
        const char* pszNext = OGRWktReadToken( pszInput, szToken );
 
368
        if (EQUAL(szToken,"EMPTY"))
 
369
        {
 
370
            poGeom = new OGRPoint(0,0);
 
371
            poGeom->empty();
 
372
            eErr = addGeometryDirectly( poGeom );
 
373
            if( eErr != OGRERR_NONE )
 
374
                return eErr;
 
375
 
 
376
            pszInput = pszNext;
 
377
 
 
378
            continue;
 
379
        }
 
380
 
326
381
        pszInput = OGRWktReadPoints( pszInput, &paoPoints, &padfZ, &nMaxPoint,
327
382
                                     &nPointCount );
328
383
 
329
384
        if( pszInput == NULL || nPointCount != 1 )
 
385
        {
 
386
            OGRFree( paoPoints );
 
387
            OGRFree( padfZ );
330
388
            return OGRERR_CORRUPT_DATA;
 
389
        }
331
390
 
332
 
        if( padfZ )
 
391
        /* Ignore Z array when we have a MULTIPOINT M */
 
392
        if( padfZ && !(bHasM && !bHasZ))
333
393
            poGeom = new OGRPoint( paoPoints[0].x, 
334
394
                                   paoPoints[0].y, 
335
395
                                   padfZ[0] );