void grdnav_init()
{
int ier, iret, nitm;
char buf[255], subst[255], *cpos;
FILE *fp;
nav_list *q;
if ( ( fp = cfl_tbop ( "grdnav.tbl", "grid", &ier) ) != NULL ) {
while ( ier == 0 ) {
cfl_trln ( fp, sizeof(buf), buf, &ier);
if ( ( ier == 0 ) && ( ( q = (nav_list *)malloc( sizeof(nav_list) ) ) != NULL ) ) {
cpos = cst_split( buf, ' ', sizeof(subst)-1, subst, &iret);
if ( iret == 0 ) {
cst_ncpy(q->id,subst,sizeof(q->id)-1, &iret);
cst_ldsp(cpos, cpos, &nitm, &iret);
}
cpos = cst_split( cpos, ' ', sizeof(subst)-1, subst, &iret);
if ( ( iret == 0 ) && ( cpos != NULL ) ) {
iret = sscanf(subst,"%d",&(q->gnum));
cst_ldsp(cpos, cpos, &nitm, &iret);
}
else {
free(q);
continue;
}
cpos = cst_split( cpos, ' ', sizeof(subst)-1, subst, &iret);
if ( ( iret == 0 ) && ( cpos != NULL ) ) {
cst_ncpy(q->proj,subst,sizeof(q->proj)-1, &iret);
cst_ldsp(cpos, cpos, &nitm, &iret);
}
else {
free(q);
continue;
}
iret = sscanf(cpos,"%f %f %f %f %f %f %f %d %d",
&(q->angle[0]), &(q->angle[1]), &(q->angle[2]),
&(q->llt), &(q->lln), &(q->ult), &(q->uln),
&(q->kx), &(q->ky) );
if ( iret == 9 ) {
q->next = nav_head;
nav_head = q;
}
else {
free(q);
}
}
}
}
}
void mainw_setIconName ( char* iconName )
/************************************************************************
* mainw_setIconName *
* *
* This function sets the toplevel icon name. *
* *
* void mainw_setIconName(iconName) *
* *
* Input parameters: *
* iconName char* proposed icon name *
* *
* Output parameters: *
* Return parameters: *
* NONE *
* *
** *
* Log: *
* H. Zeng/SAIC 09/04 initial coding *
* E. Safford/SAIC 07/07 use defined COMPONENT_LEN *
***********************************************************************/
{
static char icon_name[ COMPONENT_LEN ];
int ier;
/*---------------------------------------------------------------------*/
if ( _topLevel != NULL ) {
cst_ncpy ( icon_name, iconName, 120, &ier );
XtVaSetValues( _topLevel, XmNiconName, icon_name, NULL);
}
}
void utl_ctim ( int len, char *curtim, int *iret )
/************************************************************************
* utl_ctim *
* *
* This function retrieves the current system time and converts it to *
* a character string of the form DDHHMM. *
* *
* utl_ctim ( len, curtim, iret ) *
* *
* Input parameters: *
* *
* len int Max length of 'curtim' *
* Output parameters: *
* *curtim char Current time as DDHHMM *
* *iret int Return Code *
* *
** *
* Log: *
* A. Hardy/NCEP 5/03 From VFCTIM *
* B. Yin/SAIC 3/04 changed css_date calling sequences *
***********************************************************************/
{
char dattim[7], zone[4];
int itype, iyr, imon, idy, ihr, imin, isc, julian, ier;
/*-------------------------------------------------------------------*/
*iret = 0;
itype = 1;
curtim[0] = '\0';
/*
* Get current system time for UTC issue time of cancel product.
*/
css_date ( &itype, &iyr, &imon, &idy, &ihr, &imin, &isc, &julian,
zone, iret);
if ( (idy >= 1) && (idy <= 9 ) ) {
cst_ncpy( curtim, "0", 1, &ier);
}
cst_inch ( idy, dattim, iret);
cst_ncat (curtim, dattim, &len, iret);
if ( (ihr >= 0) && (ihr <= 9 ) ) {
cst_ncat( curtim, "0", &len, iret);
}
cst_inch ( ihr, dattim, iret );
cst_ncat (curtim, dattim, &len, iret);
if ( (imin >= 0) && (imin <= 9 ) ) {
cst_ncat( curtim, "0", &len, iret);
}
cst_inch ( imin, dattim, iret );
cst_ncat (curtim, dattim, &len, iret);
}
void wbc_mzrm ( char *states, char *ststr, int *len1, int *iret )
/************************************************************************
* wbc_mzrm *
* *
* This function removes the specific marine zones listed above from *
* the state id string. *
* *
* wbc_mzrm ( states, len1, len2, stzstr, sttstr, iret ) *
* *
* Input parameters: *
* *states char String of state ids *
* *
* Output parameters: *
* *ststr char States id string; no Mar. Zones *
* *len1 int Length of ststr *
* *iret int Return Code *
* *
** *
* Log: *
* A. Hardy/NCEP 5/03 *
* A. Hardy/NCEP 9/04 Added "SL" *
* T. Piper/SAIC 02/05 Removed unused variable 'stnam' *
***********************************************************************/
{
int ii, ier, ilen, ipos;
/*-------------------------------------------------------------------*/
*iret = 0;
ier = 0;
ststr[0] = '\0';
/*
* Remove unwanted marine zones listed above from state strings.
*/
ii = 0;
while ( ( ii < NUM_ZNS ) ) {
cst_rmst ( states, _mzones[ii], &ipos, states, &ier);
if ( ipos > 0 ) {
cst_rxbl ( states, states, &ilen, &ier);
}
ii++;
}
cst_lstr ( states, &ilen, &ier );
cst_ncpy ( ststr, states, ilen, &ier );
}
void gb2_ctim ( int time, char *param )
/************************************************************************
* gb2_ctim *
* *
* This routine replaces the "--" characters in a GEMPAK parameter *
* string with the number specified in variable time. *
* *
* gb2_ctim ( time, param ) *
* *
* Input parameters: *
* time int Integer time range *
* *
* Input/Output parameters: *
* *param char GEMPAK parameter string *
** *
* Log: *
* S. Gilbert 12/04 *
* T. Piper/SAIC 07/06 Replaced strncpy with cst_ncpy *
***********************************************************************/
{
int ier, len;
char ctim[12], dash[]="--", *cptr;
/*
** Convert integer to character
*/
if ( time != IMISSD )
if ( time >= 0 && time < 10 )
sprintf ( ctim, "%.2d", time);
else
cst_inch ( time, ctim, &ier);
else
cst_ncpy(ctim, "XX", 2, &ier);
/*
** replace "--" or append time character in parameter string.
*/
cptr = strstr( param, dash);
if ( cptr != 0 )
cst_rpst( param, dash, ctim, param, &ier);
else
if ( time > 0 ) cst_ncat( param, ctim, &len, &ier);
}
void utl_gmon ( int dtmonth, char *pmm, int *iret )
/************************************************************************
* utl_gmon *
* *
* This function converts the numerical value of a month into the three *
* character abbreviation for the month. *
* *
* utl_gmon ( dtmonth, pmm, iret ) *
* *
* Input parameters: *
* dtmonth int Month *
* *
* Output parameters: *
* *pmm char 3-character month name *
* *iret int Return code *
* -6 = Bad month number *
** *
* Log: *
* A. Hardy/NCEP 7/03 *
* A. Hardy/NCEP 8/03 Changed length check 4 -> 3 *
***********************************************************************/
{
int len1, lenp, ier;
char noname[12][4] = { "JAN", "FEB", "MAR", "APR", "MAY",
"JUN", "JUL", "AUG", "SEP", "OCT",
"NOV", "DEC" };
/*---------------------------------------------------------------------*/
*iret = 0;
lenp = 4;
pmm[0] = '\0';
/*
* Retrieve the 3 character month.
*/
if ( dtmonth >= 1 && dtmonth <= 12 ) {
len1 = G_MIN ( lenp, 3 );
cst_ncpy ( pmm, noname[dtmonth-1], len1, &ier);
}
else {
*iret = -6;
return;
}
}
void de_mbr1 ( const int *k, const char *infl, char *outfl, int *iret )
/************************************************************************
* de_mbr1 *
* *
* This subroutine parses a GDFILE entry to find and handle ensemble *
* specifications. It is called from DG_NFIL. The routine turns an *
* ensemble entry into a single entry that DG_NFIL can handle. *
* *
* de_mbr1 ( k, infl, outfl, iret ) *
* *
* Input parameters: *
* *k const int GDFILE entry position number *
* *infl const char Input file entry *
* *
* Output parameters: *
* *outfl char* Output file replaces INFL *
* *iret int Return code *
* 0 = normal return *
* -2 = grid file or template not *
* exist *
* *
* Log: *
* T. Lee/SAIC 12/04 *
* T. Lee/SAIC 06/05 Parsed weight value *
* R. Tian/SAIC 12/05 Translated from Fortran *
* m.gamazaychikov/SAIC 04/06 Added idtmch flag to CTB_DTGET CS *
* T. Piper/SAIC 04/07 Modified for cfl_scnt CSC *
* F. J. Yen/NCEP 4/08 Added bin mins & mstrct to CTB_DTGET CSC*
* S. Jacobs/NCEP 12/11 Fixed check if there is no table entry *
* returned by ctb_dtget *
***********************************************************************/
{
int index, nfarr, ic, is, iff, ir, ii, ino, ihb, mnb, iha, mna,
mstrct, idtmch, nfile, istar, last, len, ier;
long lens;
char lsv[MXFLSZ], newfil[MXFLSZ], filnam[MXFLSZ], cycle[DTTMSZ],
path[MXFLSZ], tmplt[MXFLSZ], dum[DTTMSZ], rplc[DTTMSZ], membr[17];
char *opnptr, *clsptr, *starp, *ptr, **farr, *def = " ";
struct dirent **dnlist=NULL;
/*----------------------------------------------------------------------*/
*iret = 0;
outfl[0] = '\0';
/*
* Check if INFL contains a curly-bracket enclosed ensemble spec.
* If not, the first entry is not an ensemble grid. Do nothing.
*/
opnptr = strchr ( infl, '{' );
if ( ! opnptr ) {
strcpy ( outfl, infl );
return;
}
/*
* Save the string between curly brackets to ensspc (k). Get
* the first element of the file(s).
*/
cst_opcl ( infl, opnptr, &clsptr, &ier );
if ( ier != 0 ) {
*iret = -2;
return;
}
for ( index = 0, ptr = opnptr + 1; ptr < clsptr; index++, ptr++ ) {
_ensdiag.ensspc[*k-1][index] = *ptr;
}
_ensdiag.ensspc[*k-1][index] = '\0';
clsptr = strchr ( _ensdiag.ensspc[*k-1], ',' );
if ( ! clsptr ) {
strcpy ( lsv, _ensdiag.ensspc[*k-1] );
} else {
for ( index = 0, ptr = _ensdiag.ensspc[*k-1];
ptr < clsptr; index++, ptr++ ) {
lsv[index] = *ptr;
}
lsv[index] = '\0';
}
/*
* If file name is not an alias, do nothing.
*/
cfl_inqr ( lsv, NULL, &lens, newfil, &ier );
if ( ier == 0 ) {
strcpy ( outfl, lsv );
return;
}
/*
* Get the template. If the template does not end with "*",
* do nothing.
*/
farr = (char **)cmm_malloc2d ( 2, MXFLSZ, sizeof(char), &ier );
if ( strchr ( lsv, '%' ) ) {
cst_clst ( lsv, '%', def, 2, MXFLSZ, farr, &nfarr, &ier );
strcpy ( lsv, farr[1] );
}
cst_clst ( lsv, '|', def, 2, MXFLSZ, farr, &nfarr, &ier );
strcpy ( filnam, farr[0] );
strcpy ( cycle, farr[1] );
cmm_free2d ( (void **)farr, &ier );
ctb_dtget ( filnam, path, tmplt, &ic, &is, &iff, &ir, &ii, &ino,
&ihb, &mnb, &iha, &mna, &mstrct, &idtmch, &ier );
if ( ier != 0 ) {
strcpy ( outfl, lsv );
return;
}
else {
starp = strchr ( tmplt, '*' );
istar = (int)( starp - tmplt );
if ( ! starp ) {
strcpy ( outfl, lsv );
return;
}
}
/*
* If the template contains an "*", then it is an ensemble with
* multiple members. The last member is the one sought.
*/
if ( strcmp ( cycle, def ) != 0 ) {
cti_stan ( cycle, "YYMMDD/HHNN", dum, &ier );
if ( strstr ( tmplt, "YYYYMMDD" ) ) {
strcpy ( rplc, "YY" );
strncat ( rplc, dum, 6 );
rplc[8] = '\0';
cst_rpst ( tmplt, "YYYYMMDD", rplc, tmplt, &ier );
} else {
strncpy ( rplc, dum, 6 );
rplc[6] = '\0';
cst_rpst ( tmplt, "YYMMDD", rplc, tmplt, &ier );
}
strncpy ( rplc, &dum[7], 2 );
rplc[2] = '\0';
cst_rpst ( tmplt, "HH", rplc, tmplt, &ier );
}
/*
* Retrieve the last member of the ensemble alias.
*/
cfl_scnt ( path, tmplt, -1, &dnlist, &nfile, &ier );
if ( nfile == 0 ) {
*iret = -2;
er_wmsg ( "DE", iret, " ", &ier, strlen("DE"), strlen(" ") );
return;
}
strcpy ( newfil, dnlist[0]->d_name );
for (ii=0;ii<nfile;ii++){
free(dnlist[ii]);
}
if ( dnlist != NULL ) free(dnlist);
/*
* Replace "*" in the template with member names. Note
* that "*" may be embedded in the template.
*/
if ( *(starp+1) == '\0' ) {
last = G_TRUE;
} else {
last = G_FALSE;
}
if ( last == G_TRUE ) {
strcpy ( membr, &newfil[istar] );
} else {
len = strlen ( newfil ) - strlen ( tmplt ) + 1;
cst_ncpy ( membr, &newfil[istar], len, &ier );
}
/*
* Recombine the alias and last member with the cycle.
*/
strcpy ( outfl, filnam );
strcat ( outfl, ":" );
strcat ( outfl, membr );
if ( strcmp ( cycle, def ) != 0 ) {
strcat ( outfl, "|" );
strcat ( outfl, cycle );
}
return;
}
void srchw_fosdMarkrep ( srchinfo_t *srch_info, char *text_rep,
char *srch_str, int called_from, int *iret )
/************************************************************************
* srchw_fosdMarkrep *
* *
* This routine will search for the search string of each report and *
* the beginning position and save that position in a structure. *
* *
* srchw_fosdMarkrep (srch_info, text_rep, srch_str, called_from, iret) *
* *
* Input parameters: *
* *srch_info srchinfo_t Search structure *
* *text_rep char file contents *
* *srch_str char search string *
* called_from int Indicate from where it is called*
* 1 - from user click *
* 2 - from auto-update *
* *
* Output parameters: *
* *iret int Return code *
** *
* Log: *
* D.Plummer/NCEP 12/95 Reorganize for fosd type W *
* L.Williams/EAI 6/96 Check for duplicate reports *
* R.Tian/SAIC 1/02 Avoid possible overflow buf *
* R. Tian/SAIC 11/03 Added called_from arg *
* E. Safford/SAIC 12/07 rm direct access to textW widget *
***********************************************************************/
{
char *str, t_str[15];
char buf[REPMAX];
int ibeg, ipos;
int flag;
int replen;
int index, ier;
char notfound_msg[80];
char exceeds_msg[80];
struct data_file_info *file_info;
struct directory_info *dir_info;
/* ------------------------------------------------------------------- */
ipos=0;
flag=0;
file_info = &(srch_info->file_info);
dir_info = &(srch_info->dir_info);
ibeg = file_info->file_len - 1;
_cache[0] = '\0';
while ( ( ipos >= 0 ) && ( *iret == 0 ) ) {
/*
* Locate the starting position of each report
*/
cst_srch( ibeg, 0, srch_str, text_rep,
&ipos, iret );
/*
* Copy report into a temporary buffer
*/
replen = G_MIN((ibeg - ipos), (REPMAX - 1));
strncpy(buf, &text_rep[ipos], (size_t)replen);
buf[replen] = '\0';
/*
* Advance to the correct line
*/
str = strtok(buf, DELMTR);
if ( str != NULL ) {
str = strtok(NULL, DELMTR);
str = strtok(NULL, DELMTR);
}
if ( str ) {
str = strtok(str, " ");
/*
* Get the station and the WMO id
*/
while ( str ) {
if ( isalpha(str[0]) ) {
if ( flag == 0 ) {
strcpy(t_str, str);
flag = 1;
}
else {
if ( repnum < MAX_REPORTS ) {
sprintf(reportInfo[repnum].stnid, " %s ", str);
index = srchw_binSrch( stnList.srchstr, stnList.nstn,
reportInfo[repnum].stnid );
if( index >= 0 ) {
if( strncmp( _cache, &(text_rep[ipos+CACHE_POS]), 30 ) != 0 ) {
reportInfo[repnum].stnindex = index;
reportInfo[repnum].position = ipos;
sprintf(reportInfo[repnum].fname, "%s/%s",
dir_info->dirpath,
dir_info->filnam[srch_info->dir_info.cfilnum] );
repnum++;
cst_ncpy( _cache, &(text_rep[ipos+CACHE_POS]), 30, iret );
}
}
else {
sprintf( notfound_msg,
"PRODUCT STATION \"%s\" not found in table.\n",
reportInfo[repnum].stnid );
if ( called_from == 1 ) {
pdata_setReportText( notfound_msg, &ier );
txtw_dsplyReport( &ier );
}
reportInfo[repnum].stnid[0] = '\0';
}
}
else {
sprintf( exceeds_msg,
"Report limit reached (%d) -- "
"Reduce Time Covered.\n",
MAX_REPORTS );
if ( called_from == 1 ) {
pdata_setReportText( exceeds_msg, &ier );
txtw_dsplyReport( &ier );
}
}
}
}
else {
flag = 0;
break;
}
str = strtok(NULL, " ");
}
}
ibeg = --ipos;
}
stnList.nreports = repnum;
}
void nsf_gtim ( int index, dttms_t endtim, int mrange, int intrvl,
Boolean jflag, int *idelrt, int *ntime,
dttms_t timarr[], int *iret )
/************************************************************************
* nsf_gtim *
* *
* This routine returns an array of times for the requested SFC data. *
* *
* nsf_gtim ( index, endtim, mrange, intrvl, jflag, idelrt, ntime, *
* timarr, iret ) *
* *
* Input parameters: *
* index int Index to attribute arrays *
* endtim dttms_t End time of range *
* mrange int Minutes in time range *
* intrvl int Minutes in time interval *
* jflag Boolean Reference time flag *
* *
* Input and output parameters: *
* *
* *idelrt int Minutes in delta reference time *
* *
* Output parameters: *
* *ntime int Number of times in array *
* timarr[ntime] dttms_t Array of times *
* *iret int Return code *
* As for NIM_TLST *
* *
** *
* S. Jacobs/NCEP 6/99 Created *
* S. Law/GSC 06/00 MAXSFC -> MAXTMPLT *
* R. Curtis/EAI 10/00 Changed MXTIME to MXNMFL *
* T. Lee/SAIC 08/03 Added time interval to calling sequence *
* T. Lee/SAIC 01/04 Added reference time flag *
* T. Lee/SAIC 04/04 Added delta reference time *
***********************************************************************/
{
int iflag, nt, lenstr, ipos1, ipos2, ier, ierr;
char timstr[MXNMFL*20];
/*---------------------------------------------------------------------*/
*iret = 0;
/*
* Check for a valid index value.
*/
if ( index < 0 || index >= MAXTMPLT ) {
*iret = -1;
return;
}
/*
* Clear the output string.
*/
memset ( timstr, 0, sizeof(timstr) );
/*
* Given the image type and info, get a list of the MAXTIM latest
* times in a single string, separated by semi colons.
*/
iflag = (int) jflag;
nsf_tlst ( sfcdt[index].alias, sfcdt[index].cycle,
&(sfcdt[index].isbcat), endtim, &mrange, &intrvl,
&iflag, idelrt, timstr, &lenstr, &nt, iret,
strlen ( sfcdt[index].alias ),
strlen ( sfcdt[index].cycle ),
strlen ( endtim ), sizeof ( timstr ) );
/*
* If there is an error, set the number of times to 0 and return.
*/
if ( *iret != 0 ) {
*ntime = 0;
return;
}
/*
* Add a NULL to the end of the string of times.
*/
timstr[lenstr] = CHNULL;
/*
* Parse the string of times into an array of times.
*/
ierr = 0;
*ntime = 1;
ipos1 = 0;
while ( ierr == 0 ) {
/*
* Find the next semi colon.
*/
cst_nocc ( timstr, ';', *ntime, 1, &ipos2, &ierr );
if ( ierr != 0 ) ipos2 = strlen(timstr) + 1;
/*
* Copy the time into the array.
*/
cst_ncpy ( timarr[*ntime-1], &timstr[ipos1],
ipos2-ipos1, &ier );
/*
* Update the string position counter.
*/
ipos1 = ipos2 + 1;
/*
* If there is no error, increment the time counter.
*/
if ( ierr == 0 ) (*ntime)++;
}
}
void gdmakewmo ( GDG2_input *input, GDG2_gemgrid *gemgrid, char *chdr,
int *iret )
/************************************************************************
* gdmakewmo *
* *
* This routine generates a WMO Header from user input parameter WMOHDR *
* and gempak grid date/time info, if necessary. *
* *
* Usage: *
* gdmakewmo( input, gemgrid, chdr, iret ) *
* *
* Input Arguments: *
* *input GDG2_input input structure for GDGRIB2 *
* *gemgrid GDG2_gemgrid grid and Gempak info *
* *
* Output Arguments: *
* *chdr char WMO Header *
* *iret int Error return code. *
* 0 = Normal *
** *
* Log: *
* S. Gilbert/NCEP 8/05 Orig *
* S. Gilbert/NCEP 8/05 Changed string manipulations *
* S. Jacobs/NCEP 2/11 Replaced strncpy with cst_ncpy *
***********************************************************************/
{
int ret, num, j, ier2;
int numparts = 3;
char cparts[numparts][LLMXLN], *plist[numparts], *cdef="\0";
/*
* Separate WMO Header parts from user input
*/
for ( j=0; j<numparts; j++) plist[j] = cparts[j];
cst_clst( input->wmohdr, '/', cdef, numparts, LLMXLN, plist, &num, &ret);
/*
* Set first six characters of WMO Header
*/
if ( strlen( plist[0] ) == (size_t)6 ) {
cst_ncpy( chdr, plist[0], 6, &ret );
}
else {
*iret = -9;
strcpy( chdr, cdef );
return;
}
/*
* Insert space after first six characters of WMO Header
*/
strcat( chdr, " " );
/*
* Set originating center identifier.
*/
if ( strlen( plist[1] ) == (size_t)4 ) {
strcat( chdr, plist[1] );
}
else {
strcat( chdr, "KWBC" );
}
/*
* Insert space after originating center identifier.
*/
strcat( chdr, " " );
/*
* Set Date/Time group
*/
if ( strlen( plist[2] ) == (size_t)6 ) {
strcat( chdr, plist[2] );
}
else {
cst_ncpy ( chdr+12, gemgrid->ctime[0]+4, 2, &ier2 );
cst_ncpy ( chdr+14, gemgrid->ctime[0]+7, 4, &ier2 );
}
/*
* Add CR-CR-LF
*/
chdr[18] = CHCR;
chdr[19] = CHCR;
chdr[20] = CHLF;
chdr[21] = CHNULL;
return;
}
void vfwsaw ( int *iret )
/************************************************************************
* vfwsaw *
* *
* This program opens, creates and closes the Weather Watch SAW text *
* product file. *
* *
* vfwsaw ( iret ) *
* *
* Input parameters: *
* *
* Output parameters: *
* *iret int Return Code *
* *
** *
* Log: *
* A. Hardy/GSC 8/99 Created *
* M. Li/GSC 10/99 Modified output format *
* A. Hardy/GSC 11/99 Added replacement watch information *
* A. Hardy/GSC 2/00 Extracted from SPCTXT *
* A. Hardy/GSC 3/00 Add check for listing replacement states*
* A. Hardy/GSC 5/00 Changed cfl_aopn to cfl_wopn; Use *
* AWIPS/WMO header ids.; removed 'NNNN' *
* A. Hardy/GSC 10/00 Added ck for '0' dist. anchor/vor points*
* A. Hardy/GSC 12/00 Removed '&' from iret *
* A. Hardy/SAIC 10/01 Added check for old/new WMO header flag *
* R. Tian/SAIC 06/02 Modified to meet the SPC requirement *
* R. Tian/SAIC 04/03 Corrected if(iret == 0) syntax error *
* A. Hardy/NCEP 6/03 Change hail size to string for decimals *
* A. Hardy/NCEP 10/03 Modified to use utl/wbc libraries and *
* added 'TEST' if a test watch *
* A. Hardy/NCEP 3/04 Added wbc_mzrm *
* G. Grosshans/SPC 10/04 Added ADD_WATCH_APPROX check *
* G. Grosshans/SPC 11/05 Added LATLON_SAW_FORMAT tag to turn *
* off lat-lon info at bottom of product. *
* S. Jacobs/NCEP 11/05 Fixed array indices for ilat and ilon *
* T. Piper/SAIC 12/05 Updated for cst_wrap CSC *
* J. Wu/SAIC 04/06 Added parameter in cst_wrap *
***********************************************************************/
{
FILE *ifpsaw;
char blank[2]={' '}, ifname[256], wtch_type[20];
char cname1[32], cname2[32], sep[5], cpstates[256], states[256];
char newname[132], tmpsaw[500], hwmstr[500];
char prefs_tag[] = "LATLON_SAW_FORMAT";
float xx, yy;
int ii, jj, ier, len, ilat[4], ilon[4];
Boolean useln;
/*-------------------------------------------------------------------*/
ier = 0;
/*
* Create output file for appending.
*/
utl_gname ( spcinfo.ancrpt.stn1, spcinfo.ancrpt.stnnam1,
spcinfo.ancrpt.stateid1, &ier );
utl_gname ( spcinfo.ancrpt.stn2, spcinfo.ancrpt.stnnam2,
spcinfo.ancrpt.stateid2, &ier );
sprintf ( ifname, "WW%04d.SAW", spcinfo.wnum );
ifpsaw = cfl_wopn ( ifname, &ier );
/*
* Set up header information.
*/
if ( strcmp(spcinfo.wtype,"SEVERE THUNDERSTORM" ) == 0 )
strcpy ( wtch_type, "SEVERE TSTM");
if ( strcmp(spcinfo.wtype,"TORNADO" ) == 0 )
strcpy ( wtch_type, "TORNADO");
spcinfo.sssnum = spcinfo.wnum % 10;
fprintf ( ifpsaw, "WWUS30 KWNS %02d%s\n",
spcinfo.itime.day,spcinfo.itime.hour);
fprintf ( ifpsaw, "SAW%d \n", spcinfo.sssnum);
fprintf ( ifpsaw, "%cSPC AWW %02d%s\n", CHRS,
spcinfo.itime.day,spcinfo.itime.hour);
/*
* Replace underscores in the county names with a space.
*/
cst_rnan ( spcinfo.ancrpt.stnnam1, cname1, &ier );
cst_rnan ( spcinfo.ancrpt.stnnam2, cname2, &ier );
/*
* Check if watch has been issued as a 'TEST'.
*/
if ( strcmp (spcinfo.status, "TEST") == 0 ) {
fprintf ( ifpsaw, "WW %d TEST ", spcinfo.wnum);
}
else {
fprintf ( ifpsaw, "WW %d ", spcinfo.wnum);
}
/*
* Check for the marine zones which aren't the Great Lakes or
* coastal water (CW). Remove them, if found.
*/
strcpy (cpstates, spcinfo.states);
wbc_mzrm ( cpstates, states, &len, &ier );
/*
* Set up rest of section.
*/
fprintf ( ifpsaw, "%s %s %02d%sZ - %02d%sZ\n",
wtch_type, states, spcinfo.vtime.day,
spcinfo.vtime.hour, spcinfo.etime.day, spcinfo.etime.hour );
fprintf ( ifpsaw, "AXIS..%d STATUTE MILES %s OF LINE..\n",
spcinfo.ancatt.dist, spcinfo.ancatt.dirc );
/*
* Check for zero distance for anchor points.
*/
if ( (spcinfo.ancrpt.dist1 != 0 ) && ( spcinfo.ancrpt.dist2 != 0 ) ) {
fprintf ( ifpsaw, "%d%s %s/%s %s/ - %d%s %s/%s %s/\n",
spcinfo.ancrpt.dist1, spcinfo.ancrpt.dirct1, spcinfo.ancrpt.stn1,
cname1, spcinfo.ancrpt.stateid1,
spcinfo.ancrpt.dist2, spcinfo.ancrpt.dirct2, spcinfo.ancrpt.stn2,
cname2, spcinfo.ancrpt.stateid2);
}
else if ( ( spcinfo.ancrpt.dist1 == 0 ) && ( spcinfo.ancrpt.dist2 != 0 ) ) {
fprintf ( ifpsaw, "%s/%s %s/ - %d%s %s/%s %s/\n",
spcinfo.ancrpt.stn1, cname1, spcinfo.ancrpt.stateid1,
spcinfo.ancrpt.dist2, spcinfo.ancrpt.dirct2, spcinfo.ancrpt.stn2,
cname2, spcinfo.ancrpt.stateid2);
}
else if ( ( spcinfo.ancrpt.dist1 != 0 ) && ( spcinfo.ancrpt.dist2 == 0 ) ) {
fprintf ( ifpsaw, "%d%s %s/%s %s/ - %s/%s %s/\n",
spcinfo.ancrpt.dist1, spcinfo.ancrpt.dirct1, spcinfo.ancrpt.stn1,
cname1, spcinfo.ancrpt.stateid1, spcinfo.ancrpt.stn2,
cname2, spcinfo.ancrpt.stateid2);
}
else if ( ( spcinfo.ancrpt.dist1 == 0 ) && ( spcinfo.ancrpt.dist2 == 0 ) ) {
fprintf ( ifpsaw, "%s/%s %s/ - %s/%s %s/\n",
spcinfo.ancrpt.stn1, cname1, spcinfo.ancrpt.stateid1,
spcinfo.ancrpt.stn2, cname2, spcinfo.ancrpt.stateid2);
}
/*
* Check for zero distance for the vor points.
*/
if ( (spcinfo.vorrpt.dist1 != 0 ) && ( spcinfo.vorrpt.dist2 != 0 ) ) {
fprintf ( ifpsaw, "..AVIATION COORDS.. %dNM %s /%d%s %s - %d%s %s/\n",
spcinfo.voratt.dist, spcinfo.voratt.dirc,
spcinfo.vorrpt.dist1, spcinfo.vorrpt.dirct1, spcinfo.vorrpt.stn1,
spcinfo.vorrpt.dist2, spcinfo.vorrpt.dirct2, spcinfo.vorrpt.stn2);
}
else if ( (spcinfo.vorrpt.dist1 == 0 ) && ( spcinfo.vorrpt.dist2 != 0 ) ) {
fprintf ( ifpsaw, "..AVIATION COORDS.. %dNM %s /%s - %d%s %s/\n",
spcinfo.voratt.dist, spcinfo.voratt.dirc, spcinfo.vorrpt.stn1,
spcinfo.vorrpt.dist2, spcinfo.vorrpt.dirct2, spcinfo.vorrpt.stn2);
}
else if ( (spcinfo.vorrpt.dist1 != 0 ) && ( spcinfo.vorrpt.dist2 == 0 ) ) {
fprintf ( ifpsaw, "..AVIATION COORDS.. %dNM %s /%d%s %s - %s/\n",
spcinfo.voratt.dist, spcinfo.voratt.dirc, spcinfo.vorrpt.dist1,
spcinfo.vorrpt.dirct1, spcinfo.vorrpt.stn1, spcinfo.vorrpt.stn2);
}
else if ( (spcinfo.vorrpt.dist1 == 0 ) && ( spcinfo.vorrpt.dist2 == 0 ) ) {
fprintf ( ifpsaw, "..AVIATION COORDS.. %dNM %s /%s - %s/\n",
spcinfo.voratt.dist, spcinfo.voratt.dirc,
spcinfo.vorrpt.stn1, spcinfo.vorrpt.stn2);
}
/*
* Set up hail, wind gusts and lightning section.
*/
tmpsaw[0] = '\0';
cst_ncpy ( sep, "TO", 2, &ier );
len = sizeof(hwmstr);
wbc_dhwm ( sep, &(spcinfo.hailsz), &(spcinfo.maxgust),
&(spcinfo.maxtops), &(spcinfo.motion.deg),
&(spcinfo.motion.speed), len, hwmstr, &ier );
tmpsaw[0] = '\0';
strcat ( tmpsaw, hwmstr);
strcat ( tmpsaw, EOL );
cst_wrap ( tmpsaw, blank, &len, EOL, (char *)NULL, tmpsaw, &ier );
fprintf ( ifpsaw, tmpsaw);
/*
* If there are replacement watches listed, retrieve the lists of states
* for each replacement watch.
*/
if ( strcmp ( spcinfo.replcnm[0], "NONE") != 0 ) {
strcpy ( newname, "ww");
strcat ( newname, spcinfo.replcnm[0] );
strcat ( newname, ".txt" );
strcpy ( newinfo.file_info.filnam,newname);
vfrptxt (newname, iret);
if ( *iret == 0 ){
wbc_mzrm ( newinfo.states, states, &len, &ier );
fprintf ( ifpsaw, "\nREPLACES WW %d..%s \n",
atoi(spcinfo.replcnm[0]), states);
}
else {
fprintf ( ifpsaw, " WW %d.. \n",
atoi (spcinfo.replcnm[0]) );
}
/*
* If there are more that 1 replacement watches listed,
* proceed with the loop.
*/
for(jj = 1; jj <= spcinfo.wwrepnm; jj++) {
strcpy ( newname, "ww");
strcat ( newname, spcinfo.replcnm[jj] );
strcat ( newname, ".txt" );
strcpy ( newinfo.file_info.filnam,newname);
vfrptxt (newname, iret);
if ( *iret == 0 ){
wbc_mzrm ( newinfo.states, states, &len, &ier );
fprintf ( ifpsaw, "REPLACES WW %d..%s \n",
atoi (spcinfo.replcnm[jj]), states);
}
else {
fprintf ( ifpsaw, " WW %d.. \n",
atoi (spcinfo.replcnm[jj]) );
}
}
fprintf ( ifpsaw, "\n");
}
else {
fprintf ( ifpsaw, "\n");
}
/*
* Check if the LATLON_SAW_FORMAT flag is TRUE and then
* add enhanced lat-lon data to the SAW text.
* Make sure lats and lons are rounded to
* 100ths of deg.
*/
tmpsaw[0] = '\0';
ctb_pfbool (prefs_tag, &useln, &ier );
if ( useln == TRUE ) {
for ( ii = 0 ; ii < 4 ; ii++ ) {
switch ( ii ) {
case 0:
xx = ((int)(spcinfo.wcpnt1.lat*100.0F)) / 100.0F;
yy = ((int)(spcinfo.wcpnt1.lon*-100.0F)) / 100.0F;
break;
case 1:
xx = ((int)(spcinfo.wcpnt2.lat*100.0F)) / 100.0F;
yy = ((int)(spcinfo.wcpnt2.lon*-100.0F)) / 100.0F;
break;
case 2:
xx = ((int)(spcinfo.wcpnt3.lat*100.0F)) / 100.0F;
yy = ((int)(spcinfo.wcpnt3.lon*-100.0F)) / 100.0F;
break;
case 3:
xx = ((int)(spcinfo.wcpnt4.lat*100.0F)) / 100.0F;
yy = ((int)(spcinfo.wcpnt4.lon*-100.0F)) / 100.0F;
break;
default:
break;
}
if ( yy >= 100.0F ) yy = yy - 100.0F;
ilat[ii] = G_NINT(xx*100.0F);
ilon[ii] = G_NINT(yy*100.0F);
}
fprintf ( ifpsaw, "LAT...LON %4d%04d %4d%04d %4d%04d %4d%04d\n\n",
ilat[0], ilon[0],
ilat[1], ilon[1],
ilat[2], ilon[2],
ilat[3], ilon[3]);
}
/*
* Check if the approximation verbage needs to be included
* in the SAW text.
*/
tmpsaw[0] = '\0';
strcpy (prefs_tag, "ADD_WATCH_APPROX");
ctb_pfbool (prefs_tag, &useln, &ier );
if ( useln == TRUE ) {
tmpsaw[0] = '\0';
fprintf(ifpsaw, "THIS IS AN APPROXIMATION TO THE WATCH AREA. FOR A\n");
fprintf(ifpsaw, "COMPLETE DEPICTION OF THE WATCH SEE WOUS64 KWNS\n");
fprintf(ifpsaw, "FOR WOU%d.\n", spcinfo.sssnum);
fprintf(ifpsaw, "\n");
}
/*
* Close output file.
*/
cfl_clos ( ifpsaw, &ier );
}
void im_icmn ( int *hv, int *iret )
/************************************************************************
* im_icmn *
* *
* This subroutine sets some information in the image common header. *
* *
* im_icmn ( hv, iret ) *
* *
* Input parameters: *
* *hv int Pointer to first header variable*
* *
* Output parameters: *
* *iret int Return code *
* 0 = normal return *
** *
* Log: *
* D.W.Plummer/NCEP 6/04 From xsicmn *
* T. Piper/SAIC 09/07 Replaced strncpy with cst_ncpy. *
***********************************************************************/
{
int ier;
char *cptr;
/*---------------------------------------------------------------------*/
*iret = G_NORMAL;
/*
* Set variables - order is important here.
* Follow the order in the imgdef.h file.
*/
imftyp = *hv++ ;
imbank = *hv++ ;
imdoff = *hv++ ;
imldat = *hv++ ;
imnpix = *hv++ ;
imnlin = *hv++ ;
imdpth = *hv++ ;
rmxres = *(float *) hv++ ;
rmyres = *(float *) hv++ ;
imleft = *hv++ ;
imtop = *hv++ ;
imrght = *hv++ ;
imbot = *hv++ ;
rmxysc = *(float *) hv++ ;
imbswp = *hv++ ;
imnchl = *hv++ ;
imprsz = *hv++ ;
imdcsz = *hv++ ;
imclsz = *hv++ ;
imlvsz = *hv++ ;
imvald = *hv++ ;
imrdfl = *hv++ ;
immnpx = *hv++ ;
immxpx = *hv++ ;
imsorc = *hv++ ;
imtype = *hv++ ;
imradf = *hv++ ;
rmbelv = *(float *) hv++ ;
immode = *hv++ ;
imdate = *hv++ ;
imtime = *hv++ ;
cptr = (char *)hv;
cst_ncpy ( cmsorc, cptr, 20, &ier );
cptr += 20;
cst_ncpy ( cmtype, cptr, 8, &ier );
cptr += 8;
cst_ncpy ( cmstyp, cptr, 4, &ier );
cptr += 4;
cst_ncpy ( cmcalb, cptr, 4, &ier );
cptr += 4;
}
void ngd_gnms ( char *alias, int *nname, nmlst_t namarr[], int *iret )
/************************************************************************
* ngd_gnms *
* *
* This routine returns an array of storm or volcano names for the *
* requested GRID data. *
* *
* ngd_gnms ( alias, nname, namarr, iret ) *
* *
* Input parameters: *
* *alias char Data type alias name *
* *
* Output parameters: *
* *nname int Number of names in array *
* namarr[nname] nmlst_t Array of names *
* *iret int Return code *
* As for NGD_NLST *
* *
** *
* S. Jacobs/NCEP 3/01 Created *
***********************************************************************/
{
int lenstr, ipos1, ipos2, ier, ierr;
char namstr[MXNMFL*MXFLSZ];
/*---------------------------------------------------------------------*/
*iret = 0;
/*
* Given the grid data type, get the list of names from the
* file names.
*/
ngd_nlst ( alias, namstr, &lenstr, iret,
strlen ( alias ), sizeof ( namstr ) );
/*
* If there is an error, set the number of names to 0 and return.
*/
if ( *iret != 0 ) {
*nname = 0;
return;
}
/*
* Add a NULL to the end of the string of names.
*/
namstr[lenstr] = CHNULL;
/*
* Parse the string of names into an array of names.
*/
ierr = 0;
*nname = 1;
ipos1 = 0;
while ( ierr == 0 ) {
/*
* Find the next semi colon.
*/
cst_nocc ( namstr, ';', *nname, 1, &ipos2, &ierr );
if ( ierr != 0 ) ipos2 = strlen(namstr) + 1;
/*
* Copy the name into the array.
*/
cst_ncpy ( namarr[*nname-1], &namstr[ipos1],
ipos2-ipos1, &ier );
/*
* Update the string position counter.
*/
ipos1 = ipos2 + 1;
/*
* If there is no error, increment the name counter.
*/
if ( ierr == 0 ) (*nname)++;
}
}
void css_envr ( const char *filnam, char *file, int *iret )
/************************************************************************
* css_envr *
* *
* This routine checks filnam for an environment variable. If one is *
* found, it is replaced with the actual path name. The new expanded *
* file name is returned. Environment variables are identified by names*
* beginning with $ and ending with a /. *
* *
* This routine only checks for environmental variables at the beginning*
* of 'filnam', not embedded within the string. Additionally, the *
* environmental variable must be immediately followed by a '/' and *
* the remainder of the full path filename. The environmental variable *
* may not be surrounded by braces, i.e., '{}'. The old VAX syntax is *
* supported, in that the leading '$' may be omitted and the *
* environmental variable followed by a colon ':' in which case the '/' *
* may be omitted. *
* *
* To summarize, if an environmental variable is used in a filename the *
* filname must be in one of the following formats: *
* *
* $ENV/dir1/dir2/.../dirN/file *
* ENV:dir1/dir2/.../dirN/file *
* *
* css_envr ( filnam, file, iret ) *
* *
* Input parameters: *
* *filnam const char User input file name *
* *
* Output parameters: *
* *file char Expanded file name *
* *iret int Return code *
* 2 = Symbol not found *
** *
* Log: *
* S. Jacobs/NMC 6/94 *
* L. Williams/EAI 7/94 Reformat header *
* S. Jacobs/NMC 7/94 Fixed bug with getenv *
* G. Krueger/EAI 3/96 ANSI, always return a file name *
* R. Tian/SAIC 10/04 Handle '~' in file name *
* D.W.Plummer/NCEP 10/06 Add colon processing (VAX syntax) *
* T. Piper/SAIC 03/07 Fixed '~/' case, put result in file *
***********************************************************************/
{
char symbol[133], filtmp[73], usernm[73], *cptr;
int ipos, ier;
size_t ii, jj;
struct passwd *pw;
/*---------------------------------------------------------------------*/
*iret = 0;
file[0] = '\0';
symbol[0] = '\0';
filtmp[0] = '\0';
strcpy ( file, filnam );
/*
* Handle '~' in file name.
*/
if ( filnam[0] == '~' ) {
if ( filnam[1] == '/' ) {
/*
* '~/user'.
*/
cst_rpst ( filnam, "~", "$HOME", file, &ier );
} else {
/*
* '~user'.
*/
cst_nocc ( filnam, '/', 1, 0, &ipos, &ier );
if ( ier == 0 ) {
cst_ncpy ( usernm, &filnam[1], ipos-1, &ier );
} else if ( ier == -5 ) {
ipos = strlen ( filnam );
strcpy ( usernm, &filnam[1] );
}
pw = getpwnam ( usernm );
if ( pw ) {
strcpy ( file, pw->pw_dir );
strcat ( file, &filnam[ipos] );
} else {
*iret = 2;
return;
}
}
}
/*
* Find the part of the name which is an environmental variable.
* Translate the variable to a path name.
*/
else if ( filnam[0] == '$' ) {
ii = 1;
while ( ( ii < strlen(filnam)+1 ) && ( filnam[ii] != '/' ) ) {
symbol[ii-1] = filnam[ii];
symbol[ii] = '\0';
ii++;
}
jj = ii;
while ( jj < strlen(filnam)+1 ) {
filtmp[jj-ii] = filnam[jj];
jj++;
}
if ( getenv ( symbol ) != NULL ) {
strcpy ( file, getenv ( symbol ) );
strcat ( file, filtmp );
} else {
*iret = 2;
}
}
/*
* Search for a colon ':' and, if found, pull out and process.
*/
else {
cptr = strchr ( filnam, ':' );
if ( cptr != (char *)NULL ) {
strncpy ( symbol, filnam, (size_t)(cptr-filnam) );
symbol[(cptr-filnam)] = '\0';
if ( getenv ( symbol ) != NULL ) {
strcpy ( file, getenv ( symbol ) );
strcat ( file, "/" );
strcat ( file, (cptr+1) );
} else {
*iret = 2;
}
}
}
}
void ctb_hfread ( int *iret )
/************************************************************************
* ctb_pfread *
* *
* This function reads the info from the Hershey Fonts tables. *
* *
* The Hershey Font coordinates are encoded using the ASCII characters. *
* Each character pair represents a coordinate in the drawing system *
* with 'R,R' as the origin. To get the coordinate values, subtract *
* 'R' from the given character. For example, the pair 'SB' corresponds *
* to (+1,-16). *
* *
* ctb_hfread ( iret ) *
* *
* Input parameters: *
* *
* Output parameters: *
* *iret int Return code *
* -1 = cannot open or read table*
* -12 = cannot allocate memory *
** *
* Log: *
* S. Jacobs/NCEP 10/07 Created *
* T. Piper/SAIC 03/08 Replaced cmm functions with Macros *
***********************************************************************/
{
FILE *fp;
char buffer[256], av[6];
int ii, nr, ier, ifont, ier2, jj, kk, nf, one = 1;
font_tbl_name_t tbl[] = { {"hfont03.tbl", 3},
{"hfont23.tbl", 23},
{"hfont04.tbl", 4},
{"hfont14.tbl", 14},
{"hfont24.tbl", 24},
{"hfont34.tbl", 34} };
/*---------------------------------------------------------------------*/
*iret = G_NORMAL;
/*
* Allocate space for all of the font structures.
*/
nf = sizeof(tbl)/sizeof(tbl[0]);
G_MALLOC ( _hfontTbl, HF_font_t, nf, "ctb_hfread - _hfontTbl");
if ( _hfontTbl == NULL ) {
*iret = -12;
return;
}
_nhfont = 0;
for ( ifont = 0; ifont < nf; ifont++ ) {
/*
* Read the font table and add entries into the structure.
*/
nr = 0;
fp = cfl_tbop ( tbl[ifont].table_name, "hershey", &ier );
if ( ier == 0 ) {
cfl_tbnr ( fp, &nr, &ier);
}
if ( nr == 0 ) {
cfl_clos ( fp, &ier );
*iret = -1;
return;
}
_hfontTbl[ifont].font_code = tbl[ifont].font_num;
/*
* Allocate space for the characters.
*/
G_MALLOC ( _hfontTbl[ifont].character, HF_char_t, nr, "ctb_hfread - _hfontTbl[ifont].character");
if ( _hfontTbl[ifont].character == NULL ) {
cfl_clos ( fp, &ier );
*iret = -12;
return;
}
/*
* Read table entries into the structure.
*/
ii = 0;
/* Read the next line from the file */
cfl_trln ( fp, 256, buffer, &ier );
/*
* Process the file while there is no error and
* the end of the file has not been reached.
*/
while ( ier >= 0 && ier != 4 ) {
if ( ier == 0 ) {
G_MALLOC ( _hfontTbl[ifont].character[ii].point_code, char,
strlen(buffer)+1, " ctb_hfread - _hfontTbl[ifont].character[ii].point_code");
if ( _hfontTbl[ifont].character[ii].point_code == NULL ) {
cfl_clos ( fp, &ier );
*iret = -12;
return;
}
strcpy ( _hfontTbl[ifont].character[ii].point_code, buffer );
/* Get the character ASCII code */
cst_ncpy ( av, &(buffer[0]), 5, &ier2 );
cst_numb ( av, &(_hfontTbl[ifont].character[ii].ascii_val),
&ier2 );
/*
* Get the number of points for the character
* (The number in the file includes the X min and max,
* so subtract one)
*/
cst_ncpy ( av, &(buffer[5]), 3, &ier2 );
cst_numb ( av, &(_hfontTbl[ifont].character[ii].npts),
&ier2 );
(_hfontTbl[ifont].character[ii].npts)--;
/* Get the X min and max */
_hfontTbl[ifont].character[ii].xmin = buffer[8] - 'R';
_hfontTbl[ifont].character[ii].xmax = buffer[9] - 'R';
/* Get the coordinates, if the number of points is > 0 */
if ( _hfontTbl[ifont].character[ii].npts > 0 ) {
G_MALLOC ( _hfontTbl[ifont].character[ii].point, HF_point_t,
_hfontTbl[ifont].character[ii].npts,
" ctb_hfread - _hfontTbl[ifont].character[ii].point");
if ( _hfontTbl[ifont].character[ii].point == NULL ) {
cfl_clos ( fp, &ier );
*iret = -12;
return;
}
/*
* Check for " R", which denotes a "pen up".
* If there is a pen up code, set the points to missing.
* Otherwise, decode the coordinate values.
*/
kk = 10;
for ( jj = 0;
jj < _hfontTbl[ifont].character[ii].npts;
jj++ ) {
if ( strncmp ( &(buffer[kk]), " R", 2 ) == 0 ) {
_hfontTbl[ifont].character[ii].point[jj].x = -99;
_hfontTbl[ifont].character[ii].point[jj].y = -99;
kk += 2;
}
else {
_hfontTbl[ifont].character[ii].point[jj].x =
buffer[kk] - 'R'; kk++;
_hfontTbl[ifont].character[ii].point[jj].y =
buffer[kk] - 'R'; kk++;
}
}
}
/*
* If there are no character codes,
* set one point at the origin
*/
else {
G_MALLOC ( _hfontTbl[ifont].character[ii].point, HF_point_t,
one, " ctb_hfread - _hfontTbl[ifont].character[ii].point");
if ( _hfontTbl[ifont].character[ii].point == NULL ) {
cfl_clos ( fp, &ier );
*iret = -12;
return;
}
_hfontTbl[ifont].character[ii].point[0].x = 0;
_hfontTbl[ifont].character[ii].point[0].y = 0;
}
ii++;
}
/* Read the next line from the file */
cfl_trln ( fp, 256, buffer, &ier );
}
/* Set the number of characters for the font */
_hfontTbl[ifont].numchr = ii;
/* Close the font table */
cfl_clos ( fp, &ier );
/* Increase the count for the number of fonts */
_nhfont++;
}
void nim_flnm ( const char *imgtyp, const char *imginf,
char *basetm, char *endtim, int mrange,
int intrvl, Boolean bflag, Boolean bauto, char *path,
char ***namarr, char ***timarr, int *ntimes, int *iret )
/************************************************************************
* nim_flnm *
* *
* This routine returns an array of file names given the image info. *
* The type of image, SAT or RAD, and the image info, which is the *
* directory of the data, are used to locate the image data files on *
* disk. For satellite images, the info is the part of the directory *
* path that defines the source/geog_area/channel. For radar images, *
* the info is lcl_or_natl/area/type. *
* *
* void nim_flnm ( imgtyp, imginf, basetm, endtim, mrange, intrvl, *
* bflag, bauto, path, namarr, timarr, nfound, iret ) *
* *
* Input parameters: *
* *imgtyp const char Type of image *
* *imginf const char Directory information *
* *basetm char Base time *
* *endtim char End time of range *
* mrange int Minutes in time range *
* intrvl int Minutes in time interval *
* bflag Boolean Reference time flag *
* bauto Boolean Auto update flag *
* *
* Output parameters: *
* *path char Full directory path *
* ***namarr char Array of all file names *
* ***timarr char Array of all file times *
* *ntimes int Number of files/times returned *
* *iret int Return code *
* -3 = no files found *
** *
* Log: *
* S. Jacobs/NCEP 8/99 Created *
* S. Jacobs/NCEP 2/00 Use the path and templ from datatype.tbl*
* S. Jacobs/NCEP 7/00 Moved error check to after FL_SCND call *
* S. Jacobs/NCEP 8/00 Added check: len of tmpl = len of file *
* S. Jacobs/NCEP 3/01 Increased file template to 48 chars *
* S. Jacobs/NCEP 9/01 Ignore the non-date part of the template*
* A. Hardy/SAIC 2/02 Changed call FL_SCND *
* T. Lee/SAIC 6/02 Handled wild card template; return ipos *
* T. Lee/SAIC 9/04 Replaced FL_TMPL with CTB_DTGET *
* A. Hardy/NCEP 11/04 Added calls to ST_RNUL *
* m.gamazaychikov/SAIC 12/04 Added ion flag to CTB_DTGET CS *
* m.gamazaychikov/SAIC 01/06 Changed ctmpl string length to MXTMPL *
* m.gamazaychikov/SAIC 04/06 Added idtmch flag to CTB_DTGET CS *
* T. Piper/SAIC 04/07 Re-wrote in 'C'; dynamic arrays *
* T. Piper/SAIC 10/07 Check value of nt before cti_tmln *
* F. J. Yen/NCEP 4/08 Add bin mins and mstrct to CTB_DTGET CSC*
***********************************************************************/
{
long istar;
int ic, is, nf, ir, ii, kk, ion, ihb, iha, idtmch, iorder, lens;
int imb, ima, mstrct;
int ier, ier1, ier2, itarr[5], jtarr[5], lenf, lent, mdif, ndif, nt;
int idir=-1, idelrt=-1, nfiles;
size_t timlen=DTTMS_SIZE;
/*
* The following dimensions are based upon the sizes in the datatype.tbl
* plus one for the null character; then rounded up to the neartest
* multiple of four.
*/
char *pstar, **t_names=NULL, **t_times=NULL, **tarr=NULL;
char cpath[28], ctmpl[MXTMPL], tmplt[MXTMPL];
dattm_t strtim;
nmlst_t tfil;
struct dirent **dnlist=NULL;
/*---------------------------------------------------------------------*/
/*
* Construct the directory name from the image data attributes.
*/
ctb_dtget ( (char*)imgtyp, cpath, ctmpl, &ic, &is, &nf, &ir, &ii,
&ion, &ihb, &imb, &iha, &ima, &mstrct, &idtmch, &ier );
strcpy ( path, cpath );
strcat ( path, "/" );
strcat ( path, imginf );
/*
* Scan the directory.
*/
iorder = 1;
cfl_scnt ( path, ctmpl, iorder, &dnlist, &nfiles, &ier );
/*
* If there are no files, there is an error.
*/
if ( nfiles > 0 ) {
/*
* Construct the full file name template for this directory.
*/
pstar = strchr(ctmpl, '*' );
if ( pstar == NULL ) {
/* No '*' was found in the template. */
strcpy(tmplt, ctmpl);
}
else {
/* An '*' was found in the template. */
istar = ( pstar - ctmpl );
if ( istar == 0 ) {
/* An '*' was found at the beginning of the template. */
strcpy(tmplt, (ctmpl+2));
}
else {
cst_ncpy(tmplt, ctmpl, istar, &ier);
}
}
/*
* Convert each file name to a time.
*/
cst_lstr(tmplt, &lent, &ier );
cst_lstr(dnlist[0]->d_name, &lenf, &ier );
G_MALLOC(tarr, char*, nfiles, "nim_flnm: tarr");
for ( ii = 0; ii < nfiles; ii++ ) {
G_CALLOC(tarr[ii], char, timlen, "nim_flnm: tarr[ii]");
if ( pstar == NULL ) {
cfl_mdat(dnlist[ii]->d_name, tmplt, "YYMMDD/HHNN",
tarr[ii], &ier );
}
else {
if ( istar == 0 ) {
strcpy(tfil, dnlist[ii]->d_name+(lenf-lent));
}
else {
cst_ncpy(tfil, dnlist[ii]->d_name, lent, &ier);
}
cfl_mdat(tfil, tmplt, "YYMMDD/HHNN", tarr[ii], &ier );
}
}
/*
* Sort the times.
*/
qsort( (void*)tarr, (size_t)nfiles, sizeof(char*), compare );
cti_yyyy(nfiles, tarr, tarr, &ier);
/*
* Compute the start time of the range from the end time
* and the number of minutes.
*/
ti_ctoi ( endtim, itarr, &ier, strlen(endtim) );
ti_subm ( itarr, &mrange, jtarr, &ier );
ti_itoc ( jtarr, strtim, &ier, sizeof(strtim) );
st_null ( strtim, strtim, &lens, &ier, sizeof(strtim), sizeof(strtim) );
/*
* Find the number of times to return.
*/
nt = 0;
for ( ii = 0; ii < nfiles; ii++ ) {
ti_diff ( strtim, tarr[ii], &mdif, &ier1, strlen(strtim), timlen-1 );
ti_diff ( tarr[ii], endtim, &ndif, &ier2, timlen-1, strlen(endtim));
if ( ( ier1 == 0 ) && ( ier2 == 0 ) ) {
if ( ( mdif <= 0 ) && ( ndif <= 0 ) ) {
G_REALLOC(t_names, char*, nt+1, "nim_flnm: t_names");
G_MALLOC(t_names[nt], char, (strlen(dnlist[ii]->d_name)+1),
"nim_flnm: t_names[nt]");
strcpy(t_names[nt], dnlist[ii]->d_name);
G_REALLOC(t_times, char*, nt+1, "nim_flnm: t_times");
G_MALLOC(t_times[nt], char, (strlen(tarr[ii])+1),
"nim_flnm: t_times[nt]");
strcpy(t_times[nt], tarr[ii]);
nt++;
}
}
G_FREE(tarr[ii], char);
free (dnlist[ii]);
}
void mainw_setTitleName ( const char* spfName, const char *cycle )
/************************************************************************
* mainw_setTitleName *
* *
* This function adds the title addtion to the NMAP2 window title name. *
* *
* The nmap2 title format is: *
* *
* "NMAP2 (Version) -- [spf file name ] -- [forecast day/cycle]" *
* *
* The spf file name is only used if an spf file has been loaded, and *
* the forecast day/cycle string will only be added if the prefs.tbl *
* file's USE_DAY_CYCLE switch is set to True and product generation is *
* active. *
* *
* void mainw_setTitleName ( titleAdditon ) *
* *
* Input parameters: *
* spfName char* spf file name *
* cycle char* forecast day/cycle time string *
* *
* Output parameters: *
* Return parameters: *
* NONE *
* *
** *
* Log: *
* J. Wu/SAIC 03/05 initial coding *
* E. Safford/SAIC 07/07 change input params to spfName & cycle *
***********************************************************************/
{
static char *oldTitle, newTitle[256];
int nc, ier;
Boolean haveSpf = False, haveCycle = False;
/*---------------------------------------------------------------------*/
if ( _topLevel != NULL ) {
/*
* Determine what inputs have been provided.
*/
if( spfName ) {
cst_ncpy( _spfName, spfName, COMPONENT_LEN -1, &ier );
if( ier < 0 ) return;
}
if( cycle ) {
cst_ncpy( _dayCycle, cycle, COMPONENT_LEN -1, &ier );
if( ier < 0 ) return;
}
if( strlen( _spfName ) > 0 ) haveSpf = True;
if( strlen( _dayCycle ) > 0 ) haveCycle = True;
/*
* Get the current title string.
*/
XtVaGetValues ( _topLevel, XmNtitle, &oldTitle, NULL );
/*
* Chop off the old title at the right ')' which is the end of
* the version number in the title.
*/
cst_nocc ( oldTitle, ')', 1, 1, &nc, &ier );
cst_ncpy ( newTitle, oldTitle, nc+1, &ier );
/*
* Add the SPF file.
*/
if( haveSpf ) {
strcat ( newTitle, " -- " );
strcat ( newTitle, _spfName );
}
/*
* Add the day/cycle string.
*/
if( haveCycle ) {
strcat ( newTitle, " -- " );
strcat ( newTitle, _dayCycle );
}
/*
* Display the new title.
*/
XtVaSetValues ( _topLevel, XmNtitle, newTitle, NULL );
}
}
void wbc_area ( char *locnam, char *vorstr, int len, char *areastr,
int *iret )
/************************************************************************
* wbc_area *
* *
* This function converts the VOR stations string to the VOR watch area *
* string,containing distance, direction, county names and state ids. *
* *
* Input example: *
* 17 WNW DEC;26 E FAM;26 WNW FAM;55 SSE COU;22 NNW UIN;47 ENE UIN; *
* *
* Output example: *
* 17 WNW OF DECATUR, IL..TO 26 E OF FARMINGTON, MO..TO 26 WNW OF *
* FARMINGTON, MO..TO 55 SSE OF COLUMBIA, MO..TO 22 NNW OF QUINCY, *
* IL..TO 47 ENE OF QUINCY, IL. *
* *
* wbc_area ( locnam, vorstr, len, areastr, iret ) *
* *
* Input parameters: *
* *locnam char Locator type *
* *vorstr char Polygon text string *
* len int Max length of 'areastr' *
* *
* Output parameters: *
* *areastr char Polygon area text string *
* *iret int Return value *
* -5 = VORSTR too big *
* *
** *
* Log: *
* A. Hardy/NCEP 5/03 From VF_AREA *
************************************************************************/
{
int ii, nstn, maxlen, nstr, np, icnt, ier, exp, max, len1;
char tmpstr[420], holdstr[200], qstate[1], pstn[180];
char arrgrp[15], **aryvor, county[30], state[3];
/*---------------------------------------------------------------------*/
*iret = 0;
np = 1;
icnt = 1;
max = 6;
exp = 4;
qstate[0] = '\0';
tmpstr[0] = '\0';
maxlen = sizeof(pstn);
if ( strcmp ( locnam, "VOR") != 0 ) {
*iret = -2;
return;
}
cst_lstr ( vorstr, &len1, &ier );
if ( len1 >= 400 ) {
*iret = -5;
return;
}
/*
* Set up the memory space to break up the VOR area string.
*/
clo_init ( &ier );
aryvor = (char **) malloc(sizeof(char *) * 4);
for ( ii = 0; ii < 4; ii++ ) {
aryvor[ii] = (char *) malloc(6) ;
}
/*
* Get the city and state of the VOR station.
*/
for ( ii = 0; ii < 6; ii++) {
vorstr = (char *) cst_split ( vorstr, ';', 12, arrgrp, &ier);
cst_clst ( arrgrp, ' ', " ", exp, max, aryvor, &nstr, &ier);
if ( nstr == 3 ) {
clo_findstn ( locnam, aryvor[2], qstate, np, maxlen,
&nstn, pstn, &ier);
}
else if ( nstr == 2) {
clo_findstn ( locnam, aryvor[1], qstate, np, maxlen,
&nstn, pstn, &ier);
}
cst_gtag ( "NAME", pstn, " ", county, &ier );
cst_gtag ( "ST", pstn, " ", state, &ier );
cst_rnan (county, county, &ier);
/*
* Create the watch area string.
*/
holdstr[0] = '\0';
if ( icnt < 6 ) {
if ( strcmp ( aryvor[0], "..") != 0 ) {
sprintf( holdstr," %s %s OF %s, %s..TO ",aryvor[0],
aryvor[1], county, state);
}
else {
/*
* Print string for zero distance and no direction.
*/
sprintf( holdstr," %s, %s..TO ", county, state);
}
}
else {
if ( strcmp ( aryvor[0], "..") != 0 ) {
sprintf( holdstr," %s %s OF %s, %s.",aryvor[0], aryvor[1],
county, state);
}
else {
/*
* Print string for zero distance and no direction.
*/
sprintf( holdstr," %s, %s.", county, state);
}
}
icnt++;
cst_ncat ( tmpstr, holdstr, &len1, &ier);
}
len1 = G_MIN ( len, (int)strlen(tmpstr) );
cst_ncpy( areastr, tmpstr, len1, &ier);
/*
* Free memory space.
*/
for ( ii = 0; ii < 4; ii++ ) {
free ( aryvor[ii] );
}
free ( aryvor);
}
void ctb_rdprf ( char *tblnam, char *dirsym, char *tag, char *value,
int *iret )
/************************************************************************
* ctb_rdprf *
* *
* This subroutine reads a prefs table and returns a single value *
* associated with a single tage in the table. *
* *
* ctb_rdprf ( tblnam, dirsym, tag, value, iret ) *
* *
* Input parameters: *
* *tblnam char Prefs table file name *
* *dirsym char Lowest level directory name *
* *tag char Tags for prefs table definition *
* *
* Output parameters: *
*value char Value for prefs table tag *
* *iret int Return code *
* -1 = table cannot be opened *
* -2 = entry not found *
** *
* Log: *
* M. Li/SAIC 10/04 Modified from ctb_rdwou *
***********************************************************************/
{
FILE *ftbl;
char chname[25], label[120], buffer[180];
int ier, ilen2, lens;
Boolean found;
/*---------------------------------------------------------------------*/
/*
* Initialize output variables.
*/
*iret = -2;
ilen2 = 0;
chname[0] = '\0';
label[0] = '\0';
value[0] = '\0';
found = False;
/*
* Open the prefs table file.
*/
ftbl = cfl_tbop ( tblnam, dirsym, &ier );
if ( ier != 0 ) {
*iret = -1;
return;
}
cst_lstr ( tag, &lens, &ier );
/*
* Read in the next record, check for a comment,
* and process valid table entries.
*/
while ( ( fgets ( buffer, 180, ftbl ) != NULL ) && ( !found ) ) {
if ( buffer[0] != '!' ) {
if ( sscanf ( buffer,"%s %s", chname, label) ) {
cst_rmbl ( chname, chname, &ilen2, &ier );
cst_lstr ( label, &lens, &ier );
if (strcmp ( chname, tag ) == 0 ) {
cst_ncpy ( value, label, lens, &ier );
found = True;
*iret = 0;
}
else {
chname[0] = '\0';
label[0] = '\0';
}
}
}
}
if ( !found ) {
*iret = -2;
}
cfl_clos ( ftbl, &ier );
}
