source: trunk/gdal/apps/gdalsrsinfo.cpp

Last change on this file was 34654, checked in by goatbar, 13 days ago

Remove svn:keywords $Id$ from the comments in apps/*.cpp and add missing CPL_CVSID (#6547)

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