/******************************************************************************
Destructor, for an "Entry" object.
*/
void CSdeleteNad27ToCsrsEntry (struct csNad27ToCsrsEntry_* __This)
{
if (__This != NULL)
{
switch (__This->type){
case dtNad27ToCsrsC2:
CSdeleteDatumShiftCa2 (__This->pointers.c2DatumPtr);
break;
case dtNad27ToCsrsXfrm:
if (__This->pointers.nad27ToCsrsViaXfrm != NULL)
{
if (__This->pointers.nad27ToCsrsViaXfrm->nad27ToAts77 != NULL)
{
CSn27a77Cls ();
__This->pointers.nad27ToCsrsViaXfrm->nad27ToAts77 = NULL;
}
if (__This->pointers.nad27ToCsrsViaXfrm->ats77ToCsrs != NULL)
{
CSats77Cls ();
__This->pointers.nad27ToCsrsViaXfrm->ats77ToCsrs = NULL;
}
CS_free (__This->pointers.nad27ToCsrsViaXfrm);
__This->pointers.nad27ToCsrsViaXfrm = NULL;
}
break;
case dtNad27ToCsrsNoneYet:
default:
break;
}
CS_free (__This);
}
return;
}
/*****************************************************************************
Destructor
*/
void CSdeleteGeoid99GridFile (struct csGeoid99GridFile_* __This)
{
if (__This != NULL)
{
if (__This->strm != NULL) CS_fclose (__This->strm);
if (__This->dataBuffer != NULL) CS_free (__This->dataBuffer);
CS_free (__This);
}
}
/* Destructor */
void CSdeleteGridFileCa2 (struct csGridFileCa2_* __This)
{
if (__This != NULL)
{
if (__This->Stream != NULL) CS_fclose (__This->Stream);
if (__This->SubGridDir != NULL) CS_free (__This->SubGridDir);
CS_free (__This);
}
}
/* Destructor */
void CSdeleteNTv2 (struct cs_NTv2_* thisPtr)
{
if (thisPtr != NULL)
{
if (thisPtr->fileImage != NULL) CS_free (thisPtr->fileImage);
if (thisPtr->SubGridDir != NULL) CS_free (thisPtr->SubGridDir);
CS_free (thisPtr);
}
}
/******************************************************************************
Destructor
*/
void CSdeleteRgf93ToNtf (struct csRgf93ToNtf_* __This)
{
struct csRgf93ToNtfEntry_ *dtEntryPtr;
if (__This != NULL)
{
if (__This->fallback != NULL)
{
CSdeleteFallback (__This->fallback);
__This->fallback = NULL;
}
if (__This->cachePtr != NULL)
{
CSdeleteLLGridCellCache (__This->cachePtr);
__This->cachePtr = NULL;
}
while (__This->listHead != NULL)
{
dtEntryPtr = __This->listHead;
__This->listHead = __This->listHead->next;
CSdeleteRgf93ToNtfEntry (dtEntryPtr);
}
CS_free (__This);
}
return;
}
/******************************************************************************
Constructor
*/
struct csGeoidHeight_* CSnewGeoidHeight (Const char *catalog)
{
int index;
struct csGeoidHeight_ *__This;
struct csDatumCatalog_ *catPtr;
struct csDatumCatalogEntry_ *catEntryPtr;
struct csGeoidHeightEntry_* ghEntryPtr;
struct csGeoidHeightEntry_* findPtr;
/* Prepare for an error. */
__This = NULL;
catPtr = NULL;
catEntryPtr = NULL;
ghEntryPtr = NULL;
__This = (struct csGeoidHeight_*) CS_malc (sizeof (struct csGeoidHeight_));
if (__This == NULL)
{
CS_erpt (cs_NO_MEM);
goto error;
}
__This->listHead = NULL;
/* Open the catalog file. */
catPtr = CSnewDatumCatalog (catalog);
if (catPtr == NULL) goto error;
/* For each entry in the catalog, we build an appropriate geoid height
grid file entry. Right now, this is based on file names and file
extensions. Not very good, but that's life. */
index = 0;
for (;;)
{
catEntryPtr = CSgetDatumCatalogEntry (catPtr,index++);
if (catEntryPtr == NULL) break;
ghEntryPtr = CSnewGeoidHeightEntry (catEntryPtr);
if (ghEntryPtr == NULL)
{
goto error;
}
/* Keep the list in the same order as they appear in the file. */
if (__This->listHead == NULL)
{
__This->listHead = ghEntryPtr;
}
else
{
for (findPtr = __This->listHead;findPtr->next != NULL;findPtr = findPtr->next);
findPtr->next = ghEntryPtr;
}
}
CSdeleteDatumCatalog (catPtr);
catPtr = NULL;
return __This;
error:
if (catPtr != NULL) CSdeleteDatumCatalog (catPtr);
if (__This != NULL) CS_free (__This);
return NULL;
}
char * EXP_LVL1 CS_eldflt (Const char *dflt_el)
{
extern char csElDflt [];
struct cs_Eldef_ *elp;
CS_stncp (previous,csElDflt,sizeof (previous));
if (dflt_el == NULL)
{
return (previous);
}
if (*dflt_el == '\0')
{
csElDflt [0] = '\0';
return (previous);
}
elp = CS_eldef (dflt_el);
if (elp == NULL)
{
return (NULL);
}
CS_free (elp);
CS_stncp (csElDflt,dflt_el,cs_KEYNM_DEF);
return (previous);
}
double EXP_LVL9 CSkrovkCsMapParam (double e_rad,double e_sq,double orgLng,double stdLat,double epsgParm)
{
extern double cs_Zero;
extern double cs_Half; /* 0.5 */
extern double cs_One; /* 1.0 */
extern double cs_Two;
extern double cs_Pi_o_4; /* pi over 4 */
extern double cs_Pi_o_2; /* pi over 2 */
extern double cs_Degree;
extern double cs_Radian;
struct cs_Gauss_ *gauss;
double csMapParm;
double latS;
double ellipsoidal [2];
double gaussian [2];
csMapParm = cs_Zero;
gauss = CSgaussS (e_rad,e_sq,orgLng,stdLat);
if (gauss != 0)
{
gaussian [LNG] = orgLng;
latS = cs_Pi_o_2 - (epsgParm * cs_Degree);
gaussian [LAT] = latS * cs_Radian;
CSgaussI (gauss,ellipsoidal,gaussian);
csMapParm = ellipsoidal [LAT];
CS_free (gauss);
}
return csMapParm;
}
/*****************************************************************************
Release resources
*/
void CSreleaseGeoid99GridFile (struct csGeoid99GridFile_* __This)
{
if (__This != NULL)
{
/* Close the file and release the buffer. Leave the file size,
buffer size, coverage information, and other stuff intact.
The only purpose here is to release allocated resources. */
/* Free and invalidate the buffer, if there is one. */
if (__This->dataBuffer != NULL)
{
CS_free (__This->dataBuffer);
}
__This->dataBuffer = NULL;
__This->bufferBeginPosition = -1L;
__This->bufferEndPosition = -2L;
/* Close the file (if open). */
if (__This->strm != NULL)
{
CS_fclose (__This->strm);
}
__This->strm = NULL;
}
return;
}
double EXP_LVL9 CSkrovkEpsgParam (double e_rad,double e_sq,double orgLng,double stdLat,double csMapParm)
{
extern double cs_Zero;
extern double cs_Half; /* 0.5 */
extern double cs_One; /* 1.0 */
extern double cs_Two;
extern double cs_Pi_o_4; /* pi over 4 */
extern double cs_Pi_o_2; /* pi over 2 */
extern double cs_Degree;
extern double cs_Radian;
struct cs_Gauss_ *gauss;
double epsgParm;
double latE;
double ellipsoidal [2];
double gaussian [2];
epsgParm = cs_Zero;
gauss = CSgaussS (e_rad,e_sq,orgLng,stdLat);
if (gauss != 0)
{
ellipsoidal [LNG] = orgLng;
ellipsoidal [LAT] = csMapParm;
CSgaussF (gauss,gaussian,ellipsoidal);
latE = gaussian [LAT] * cs_Degree;
epsgParm = (cs_Pi_o_2 - latE) * cs_Radian;
CS_free (gauss);
}
return epsgParm;
}
/******************************************************************************
Destructor: for the "Entry" sub-object.
*/
void CSdeleteGeoidHeightEntry (struct csGeoidHeightEntry_* __This)
{
if (__This != NULL)
{
switch (__This->type){
case csGeoidHgtTypeGeoid96:
CSdeleteGeoid96GridFile (__This->pointers.geoid96Ptr);
break;
case csGeoidHgtTypeGeoid99:
CSdeleteGeoid99GridFile (__This->pointers.geoid99Ptr);
break;
case csGeoidHgtTypeOsgm91:
CSdeleteOsgm91 (__This->pointers.osgm91Ptr);
break;
case csGeoidHgtTypeBynGridFile:
CSdeleteBynGridFile (__This->pointers.bynGridFilePtr);
break;
case csGeoidHgtTypeEgm96:
CSdeleteEgm96 (__This->pointers.egm96Ptr);
break;
case csGeoidHgtTypeWorld:
case csGeoidHgtTypeAustralia:
case csGeoidHgtTypeNone:
default:
break;
}
CS_free (__This);
}
return;
}
char * EXP_LVL1 CS_dtdflt (Const char *dflt_dt)
{
extern char csDtDflt [];
struct cs_Dtdef_ *dtp;
CS_stncp (previous,csDtDflt,sizeof (previous));
if (dflt_dt == NULL)
{
return (previous);
}
if (*dflt_dt == '\0')
{
csDtDflt [0] = '\0';
return (previous);
}
/* Verify the value provided is a valid datum name. */
dtp = CS_dtdef (dflt_dt);
if (dtp == NULL)
{
return (NULL);
}
CS_free (dtp);
CS_stncp (csDtDflt,dflt_dt,cs_KEYNM_DEF);
return (previous);
}
void CelSelect::ShowDetails ()
{
double flat;
struct cs_Eldef_ *elPtr;
elPtr = CS_eldef (m_KeyName);
if (elPtr == NULL)
{
char errMesg [256];
CS_errmsg (errMesg,sizeof (errMesg));
AfxMessageBox (errMesg);
return;
}
flat = 0.0;
if (fabs (elPtr->flat) > 1.0E-10) flat = 1.0 / elPtr->flat;
m_Description = elPtr->name;
m_Source = elPtr->source;
m_Numbers.Format ("%12.3f, %12.3f, %10.5f, %10.8f",
elPtr->e_rad,
elPtr->p_rad,
flat,
elPtr->ecent * elPtr->ecent);
CS_free (elPtr);
UpdateData (FALSE);
return;
}
/* Destructor */
void CSdeleteDatumShiftCa1 (struct csDatumShiftCa1_* __This)
{
if (__This != NULL)
{
if (__This->gridPtr != NULL) CSdeleteGridFileCa1 (__This->gridPtr);
CS_free (__This);
}
}
/* The equivalent of a destructor follows. */
void CSdeleteJgd2kGridFile (struct cs_Japan_ *thisPtr)
{
if (thisPtr != NULL)
{
if (thisPtr->strm != NULL)
{
CS_fclose (thisPtr->strm);
thisPtr->strm = NULL;
}
if (thisPtr->dataBuffer != NULL)
{
CS_free (thisPtr->dataBuffer);
thisPtr->dataBuffer = NULL;
}
CS_free (thisPtr);
}
return;
}
/* Release allocated resources without losing existence information.
object can still be used. */
void CSreleaseNTv2 (struct cs_NTv2_* thisPtr)
{
if (thisPtr != NULL)
{
if (thisPtr->fileImage != NULL)
{
CS_free(thisPtr->fileImage); thisPtr->fileImage = NULL;
}
}
}
/******************************************************************************
Destructor (for an 'Entry' sub object)
*/
void CSdeleteVertconUSEntry (struct csVertconUSEntry_* __This)
{
if (__This != NULL)
{
if (__This->usGridPtr != NULL)
{
CSdeleteGridFileUS (__This->usGridPtr);
}
CS_free (__This);
}
return;
}
int EXP_LVL1 CS_cs2WktEx (char *bufr,size_t bufrSize,const char *csKeyName,int flavor,unsigned short flags)
{
int rtnValue = -1;
struct cs_Dtdef_ *dtDefPtr = 0;
struct cs_Eldef_ *elDefPtr = 0;
struct cs_Csdef_ *csDefPtr = 0;
if (bufrSize > 0)
{
*bufr = '\0';
csDefPtr = CS_csdef (csKeyName);
if (csDefPtr != 0)
{
if (csDefPtr->dat_knm [0] == '\0')
{
CS_erpt (cs_WKT_NODTREF);
}
else
{
dtDefPtr = CS_dtdef (csDefPtr->dat_knm);
if (dtDefPtr != 0)
{
elDefPtr = CS_eldef (dtDefPtr->ell_knm);
if (elDefPtr != 0)
{
rtnValue = CScs2WktEx (bufr,bufrSize,flavor,csDefPtr,dtDefPtr,elDefPtr,flags); /*lint !e64 */
CS_free (elDefPtr);
elDefPtr = 0;
}
CS_free (dtDefPtr);
dtDefPtr = 0;
}
}
CS_free (csDefPtr);
csDefPtr = 0;
}
}
return rtnValue;
}
void CdtSelect::ShowDetails ()
{
int ii, ident;
struct cs_Dtdef_ *dtPtr;
struct cs_Eldef_ *elPtr;
char description [64];
dtPtr = CS_dtdef (m_KeyName);
if (dtPtr == NULL)
{
char errMesg [256];
CS_errmsg (errMesg,sizeof (errMesg));
AfxMessageBox (errMesg);
return;
}
m_Description = dtPtr->name;
m_Source = dtPtr->source;
elPtr = CS_eldef (dtPtr->ell_knm);
if (elPtr == NULL) m_Ellipsoid = "???";
else
{
m_Ellipsoid = elPtr->name;
CS_free (elPtr);
}
m_Technique = "???";
for (ii = 0;
CS_viaEnum (ii,description,sizeof (description),&ident) > 0;
ii += 1)
{
if (dtPtr->to84_via == ident)
{
m_Technique = description;
break;
}
}
CS_free (dtPtr);
UpdateData (FALSE);
return;
}
void CdtSelect::ShowDetails ()
{
int ii, ident;
struct cs_Dtdef_ *dtPtr;
struct cs_Eldef_ *elPtr;
TCHAR description [64];
dtPtr = CSt_dtdef (m_KeyName);
if (dtPtr == NULL)
{
TCHAR errMesg [256];
CSt_errmsg (errMesg,tchrCount (errMesg));
AfxMessageBox (errMesg);
return;
}
CSt_cstringAssign (m_Description,dtPtr->name);
CSt_cstringAssign (m_Source,dtPtr->source);
elPtr = CS_eldef (dtPtr->ell_knm);
if (elPtr == NULL) m_Ellipsoid = _T("???");
else
{
CSt_cstringAssign (m_Ellipsoid,elPtr->name);
CS_free (elPtr);
}
m_Technique = _T("???");
for (ii = 0;
CSt_viaEnum (ii,description,tchrCount (description),&ident) > 0;
ii += 1)
{
if (dtPtr->to84_via == ident)
{
m_Technique = description;
break;
}
}
CS_free (dtPtr);
UpdateData (FALSE);
return;
}
/**********************************************************************
The following function releases all resources acquired by the
functions defined in this module.
**********************************************************************/
int EXP_LVL1 CS_mgrsSetUp (const char* ellipsoid,short bessel)
{
extern struct cs_Mgrs_ *cs_MgrsPtr;
if (cs_MgrsPtr != NULL)
{
CS_free (cs_MgrsPtr);
cs_MgrsPtr = NULL;
}
cs_MgrsPtr = CSnewMgrsE (ellipsoid,bessel);
return (cs_MgrsPtr == NULL) ? -1 : 0;
}
/******************************************************************************
Destructor, for an "Entry" object.
*/
void CSdeleteEd50ToEtrf89Entry (struct csEd50ToEtrf89Entry_* __This)
{
if (__This != NULL)
{
switch (__This->type){
case dtEd50ToEtrf89C2:
CSdeleteDatumShiftCa2 (__This->pointers.c2DatumPtr);
break;
case dtEd50ToEtrf89NoneYet:
default:
break;
}
CS_free (__This);
}
return;
}
/******************************************************************************
Destructor
*/
void CSdeleteGeoidHeight (struct csGeoidHeight_* __This)
{
struct csGeoidHeightEntry_ *ghEntryPtr;
if (__This != NULL)
{
while (__This->listHead != NULL)
{
ghEntryPtr = __This->listHead;
__This->listHead = __This->listHead->next;
CSdeleteGeoidHeightEntry (ghEntryPtr);
}
CS_free (__This);
}
return;
}
/******************************************************************************
Destructor, for an "Entry" object.
*/
void CSdeleteAts77ToCsrsEntry (struct csAts77ToCsrsEntry_* __This)
{
if (__This != NULL)
{
switch (__This->type){
case dtAts77ToCsrsC2:
CSdeleteDatumShiftCa2 (__This->pointers.c2DatumPtr);
break;
case dtAts77ToCsrsNoneYet:
default:
break;
}
CS_free (__This);
}
return;
}
/**********************************************************************
** st = CS_eldel (eldef);
**
** struct cs_Eldef_ *eldef; a pointer to the ellipsoid definition
** structure which is to be deleted from the
** Ellipsoid Dictionary.
** int st; returns a zero if the delete was successfully
** completed, else returns -1.
**
**********************************************************************/
int EXP_LVL3 CS_eldel (struct cs_Eldef_ *eldef)
{
extern char *cs_ElKeyNames;
int deletionStatus = CS_elDelete(eldef);
if (deletionStatus)
return deletionStatus;
/* cs_ElKeyNames is a memory array which contains all of the existing ellipsoid key names.
Since we're going to change this, we free up the in memory list to
force a regeneration of same next time its use is required. This
regeneration will not have this name in it if our addition completes
successfully. */
CS_free(cs_ElKeyNames);
cs_ElKeyNames = NULL;
return deletionStatus;
}
int EXP_LVL1 CS_el2WktEx (char *bufr,size_t bufrSize,const char *elKeyName,int flavor,unsigned short flags)
{
int rtnValue = -1;
struct cs_Eldef_ *elDefPtr = 0;
if (bufrSize > 0)
{
*bufr = '\0';
elDefPtr = CS_eldef (elKeyName);
if (elDefPtr != 0)
{
rtnValue = CSel2WktEx (bufr,bufrSize,flavor,elDefPtr,flags);
CS_free (elDefPtr);
elDefPtr = 0;
}
}
return rtnValue;
}
int EXP_LVL1 CS_el2Wkt (char *bufr,size_t bufrSize,const char *elKeyName,int flavor)
{
int rtnValue = -1;
struct cs_Eldef_ *elDefPtr = 0;
if (bufrSize > 0)
{
*bufr = '\0';
elDefPtr = CS_eldef (elKeyName);
if (elDefPtr != 0)
{
rtnValue = CSel2Wkt (bufr,bufrSize,(ErcWktFlavor)flavor,elDefPtr);
CS_free (elDefPtr);
elDefPtr = 0;
}
}
return rtnValue;
}
/******************************************************************************
Destructor, for an "Entry" object.
*/
void CSdeleteRgf93ToNtfEntry (struct csRgf93ToNtfEntry_* __This)
{
if (__This != NULL)
{
switch (__This->type) {
case dtRgf93ToNtfTxt:
CSdeleteRgf93ToNtfTxt (__This->pointers.txtDatumPtr);
break;
case dtRgf93ToNtfC2:
CSdeleteDatumShiftCa2 (__This->pointers.c2DatumPtr);
break;
case dtRgf93ToNtfNone:
default:
break;
}
CS_free (__This);
}
return;
}
/******************************************************************************
Destructor
*/
void CSdeleteVertconUS (struct csVertconUS_* __This)
{
struct csVertconUSEntry_ *vcEntryPtr;
if (__This != NULL)
{
if (__This->cachePtr != NULL)
{
CSdeleteZGridCellCache (__This->cachePtr);
__This->cachePtr = NULL;
}
while (__This->listHead != NULL)
{
vcEntryPtr = __This->listHead;
__This->listHead = __This->listHead->next;
CSdeleteVertconUSEntry (vcEntryPtr);
}
CS_free (__This);
}
return;
}
/******************************************************************************
Constructor */
struct csDatumShiftCa1_* CSnewDatumShiftCa1 (Const char *path,long bufferSize,unsigned long flags,double density)
{
struct csDatumShiftCa1_ *__This = NULL;
__This = (struct csDatumShiftCa1_ *)CS_malc (sizeof (struct csDatumShiftCa1_));
if (__This == NULL)
{
CS_erpt (cs_NO_MEM);
goto error;
}
__This->gridPtr = NULL;
__This->gridPtr = CSnewGridFileCa1 (path,bufferSize,flags,density);
if (__This->gridPtr == NULL) goto error;
return __This;
error:
if (__This != NULL)
{
if (__This->gridPtr != NULL) CSdeleteGridFileCa1 (__This->gridPtr);
CS_free (__This);
}
return NULL;
}
