int EXP_LVL1 CS_isHlpAvailable ()
{
if (csHlpIsAvail == 0)
{
if (csHelpFile [0] == '\0')
{
if (cs_DirP != NULL)
{
CS_stcpy (cs_DirP,"CS-MAP.hlp");
if (CS_access (cs_Dir,4) == 0)
{
csHlpIsAvail = 1;
CS_stcpy (csHelpFile,cs_Dir);
}
}
else
{
csHlpIsAvail = -1;
}
}
else if (CS_access (csHelpFile,4) == 0)
{
csHlpIsAvail = 1;
}
else
{
csHlpIsAvail = -1;
}
}
return (csHlpIsAvail > 0);
}
int CS_ftw (const char *path,int (*fn)(const char*,const struct stat*,int),int depth)
{
/* Apple doesn't include an "ftw" implementation, and the
* only one I could find is subject to the GNU license,
* so we'll go for a different implementation. [GEH 2000/11/30]
*
* This is a bit of a farce, really; the "depth" parameter is completely
* ignored. It would take very little work to make it call CS_ftw()
* recursively.
*/
extern char cs_DirsepC;
extern char *cs_DirP;
extern char cs_ExtsepC;
char *cp;
char ctemp[MAXPATH];
DIR *directory = NULL;
int st = 0;
cp = CS_stcpy(ctemp,path);
directory = opendir(ctemp);
if ( directory )
{
struct dirent *entry;
*(cp - 1) = cs_DirsepC;
while ( entry = readdir(directory) )
{
struct stat stat_buf;
CS_stcpy(cp,entry->d_name);
st = stat (ctemp,&stat_buf);
if (st == 0)
{
if ( S_ISDIR(stat_buf.st_mode) ) /* Should really be smarter here */
{
st = (*fn) (ctemp,&stat_buf,FTW_D);
}
else
{
st = (*fn) (ctemp,&stat_buf,FTW_F);
}
if (st != 0)
{
break;
}
}
}
closedir(directory);
}
return st;
}
/******************************************************************************
Initialize the NZGD49 <--> NZGD2K conversion system. The catalog file is
expected to reside in the basic data directory. The name of the file is
taken from the cs_Nzgd49Name global variable.
*/
int EXP_LVL7 CSnzgd49Init (void)
{
extern char cs_Dir [];
extern char* cs_DirP;
extern char cs_Nzgd49Name [];
char catalog [MAXPATH];
if (csNzgd49ToNzgd2K == NULL)
{
/* Set up the catalog file name. */
CS_stcpy (cs_DirP,cs_Nzgd49Name);
CS_stncp (catalog,cs_Dir,sizeof (catalog));
/* Use it to build the Nzgd49ToNzgd2K object. */
csNzgd49ToNzgd2K = CSnewNzgd49ToNzgd2K (catalog);
if (csNzgd49ToNzgd2K == NULL) goto error;
}
csNzgd49ToNzgd2KCnt += 1;
return 0;
error:
if (csNzgd49ToNzgd2K != NULL)
{
CSdeleteNzgd49ToNzgd2K (csNzgd49ToNzgd2K);
csNzgd49ToNzgd2K = NULL;
csNzgd49ToNzgd2KCnt = 0;
}
return -1;
}
/**********************************************************************
** st = CSvrtconInit ();
**
** int st; returns 0 if the initialization proceeded to
** completion successfully. Otherwise,
** returns -1.
**********************************************************************/
int EXP_LVL7 CSvrtconInit (void)
{
extern char *cs_DirP;
extern char cs_Dir [];
extern char cs_VertconName [];
/* See if we already have a csVertconUS object.
Note, we can have such even if the count is zero. */
if (csVertconUS == NULL)
{
/* Nope, we best create one. */
CS_stcpy (cs_DirP,cs_VertconName);
csVertconUS = CSnewVertconUS (cs_Dir);
if (csVertconUS == NULL)
{
goto error;
}
csVertconUSCnt = 0;
}
csVertconUSCnt += 1;
return 0;
error:
if (csVertconUS != NULL)
{
CSdeleteVertconUS (csVertconUS);
csVertconUS = NULL;
}
csVertconUSCnt = 0;
return -1;
}
/******************************************************************************
Initialize the DHDN <--> ETRF conversion system. The catalog file is
expected to reside in the basic data directory.
*/
int EXP_LVL7 CSdhdnInit (void)
{
extern char cs_Dir [];
extern char* cs_DirP;
extern char cs_DhdnName [];
char catalog [MAXPATH];
if (csDhdnToEtrf89 == NULL)
{
/* Set up the catalog file name. Need a copy of it as the
new function will access CS_dtloc. */
CS_stcpy (cs_DirP,cs_DhdnName);
CS_stncp (catalog,cs_Dir,sizeof (catalog));
/* Use it to build the DhdnToEtrf89 object. */
csDhdnToEtrf89 = CSnewDhdnToEtrf89 (catalog);
if (csDhdnToEtrf89 == NULL) goto error;
}
csDhdnToEtrf89Cnt += 1;
return 0;
error:
if (csDhdnToEtrf89 != NULL)
{
CSdeleteDhdnToEtrf89 (csDhdnToEtrf89);
csDhdnToEtrf89 = NULL;
csDhdnToEtrf89Cnt = 0;
}
return -1;
}
/**********************************************************************
** st = CSn27a77Init ();
**********************************************************************/
int EXP_LVL7 CSn27a77Init (void)
{
extern char *cs_DirP;
extern char cs_Dir [];
extern char cs_N27A77Name [];
char catalog [MAXPATH];
/* See if we already have a csNad27ToNad83 object.
Note, we can have such even if the count is zero. */
if (csNad27ToAts77 == NULL)
{
/* Nope, we best create one. */
CS_stcpy (cs_DirP,cs_N27A77Name);
CS_stncp (catalog,cs_Dir,sizeof (catalog));
csNad27ToAts77 = CSnewNad27ToAts77 (catalog);
if (csNad27ToAts77 == NULL)
{
goto error;
}
csNad27ToAts77Cnt = 0;
}
csNad27ToAts77Cnt += 1;
return 0;
error:
if (csNad27ToAts77 != NULL)
{
CSdeleteNad27ToAts77 (csNad27ToAts77);
csNad27ToAts77 = NULL;
}
csNad27ToAts77Cnt = 0;
return -1;
}
/**********************************************************************
The following function returns a list of the coordinate systems
in the cache.
**********************************************************************/
void EXP_LVL1 CSbccDbg (char *results,int rsltSz)
{
extern csThread struct csCscach_ *csCscachP;
int need;
char *cp;
char *rsltPtr = results;
cs_Register struct csCscach_ *ch_ptr;
char myName [32];
*results = '\0';
if (csCscachP == NULL)
{
CS_stncp (results,"<none>",rsltSz);
}
else
{
rsltSz -= 1;
for (ch_ptr = csCscachP;ch_ptr != NULL;ch_ptr = ch_ptr->next)
{
if (rsltSz > 0)
{
cp = myName;
if (*results != '\0') *cp++ = ',';
if (ch_ptr->cs_nam [0] == '\0')
{
cp = CS_stcpy (cp,"<none>");
}
else if (ch_ptr->cs_ptr != NULL)
{
cp = CS_stncp (cp,ch_ptr->cs_nam,sizeof (myName) - 1);
}
else
{
cp = CS_stcpy (cp,"<none>");
}
need = (int)strlen (myName);
if (need > rsltSz) need = rsltSz;
rsltPtr = CS_stncp (rsltPtr,myName,need + 1);
rsltSz -= need;
}
}
}
return;
}
void EXP_LVL5 CSasciiToXml (char *xml,const char *ascii)
{
const char *srcPtr;
char *trgPtr;
char cc;
srcPtr = ascii;
trgPtr = xml;
while ((cc = *srcPtr++) != '\0')
{
if (cc == '&' ) trgPtr = CS_stcpy (trgPtr,"&");
else if (cc == '<' ) trgPtr = CS_stcpy (trgPtr,"<");
else if (cc == '>' ) trgPtr = CS_stcpy (trgPtr,">");
else if (cc == '"' ) trgPtr = CS_stcpy (trgPtr,""");
else if (cc == '\'') trgPtr = CS_stcpy (trgPtr,"'");
else *trgPtr++ = cc;
}
*trgPtr = '\0';
return;
}
/**********************************************************************
The following function returns a list of the coordinate systems
in the cache.
**********************************************************************/
void EXP_LVL1 CSbdcDbg (char *results,int rsltSz)
{
extern csThread struct csDtcach_ *csDtcachP;
int need;
char *cp;
char *rsltPtr = results;
cs_Register struct csDtcach_ *ch_ptr;
char myName [64];
*results = '\0';
if (csDtcachP == NULL)
{
CS_stncp (results,"<none>",rsltSz);
}
else
{
rsltSz -= 1;
for (ch_ptr = csDtcachP;ch_ptr != NULL;ch_ptr = ch_ptr->next)
{
if (rsltSz > 0)
{
cp = myName;
if (*results != '\0') *cp++ = ';';
if (ch_ptr->dtc_ptr == NULL)
{
cp = CS_stcpy (cp,"<none>");
}
else
{
*cp++ = '<';
cp = CS_stncp (cp,ch_ptr->dtc_ptr->srcKeyName,28);
*cp++ = ':';
*cp++ = ':';
cp = CS_stncp (cp,ch_ptr->dtc_ptr->trgKeyName,28);
*cp++ = '>';
*cp = '\0';
}
need = (int)strlen (myName);
if (need > rsltSz) need = rsltSz;
rsltPtr = CS_stncp (rsltPtr,myName,need + 1);
rsltSz -= need;
}
}
}
return;
}
/////////////////////////////////////////////////////////////////////////////
// CcsDataDir message handlers
void CcsDataDir::OnBtnDirbrwse()
{
int ii;
CString newPath;
DWORD options = OFN_HIDEREADONLY | OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR | OFN_SHAREAWARE;
CS_stcpy (cs_DirP,cs_Csname);
CFileDialog dataDir (TRUE,NULL,cs_Dir,options,"All Files (*.*)|*.*||",NULL);
AfxMessageBox ("Windows does not provide a 'directory browser' as a 'common dialog'! A 'file browser' dialog will next appear. Use it to specify a directory by choosing a file (any file) in the desired directory.");
INT_PTR st = dataDir.DoModal ();
if (st == IDOK)
{
newPath = dataDir.GetPathName ();
ii = newPath.ReverseFind (cs_DirsepC);
if (ii >= 0)
{
m_DataDirectory = newPath.Left (ii);
UpdateData (FALSE);
}
}
}
/******************************************************************************
High Level Interface access functions.
*/
int EXP_LVL1 CS_geoidHgt (Const double ll84 [2],double *height)
{
extern double cs_Mhuge; /* -1.0E+32 */
extern char cs_Dir [];
extern char *cs_DirP;
extern struct csGeoidHeight_ *csGeoidHeight;
int status = -1;
*height = cs_Mhuge;
if (csGeoidHeight == NULL)
{
CS_stcpy (cs_DirP,cs_GEOID_NAME);
csGeoidHeight = CSnewGeoidHeight (cs_Dir);
}
if (csGeoidHeight != NULL)
{
status = CScalcGeoidHeight (csGeoidHeight,height,ll84);
}
return status;
}
int EXP_LVL3 CSel2WktEx (char *bufr,size_t bufrSize,enum ErcWktFlavor flavor,const struct cs_Eldef_ *el_def,unsigned short flags)
{
short mapWktNames;
EcsMapSt csMapSt;
EcsNameFlavor nmFlavor;
Const char* kCp;
double rcpFlattening = 0.0;
char wktEllipsoidName [96];
char cTemp [1024];
CS_stcpy (csErrnam,"CSel2WktEx");
if (bufr == 0)
{
CS_erpt (cs_INV_ARG1);
return -(cs_Error);
}
if (bufrSize < 1)
{
CS_erpt (cs_INV_ARG2);
return -(cs_Error);
}
*bufr = '\0';
nmFlavor = csWktFlvrToCsMapFlvr (flavor);
mapWktNames = ((flags & cs_WKTFLG_MAPNAMES) != 0);
if (el_def->flat != 0.0)
{
rcpFlattening = cs_One / el_def->flat;
}
else
{
/* The real value is infinity, but that this a rather awkward number
to deal with. So, we use zero to indicate a sphere. Quite frankly,
the specification (if there really is one) for WKT does not handle
spheres at all. We should probably just bag anything references to
a spehere. */
rcpFlattening = cs_Zero;
}
if (!mapWktNames)
{
kCp = el_def->key_nm;
if (flavor == wktFlvrEsri || flavor == wktFlvrOracle)
{
kCp = el_def->name;
}
CS_stncp (wktEllipsoidName,kCp,sizeof (wktEllipsoidName));
}
else
{
csMapSt = csMapNameToNameC (csMapEllipsoidKeyName,wktEllipsoidName,
sizeof (wktEllipsoidName),
nmFlavor,
csMapFlvrAutodesk,
el_def->key_nm);
if (csMapSt != csMapOk)
{
CS_stncp (wktEllipsoidName,el_def->key_nm,sizeof (wktEllipsoidName));
}
}
sprintf (cTemp,"SPHEROID[\"%s\",%.3f,%.8f]",wktEllipsoidName,el_def->e_rad,rcpFlattening);
CS_stncp (bufr,cTemp,(int)bufrSize);
return 0;
}
int EXP_LVL7 CS_tmpfn (char *tmp_fnm)
{
extern char cs_Dir [];
extern char *cs_DirP;
char cc_save;
int count;
char *cp;
/* Establish the drive and the directory. */
cc_save = *cs_DirP;
*cs_DirP = '\0';
cp = CS_stcpy (tmp_fnm,cs_Dir);
*cs_DirP = cc_save;
/* Add a file name. */
cp = CS_stcpy (cp,"DEL_ME.$");
/* Add an extension which will make this file unique in the
directory. Hopefully, we will never need to iterate
more than once since tempoary files should always be
deleted after their use. */
count = 0;
strcpy (unique,"ZZ");
do
{
count++;
if (count >= 676)
{
CS_erpt (cs_TMPFN_MAXED);
return (-1);
}
/* Bump the unique portion of the name by one, wrapping
arround if necessary. */
if (unique [1] >= 'Z')
{
unique [1] = 'A';
if (unique [0] >= 'Z')
{
unique [0] = 'A';
}
else unique [0]++;
} else unique [1]++;
/* Add the unique two character name generated above
to the result. */
(void) CS_stcpy (cp,unique);
/* We continue generating names until we find one
that doesn't exist. In this case, access
does just what we need it to. */
} while (CS_access (tmp_fnm,0) == 0);
/* If we get here, we have made a unique name. */
return (0);
}
int main (int argc,char *argv [])
{
extern char cs_Dir [];
extern char* cs_DirP;
extern char cs_Csname [];
extern char cs_Dtname [];
extern char cs_Elname [];
int cmpVal, iTmp;
int csDiffCnt, dtDiffCnt, elDiffCnt;
int dummy;
int nlFlag;
csFILE *wasStrm, *isStrm;
char wasDir [MAXPATH];
char isDir [MAXPATH];
char errorText [260];
struct cs_Csdef_ wasCsDef, isCsDef;
struct cs_Dtdef_ wasDtDef, isDtDef;
struct cs_Eldef_ wasElDef, isElDef;
csDiffCnt = 0;
dtDiffCnt = 0;
elDiffCnt = 0;
if (argc != 3) Usage ();
strncpy (wasDir,argv [1],sizeof (wasDir));
wasDir [sizeof (wasDir) - 1] = '\0';
strncpy (isDir,argv [2],sizeof (isDir));
isDir [sizeof (isDir) - 1] = '\0';
if (CS_altdr (wasDir) != 0)
{
printf ("%s file not found in %s directory.\n",cs_Csname,wasDir);
Usage ();
}
CS_stcpy (cs_DirP,cs_Dtname);
if (CS_access (cs_Dir,4) != 0)
{
printf ("%s file not found in %s directory.\n",cs_Dtname,wasDir);
Usage ();
}
CS_stcpy (cs_DirP,cs_Elname);
if (CS_access (cs_Dir,4) != 0)
{
printf ("%s file not found in %s directory.\n",cs_Elname,wasDir);
Usage ();
}
if (CS_altdr (isDir) != 0)
{
printf ("%s file not found in %s directory.\n",cs_Csname,isDir);
Usage ();
}
CS_stcpy (cs_DirP,cs_Dtname);
if (CS_access (cs_Dir,4) != 0)
{
printf ("%s file not found in %s directory.\n",cs_Dtname,isDir);
Usage ();
}
CS_stcpy (cs_DirP,cs_Elname);
if (CS_access (cs_Dir,4) != 0)
{
printf ("%s file not found in %s directory.\n",cs_Elname,isDir);
Usage ();
}
/* Ok, we're ready to do our thing. Do coordinate systems first. */
CS_altdr (wasDir); /*lint !e534 */
wasStrm = CS_csopn (_STRM_BINRD);
if (wasStrm == NULL)
{
printf ("Open of %s in the 'WAS' directory failed.\n",cs_Csname);
Usage ();
}
CS_altdr (isDir); /*lint !e534 */
isStrm = CS_csopn (_STRM_BINRD);
if (isStrm == NULL)
{
printf ("Open of %s in the 'IS' directory failed.\n",cs_Csname);
Usage ();
}
/* Now, we loop through the dictionaries. In this module, we simply
compare key names, looking for new definitions, or deleted
definitions. When we have definitions with the same name, we call
CS_csDiff to report any differences.
First, we prime the pump. */
iTmp = CS_csrd (wasStrm,&wasCsDef,&dummy);
if (iTmp < 0)
{
CS_errmsg (errorText,sizeof (errorText));
printf ("%s\n",errorText);
Usage ();
}
if (iTmp == 0)
{
printf ("'WAS' coordinate system dictionary is empty.\n");
Usage ();
}
iTmp = CS_csrd (isStrm,&isCsDef,&dummy);
if (iTmp < 0)
{
CS_errmsg (errorText,sizeof (errorText));
printf ("%s\n",errorText);
Usage ();
}
if (iTmp == 0)
{
printf ("'IS' coordinate system dictionary is empty.\n");
Usage ();
}
nlFlag = FALSE;
while (TRUE)
{
cmpVal = CS_stricmp (wasCsDef.key_nm,isCsDef.key_nm);
if (cmpVal < 0)
{
if (nlFlag)
{
printf ("\n");
nlFlag = FALSE;
}
printf ("%s deleted from coordinate system dictionary!!!\n",wasCsDef.key_nm);
csDiffCnt += 1;
}
else if (cmpVal > 0)
{
if (nlFlag)
{
printf ("\n");
nlFlag = FALSE;
}
printf ("%s added to coordinate system dictionary!!!\n",isCsDef.key_nm);
csDiffCnt += 1;
}
else
{
/* Normal case, we have two definitions with the same name, */
iTmp = CS_csDiff (stdout,&wasCsDef,&isCsDef);
if (iTmp != 0)
{
csDiffCnt += 1;
nlFlag = TRUE;
}
}
if (cmpVal >= 0)
{
iTmp = CS_csrd (isStrm,&isCsDef,&dummy);
if (iTmp < 0)
{
CS_errmsg (errorText,sizeof (errorText));
printf ("%s\n",errorText);
Usage ();
}
if (iTmp == 0)
{
CS_fclose (isStrm);
isStrm = NULL;
break;
}
}
if (cmpVal <= 0)
{
iTmp = CS_csrd (wasStrm,&wasCsDef,&dummy);
if (iTmp < 0)
{
CS_errmsg (errorText,sizeof (errorText));
printf ("%s\n",errorText);
Usage ();
}
if (iTmp == 0)
{
CS_fclose (wasStrm);
wasStrm = NULL;
break;
}
}
}
/* Finish up properly. */
nlFlag = TRUE;
while (wasStrm != NULL)
{
iTmp = CS_csrd (wasStrm,&wasCsDef,&dummy);
if (iTmp > 0)
{
if (nlFlag)
{
printf ("\n");
nlFlag = FALSE;
}
printf ("%s deleted from coordinate system dictionary!!!\n",wasCsDef.key_nm);
csDiffCnt += 1;
}
else if (iTmp == 0)
{
CS_fclose (wasStrm);
wasStrm = NULL;
}
else
{
CS_errmsg (errorText,sizeof (errorText));
printf ("%s\n",errorText);
Usage ();
}
}
while (isStrm != NULL)
{
iTmp = CS_csrd (isStrm,&wasCsDef,&dummy);
if (iTmp > 0)
{
if (nlFlag)
{
printf ("\n");
nlFlag = FALSE;
}
printf ("%s added to coordinate system dictionary!!!\n",isCsDef.key_nm);
csDiffCnt += 1;
}
else if (iTmp == 0)
{
CS_fclose (isStrm);
isStrm = NULL;
}
else
{
CS_errmsg (errorText,sizeof (errorText));
printf ("%s\n",errorText);
Usage ();
}
}
if (csDiffCnt == 0)
{
printf ("\nCoordinate system dictionaries are the same.\n\n");
}
else
{
printf ("\n%d coordinate systems are different.\n\n",csDiffCnt);
}
/* Done with the coordinate system dictionary. Same as above, but with the
Datum Dictionary this time. */
CS_altdr (wasDir); /*lint !e534 */
wasStrm = CS_dtopn (_STRM_BINRD);
if (wasStrm == NULL)
{
printf ("Open of %s in the 'WAS' directory failed.\n",cs_Dtname);
Usage ();
}
CS_altdr (isDir); /*lint !e534 */
isStrm = CS_dtopn (_STRM_BINRD);
if (isStrm == NULL)
{
printf ("Open of %s in the 'IS' directory failed.\n",cs_Dtname);
Usage ();
}
iTmp = CS_dtrd (wasStrm,&wasDtDef,&dummy);
if (iTmp < 0)
{
CS_errmsg (errorText,sizeof (errorText));
printf ("%s\n",errorText);
Usage ();
}
if (iTmp == 0)
{
printf ("'WAS' datum dictionary is empty.\n");
Usage ();
}
iTmp = CS_dtrd (isStrm,&isDtDef,&dummy);
if (iTmp < 0)
{
CS_errmsg (errorText,sizeof (errorText));
printf ("%s\n",errorText);
Usage ();
}
if (iTmp == 0)
{
printf ("'IS' datum dictionary is empty.\n");
Usage ();
}
nlFlag = FALSE;
while (TRUE)
{
cmpVal = CS_stricmp (wasDtDef.key_nm,isDtDef.key_nm);
if (cmpVal < 0)
{
if (nlFlag)
{
printf ("\n");
nlFlag = FALSE;
}
printf ("%s deleted from datum dictionary!!!\n",wasDtDef.key_nm);
dtDiffCnt += 1;
}
else if (cmpVal > 0)
{
if (nlFlag)
{
printf ("\n");
nlFlag = FALSE;
}
printf ("%s added to datum dictionary!!!\n",isDtDef.key_nm);
dtDiffCnt += 1;
}
else
{
/* Normal case, we have two definitions with the same name, */
iTmp = CS_dtDiff (stdout,&wasDtDef,&isDtDef);
if (iTmp != 0)
{
dtDiffCnt += 1;
nlFlag = TRUE;
}
}
if (cmpVal >= 0)
{
iTmp = CS_dtrd (isStrm,&isDtDef,&dummy);
if (iTmp < 0)
{
CS_errmsg (errorText,sizeof (errorText));
printf ("%s\n",errorText);
Usage ();
}
if (iTmp == 0)
{
CS_fclose (isStrm);
isStrm = NULL;
break;
}
}
if (cmpVal <= 0)
{
iTmp = CS_dtrd (wasStrm,&wasDtDef,&dummy);
if (iTmp < 0)
{
CS_errmsg (errorText,sizeof (errorText));
printf ("%s\n",errorText);
Usage ();
}
if (iTmp == 0)
{
CS_fclose (wasStrm);
wasStrm = NULL;
break;
}
}
}
nlFlag = TRUE;
while (wasStrm != NULL)
{
iTmp = CS_dtrd (wasStrm,&wasDtDef,&dummy);
if (iTmp > 0)
{
if (nlFlag)
{
printf ("\n");
nlFlag = FALSE;
}
printf ("%s deleted from datum dictionary!!!\n",wasDtDef.key_nm);
dtDiffCnt += 1;
}
else if (iTmp == 0)
{
CS_fclose (wasStrm);
wasStrm = NULL;
}
else
{
CS_errmsg (errorText,sizeof (errorText));
printf ("%s\n",errorText);
Usage ();
}
}
while (isStrm != NULL)
{
iTmp = CS_dtrd (isStrm,&wasDtDef,&dummy);
if (iTmp > 0)
{
if (nlFlag)
{
printf ("\n");
nlFlag = FALSE;
}
printf ("%s added to datum dictionary!!!\n",isDtDef.key_nm);
dtDiffCnt += 1;
}
else if (iTmp == 0)
{
CS_fclose (isStrm);
isStrm = NULL;
}
else
{
CS_errmsg (errorText,sizeof (errorText));
printf ("%s\n",errorText);
Usage ();
}
}
if (dtDiffCnt == 0)
{
printf ("\nDatum dictionaries are the same.\n\n");
}
else
{
printf ("\n%d datum definitions are different.\n\n",dtDiffCnt);
}
/* Ellipsoid Dictionary */
CS_altdr (wasDir); /*lint !e534 */
wasStrm = CS_elopn (_STRM_BINRD);
if (wasStrm == NULL)
{
printf ("Open of %s in the 'WAS' directory failed.\n",cs_Elname);
Usage ();
}
CS_altdr (isDir); /*lint !e534 */
isStrm = CS_elopn (_STRM_BINRD);
if (isStrm == NULL)
{
printf ("Open of %s in the 'IS' directory failed.\n",cs_Elname);
Usage ();
}
iTmp = CS_elrd (wasStrm,&wasElDef,&dummy);
if (iTmp < 0)
{
CS_errmsg (errorText,sizeof (errorText));
printf ("%s\n",errorText);
Usage ();
}
if (iTmp == 0)
{
printf ("'WAS' ellipsoid dictionary is empty.\n");
Usage ();
}
iTmp = CS_elrd (isStrm,&isElDef,&dummy);
if (iTmp < 0)
{
CS_errmsg (errorText,sizeof (errorText));
printf ("%s\n",errorText);
Usage ();
}
if (iTmp == 0)
{
printf ("'IS' ellipsoid dictionary is empty.\n");
Usage ();
}
nlFlag = FALSE;
while (TRUE)
{
cmpVal = CS_stricmp (wasElDef.key_nm,isElDef.key_nm);
if (cmpVal < 0)
{
if (nlFlag)
{
printf ("\n");
nlFlag = FALSE;
}
printf ("%s deleted from ellipsoid dictionary!!!\n",wasElDef.key_nm);
elDiffCnt += 1;
}
else if (cmpVal > 0)
{
if (nlFlag)
{
printf ("\n");
nlFlag = FALSE;
}
printf ("%s added to ellipsoid dictionary!!!\n",isElDef.key_nm);
elDiffCnt += 1;
}
else
{
/* Normal case, we have two definitions with the same name, */
iTmp = CS_elDiff (stdout,&wasElDef,&isElDef);
if (iTmp != 0)
{
elDiffCnt += 1;
nlFlag = TRUE;
}
}
if (cmpVal >= 0)
{
iTmp = CS_elrd (isStrm,&isElDef,&dummy);
if (iTmp < 0)
{
CS_errmsg (errorText,sizeof (errorText));
printf ("%s\n",errorText);
Usage ();
}
if (iTmp == 0)
{
CS_fclose (isStrm);
isStrm = NULL;
break;
}
}
if (cmpVal <= 0)
{
iTmp = CS_elrd (wasStrm,&wasElDef,&dummy);
if (iTmp < 0)
{
CS_errmsg (errorText,sizeof (errorText));
printf ("%s\n",errorText);
Usage ();
}
if (iTmp == 0)
{
CS_fclose (wasStrm);
wasStrm = NULL;
break;
}
}
}
nlFlag = TRUE;
while (wasStrm != NULL)
{
iTmp = CS_elrd (wasStrm,&wasElDef,&dummy);
if (iTmp > 0)
{
if (nlFlag)
{
printf ("\n");
nlFlag = FALSE;
}
printf ("%s deleted from ellipsoid dictionary!!!\n",wasElDef.key_nm);
elDiffCnt += 1;
}
else if (iTmp == 0)
{
CS_fclose (wasStrm);
wasStrm = NULL;
}
else
{
CS_errmsg (errorText,sizeof (errorText));
printf ("%s\n",errorText);
Usage ();
}
}
while (isStrm != NULL)
{
iTmp = CS_elrd (isStrm,&wasElDef,&dummy);
if (iTmp > 0)
{
if (nlFlag)
{
printf ("\n");
nlFlag = FALSE;
}
printf ("%s added to ellipsoid dictionary!!!\n",isElDef.key_nm);
dtDiffCnt += 1;
}
else if (iTmp == 0)
{
CS_fclose (isStrm);
isStrm = NULL;
}
else
{
CS_errmsg (errorText,sizeof (errorText));
printf ("%s\n",errorText);
Usage ();
}
}
if (elDiffCnt == 0)
{
printf ("\nEllipsoid dictionaries are the same.\n\n");
}
else
{
printf ("\n%d ellipsoid definitions are different.\n\n",elDiffCnt);
}
return 0;
}
int CSjapanQ (struct csGeodeticXfromParmsFile_* fileParms,Const char* dictDir,int err_list [],int list_sz)
{
extern char cs_DirsepC;
extern char cs_ExtsepC;
int err_cnt;
char *cp;
csFILE* strm;
char meshCode [] = "Meshcode";
char line1Buffer [256];
char line2Buffer [256];
char line3Buffer [256];
char pathBuffer [MAXPATH];
cp = fileParms->fileName;
if (*cp == '.' && *(cp + 1) == cs_DirsepC)
{
CS_stncp (pathBuffer,dictDir,sizeof (pathBuffer));
CS_stncat (pathBuffer,cp,MAXPATH);
}
else
{
CS_stncp (pathBuffer,cp,MAXPATH);
}
/* We will return (err_cnt + 1) below. */
err_cnt = -1;
if (err_list == NULL) list_sz = 0;
/* Verify that the file exists and that the format appears to be correct. */
strm = CS_fopen (pathBuffer,_STRM_TXTRD);
if (strm != NULL)
{
CS_fgets (line1Buffer,sizeof (line1Buffer),strm);
CS_fgets (line2Buffer,sizeof (line2Buffer),strm);
CS_fgets (line3Buffer,sizeof (line3Buffer),strm);
CS_fclose (strm);
strm = NULL;
if (!CS_stristr (line1Buffer,meshCode) &&
!CS_stristr (line2Buffer,meshCode) &&
!CS_stristr (line3Buffer,meshCode))
{
/* The pohrase meshcode was not found anywhere on the first three
lines, we assume this is not a ".par" file. */
if (++err_cnt < list_sz) err_list [err_cnt] = cs_DTQ_FORMAT;
}
}
else
{
//the txt file didn't exist - so, check whether at least the binary file does
cp = strrchr (pathBuffer,cs_ExtsepC);
if (cp == NULL)
{
if (++err_cnt < list_sz) err_list [err_cnt] = cs_DTQ_FILE;
}
else
{
CS_stcpy ((cp + 1),"_par");
if (0 != CS_access(pathBuffer, 4))
{
if (++err_cnt < list_sz) err_list [err_cnt] = cs_DTQ_FILE;
}
}
}
return (err_cnt + 1);
}
/* This function creates a binary version of the Jgd2k file if it doesn't
exist, or if the date on the binary file is older than or equal to
that of the primary text file. Note, that this function uses the path name
in the provided object, and modifies it to point to the binary file which
is then created if necessary.
This function is implemented as records in the ASCII text file may not be
of fixed length, there can be a million of them, and there is no guarantee
that the records in the text file will be properly sorted. The binary
file enables random access to the data file for decent performance without
eating up 12MB of RAM. */
int CSmakeBinaryJgd2kFile (struct cs_Japan_* thisPtr)
{
extern char cs_ExtsepC;
extern char csErrnam [];
extern double cs_Zero;
int st;
cs_Time_ aTime, bTime;
size_t wrCnt;
char *cp1, *cp2;
csFILE *aStrm, *bStrm;
long32_t tempL;
long32_t dblFrmt;
ulong32_t meshCode;
double lngTmp, latTmp;
double mesh_ll [2];
char lineBufr [128];
char binaryPath [MAXPATH];
struct csJgd2kGridRecord_ gridRec;
struct csJgd2kGridRecord_ minRec;
struct csJgd2kGridRecord_ maxRec;
/* We will write two records to the file with bogus mesh codes. These
records will carry the minimum (i.e. southwest) longitude and latitude
and the maximum (i.e. northeast) longitude and latitude of the data in
the file. This is an attempt to make the file format something which
does not inherently imply applicability to Japanese geography.
The bogus mesh codes were devised such that the min/max will be the
first two records in the file, thus easily accessible. For these two
special records, the deltaLng and DeltaLat fields carry absolute
longitude and latitude in seconds. */
minRec.meshCode = 1UL;
minRec.deltaLat = (long32_t)( 90 * 3600);
minRec.deltaLng = (long32_t)(180 * 3600);
maxRec.meshCode = 2UL;
maxRec.deltaLat = (long32_t)( -90 * 3600);
maxRec.deltaLng = (long32_t)(-180 * 3600);
/* Prepare for an error of some sort. */
aStrm = bStrm = NULL;
lngTmp = latTmp = cs_Zero;
/* Manufacture the name of the binary file. */
CS_stncp (binaryPath,thisPtr->filePath,sizeof (binaryPath));
cp1 = strrchr (binaryPath,cs_ExtsepC);
if (cp1 == NULL)
{
CS_stncp (csErrnam,thisPtr->filePath,MAXPATH);
CS_erpt (cs_DTC_FILE);
goto error;
}
CS_stcpy ((cp1 + 1),"_par");
bTime = CS_fileModTime (binaryPath);
/* Build a new binary file only if it doesn't exist yet. */
if (0 == bTime)
{
/* Determine the last modification time for the two files. Zero time value
means the file does not exist. */
aTime = CS_fileModTime (thisPtr->filePath);
if (aTime == 0)
{
/* The indicated source file does not exist, not uncommon among the
error conditions possible. */
CS_stncp (csErrnam,thisPtr->filePath,MAXPATH);
CS_erpt (cs_DTC_FILE);
goto error;
}
/* Here to create a, possibly new, binary version of the Jgd2k file,
typically named "TKY2JGD.par". To follow the general design
theme, we assume there can be several files, and there is no fixed
name for any of the files. At this particular point, of course,
we're only dealing with one file, the file whose name was provided.
We write one csJgd2kGridRecord structure for each line of text that
we read. Of course, we need to skip the first two lines (usually)
in the file as they are of the mets-data variety. */
aStrm = CS_fopen (thisPtr->filePath,_STRM_TXTRD);
if (aStrm == NULL)
{
/* This could happen if the file exists, but for some reason we
are denied permission to read the file.*/
CS_stncp (csErrnam,thisPtr->filePath,MAXPATH);
CS_erpt (cs_DTC_FILE);
goto error;
}
/* The mode of the following open will truncate any existing file, and
create a new binary file if necessary. */
bStrm = CS_fopen (binaryPath,_STRM_BINWR);
if (bStrm == NULL)
{
CS_stncp (csErrnam,thisPtr->filePath,MAXPATH);
CS_erpt (cs_FL_OPEN);
goto error;
}
/* If we're still here, we can copy the file, converting it to binary
form as we do. While doing so, we'll convert each mesh code to
latitude and longitude form and accumulate an estimate of the
coverage of the file. */
while (CS_fgets (lineBufr,sizeof (lineBufr),aStrm) != NULL)
{
/* Parse the information is in a record. */
meshCode = CS_strtoul (lineBufr,&cp1,10);
/* The first two lines of the files we've seen contain labels and
other data. We use the following to filter these out. This may
need to be improved should new versions of the file include some
other form of header. */
if (meshCode == 0 || meshCode == 0xffffffffUL) continue;
/* Accumulate a bounding box (or minimum and maximum as us old
farts used to call it) so we have a rough estimate of the
coverage of the file. */
CSjpnMeshCodeToLl (mesh_ll,meshCode);
if (mesh_ll [LNG] < -180.0 || mesh_ll [LNG] > 180.0 ||
mesh_ll [LAT] < -90.0 || mesh_ll [LAT] > 90.0)
{
/* Bogus mesh code. We could consider this to be meta-data
that slipped through the code immediately above, or that
the file is invalid. For now, we consider it to be the
latter: The file is not a validly formatted data file. */
CS_erpt (cs_INV_FILE);
goto error;
}
tempL = (long32_t)(mesh_ll [LNG] * 3600 + 0.01);
if (tempL < minRec.deltaLng) minRec.deltaLng = tempL;
if (tempL > maxRec.deltaLng) maxRec.deltaLng = tempL;
tempL = (long32_t)(mesh_ll [LAT] * 3600 + 0.01);
if (tempL < minRec.deltaLat) minRec.deltaLat = tempL;
if (tempL > maxRec.deltaLat) maxRec.deltaLat = tempL;
/* Separate the two data values. We avoid strtod as it is
locale dependent and the data file is not. */
while (*cp1 == ' ') cp1++;
cp2 = strchr (cp1,' ');
*cp2++ = '\0';
while (*cp2 == ' ') cp2++;
dblFrmt = CSatof (&latTmp,cp1,'.',',',':');
if (dblFrmt >= 0)
{
dblFrmt = CSatof (&lngTmp,cp2,'.',',',':');
}
if (dblFrmt < 0)
{
CS_erpt (cs_INV_FILE);
goto error;
}
/* Build a new record in the array. */
gridRec.meshCode = meshCode;
/* NTO 30 Oct 2008, Trac # 13
The following was necessiatated by Linux. It appears that on the
Linux platform (or some of them, anyway), the rounding of doubles
(especially negative ones) is different than what you will see on
WIN32 platforms. Which one is correct is of no concern to me,
only that they are different. */
latTmp *= 100000.0;
latTmp += (latTmp >= 0.0) ? 0.1 : -0.1;
lngTmp *= 100000.0;
lngTmp += (lngTmp >= 0.0) ? 0.1 : -0.1;
/* End Linux fix, Trac #13 */
gridRec.deltaLat = (long32_t)(latTmp);
gridRec.deltaLng = (long32_t)(lngTmp);
wrCnt = CS_fwrite (&gridRec,sizeof (gridRec),1,bStrm);
if (wrCnt != 1)
{
CS_erpt (cs_IOERR);
goto error;
}
}
/* If we're still here, we write minRec and maxRec to the file so we
have a record of the coverage of the file. */
wrCnt = CS_fwrite (&minRec,sizeof (minRec),1,bStrm);
if (wrCnt != 1)
{
CS_erpt (cs_IOERR);
goto error;
}
wrCnt = CS_fwrite (&maxRec,sizeof (maxRec),1,bStrm);
if (wrCnt != 1)
{
CS_erpt (cs_IOERR);
goto error;
}
/* Close the file streams. We're going to open the binary file back
up immediately, but have found this redundant close and open to
produce more reliable operation cross platforms. */
CS_fclose (aStrm);
aStrm = NULL;
st = CS_fclose (bStrm);
bStrm = NULL;
/* OK, we need to sort the file by mesh codes so we can use a binary
search algorithm on it. This should also cause the min/max records
to end up being the first two records in the file. This is very
convenient.
Note that the position of any one record in the file with respect
to any other record in the file is immaterial in this file format.
Thus, we can reorder the file any way we want to. The original
code was written in the Windows 95 era, so the current scheme may
look rather dumb. Nevertheless, it works and I have no motivation
to fix it. */
bStrm = CS_fopen (binaryPath,_STRM_BINUP);
if (bStrm == NULL)
{
CS_stncp (csErrnam,binaryPath,MAXPATH);
CS_erpt (cs_FL_OPEN);
goto error;
}
st = CS_ips (bStrm,sizeof (gridRec),0L,(CMPFUNC_CAST)CScompareJgd2kGridRecord);
CS_fclose (bStrm);
bStrm = NULL;
if (st < 0) goto error;
if (st == 1) st = csGRIDI_ST_OK; /* CS_ips returns 1 for success, for historical reasons. */
/* OK, now we're really done. */
}
/* If all that was done successfully, we change the name of
the file and return success. */
CS_stncp (thisPtr->filePath,binaryPath,sizeof (thisPtr->filePath));
return csGRIDI_ST_OK;
error:
if (aStrm != NULL)
{
CS_fclose (aStrm);
aStrm = NULL;
}
if (bStrm != NULL)
{
CS_fclose (bStrm);
bStrm = NULL;
}
return csGRIDI_ST_SYSTEM;
}
int EXP_LVL3 CScs2WktEx (char *csWktBufr,size_t bufrSize,enum ErcWktFlavor flavor,const struct cs_Csdef_ *cs_def,const struct cs_Dtdef_ *dt_def,const struct cs_Eldef_ *el_def,unsigned short flags)
{
extern double cs_One;
extern double cs_K90;
extern double cs_Degree;
extern char csErrnam [];
extern struct cs_Prjtab_ cs_Prjtab [];
int status;
short prjCode;
double tmpDbl;
double primeMer;
double unitFactor;
const char *kCp;
const char *prjNmPtr;
const char *prmNmFalseEasting;
const char *prmNmFalseNorthing;
const char *prmNmScaleFactor;
const char *prmNmCentralMeridian;
const char *prmNmLatitudeOfOrigin;
const char *prmNmStandardParallel1;
const char *prmNmStandardParallel2;
const char *prmNmYAxisAzimuth;
const char *prmNmAzimuth;
const char *prmNmLongitudeOfCenter;
const char *prmNmLatitudeOfCenter;
const char *prmNmLongitudeOf1stPoint;
const char *prmNmLatitudeOf1stPoint;
const char *prmNmLongitudeOf2ndPoint;
const char *prmNmLatitudeOf2ndPoint;
const char *prmNmLatitudeOfStdParall;
struct cs_Dtdef_ *dtDefPtr;
struct cs_Prjtab_ *prjPtr;
char refDtmName [24];
char baseName [24];
char cTemp [64];
char datmWkt [512];
char pmerWkt [512];
char geogWkt [512];
char parmWkt [512];
char unitWkt [128];
char projWkt [1024];
char geoAxis [1024];
char prjAxis [1024];
char geoTranWkt [1024];
char projection [64];
char gcsName [128];
char dtmName [128];
char csysWktName [96];
status = 0;
refDtmName [0] = '\0';
dtDefPtr = 0;
if (cs_def == 0)
{
CS_stncp (csErrnam,"CS_cs2Wkt:1",MAXPATH);
CS_erpt (cs_ISER);
goto error;
}
/* Make sure we have a datum pointer. */
if (dt_def == NULL)
{
/* The calling application did not provide a specific datum definition.
We use the datum name in the Coordinate System definition to obtain
a definition fomr the dictionary. */
if (cs_def->dat_knm [0] == '\0')
{
/* Oops!!! No datum definition in the coordinate system definition.
If we were to output something special for a cartographic definition,
i.e. a coordinate system referenced directly to an ellipsoid, we
would do that here. */
CS_erpt (cs_NO_REFERNCE);
goto error;
}
/* We need to free this definition, we stash it in a new pointer variable. */
dtDefPtr = CS_dtdef (cs_def->dat_knm);
if (dtDefPtr == NULL)
{
/* If the coordinate system definition came from the dictionary,
this shouldn't happen. If the application got the cs_Csdef_
data from somewhere else, it is possible. */
CS_erpt (cs_NO_REFERNCE);
goto error;
}
dt_def = dtDefPtr;
}
if (el_def != 0)
{
if (CS_stricmp (dt_def->ell_knm,el_def->key_nm))
{
CS_erpt (cs_WKT_INCNSIST);
goto error;
}
}
/* Locate the projection in the projection table. We need this for access
to the flag word for this projection. */
for (prjPtr = cs_Prjtab;prjPtr->code != cs_PRJCOD_END;prjPtr += 1)
{
if (!strcmp (cs_def->prj_knm,prjPtr->key_nm)) break;
}
if (prjPtr->code == cs_PRJCOD_END)
{
CS_erpt (cs_UNKWN_PROJ);
goto error;
}
prjCode = prjPtr->code;
prjNmPtr = 0;
if (prjCode == cs_PRJCOD_SWISS && (flavor == wktFlvrEsri || flavor == wktFlvrOracle))
{
prjNmPtr = CSwktPrjCode2Name (cs_PRJCOD_RSKEW,flavor);
}
else if (prjCode == cs_PRJCOD_LMTAN)
{
prjNmPtr = CSwktPrjCode2Name (cs_PRJCOD_LM1SP,flavor);
}
else if (prjPtr->code == cs_PRJCOD_UNITY)
{
prjNmPtr = "LL";
}
else
{
prjNmPtr = CSwktPrjCode2Name (prjCode,flavor);
}
if (prjNmPtr == 0 || *prjNmPtr == '\0')
{
/* This projection is not supported by this flavor of WKT. */
CS_stncp (csErrnam,prjPtr->descr,MAXPATH);
CS_erpt (cs_WKT_PRJSUPRT);
goto error;
}
/* Locate the datum definition, if there is one. We can't do anything
that isn't referenced to a datum. */
if (dt_def == NULL) /*lint !e774 */
{
/* The calling application did not provide a specific deatum definition.
We use the datum name in the Coordinate System definition to obtain
a definition fomr the dictionary. */
if (cs_def->dat_knm [0] == '\0')
{
/* Oops!!! No datum definition in the coordinate system definition.
If we were to output something special for a cartographic definition,
i.e. a coordinate system referenced directly to an ellipsoid, we
would do that here. */
CS_erpt (cs_NO_REFERNCE);
goto error;
}
dtDefPtr = CS_dtdef (cs_def->dat_knm);
if (dtDefPtr == NULL)
{
/* If the coordinate system definition came from the dictionary,
this shouldn't happen. If the application got the cs_Csdef_
data from somewhere else, it is possible. */
CS_erpt (cs_NO_REFERNCE);
goto error;
}
/* Capture the name of referenced datum which we will be using. */
CS_stncp (refDtmName,cs_def->dat_knm,sizeof (refDtmName));
/* I don't have to locate the ellipsoid, CSdt2WktEx will do that. */
status = CSdt2WktEx (datmWkt,sizeof (datmWkt),geoTranWkt,sizeof (geoTranWkt),flavor,dtDefPtr,0,flags);
CS_free (dtDefPtr);
dtDefPtr = 0;
}
else
{
CS_stncp (refDtmName,dt_def->key_nm,sizeof (refDtmName));
status = CSdt2WktEx (datmWkt,sizeof (datmWkt),geoTranWkt,sizeof (geoTranWkt),flavor,dt_def,el_def,flags);
}
if (status != 0)
{
/* CSdt2WktEx will have reported the nature of the error. */
goto error;
}
/* Deal with the quad/axis situation. */
geoAxis [0] = '\0';
prjAxis [0] = '\0';
if (cs_def->quad != 0 && cs_def->quad != 1)
{
if ((prjPtr->flags & cs_PRJFLG_GEOGR) != 0)
{
switch (cs_def->quad) {
default:
case 0:
case 1:
CS_stncp (geoAxis,",AXIS[\"Lon\",EAST],AXIS[\"Lat\",NORTH]",sizeof (prjAxis));
break;
case 2:
CS_stncp (geoAxis,",AXIS[\"Lon\",WEST],AXIS[\"Lat\",NORTH]",sizeof (prjAxis));
break;
case 3:
CS_stncp (geoAxis,",AXIS[\"Lon\",WEST],AXIS[\"Lat\",SOUTH]",sizeof (prjAxis));
break;
case 4:
CS_stncp (geoAxis,",AXIS[\"Lon\",EAST],AXIS[\"Lat\",SOUTH]",sizeof (prjAxis));
break;
case -1:
CS_stncp (geoAxis,",AXIS[\"Lat\",NORTH],AXIS[\"Lon\",EAST]",sizeof (prjAxis));
break;
case -2:
CS_stncp (geoAxis,",AXIS[\"Lat\",NORTH],AXIS[\"Lon\",WEST]",sizeof (prjAxis));
break;
case -3:
CS_stncp (geoAxis,",AXIS[\"Lat\",SOUTH],AXIS[\"Lon\",WEST]",sizeof (prjAxis));
break;
case -4:
CS_stncp (geoAxis,",AXIS[\"Lat\",SOUTH],AXIS[\"Lon\",EAST]",sizeof (prjAxis));
break;
}
}
else
{
switch (cs_def->quad) {
default:
case 0:
case 1:
CS_stncp (prjAxis,",AXIS[\"X\",EAST],AXIS[\"Y\",NORTH]",sizeof (prjAxis));
break;
case 2:
CS_stncp (prjAxis,",AXIS[\"X\",WEST],AXIS[\"Y\",NORTH]",sizeof (prjAxis));
break;
case 3:
CS_stncp (prjAxis,",AXIS[\"X\",WEST],AXIS[\"Y\",SOUTH]",sizeof (prjAxis));
break;
case 4:
CS_stncp (prjAxis,",AXIS[\"X\",EAST],AXIS[\"Y\",SOUTH]",sizeof (prjAxis));
break;
case -1:
CS_stncp (prjAxis,",AXIS[\"Y\",NORTH],AXIS[\"X\",EAST]",sizeof (prjAxis));
break;
case -2:
CS_stncp (prjAxis,",AXIS[\"Y\",NORTH],AXIS[\"X\",WEST]",sizeof (prjAxis));
break;
case -3:
CS_stncp (prjAxis,",AXIS[\"Y\",SOUTH],AXIS[\"X\",WEST]",sizeof (prjAxis));
break;
case -4:
CS_stncp (prjAxis,",AXIS[\"Y\",SOUTH],AXIS[\"X\",EAST]",sizeof (prjAxis));
break;
}
}
}
/* Locate the base. The base is what this coordinate system is referenced
to. For example, the definition of UTM27-13 defines how to get from
LL27 to UTM27-13. Therefore, LL27 is the base for that coordinate
system. */
if ((prjPtr->flags & cs_PRJFLG_GEOGR) != 0)
{
/* This is a geographic coordinate system, so the base name is whatever
the coordinate system name is. */
CS_stncp (baseName,cs_def->key_nm,sizeof (baseName));
}
else
{
/* Otherwise, basename is the name of a geographic coordinate system
referenced to the same datum as the projected coordinate system.
We have a function which will find this for us. If we don't
have one, we are in trouble. */
CSllCsFromDt (baseName,sizeof baseName,refDtmName);
if (!CS_csIsValid (baseName))
{
CS_stncp (csErrnam,cs_def->key_nm,MAXPATH);
CS_erpt (cs_WKT_NOLLBASE);
return -1;
}
}
/* Manufacture the prime meridian. */
CS_stncp (pmerWkt,"PRIMEM[\"Greenwich\",0]",sizeof (pmerWkt));
if ((prjPtr->flags & cs_PRJFLG_GEOGR) != 0 && cs_def->org_lng != 0.0)
{
int orgLng = (int)cs_def->org_lng;
switch (orgLng) {
case 0:
primeMer = 0.0;
CS_stncp (pmerWkt,"PRIMEM[\"Greenwich\",0]",sizeof (pmerWkt));
break;
case 2:
primeMer = 2.337229166666667;
CS_stncp (pmerWkt,"PRIMEM[\"Paris\",2.337229166666667]",sizeof (pmerWkt));
break;
case 9:
primeMer = 9.13190611111111;
CS_stncp (pmerWkt,"PRIMEM[\"Lisbon\",9.13190611111111]",sizeof (pmerWkt));
break;
case -17:
primeMer = -17.4;
CS_stncp (pmerWkt,"PRIMEM[\"Ferro\",-17.4]",sizeof (pmerWkt));
break;
case -74:
primeMer = -74.08175;
CS_stncp (pmerWkt,"PRIMEM[\"Bogota\",-74.08175]",sizeof (pmerWkt));
break;
default:
break;
}
}
/* We will always need the GEOGCS object. If this is a geographic
coordinate system definition, than that's all we'll need. If this is
a Projective coordinate system, the unit is the default for internal
coordinates within CS-MAP, namely the degree. Only if this is a
Geographic Coordinate system, is the actual unit of the definition
of importance to us here. */
kCp = CSmsiUnitName2WktName ("DEGREE",flavor);
if (kCp == 0 || *kCp == '\0')
{
kCp = "Degree";
}
sprintf (unitWkt,"UNIT[\"%s\",0.017453292519943295]",kCp);
if ((prjPtr->flags & cs_PRJFLG_GEOGR) != 0)
{
/* This is a geographic coordinate system, extract the unit information
from the definition. */
kCp = CSmsiUnitName2WktName (cs_def->unit,flavor);
if (kCp == 0)
{
/* Just in case the flavor does not define angular units... */
kCp = "Degree";
unitFactor = cs_Degree;
}
else
{
unitFactor = CS_unitlu (cs_UTYP_ANG,cs_def->unit) * cs_Degree;
}
sprintf (unitWkt,"UNIT[\"%s\",%.14f]",kCp,unitFactor);
}
/* If we are mapping names, the GCS name and the Datum name need to be
mapped, and then configured for the active flavor.
First, we do the default in case anything goes wrong in the mapping
process. */
sprintf (geogWkt,"GEOGCS[\"%s\",%s,%s,%s%s]",baseName,datmWkt,pmerWkt,unitWkt,geoAxis);
if ((flags & cs_WKTFLG_MAPNAMES) != 0)
{
CS_stncp (dtmName,baseName,sizeof (dtmName));
CS_stncp (gcsName,baseName,sizeof (gcsName));
if (flavor == wktFlvrEsri)
{
kCp = CS_msiDtmName2Esri (dt_def->key_nm,0);
if (kCp != 0)
{
if (*kCp != 'D' || *(kCp + 1) != '_')
{
CS_stcpy (dtmName,"D_");
CS_stncp (&dtmName [2],kCp,sizeof (dtmName) - 2);
CS_stcpy (gcsName,"GCS_");
CS_stncp (&gcsName [4],kCp,sizeof (gcsName) - 4);
}
else
{
CS_stncp (dtmName,kCp,sizeof (dtmName));
CS_stcpy (gcsName,"GCS_");
CS_stncp (&gcsName [4],kCp+2,sizeof (gcsName) - 4);
}
}
}
else if (flavor == wktFlvrOracle)
{
kCp = CS_msiDtmName2Oracle (dt_def->key_nm,0);
if (kCp != 0)
{
CS_stncp (dtmName,kCp,sizeof (dtmName));
if ((prjPtr->flags & cs_PRJFLG_GEOGR) != 0)
{
sprintf (gcsName,"Longitude / Latitude (%s)",kCp);
}
else
{
CS_stncp (gcsName,kCp,sizeof (gcsName));
}
}
}
sprintf (geogWkt,"GEOGCS[\"%s\",%s,%s,%s%s]",gcsName,datmWkt,pmerWkt,unitWkt,geoAxis);
}
if ((prjPtr->flags & cs_PRJFLG_GEOGR) != 0)
{
/* If this is a geographic coordinate system, we're done. */
CS_stncp (csWktBufr,geogWkt,(int)bufrSize);
}
else
{
/* We get here only if the coordinate system is of the projected type. */
/* Do the linear unit for the projWkt. */
unitFactor = CS_unitlu (cs_UTYP_LEN,cs_def->unit);
kCp = CSmsiUnitName2WktName (cs_def->unit,flavor);
if (kCp == 0 || *kCp == '\0')
{
CS_stncp (csErrnam,cs_def->unit,MAXPATH);
CS_erpt (cs_WKT_UNITMAP);
return -1;
}
sprintf (unitWkt,"UNIT[\"%s\",%.14f]",kCp,unitFactor);
prmNmFalseEasting = CSwktPrmEnum2Name (csWktPrmFalseEasting,flavor);
prmNmFalseNorthing = CSwktPrmEnum2Name (csWktPrmFalseNorthing,flavor);
prmNmScaleFactor = CSwktPrmEnum2Name (csWktPrmScaleAtCenter,flavor);
prmNmCentralMeridian = CSwktPrmEnum2Name (csWktPrmLongitudeOfOrg,flavor);
prmNmLatitudeOfOrigin = CSwktPrmEnum2Name (csWktPrmLatitudeOfOrg,flavor);
prmNmStandardParallel1 = CSwktPrmEnum2Name (csWktPrmStdParallel1,flavor);
prmNmStandardParallel2 = CSwktPrmEnum2Name (csWktPrmStdParallel2,flavor);
prmNmYAxisAzimuth = CSwktPrmEnum2Name (csWktPrmYaxisAzimuth,flavor);
prmNmAzimuth = CSwktPrmEnum2Name (csWktPrmAzimuth,flavor);
prmNmLongitudeOfCenter = CSwktPrmEnum2Name (csWktPrmLongitudeOfCtr,flavor);
prmNmLatitudeOfCenter = CSwktPrmEnum2Name (csWktPrmLatitudeOfCtr,flavor);
prmNmLongitudeOf1stPoint = CSwktPrmEnum2Name (csWktPrmLngFirstPoint,flavor);
prmNmLatitudeOf1stPoint = CSwktPrmEnum2Name (csWktPrmLatFirstPoint,flavor);
prmNmLongitudeOf2ndPoint = CSwktPrmEnum2Name (csWktPrmLngSecondPoint,flavor);
prmNmLatitudeOf2ndPoint = CSwktPrmEnum2Name (csWktPrmLatSecondPoint,flavor);
prmNmLatitudeOfStdParall = CSwktPrmEnum2Name (csWktPrmLatOfStdParall,flavor);
/* Build the projection and parameter portions of this thing. */
parmWkt [0] = '\0';
CS_stcpy (projection,prjNmPtr);
switch (prjCode) {
case cs_PRJCOD_TRMER:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.12f]",prmNmScaleFactor,cs_def->scl_red);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLatitudeOfOrigin,cs_def->org_lat);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_ALBER:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmStandardParallel1,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmStandardParallel2,cs_def->prj_prm2);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLatitudeOfOrigin,cs_def->org_lat);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->org_lng);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_MRCAT:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmStandardParallel1,cs_def->prj_prm2);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLatitudeOfOrigin,cs_def->org_lat);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_AZMED:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmYAxisAzimuth,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->org_lng);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLatitudeOfOrigin,cs_def->org_lat);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_PLYCN:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLatitudeOfOrigin,cs_def->org_lat);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_AZMEA:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->org_lng);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLatitudeOfOrigin,cs_def->org_lat);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmYAxisAzimuth,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_EDCNC:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmStandardParallel1,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmStandardParallel2,cs_def->prj_prm2);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLatitudeOfOrigin,cs_def->org_lat);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_MILLR:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLatitudeOfOrigin,cs_def->org_lat);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_NZLND:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLatitudeOfOrigin,cs_def->org_lat);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->org_lng);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_SINUS:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_EDCYL:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmStandardParallel1,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLatitudeOfOrigin,cs_def->org_lat);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_VDGRN:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_CSINI:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLatitudeOfOrigin,cs_def->org_lat);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_ROBIN:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_BONNE:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmStandardParallel1,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_EKRT4:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_EKRT6:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_MOLWD:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_PSTRO:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLatitudeOfOrigin,cs_def->org_lat);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.12f]",prmNmScaleFactor,cs_def->scl_red);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_PSTROSL:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLatitudeOfOrigin,cs_def->org_lat);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmStandardParallel1,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
/* Kludge time again. If the flavor is ESRI, we change the rpojection name based
on the origin latitude. Sorry about that, but this WKT stuff is maddening. */
if (flavor == wktFlvrEsri)
{
if (cs_def->org_lat < -89.0)
{
CS_stncp (projection,"Stereographic_South_Pole",sizeof (projection));
}
else if (cs_def->org_lat < -89.0)
{
CS_stncp (projection,"Stereographic_North_Pole",sizeof (projection));
}
}
break;
case cs_PRJCOD_OSTRO:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLatitudeOfOrigin,cs_def->org_lat);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->org_lng);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.12f]",prmNmScaleFactor,cs_def->scl_red);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_LM1SP:
case cs_PRJCOD_LMTAN:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.12f]",prmNmScaleFactor,cs_def->scl_red);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->org_lng);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLatitudeOfOrigin,cs_def->org_lat);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_LM2SP:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->org_lng);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLatitudeOfOrigin,cs_def->org_lat);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmStandardParallel1,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmStandardParallel2,cs_def->prj_prm2);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_UTM:
tmpDbl = 500000.00 / unitFactor;
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,tmpDbl);
strcat (parmWkt,cTemp);
tmpDbl = (cs_def->prj_prm2 >= 0.0) ? 0.0 : 10000000.0;
tmpDbl /= unitFactor;
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,tmpDbl);
strcat (parmWkt,cTemp);
tmpDbl = (double)(-183 + (6 * (int)cs_def->prj_prm1)); /*lint !e790 */
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,tmpDbl);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",0.9996]",prmNmScaleFactor);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",0.000]",prmNmLatitudeOfOrigin);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_TRMRS:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.12f]",prmNmScaleFactor,cs_def->scl_red);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLatitudeOfOrigin,cs_def->org_lat);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_HOM1XY:
case cs_PRJCOD_RSKEW:
case cs_PRJCOD_RSKEWC:
case cs_PRJCOD_RSKEWO:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.12f]",prmNmScaleFactor,cs_def->scl_red);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmAzimuth,cs_def->prj_prm3);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLongitudeOfCenter,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLatitudeOfCenter,cs_def->prj_prm2);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_HOM2XY:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.12f]",prmNmScaleFactor,cs_def->scl_red);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLongitudeOf1stPoint,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLatitudeOf1stPoint,cs_def->prj_prm2);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLongitudeOf2ndPoint,cs_def->prj_prm3);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLatitudeOf2ndPoint,cs_def->prj_prm4);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLatitudeOfCenter,cs_def->org_lat);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_GAUSSK:
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.12f]",prmNmScaleFactor,cs_def->scl_red);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmCentralMeridian,cs_def->prj_prm1);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLatitudeOfOrigin,cs_def->org_lat);
strcat (parmWkt,cTemp);
break;
case cs_PRJCOD_SWISS:
CS_stncp (projection,prjNmPtr,sizeof (projection));
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseEasting,cs_def->x_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.3f]",prmNmFalseNorthing,cs_def->y_off);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.12f]",prmNmScaleFactor,cs_One);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmAzimuth,cs_K90);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLongitudeOfCenter,cs_def->org_lng);
strcat (parmWkt,cTemp);
sprintf (cTemp,",PARAMETER[\"%s\",%.14f]",prmNmLatitudeOfCenter,cs_def->org_lat);
strcat (parmWkt,cTemp);
break;
} /*lint !e744 */
/* Need to determine the name we will assign to this definition. We
generate a default value which is used if anything else fails. */
CS_stncp (csysWktName,cs_def->key_nm,sizeof (csysWktName));
if ((flags & cs_WKTFLG_MAPNAMES) != 0)
{
if (flavor == wktFlvrEsri)
{
kCp = CS_msiName2Esri (cs_def->key_nm);
if (kCp != 0)
{
CS_stncp (csysWktName,kCp,sizeof (csysWktName));
}
}
else if (flavor == wktFlvrOracle)
{
kCp = CS_msiName2Oracle (cs_def->key_nm);
if (kCp != 0)
{
CS_stncp (csysWktName,kCp,sizeof (csysWktName));
}
}
}
/* Construct the final string. */
sprintf (projWkt,"PROJCS[\"%s\",%s,PROJECTION[\"%s\"]%s,%s%s]",csysWktName,geogWkt,projection,parmWkt,unitWkt,prjAxis);
CS_stncp (csWktBufr,projWkt,(int)bufrSize);
}
if (dtDefPtr != 0)
{
CS_free (dtDefPtr);
}
return 0;
error:
if (dtDefPtr != 0)
{
CS_free (dtDefPtr);
}
return -1;
}
int CS_csDiff (FILE *rptStrm,struct cs_Csdef_ *was,struct cs_Csdef_ *is)
{
extern struct cs_Prjtab_ cs_Prjtab []; /* Projection Table */
int flag = TRUE;
int errCnt = 0;
double okValue;
struct cs_Prjtab_ *pp;
char key_name [64];
if (strcmp (was->dat_knm,is->dat_knm))
{
fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Datum Key Name (dat_knm):\n was: %s\n is now: %s\n",was->dat_knm,is->dat_knm);
}
if (strcmp (was->elp_knm,is->elp_knm))
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Ellipsoid Key Name (elp_knm):\n was: %s\n is now: %s\n",was->elp_knm,is->elp_knm);
}
if (strcmp (was->prj_knm,is->prj_knm))
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Projection Key Name (prj_knm):\n was: %s\n is now: %s\n",was->prj_knm,is->prj_knm);
}
if (strcmp (was->group,is->group))
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Group (group):\n was: %s\n is now: %s\n",was->group,is->group);
}
if (strcmp (was->locatn,is->locatn))
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Group (group):\n was: %s\n is now: %s\n",was->locatn,is->locatn);
}
if (strcmp (was->cntry_st,is->cntry_st))
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Political Location (cntry_st):\n was: %s\n is now: %s\n",was->cntry_st,is->cntry_st);
}
if (strcmp (was->unit,is->unit))
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Unit (unit):\n was: %s\n is now: %s\n",was->unit,is->unit);
}
/* Look this projection up in the projection table, we need to pass the
projection code to the parameter check function. */
for (pp = cs_Prjtab;pp->key_nm [0] != '\0';pp += 1)
{
if (!CS_stricmp (was->prj_knm,pp->key_nm))
{
break;
}
}
if (pp->check == NULL)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
fprintf (rptStrm," %s has an invalid projection code name.",was->prj_knm);
}
else
{
/* Check all of the parameters. */
if (flag) CS_stcpy (key_name,was->key_nm);
else key_name [0] = '\0';
errCnt += CScmpPrjParm (rptStrm,key_name,pp, 1,was->prj_prm1 ,is->prj_prm1);
errCnt += CScmpPrjParm (rptStrm,key_name,pp, 2,was->prj_prm2 ,is->prj_prm2);
errCnt += CScmpPrjParm (rptStrm,key_name,pp, 3,was->prj_prm3 ,is->prj_prm3);
errCnt += CScmpPrjParm (rptStrm,key_name,pp, 4,was->prj_prm4 ,is->prj_prm4);
errCnt += CScmpPrjParm (rptStrm,key_name,pp, 5,was->prj_prm5 ,is->prj_prm5);
errCnt += CScmpPrjParm (rptStrm,key_name,pp, 6,was->prj_prm6 ,is->prj_prm6);
errCnt += CScmpPrjParm (rptStrm,key_name,pp, 7,was->prj_prm7 ,is->prj_prm7);
errCnt += CScmpPrjParm (rptStrm,key_name,pp, 8,was->prj_prm8 ,is->prj_prm8);
errCnt += CScmpPrjParm (rptStrm,key_name,pp, 9,was->prj_prm9 ,is->prj_prm9);
errCnt += CScmpPrjParm (rptStrm,key_name,pp,10,was->prj_prm10,is->prj_prm10);
errCnt += CScmpPrjParm (rptStrm,key_name,pp,11,was->prj_prm11,is->prj_prm11);
errCnt += CScmpPrjParm (rptStrm,key_name,pp,12,was->prj_prm12,is->prj_prm12);
errCnt += CScmpPrjParm (rptStrm,key_name,pp,13,was->prj_prm13,is->prj_prm13);
errCnt += CScmpPrjParm (rptStrm,key_name,pp,14,was->prj_prm14,is->prj_prm14);
errCnt += CScmpPrjParm (rptStrm,key_name,pp,15,was->prj_prm15,is->prj_prm15);
errCnt += CScmpPrjParm (rptStrm,key_name,pp,16,was->prj_prm16,is->prj_prm16);
errCnt += CScmpPrjParm (rptStrm,key_name,pp,17,was->prj_prm17,is->prj_prm17);
errCnt += CScmpPrjParm (rptStrm,key_name,pp,18,was->prj_prm18,is->prj_prm18);
errCnt += CScmpPrjParm (rptStrm,key_name,pp,19,was->prj_prm19,is->prj_prm19);
errCnt += CScmpPrjParm (rptStrm,key_name,pp,20,was->prj_prm20,is->prj_prm20);
errCnt += CScmpPrjParm (rptStrm,key_name,pp,21,was->prj_prm21,is->prj_prm21);
errCnt += CScmpPrjParm (rptStrm,key_name,pp,22,was->prj_prm22,is->prj_prm22);
errCnt += CScmpPrjParm (rptStrm,key_name,pp,23,was->prj_prm23,is->prj_prm23);
errCnt += CScmpPrjParm (rptStrm,key_name,pp,24,was->prj_prm24,is->prj_prm24);
}
okValue = 1.0E-09;
if (fabs (was->org_lng - is->org_lng) > okValue)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Origin Longitude (org_lng):\n was: %18.12f\n is now: %18.12f\n",was->org_lng,is->org_lng);
}
if (fabs (was->org_lat - is->org_lat) > okValue)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Origin Latitude (org_lat):\n was: %18.12f\n is now: %18.12f\n",was->org_lat,is->org_lat);
}
okValue = 1.0E-03;
if (fabs (was->x_off - is->x_off) > okValue)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," FALSE Easting (x_off):\n was: %16.6f\n is now: %16.6f\n",was->x_off,is->x_off);
}
if (fabs (was->y_off - is->y_off) > okValue)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," FALSE Northing (y_off):\n was: %16.6f\n is now: %16.6f\n",was->y_off,is->y_off);
}
okValue = 1.0E-09;
if (fabs (was->scl_red - is->scl_red) > okValue)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Scale Reduction (scl_red):\n was: %18.12f\n is now: %18.12f\n",was->scl_red,is->scl_red);
}
if (!CS_stricmp (was->prj_knm,"LL"))
{
okValue = 1.0E-09;
if (fabs (was->zero [0] - is->zero [0]) > okValue || fabs (was->zero [1] - is->zero [1]) > okValue)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Miinimum Non Zero (zero):\n was: %14.12f:%14.12f\n is now: %14.12f:%14.12f\n",was->zero [0],was->zero[1],is->zero [0],is->zero [1]);
}
}
else
{
okValue = 1.0E-03;
if (fabs (was->zero [0] - is->zero [0]) > okValue || fabs (was->zero [1] - is->zero [1]) > okValue)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Miinimum Non Zero (zero):\n was: %8.6f:%8.6f\n is now: %8.6f:%8.6f\n",was->zero [0],was->zero[1],is->zero [0],is->zero [1]);
}
}
okValue = 1.0E-09;
if (fabs (was->hgt_lng - is->hgt_lng) > okValue)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Height Longitude (hgt_lng):\n was: %18.12f\n is now: %18.12f\n",was->hgt_lng,is->hgt_lng);
}
if (fabs (was->hgt_lat - is->hgt_lat) > okValue)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Height Latitude (hgt_lat):\n was: %18.12f\n is now: %18.12f\n",was->hgt_lat,is->hgt_lat);
}
if (fabs (was->hgt_zz - is->hgt_zz) > okValue)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Height Elevation (hgt_zz):\n was: %12.6f\n is now: %12.6f\n",was->hgt_zz,is->hgt_zz);
}
if (fabs (was->geoid_sep - is->geoid_sep) > okValue)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Geoid Separation (geoid_sep):\n was: %12.6f\n is now: %12.6f\n",was->geoid_sep,is->geoid_sep);
}
okValue = 1.0E-08;
if (fabs (was->ll_min [0] - is->ll_min [0]) > okValue || fabs (was->ll_min [1] - is->ll_min [1]) > okValue)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Min Lat/Lng (ll_min):\n was: %14.8f:%14.8f\n is now: %14.8f:%14.8f\n",was->ll_min [0],was->ll_min[1],is->ll_min [0],is->ll_min [1]);
}
if (fabs (was->ll_max [0] - is->ll_max [0]) > okValue || fabs (was->ll_max [1] - is->ll_max [1]) > okValue)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Max Lat/Lng (ll_max):\n was: %14.8f:%14.8f\n is now: %14.8f:%14.8f\n",was->ll_max [0],was->ll_max[1],is->ll_max [0],is->ll_max [1]);
}
okValue = 1.0E-03;
if (fabs (was->xy_min [0] - is->xy_min [0]) > okValue || fabs (was->xy_min [1] - is->xy_min [1]) > okValue)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Min X/Y (xy_min):\n was: %14.4f:%14.4f\n is now: %14.4f:%14.4f\n",was->xy_min [0],was->xy_min[1],is->xy_min [0],is->xy_min [1]);
}
if (fabs (was->xy_max [0] - is->xy_max [0]) > okValue || fabs (was->xy_max [1] - is->xy_max [1]) > okValue)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Max X/Y (xy_max):\n was: %14.4f:%14.4f\n is now: %14.4f:%14.4f\n",was->xy_max [0],was->xy_max[1],is->xy_max [0],is->xy_max [1]);
}
if (strcmp (was->desc_nm,is->desc_nm))
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Descriptive Name (desc_nm):\n was: %s\n is now: %s\n",was->desc_nm,is->desc_nm);
}
if (strcmp (was->source,is->source))
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Source description (source):\n was: %s\n is now: %s\n",was->source,is->source);
}
if (was->quad != is->quad)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Quadrant (quad):\n was: %d\n is now: %d\n",was->quad,is->quad);
}
if (was->order != is->order)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Polynomial Order (order):\n was: %d\n is now: %d\n",was->order,is->order);
}
if (was->zones != is->zones)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Zone Count (zones):\n was: %d\n is now: %d\n",was->zones,is->zones);
}
if (was->protect != is->protect)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Protection Flag (protect):\n was: %d\n is now: %d\n",was->protect,is->protect);
}
if (was->epsg_qd != is->epsg_qd)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Automatic Geoid Flag (epsg_qd):\n was: %d\n is now: %d\n",was->epsg_qd,is->epsg_qd);
}
if (was->srid != is->srid)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," Elevation Technique (srid):\n was: %d\n is now: %d\n",was->srid,is->srid);
}
if (was->epsgNbr != is->epsgNbr)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," EPSG (epsgNbr):\n was: %d\n is now: %d\n",was->epsgNbr,is->epsgNbr);
}
if (was->wktFlvr != is->wktFlvr)
{
if (flag) fprintf (rptStrm,"\n%s has changed:\n",is->key_nm);
flag = FALSE;
errCnt += 1;
fprintf (rptStrm," WKT Flavor (wktFlvr):\n was: %d\n is now: %d\n",was->wktFlvr,is->wktFlvr);
}
return errCnt;
}
