source: trunk/gdal/apps/gdalsrsinfo.cpp

Last change on this file was 33757, checked in by goatbar, 2 months ago

Remove OGR_ENABLED c preprocessor directives (#6117).

GDAL has required OGR to be enabled for a while, so get rid of most of the
now unnecessary #if logic. Hardcodes the response that OGR is enabled for
things like gdal-config.

File size: 22.9 KB
Line 
1/******************************************************************************
2 * $Id$
3 *
4 * Project:  GDAL Utilities
5 * Purpose:  Command line application to list info about a given CRS.
6 *           Outputs a number of formats (WKT, PROJ.4, etc.).
7 * Author:   Frank Warmerdam, warmerdam@pobox.com
8 *           Etienne Tourigny, etourigny.dev-at-gmail-dot-com
9 *
10 * ****************************************************************************
11 * Copyright (c) 1998, Frank Warmerdam
12 * Copyright (c) 2011-2013, Even Rouault <even dot rouault at mines-paris dot org>
13 *
14 * Permission is hereby granted, free of charge, to any person obtaining a
15 * copy of this software and associated documentation files (the "Software"),
16 * to deal in the Software without restriction, including without limitation
17 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
18 * and/or sell copies of the Software, and to permit persons to whom the
19 * Software is furnished to do so, subject to the following conditions:
20 *
21 * The above copyright notice and this permission notice shall be included
22 * in all copies or substantial portions of the Software.
23 *
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
25 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
27 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
29 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
30 * DEALINGS IN THE SOFTWARE.
31 ****************************************************************************/
32
33#include "gdal_priv.h"
34#include "cpl_string.h"
35#include "ogr_spatialref.h"
36#include "ogr_api.h"
37#include "ogrsf_frmts.h"
38#include "commonutils.h"
39
40CPL_CVSID("$Id$");
41
42bool FindSRS( const char *pszInput, OGRSpatialReference &oSRS );
43CPLErr PrintSRS( const OGRSpatialReference &oSRS,
44                 const char * pszOutputType,
45                 bool bPretty, bool bPrintSep );
46void PrintSRSOutputTypes( const OGRSpatialReference &oSRS,
47                          const char ** papszOutputTypes );
48int FindEPSG( const OGRSpatialReference &oSRS );
49int SearchCSVForWKT( const char *pszFileCSV, const char *pszTarget );
50
51/************************************************************************/
52/*                               Usage()                                */
53/************************************************************************/
54
55static void Usage(const char* pszErrorMsg = NULL)
56
57{
58    printf( "\nUsage: gdalsrsinfo [options] srs_def\n"
59            "\n"
60            "srs_def may be the filename of a dataset supported by GDAL/OGR "
61            "from which to extract SRS information\n"
62            "OR any of the usual GDAL/OGR forms "
63            "(complete WKT, PROJ.4, EPSG:n or a file containing the SRS)\n"
64            "\n"
65            "Options: \n"
66            "   [--help-general] [-h]  Show help and exit\n"
67            "   [-p]                   Pretty-print where applicable (e.g. WKT)\n"
68            "   [-V]                   Validate SRS\n"
69            "   [-e]                   Search for EPSG number corresponding to SRS (experimental)\n"
70            "   [-o out_type]          Output type { default, all, wkt_all,\n"
71            "                                        proj4, epsg,\n"
72            "                                        wkt, wkt_simple, wkt_noct, wkt_esri,\n"
73            "                                        mapinfo, xml }\n\n" );
74
75    if( pszErrorMsg != NULL )
76        fprintf(stderr, "\nFAILURE: %s\n", pszErrorMsg);
77
78    exit( 1 );
79}
80
81
82/************************************************************************/
83/*                                main()                                */
84/************************************************************************/
85
86#define CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(nExtraArg) \
87    do { if (i + nExtraArg >= argc) \
88        Usage(CPLSPrintf("%s option requires %d argument(s)", argv[i], nExtraArg)); } while(0)
89
90int main( int argc, char ** argv )
91
92{
93    bool bGotSRS = false;
94    bool bPretty = false;
95    bool bValidate = false;
96    bool bFindEPSG = false;
97    int            nEPSGCode = -1;
98    const char     *pszInput = NULL;
99    const char     *pszOutputType = "default";
100    OGRSpatialReference  oSRS;
101
102    /* Check strict compilation and runtime library version as we use C++ API */
103    if (! GDAL_CHECK_VERSION(argv[0]))
104        exit(1);
105
106    EarlySetConfigOptions(argc, argv);
107
108/* -------------------------------------------------------------------- */
109/*      Register standard GDAL and OGR drivers.                         */
110/* -------------------------------------------------------------------- */
111    GDALAllRegister();
112
113/* -------------------------------------------------------------------- */
114/*      Register standard GDAL drivers, and process generic GDAL        */
115/*      command options.                                                */
116/* -------------------------------------------------------------------- */
117    argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
118    if( argc < 1 )
119        exit( -argc );
120
121/* -------------------------------------------------------------------- */
122/*      Parse arguments.                                                */
123/* -------------------------------------------------------------------- */
124    for( int i = 1; i < argc; i++ )
125    {
126        CPLDebug( "gdalsrsinfo", "got arg #%d : [%s]", i, argv[i] );
127
128        if( EQUAL(argv[i], "--utility_version") )
129        {
130            printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
131                   argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
132            CSLDestroy( argv );
133            return 0;
134        }
135        else if( EQUAL(argv[i], "-h") || EQUAL(argv[i], "--help") )
136            Usage();
137        else if( EQUAL(argv[i], "-e") )
138            bFindEPSG = true;
139        else if( EQUAL(argv[i], "-o") )
140        {
141            CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
142            pszOutputType = argv[++i];
143        }
144        else if( EQUAL(argv[i], "-p") )
145            bPretty = true;
146        else if( EQUAL(argv[i], "-V") )
147            bValidate = true;
148        else if( argv[i][0] == '-' )
149        {
150            Usage(CPLSPrintf("Unknown option name '%s'", argv[i]));
151        }
152        else
153            pszInput = argv[i];
154    }
155
156    if ( pszInput == NULL ) {
157        CSLDestroy( argv );
158        Usage("No input specified.");
159    }
160
161    /* Search for SRS */
162    /* coverity[tainted_data] */
163    bGotSRS = FindSRS( pszInput, oSRS ) == TRUE;
164
165    CPLDebug( "gdalsrsinfo",
166              "bGotSRS: %d bValidate: %d pszOutputType: %s bPretty: %d",
167              static_cast<int>(bGotSRS),
168              static_cast<int>(bValidate),
169              pszOutputType,
170              static_cast<int>(bPretty) );
171
172    /* Make sure we got a SRS */
173    if ( ! bGotSRS ) {
174        CPLError( CE_Failure, CPLE_AppDefined,
175                  "ERROR - failed to load SRS definition from %s",
176                  pszInput );
177    }
178
179    else {
180
181        /* Find EPSG code - experimental */
182        if ( EQUAL(pszOutputType,"epsg") )
183            bFindEPSG = true;
184        if ( bFindEPSG ) {
185            CPLError( CE_Warning, CPLE_AppDefined,
186                      "EPSG detection is experimental and requires new data files (see bug #4345)" );
187            nEPSGCode = FindEPSG( oSRS );
188            /* If found, replace oSRS based on EPSG code */
189            if(nEPSGCode != -1) {
190                CPLDebug( "gdalsrsinfo",
191                          "Found EPSG code %d", nEPSGCode );
192                OGRSpatialReference oSRS2;
193                if ( oSRS2.importFromEPSG( nEPSGCode ) == OGRERR_NONE )
194                    oSRS = oSRS2;
195            }
196        }
197        /* Validate - not well tested!*/
198        if ( bValidate ) {
199            OGRErr eErr = oSRS.Validate( );
200            if ( eErr != OGRERR_NONE ) {
201                printf( "\nValidate Fails" );
202                if ( eErr == OGRERR_CORRUPT_DATA )
203                    printf( " - SRS is not well formed");
204                else if ( eErr == OGRERR_UNSUPPORTED_SRS )
205                    printf(" - contains non-standard PROJECTION[] values");
206                printf("\n");
207            }
208            else
209                printf( "\nValidate Succeeds\n" );
210        }
211
212        /* Output */
213        if ( EQUAL("default", pszOutputType ) ) {
214            /* does this work in MSVC? */
215            const char* papszOutputTypes[] =
216                { "proj4", "wkt", NULL };
217            if ( bFindEPSG )
218                printf("\nEPSG:%d\n",nEPSGCode);
219            PrintSRSOutputTypes( oSRS, papszOutputTypes );
220        }
221        else if ( EQUAL("all", pszOutputType ) ) {
222            if ( bFindEPSG )
223                printf("\nEPSG:%d\n\n",nEPSGCode);
224            const char* papszOutputTypes[] =
225                {"proj4","wkt","wkt_simple","wkt_noct","wkt_esri","mapinfo","xml",NULL};
226            PrintSRSOutputTypes( oSRS, papszOutputTypes );
227        }
228        else if ( EQUAL("wkt_all", pszOutputType ) ) {
229            const char* papszOutputTypes[] =
230                { "wkt", "wkt_simple", "wkt_noct", "wkt_esri", NULL };
231            PrintSRSOutputTypes( oSRS, papszOutputTypes );
232        }
233        else {
234            if ( bPretty )
235                printf( "\n" );
236            if ( EQUAL(pszOutputType,"epsg") )
237                printf("EPSG:%d\n",nEPSGCode);
238            else
239                PrintSRS( oSRS, pszOutputType, bPretty, FALSE );
240            if ( bPretty )
241                printf( "\n" );
242        }
243    }
244
245    /* cleanup anything left */
246    GDALDestroyDriverManager();
247    OGRCleanupAll();
248    CSLDestroy( argv );
249
250    return 0;
251}
252
253/************************************************************************/
254/*                      FindSRS()                                       */
255/*                                                                      */
256/*      Search for SRS from pszInput, update oSRS.                      */
257/************************************************************************/
258bool FindSRS( const char *pszInput, OGRSpatialReference &oSRS )
259
260{
261    bool bGotSRS = false;
262    GDALDataset *poGDALDS = NULL;
263    OGRLayer      *poLayer = NULL;
264    const char    *pszProjection = NULL;
265    CPLErrorHandler oErrorHandler = NULL;
266    bool bIsFile = false;
267    OGRErr eErr = OGRERR_NONE;
268
269    /* temporarily suppress error messages we may get from xOpen() */
270    bool bDebug = CPLTestBool(CPLGetConfigOption("CPL_DEBUG", "OFF"));
271    if( !bDebug )
272        oErrorHandler = CPLSetErrorHandler ( CPLQuietErrorHandler );
273
274    /* Test if argument is a file */
275    VSILFILE *fp = VSIFOpenL( pszInput, "r" );
276    if ( fp )  {
277        bIsFile = true;
278        VSIFCloseL( fp );
279        CPLDebug( "gdalsrsinfo", "argument is a file" );
280    }
281
282    /* try to open with GDAL */
283    if( !STARTS_WITH(pszInput, "http://spatialreference.org/") )    {
284        CPLDebug( "gdalsrsinfo", "trying to open with GDAL" );
285        poGDALDS = (GDALDataset *) GDALOpenEx( pszInput, 0, NULL, NULL, NULL );
286    }
287    if ( poGDALDS != NULL ) {
288        pszProjection = poGDALDS->GetProjectionRef( );
289        if( pszProjection != NULL && pszProjection[0] != '\0' )
290        {
291            char* pszProjectionTmp = (char*) pszProjection;
292            if( oSRS.importFromWkt( &pszProjectionTmp ) == OGRERR_NONE ) {
293                CPLDebug( "gdalsrsinfo", "got SRS from GDAL" );
294                bGotSRS = true;
295            }
296        }
297        else if( poGDALDS->GetLayerCount() > 0 )
298        {
299            poLayer = poGDALDS->GetLayer( 0 );
300            if ( poLayer != NULL ) {
301                OGRSpatialReference *poSRS = poLayer->GetSpatialRef( );
302                if ( poSRS != NULL ) {
303                    CPLDebug( "gdalsrsinfo", "got SRS from OGR" );
304                    bGotSRS = true;
305                    OGRSpatialReference* poSRSClone = poSRS->Clone();
306                    oSRS = *poSRSClone;
307                    OGRSpatialReference::DestroySpatialReference( poSRSClone );
308                }
309            }
310        }
311        GDALClose( (GDALDatasetH) poGDALDS );
312        if ( ! bGotSRS )
313            CPLDebug( "gdalsrsinfo", "did not open with GDAL" );
314    }
315
316    /* Try ESRI file */
317    if ( ! bGotSRS && bIsFile && (strstr(pszInput,".prj") != NULL) ) {
318        CPLDebug( "gdalsrsinfo",
319                  "trying to get SRS from ESRI .prj file [%s]", pszInput );
320
321        char **pszTemp;
322        if ( strstr(pszInput,"ESRI::") != NULL )
323            pszTemp = CSLLoad( pszInput+6 );
324        else
325            pszTemp = CSLLoad( pszInput );
326
327        if( pszTemp ) {
328            eErr = oSRS.importFromESRI( pszTemp );
329            CSLDestroy( pszTemp );
330        }
331        else
332            eErr = OGRERR_UNSUPPORTED_SRS;
333
334        if( eErr != OGRERR_NONE ) {
335            CPLDebug( "gdalsrsinfo", "did not get SRS from ESRI .prj file" );
336        }
337        else {
338            CPLDebug( "gdalsrsinfo", "got SRS from ESRI .prj file" );
339            bGotSRS = true;
340        }
341    }
342
343    /* Last resort, try OSRSetFromUserInput() */
344    if ( ! bGotSRS ) {
345        CPLDebug( "gdalsrsinfo",
346                  "trying to get SRS from user input [%s]", pszInput );
347
348        eErr = oSRS.SetFromUserInput( pszInput );
349
350       if(  eErr != OGRERR_NONE ) {
351            CPLDebug( "gdalsrsinfo", "did not get SRS from user input" );
352        }
353        else {
354            CPLDebug( "gdalsrsinfo", "got SRS from user input" );
355            bGotSRS = true;
356        }
357    }
358
359    /* restore error messages */
360    if( !bDebug )
361        CPLSetErrorHandler ( oErrorHandler );
362
363
364    return bGotSRS;
365}
366
367
368/************************************************************************/
369/*                      PrintSRS()                                      */
370/*                                                                      */
371/*      Print spatial reference in specified format.                    */
372/************************************************************************/
373CPLErr PrintSRS( const OGRSpatialReference &oSRS,
374                 const char * pszOutputType,
375                 bool bPretty, bool bPrintSep )
376
377{
378    if ( ! pszOutputType || EQUAL(pszOutputType,""))
379        return CE_None;
380
381    CPLDebug( "gdalsrsinfo", "PrintSRS( oSRS, %s, %d, %d )\n",
382              pszOutputType, static_cast<int>(bPretty),
383              static_cast<int>(bPrintSep) );
384
385    char *pszOutput = NULL;
386
387    if ( EQUAL("proj4", pszOutputType ) ) {
388        if ( bPrintSep ) printf( "PROJ.4 : ");
389        oSRS.exportToProj4( &pszOutput );
390        printf( "\'%s\'\n", pszOutput );
391    }
392
393    else if ( EQUAL("wkt", pszOutputType ) ) {
394        if ( bPrintSep ) printf("OGC WKT :\n");
395        if ( bPretty )
396            oSRS.exportToPrettyWkt( &pszOutput, FALSE );
397        else
398            oSRS.exportToWkt( &pszOutput );
399        printf("%s\n",pszOutput);
400    }
401
402    else if (  EQUAL("wkt_simple", pszOutputType ) ) {
403        if ( bPrintSep ) printf("OGC WKT (simple) :\n");
404        oSRS.exportToPrettyWkt( &pszOutput, TRUE );
405        printf("%s\n",pszOutput);
406    }
407
408    else if ( EQUAL("wkt_noct", pszOutputType ) ) {
409        if (  bPrintSep ) printf("OGC WKT (no CT) :\n");
410        OGRSpatialReference *poSRS = oSRS.Clone();
411        poSRS->StripCTParms( );
412        if ( bPretty )
413            poSRS->exportToPrettyWkt( &pszOutput, FALSE );
414        else
415            poSRS->exportToWkt( &pszOutput );
416        OGRSpatialReference::DestroySpatialReference( poSRS );
417        printf("%s\n",pszOutput);
418    }
419
420    else if ( EQUAL("wkt_esri", pszOutputType ) ) {
421        if ( bPrintSep ) printf("ESRI WKT :\n");
422        OGRSpatialReference *poSRS = oSRS.Clone();
423        poSRS->morphToESRI( );
424        if ( bPretty )
425            poSRS->exportToPrettyWkt( &pszOutput, FALSE );
426        else
427            poSRS->exportToWkt( &pszOutput );
428        OGRSpatialReference::DestroySpatialReference( poSRS );
429        printf("%s\n",pszOutput);
430    }
431
432    else if ( EQUAL("mapinfo", pszOutputType ) ) {
433        if ( bPrintSep ) printf("MAPINFO : ");
434        oSRS.exportToMICoordSys( &pszOutput );
435        printf("\'%s\'\n",pszOutput);
436    }
437
438    else if ( EQUAL("xml", pszOutputType ) ) {
439        if ( bPrintSep ) printf("XML :\n");
440        oSRS.exportToXML( &pszOutput, NULL );
441        printf("%s\n",pszOutput);
442    }
443
444    else {
445        CPLError( CE_Failure, CPLE_AppDefined,
446                  "ERROR - %s output not supported",
447                  pszOutputType );
448        return CE_Failure;
449    }
450
451    CPLFree( pszOutput );
452
453    return CE_None;
454}
455
456/************************************************************************/
457/*                      PrintSRSOutputTypes()                           */
458/*                                                                      */
459/*      Print spatial reference in specified formats.                   */
460/************************************************************************/
461void PrintSRSOutputTypes( const OGRSpatialReference &oSRS,
462                          const char ** papszOutputTypes )
463
464{
465    int nOutputTypes = CSLCount((char**)papszOutputTypes);
466    printf( "\n" );
467    for ( int i=0; i<nOutputTypes; i++ ) {
468        PrintSRS( oSRS, papszOutputTypes[i], true, true );
469        printf( "\n" );
470    }
471}
472
473/************************************************************************/
474/*                      SearchCSVForWKT()                               */
475/*                                                                      */
476/*      Search CSV file for target WKT, return EPSG code (or -1).       */
477/*      For saving space, the file can be compressed (gz)               */
478/*      If CSV file is absent are absent the function silently exits    */
479/************************************************************************/
480int SearchCSVForWKT( const char *pszFileCSV, const char *pszTarget )
481{
482    const char *pszFilename = NULL;
483    const char *pszWKT = NULL;
484    char szTemp[1024];
485    int nPos = 0;
486    const char *pszTemp = NULL;
487
488    VSILFILE *fp = NULL;
489    OGRSpatialReference oSRS;
490    int nCode = 0;
491    int nFound = -1;
492
493    CPLDebug( "gdalsrsinfo",
494              "SearchCSVForWKT()\nfile=%s\nWKT=%s\n",
495              pszFileCSV, pszTarget);
496
497/* -------------------------------------------------------------------- */
498/*      Find and open file.                                             */
499/* -------------------------------------------------------------------- */
500    // pszFilename = pszFileCSV;
501    pszFilename = CPLFindFile( "gdal", pszFileCSV );
502    if( pszFilename == NULL )
503    {
504        CPLDebug( "gdalsrsinfo", "could not find support file %s",
505                   pszFileCSV );
506        // return OGRERR_UNSUPPORTED_SRS;
507        return -1;
508    }
509
510    /* support gzipped file */
511    if ( strstr( pszFileCSV,".gz") != NULL )
512        snprintf( szTemp, sizeof(szTemp), "/vsigzip/%s", pszFilename);
513    else
514        snprintf( szTemp, sizeof(szTemp), "%s", pszFilename);
515
516    CPLDebug( "gdalsrsinfo", "SearchCSVForWKT() using file %s",
517              szTemp );
518
519    fp = VSIFOpenL( szTemp, "r" );
520    if( fp == NULL )
521    {
522        CPLDebug( "gdalsrsinfo", "could not open support file %s",
523                  pszFilename );
524
525        // return OGRERR_UNSUPPORTED_SRS;
526        return -1;
527    }
528
529/* -------------------------------------------------------------------- */
530/*      Process lines.                                                  */
531/* -------------------------------------------------------------------- */
532    const char *pszLine;
533
534    while( (pszLine = CPLReadLine2L(fp,-1,NULL)) != NULL )
535
536    {
537        // CPLDebug( "gdalsrsinfo", "read line %s", pszLine );
538
539        if( pszLine[0] == '#' )
540            continue;
541            /* do nothing */;
542
543        // else if( STARTS_WITH_CI(pszLine, "include ") )
544        // {
545        //     eErr = importFromDict( pszLine + 8, pszCode );
546        //     if( eErr != OGRERR_UNSUPPORTED_SRS )
547        //         break;
548        // }
549
550        // else if( strstr(pszLine,",") == NULL )
551        //     /* do nothing */;
552
553        pszTemp = strstr(pszLine,",");
554        if (pszTemp)
555        {
556            nPos = static_cast<int>(pszTemp - pszLine);
557
558            if ( nPos == 0 )
559                continue;
560
561            strncpy( szTemp, pszLine, nPos );
562            szTemp[nPos] = '\0';
563            nCode = atoi(szTemp);
564
565            pszWKT = (char *) pszLine + nPos +1;
566
567            // CPLDebug( "gdalsrsinfo",
568            //           "code=%d\nWKT=\n[%s]\ntarget=\n[%s]\n",
569            //           nCode,pszWKT, pszTarget );
570
571            if ( EQUAL(pszTarget,pszWKT) )
572            {
573                nFound = nCode;
574                CPLDebug( "gdalsrsinfo", "found EPSG:%d\n"
575                          "current=%s\ntarget= %s\n",
576                          nCode, pszWKT, pszTarget );
577                break;
578            }
579        }
580    }
581
582    VSIFCloseL( fp );
583
584    return nFound;
585
586}
587
588/* TODO
589   - search for well-known values (AutoIdentifyEPSG())
590
591   - should we search .override.csv files?
592
593   - fix precision differences (namely in degree: 17 vs 15) so we can use epsg_ogc_simple
594target:
595 orig: GEOGCS["SAD69",DATUM["D_South_American_1969",SPHEROID["GRS_1967_Modified",6378160,298.25]],PRIMEM["Greenwich",0],UNIT["Degree",0.017453292519943295]]
596 ESRI: GEOGCS["SAD69",DATUM["D_South_American_1969",SPHEROID["GRS_1967_Truncated",6378160,298.25]],PRIMEM["Greenwich",0],UNIT["Degree",0.017453292519943295]]
597 OGC:  GEOGCS["SAD69",DATUM["South_American_Datum_1969",SPHEROID["GRS_1967_Modified",6378160,298.25]],PRIMEM["Greenwich",0],UNIT["Degree",0.017453292519943295]]
598database:
599 ESRI: GEOGCS["SAD69",DATUM["D_South_American_1969",SPHEROID["GRS_1967_Truncated",6378160,298.25]],PRIMEM["Greenwich",0],UNIT["Degree",0.017453292519943295]]
600 OGC:  GEOGCS["SAD69",DATUM["South_American_Datum_1969",SPHEROID["GRS 1967 Modified",6378160,298.25]],PRIMEM["Greenwich",0],UNIT["degree",0.0174532925199433]]
601*/
602
603/************************************************************************/
604/*                      FindEPSG()                                      */
605/*                                                                      */
606/*      Return EPSG code corresponding to spatial reference (or -1)     */
607/************************************************************************/
608int FindEPSG( const OGRSpatialReference &oSRS )
609{
610    char *pszWKT = NULL;
611    char *pszESRI = NULL;
612    OGRSpatialReference *poSRS = NULL;
613
614    poSRS = oSRS.Clone();
615    poSRS->StripCTParms();
616    poSRS->exportToWkt( &pszWKT );
617    OGRSpatialReference::DestroySpatialReference( poSRS );
618
619    poSRS = oSRS.Clone();
620    poSRS->morphToESRI( );
621    poSRS->exportToWkt( &pszESRI );
622    OGRSpatialReference::DestroySpatialReference( poSRS );
623
624    CPLDebug( "gdalsrsinfo", "FindEPSG()\nWKT (OGC)= %s\nWKT (ESRI)=%s",
625              pszWKT,pszESRI );
626
627    /* search for EPSG code in epsg_*.wkt.gz files */
628    /* using ESRI WKT for now, as it seems to work best */
629    int nFound = SearchCSVForWKT( "epsg_esri.wkt.gz", pszESRI );
630    if ( nFound == -1 )
631        nFound = SearchCSVForWKT( "epsg_ogc_simple.wkt.gz", pszESRI );
632    if ( nFound == -1 )
633        nFound = SearchCSVForWKT( "epsg_ogc.wkt.gz", pszESRI );
634
635    CPLFree( pszWKT );
636    CPLFree( pszESRI );
637
638    return nFound;
639}
Note: See TracBrowser for help on using the repository browser.