void boundry_segs(long int offset, int npts, char *bndtbl, int col1, int col2,
int ltype, int lwidth)
{
FILE *fp;
int iret;
int nsegs,i,j,k;
float mxlat,mnlat,mxlon,mnlon;
float *X,*Y;
float lt[4],ln[4];
char buf[256];
static char bounddir[]="bounds";
fp = (FILE *)cfl_tbop(bndtbl,bounddir,&iret);
if(iret == 0)
cfl_seek(fp,offset,SEEK_SET,&iret);
else
{
printf("open failed %d\n",iret);
return;
}
if(iret == 0)
{
X = (float *)malloc(npts*sizeof(float));
Y = (float *)malloc(npts*sizeof(float));
cfl_rdln(fp,255,buf,&iret);
/*printf("look cfl_rdln %d %s\n",iret,buf);*/
i = 0;
if(iret == 0)
{
sscanf(buf,"%d %f %f %f %f %f %f",&nsegs,&mxlat,&mnlat,&mxlon,&mnlon,X,Y);
i++;
while((i < nsegs/2)&&(iret == 0))
{
cfl_rdln(fp,255,buf,&iret);
if(iret == 0)
{
j = sscanf(buf,"%f %f %f %f %f %f %f %f",
lt,ln,lt+1,ln+1,lt+2,ln+2,lt+3,ln+3);
for(k=0;k<j;k+=2)
{
X[i] = lt[k/2]; Y[i] = ln[k/2]; i++;
}
}
}
}
bounds_fill(X,Y,nsegs/2,col1);
bounds_line(X, Y, nsegs/2, col2, ltype, lwidth);
free(X); free(Y);
}
cfl_clos(fp,&iret);
}
void vfasaw ( char *rcntsw, int *iwtnum, char *amdcde, int *iret )
/************************************************************************
* vfasaw *
* *
* This program opens, creates and closes the Weather Watch amended SAW *
* text product file having an extension in time. *
* *
* vfasaw ( rcntsw, iwtnum, amdcde, iret ) *
* *
* Input parameters: *
* *rcntsw char Most recent SAW bulletin *
* *iwtnum int watch number *
* *amdcde char Amendment Code(AAx, x=A,B,C,...)*
* *
* Output parameters: *
* *iret int Return Code *
* *
** *
* Log: *
* F. J. Yen/NCEP 1/07 Created *
***********************************************************************/
{
FILE *ifpsaw;
char ifname[256];
int ier;
/*-------------------------------------------------------------------*/
ier = 0;
/*
* Create output file for amended SAW.
*/
sprintf ( ifname, "WW%04d.SAW.AM%c", *iwtnum, amdcde[2] );
ifpsaw = cfl_wopn ( ifname, &ier );
fprintf ( ifpsaw, "%s", rcntsw );
fprintf ( ifpsaw, "\n");
/*
* Close output file.
*/
cfl_clos ( ifpsaw, &ier );
}
void ctb_permccrd ( char *tblnam, char *dirsym, Permclust_t *pc, int *iret )
/************************************************************************
* ctb_permccrd *
* *
* This routine will read the permanent clustered county table into a *
* structure. *
* *
* ctb_permccrd ( tblnam, dirsym, pc, iret ) *
* *
* Input parameters: *
* *tblnam char Data type table name *
* *dirsym char Directory *
* *
* Output parameters: *
* *pc Permclust_t Perm. clustered cnty structure *
* *iret int Return code *
** *
* Log: *
* A. Hardy/NCEP 10/04 copied from ctb_ccrd *
* A. Hardy/NCEP 1/05 Added creation of virtual cluster combos*
* & added error check on 1st cst_split *
***********************************************************************/
{
FILE *ftbl;
char buff[256], pcname[32], *next;
int ii, jj, ij, in, inx, numclust, fips[50], nfips, len, ier, ierr;
int ik, kk, ll, nn, itotal, srchfip, inum, ivfips, cfips[20];
Boolean found, match;
static Permclust_t vpc, tpc;
/*---------------------------------------------------------------------*/
*iret = 0;
/*
* Open the table.
*/
ftbl = cfl_tbop ( tblnam, dirsym, iret );
if ( *iret != 0 ) {
tpc.nclust = 0;
return;
}
/*
* Get number of valid table entries.
*/
cfl_tbnr( ftbl, &numclust, &ier );
if ( numclust != 0 ) {
/*
* Allocate the structure elements.
*/
tpc.nclust = numclust;
tpc.clust = (PCinfo *) malloc( numclust * sizeof(PCinfo) );
}
else {
/*
* Problem opening table file; set error code and return.
*/
cfl_clos( ftbl, &ier );
*iret = -2;
return;
}
rewind ( ftbl );
/*
* For every valid table entry, read in, parse, put in structure
*/
ii = 0;
while ( ii < numclust ) {
cfl_trln( ftbl, sizeof(buff), buff, &ier );
if ( ier == 0 ) {
next = cst_split ( buff, '|', 4, tpc.clust[ii].pcwfo, &ier );
if ( ier == 0 ) {
next = cst_split ( next, '|', 32, pcname, &ier );
tpc.clust[ii].pcname =
(char *)malloc( (strlen(pcname)+1) * sizeof(char) );
strcpy ( tpc.clust[ii].pcname, pcname );
cst_rmbl ( next, next, &len, &ier );
cst_ilst ( next, '+', IMISSD, sizeof(fips)/sizeof(fips[0]),
fips, &nfips, &ier );
tpc.clust[ii].npc = nfips;
tpc.clust[ii].pc = (int *)malloc( nfips * sizeof(int) );
for ( jj = 0; jj < nfips; jj++ ) {
tpc.clust[ii].pc[jj] = fips[jj];
}
}
else {
ierr = 3;
er_wmsg ( "CTB", &ierr, buff, &ier, 3, strlen (buff) );
}
ii++;
}
}
cfl_clos ( ftbl, &ier );
/*
* Create virtual clusters.
* Allocate the structure elements.
*/
vpc.nclust = 0;
vpc.clust = (PCinfo *) malloc( (numclust*4) * sizeof(PCinfo) );
inum = vpc.nclust;
ii = 0;
/*
* Loop over all perm clusters.
*/
while ( ii < numclust ) {
for ( jj = 1;jj < tpc.clust[ii].npc; jj++ ) {
found = False;
srchfip = tpc.clust[ii].pc[jj];
/*
* Compare search fip value to the other 1st fips codes.
* Search permanent table first.
*/
ij = 0;
while ( (!found) && (ij < numclust ) ) {
if ( srchfip == tpc.clust[ij].pc[0] ) {
found = True;
}
ij++;
}
/*
* Search virtual cluster table next.
*/
ij = 0;
while ( (!found) && (ij < vpc.nclust ) ) {
if ( srchfip == vpc.clust[ij].pc[0] ) {
found = True;
}
ij++;
}
/*
* Didn't find a cluster group with search fip as first key.
* Find all cluster groups in perm. table with this key in
* the cluster groups. Create a new virtual cluster entry.
*/
if ( !found ) {
cfips[0] = srchfip;
ik = 0;
/* Loop over rest of current clustered combo fips
* and store the codes temporarily.
*/
for ( ij = 0; ij < tpc.clust[ii].npc;ij++ ) {
if ( tpc.clust[ii].pc[ij] != srchfip ) {
ik++;
cfips[ik] = tpc.clust[ii].pc[ij];
}
}
/* Set the number of virtual fips codes we have so far*/
ivfips = ik+1;
/*
* Check rest of perm clusters combox for srchfip.
* Start with the next perm cluster combo.
*/
inx = ii + 1;
match = False;
/* loop over rest of combo clusters */
for ( kk= inx; kk < numclust; kk++ ) {
/* loop over number of counties in each cluster */
for ( ll = 0; ll < tpc.clust[kk].npc; ll++ ) {
/* look for a match in a cluster */
if ( tpc.clust[kk].pc[ll] == srchfip ) {
/* store all new codes in cfips array */
for ( nn = 0; nn < tpc.clust[kk].npc; nn++ ) {
/* loop over current cluster array, store
one's we don't have*/
in = 0;
while ( (in < ivfips ) && ( !match) ) {
if ( tpc.clust[kk].pc[nn] == cfips[in] ) {
match = True;
}
in++;
}
/* didn't find fips in cfips array, keep it */
if ( !match ) {
cfips[ivfips] = tpc.clust[kk].pc[nn];
ivfips++;
}
match = False;
}
}
}
}
/*
* Put temporary pcname, pcwfo, npc and fips array into
* virtual perm clust. combos.
* Increment number of virtual fip cluster combos
*/
strcpy ( vpc.clust[inum].pcwfo, tpc.clust[ii].pcwfo );
vpc.clust[inum].pcname =
(char *)malloc( (strlen(pcname)+1) * sizeof(char) );
/*
* Store the number of fips codes and the code numbers
*/
vpc.clust[inum].npc = ivfips;
vpc.clust[inum].pc = (int *)malloc( ivfips * sizeof(int) );
for ( ij= 0; ij < ivfips; ij++ ) {
vpc.clust[inum].pc[ij] = cfips[ij];
}
vpc.nclust++;
inum++;
} /* (!found) loop */
} /* for jj loop */
ii++;
} /* while ii loop */
/*
* Fill out output permanent cluster structure.
* Allocate the structure elements.
*/
itotal = numclust + vpc.nclust;
pc->nclust = itotal;
pc->clust = (PCinfo *) malloc( itotal * sizeof(PCinfo) );
ii = 0;
/*
* Write out permanent table cluster combos first.
*/
while ( ii < numclust ) {
strcpy (pc->clust[ii].pcwfo, tpc.clust[ii].pcwfo);
pc->clust[ii].pcname =
(char *)malloc( (strlen(tpc.clust[ii].pcname)+1) * sizeof(char) );
strcpy ( pc->clust[ii].pcname, tpc.clust[ii].pcname );
pc->clust[ii].npc = tpc.clust[ii].npc;
pc->clust[ii].pc = (int *)malloc( tpc.clust[ii].npc * sizeof(int) );
for ( jj = 0; jj < pc->clust[ii].npc; jj++ ) {
pc->clust[ii].pc[jj] = tpc.clust[ii].pc[jj];
}
ii++;
}
/*
* Write out virtual cluster combos next.
*/
jj = 0;
while ( ii < pc->nclust ) {
strcpy (pc->clust[ii].pcwfo, vpc.clust[jj].pcwfo);
pc->clust[ii].pcname =
(char *)malloc( 12 * sizeof(char) );
sprintf ( pc->clust[ii].pcname, "VClust %d", jj+1 );
pc->clust[ii].npc = vpc.clust[jj].npc;
pc->clust[ii].pc = (int *)malloc( vpc.clust[jj].npc * sizeof(int) );
for ( ij = 0; ij < pc->clust[ii].npc; ij++ ) {
pc->clust[ii].pc[ij] = vpc.clust[jj].pc[ij];
}
ii++;
jj++;
}
}
void ctb_g2rdlvl ( char *tbname, G2lvls *lvltbl, int *iret )
/************************************************************************
* ctb_g2rdlvl *
* *
* This routine will read a GRIB2 vertical coordinate level/layer *
* table into an array of structures. *
* The table is allocated locally and a pointer to the new table is *
* passed back to the user in argument lvltbl. The user is responsible *
* for freeing this memory, when the table is no longer needed, by *
* free(lvltbl.info) *
* *
* ctb_g2rdlvl ( tbname, lvltbl, iret ) *
* *
* Input parameters: *
* *tbname char Filename of the table to read *
* *
* Output parameters: *
* *lvltbl G2lvls Pointer to list of table entries *
* *iret int Return code *
* 0 = Successful *
* -1 = Could not open *
* -2 = Could not get count of of table entries *
* -52 = Memory allocation failure (G_NMEMRY) *
** *
* Log: *
* S. Gilbert/NCEP 11/04 Modified from ctb_g2rdcntr to read a *
* GRIB2 level/layer Table. *
* S. Emmerson/Unidata 12/15 Added check for malloc() returning NULL *
***********************************************************************/
{
FILE *fp = NULL;
int n, blen, id1, id2, scale, nr, ier;
char buffer[256];
char name[34], abbrev[5], unit[21];
/*---------------------------------------------------------------------*/
*iret = G_NORMAL;
/*
* Open the table. If not found return an error.
*/
fp = cfl_tbop( tbname, "grid", &ier);
if ( fp == NULL || ier != 0 ) {
if (fp)
fclose(fp);
*iret = -1;
return;
}
cfl_tbnr(fp, &nr, &ier);
if ( ier != 0 || nr == 0 ) {
*iret = -2;
cfl_clos(fp, &ier);
return;
}
lvltbl->info = (G2level *)malloc((size_t)nr*sizeof(G2level));
if (lvltbl->info == NULL) {
*iret = G_NMEMRY;
cfl_clos(fp, &ier);
return;
}
lvltbl->nlines = nr;
n = 0;
while ( n < nr ) {
cfl_trln( fp, 256, buffer, &ier );
if ( ier != 0 ) {
free(lvltbl->info);
break;
}
cst_lstr ( buffer, &blen, &ier );
sscanf( buffer, "%11d %11d %33c %20c %4s %11d",
&id1, &id2, name, unit, abbrev, &scale);
name[33] = '\0';
unit[20] = '\0';
abbrev[4] = '\0';
lvltbl->info[n].id1=id1;
lvltbl->info[n].id2=id2;
strcpy(lvltbl->info[n].name, name);
strcpy(lvltbl->info[n].unit, unit);
strcpy(lvltbl->info[n].abbrev, abbrev);
lvltbl->info[n].scale=scale;
n++;
}
cfl_clos(fp, &ier);
}
void cvg_rdrec ( char *fname, int fpos, VG_DBStruct *el, int *iret )
/************************************************************************
* cvg_rdrec *
* *
* This function reads a VG record from a VG file based upon the file *
* position. *
* *
* cvg_rdrec ( fname, fpos, el, iret ) *
* *
* Input parameters: *
* *fname char VG file name *
* fpos int File position to read from *
* *
* Output parameters: *
* *el VG_DBStruct Pointer to VG record structure *
* *iret int Return code *
* -1 = error opening VG file *
* -2 = error closing VG file *
* -13 = error reading VG header *
* -14 = error reading VG element *
* *
** *
* Log: *
* E. Wehner/EAi 11/96 Created *
* D. Keiser/GSC 1/97 Clean up *
* E. Wehner/EAi 8/97 Remove unneeded include *
* E. Wehner/EAi 9/97 Handle null file name *
* F. J. Yen/NCEP 11/97 Replace " " with NULL for *
* default directory. *
* G. Krueger/EAI 1/98 Ignore non-fatal read warnings. *
* I. Durham/GSC 5/98 Changed underscore decl. to an include *
* E. Safford/GSC 10/98 removed end from param list *
* J. Wu/SAIC 04/02 call cvg_rdrecnoc to read element *
* T. Lee/SAIC 11/03 used cvgcmn.h *
***********************************************************************/
{
int ier;
FILE *fp;
/*---------------------------------------------------------------------*/
*iret = 0;
if ( !fname ) {
*iret = -47;
return;
}
/*
* Open the file for READ only.
*/
fp = (FILE *) cfl_ropn(fname, "", &ier);
if ( ( ier != 0 ) || ( fp == NULL ) ) {
*iret = -1;
return;
}
/*
* Read the element.
*/
cvg_rdrecnoc ( fname, fp, fpos, el, iret );
/*
* Close the VG file.
*/
cfl_clos ( fp, &ier );
if ( ier != 0 ) *iret = -2;
}
void nexr_list_lev ( char *filnam, int *lenfnam,
char *radparm, int *lenparm, int *ier)
{
int i, nbin, iret;
long flen, lofset = 20;
char cfil[LLPATH], cprm[LLMXLN];
char stid[]="KFTG", callid[5];
Radar *radar=NULL;
FILE *fp;
*ier = 0;
strncpy(cfil, filnam, *lenfnam);
strncpy(cprm, radparm, *lenparm);
cfil[*lenfnam] = '\0';
cprm[*lenparm] = '\0';
/* get actual file name to use in rsl call */
cfl_inqr ( cfil, NULL, &flen, cfil, &iret);
RSL_select_fields(cprm, NULL);
/*
if ( cprm[0] == 'd' )
VINDEX = DZ_INDEX;
else if ( cprm[0] == 's' )
VINDEX = SW_INDEX;
else if ( cprm[0] == 'v' )
VINDEX = VR_INDEX;
*/
/*
* see if we can get the station ID from bytes 21-24, otherwise, just use any ID
*/
fp = cfl_ropn ( cfil, NULL, &iret );
if ( iret != 0 ) {
printf("failed to open %s\n",cfil);
*ier = -1;
return;
}
else {
cfl_seek ( fp, lofset, SEEK_SET, &iret );
if ( iret != 0 ) {
*ier = -1;
cfl_clos ( fp, &iret );
return;
}
}
cfl_read ( fp, 4, (unsigned char *)callid, &nbin, &iret );
cfl_clos ( fp, &iret );
if (( nbin < 4 )||(callid[0] < 'A')||(callid[0] > 'Z')) /* use a safe station ID....we aren't plotting lat/lon anyhow */
strcpy(callid,stid);
else
callid[4] = '\0';
/*RSL_radar_verbose_on();*/
RSL_read_these_sweeps("all", NULL);
radar = RSL_wsr88d_to_radar(cfil, callid);
/*RSL_radar_verbose_off();*/
if ( radar == NULL )
{
printf("failed to open %s\n",cfil);
*ier = -1;
return;
}
for (i=0; i<radar->h.nvolumes; i++) {
if (radar->v[i]) {
printf("Volume %s: Sweeps available %d\n", cprm, radar->v[i]->h.nsweeps);
print_header_for_volume(radar->v[i]);
}
}
RSL_free_radar(radar);
}
void srchw_fosdScan ( srchinfo_t *srchinfo, int called_from, int *iret )
/************************************************************************
* srchw_fosdScan *
* *
* This routine will scan a file given a search structure and return *
* the appropriate report. *
* *
* srchw_fosdScan ( srchinfo, called_from, iret ) *
* *
* Input parameters: *
* *srchinfo srchinfo_t Search info structure *
* called_from int Indicate from where it is called*
* 1 - from user click *
* 2 - from auto-update *
* *
* Output parameters: *
* *iret int Return code *
* -8 -- scandir failure *
* -9 -- open file error *
* *
** *
* Log: *
* L. Williams/EAI 10/95 *
* D.Plummer/NCEP 12/95 Reorganize for fosd type W *
* G. Krueger/EAI 3/96 CFL_SOPN -> CFL_ROPN *
* L. Williams/EAI 6/96 Check for duplicate reports *
* S. Jacobs/NCEP 12/98 Changed fclose to cfl_clos *
* S. Danz/AWC 12/00 Updated call to dttm_cpy *
* S. Danz/AWC 12/00 Remove NULL chars from report *
* R. Tian/SAIC 04/02 Query file size before open it *
* T. Piper/SAIC 05/02 Close last file opened before returning *
* R. Tian/SAIC 11/03 Added called_from arg *
* T. Piper/SAIC 01/04 Added check for -8 from dir_getflist *
* T. Piper/SAIC 01/04 Added check on cfl_ropn *
* E. Safford/SAIC 12/07 rm direct access to textW widget *
***********************************************************************/
{
char *text, last_flg;
char search_str[2];
static struct date_time_info _startd_save;
static struct date_time_info _endd_save;
int i, j, duplicate, ier;
char nofile_msg[80];
long flen;
char dumyname[133];
/* ------------------------------------------------------------------- */
repnum=0;
/*
* Scan the data directory for a list of valid files.
*/
if ( (srchinfo->idtyp != _idtyp_save) ||
(dttm_cmp(srchinfo->startd, _startd_save) != 0) ||
(dttm_cmp(srchinfo->endd, _endd_save) != 0) )
{
_idtyp_save = srchinfo->idtyp;
dttm_cpy(&_startd_save, srchinfo->startd);
dttm_cpy(&_endd_save, srchinfo->endd);
dir_getflist( nwxTable->dtyp_info, srchinfo->idtyp,
srchinfo->startd, srchinfo->endd,
&srchinfo->dir_info, iret );
if ( *iret == -8 ) {
return;
}
else if ( *iret != 0 ) {
/*
* no matching data file
*/
*iret = -1;
sprintf( nofile_msg, "No reports.\n\n" );
if ( called_from == 1 ) {
pdata_setReportText( nofile_msg, &ier );
txtw_dsplyReport( &ier );
}
stnList.nrptstn = 0;
return;
}
}
last_flg = 0;
search_str[0] = CHCTLA;
search_str[1] = '\0';
while ( !last_flg ) {
/*
* Get the next data file.
*/
dir_getnextf( &(srchinfo->dir_info), srchinfo->sflag,
&(srchinfo->file_info), iret);
if (srchinfo->sflag == 0)
srchinfo->sflag = -1;
if ( *iret == 3 )
last_flg = 1;
if ( (*iret == 0) || (*iret == 3) ) { /* new file */
/*
* Close the open file.
*/
if ( srchinfo->file_info.fptr != NULL ) {
cfl_clos ( srchinfo->file_info.fptr, iret );
srchinfo->file_info.fptr = NULL;
}
/*
* Get the size of the new file. If the size is 0, skip it.
*/
cfl_inqr(srchinfo->file_info.filnam, NULL, &flen, dumyname,
iret);
if ( *iret != 0 || flen == 0) {
if ( last_flg ) {
break;
} else {
continue;
}
}
srchinfo->file_info.file_len = (int)flen;
/*
* Open the new file.
*/
srchinfo->file_info.fptr = cfl_ropn(
srchinfo->file_info.filnam,
NULL, iret );
if ( *iret != 0 ) {
*iret = -9;
return;
}
/*
* Allocate enough space to hold the entire contents of the file.
*/
text = (char *) malloc((size_t)(srchinfo->file_info.file_len + 1) *
sizeof(char) );
/*
* Read the contents of the file into the TEXT string.
*/
if ( fread( text, (size_t)srchinfo->file_info.file_len, 1,
srchinfo->file_info.fptr) != (size_t)1 ){
/*
* reading error
*/
free ( text );
if ( last_flg ) {
break;
} else {
continue;
}
}
text[srchinfo->file_info.file_len] = '\0';
for (i=0; i<srchinfo->file_info.file_len; i++) {
if (!text[i]) text[i] = ' ';
}
/*
* Search the TEXT for the search string and report's position.
*/
srchw_fosdMarkrep( srchinfo, text, search_str, called_from, iret);
/*
* Free the allocated space
*/
free ( text );
}
else
break;
} /* end while */
/*
* Close the last open file.
*/
if ( srchinfo->file_info.fptr != NULL ) {
cfl_clos ( srchinfo->file_info.fptr, iret );
srchinfo->file_info.fptr = NULL;
}
stnList.nrptstn = 0;
for( i = 0 ; i < stnList.nreports; i++ ) {
duplicate = G_FALSE;
for( j=0; j < i; j++ ) {
if( reportInfo[i].stnindex == reportInfo[j].stnindex ) {
duplicate = G_TRUE;
break;
}
}
if( ! duplicate ) {
stnList.rptstn[stnList.nrptstn] = reportInfo[i].stnindex;
stnList.rptstnlat[stnList.nrptstn] = stnList.lat[reportInfo[i].stnindex];
stnList.rptstnlon[stnList.nrptstn] = stnList.lon[reportInfo[i].stnindex];
stnList.nrptstn++;
}
}
}
void shp_rdException ( int *iret )
/************************************************************************
* shp_rdException *
* *
* This function reads the shape exception table. *
* *
* void shp_rdException ( iret ) *
* *
* Input parameters: *
* *
* Output parameters: *
* *iret int Return value *
* -1 - Unable to open table *
* -2 - Information missing *
* *
** *
* Log: *
* H. Zeng/SAIC 07/07 created *
***********************************************************************/
{
int num, ilat, ilon, idx, ier;
char tagstr1[128], tagstr2[128], tagstr3[128], tagstr4[128];
char tagstr5[128], tagstr6[128], tagstr7[128], buff[256];
FILE *fp;
/*---------------------------------------------------------------------*/
*iret = 0;
/*
* Open the shape exception table. If not found, return an error.
*/
fp = cfl_tbop("shpexception.tbl", "stns", &ier);
if ( fp == NULL || ier != 0 ) {
*iret = -1;
return;
}
/*
* Count # of records on the table.
*/
cfl_tbnr (fp, &_numShpException, &ier);
/*
* Allocate space for _shpException.
*/
_shpException = (ShpException_t*) malloc( sizeof(ShpException_t) *
_numShpException );
/*
* Scan table line-by-line.
*/
idx = 0;
rewind (fp);
while ( !feof(fp) ) {
cfl_trln(fp, sizeof(buff), buff, &ier);
if ( ier != 0 ) continue;
num = sscanf (buff, "%s %s %s %s %s %s %s", tagstr1, tagstr2,
tagstr3, tagstr4, tagstr5, tagstr6, tagstr7);
if ( num != 7 ) continue;
if ( sscanf (tagstr6, "%d", &ilat) == 1 &&
sscanf (tagstr7, "%d", &ilon) == 1 ) {
strcpy ( _shpException[idx].id, tagstr1);
_shpException[idx].fips = 0;
sscanf (tagstr2, "%lu", &(_shpException[idx].fips));
_shpException[idx].clat = ilat * 0.01;
_shpException[idx].clon = ilon * 0.01;
idx++;
}
} /* the end of while (... */
cfl_clos(fp, &ier);
}
void cvg_scangfa ( char *fname, int layer, int subtype, int areatype,
char *tag, VG_DBStruct *el, int *selected, int *iret )
/************************************************************************
* cvg_scangfa *
* *
* This function scans a vector graphics file looking for a GFA element *
* that matches the layer, subtype, area type (hazard) and tag input. *
* The first matching record is returned in "el". Also, *
* the element should match one of the active filters. *
* *
* cvg_scan ( fname, layer, subtype, areatype, tag, el, selected, iret )*
* *
* Input parameters: *
* *fname char Name of file to scan from *
* layer int layer to test against *
* subtype int subtype to test against *
* areatype int area type to test against *
* tag char gfa tag to test against *
* *
* Output parameters: *
* *el VG_DBStruct Pointer to VG record structure *
* *selected int Offset to selected element *
* *iret int Return code *
* -1 = error opening VG file *
* -2 = error closing VG file *
* -6 = element not found *
* -13 = error reading VG header *
* -14 = error reading VG element *
* *
** *
* Log: *
* J. Wu/SAIC 08/04 initial coding (modified from cvg_scan) *
* J. Wu/SAIC 10/04 use cvg_getFld to access GFA attributes *
* E. Safford/SAIC 07/05 replace seqnum param with tag *
* J. Wu/SAIC 06/06 call cvg_matchfilter *
* M. Li/SAIC 03/07 Updated cvg_matchfilter *
***********************************************************************/
{
int ii, ier, el_layer, location;
float llx,lly,urx,ury;
long size;
char newfil[133], reqfil[133], cclass, ctype, value[32];
FILE *fp;
filter_t el_filter, timeMatched;
Boolean filter_match, matchAny = False;
/*---------------------------------------------------------------------*/
*iret = 0;
*selected = -1;
if ( !fname ) {
strcpy ( reqfil, work_file );
}
else {
strcpy ( reqfil, fname );
}
/*
* Inquire the size of the VG file and open the file for update.
*/
cfl_inqr ( reqfil, NULL, &size, newfil, &ier );
fp = (FILE *) cfl_uopn ( newfil, &ier );
if ( (ier != 0) || (fp == NULL) ) {
*iret = -1;
return;
}
/*
* Loop through all elements to find a match.
*/
for ( ii = 0; ii < MAX_EDITABLE_ELEMS; ii++ ) {
crg_goffset ( ii, &location, &ier );
if ( location < 0 ) {
continue;
}
crg_get ( ii, &el_layer, el_filter, &llx, &lly, &urx, &ury, &ier );
if ( ier >= 0 ) {
crg_gtyp ( ii, &cclass, &ctype, &ier );
}
if ( ier < 0 ) {
continue;
}
/*
* Match layer, class, vg type first.
*/
if ( (el_layer == layer) && (cclass == CLASS_MET) &&
(ctype == GFA_ELM) ) {
/*
* Then check if the element matches one of the filters.
*/
cvg_matchfilter ( el_filter, matchAny, &filter_match, timeMatched, &ier );
if ( !filter_match ) {
continue;
}
/*
* Read the element.
*/
cvg_rdrecnoc ( newfil, fp, location, el, iret );
if ( *iret != 0 ) {
continue;
}
/*
* Match the subtype, area type, and tag.
*/
cvg_getFld ( el, TAG_GFA_SUBTYPE, value, &ier );
if ( subtype == atoi(value) ) {
cvg_getFld ( el, TAG_GFA_AREATYPE, value, &ier );
if ( areatype == atoi(value) ) {
cvg_getFld ( el, TAG_GFA_TAG, value, &ier );
if( strcmp( tag, value ) == 0 ) {
*selected = location;
break;
}
}
}
}
}
/*
* Check if there is an matching record found.
*/
if ( *selected < 0 ) {
*iret = -6;
}
/*
* Close the VG file.
*/
cfl_clos(fp, &ier);
if ( ier != 0 ) *iret = -2;
}
void ctb_g2rdcntr ( char *tbname, G2wmocntrs *cntrtbl, int *iret )
/************************************************************************
* ctb_g2rdcntr *
* *
* This routine will read a WMO originating Center table into an array *
* of structures. *
* The table is allocated locally and a pointer to the new table is *
* passed back to the user in argument cntrtbl. The user is resposible *
* for freeing this memory, when the table is no longer needed, by *
* free(cntrtbl.info) *
* *
* ctb_g2rdcntr ( tbname, cntrtbl, iret ) *
* *
* Input parameters: *
* *tbname char Filename of the table to read *
* *
* Output parameters: *
* *cntrtbl G2wmocenter Pointer to list of table entries*
* *iret int Return code *
* 0 = Successful *
* -1 = Could not open *
* -1 = Could not get count of *
* of teble entries. *
** *
* Log: *
* m.gamazaychikov/SAIC 5/03 *
* m.gamazaychikov/SAIC 5/03 added parameter pdtnmbr to the table *
* M. Li/SAIC 4/04 added hzremap, and direction *
* S. Gilbert/NCEP 11/04 Modified from ctb_g2read to read a WMO *
* Originating Center Table. *
***********************************************************************/
{
FILE *fp;
int n, blen, id, nr, ier;
char buffer[256];
char name[65], abbrev[9];
/*---------------------------------------------------------------------*/
*iret = G_NORMAL;
/*
* Open the table. If not found return an error.
*/
fp = cfl_tbop( tbname, "grid", &ier);
if ( fp == NULL || ier != 0 ) {
*iret = -1;
return;
}
cfl_tbnr(fp, &nr, &ier);
if ( ier != 0 || nr == 0 ) {
*iret = -2;
cfl_clos(fp, &ier);
return;
}
cntrtbl->info = (G2wmocenter *)malloc((size_t)nr*sizeof(G2wmocenter));
cntrtbl->nlines = nr;
n = 0;
while ( n < nr ) {
cfl_trln( fp, 256, buffer, &ier );
if ( ier != 0 ) break;
cst_lstr ( buffer, &blen, &ier );
sscanf( buffer, "%d %64c %s",
&id, name, abbrev);
name[64] = '\0';
abbrev[8] = '\0';
cntrtbl->info[n].id=id;
strcpy(cntrtbl->info[n].name, name);
strcpy(cntrtbl->info[n].abbrev, abbrev);
n++;
}
cfl_clos(fp, &ier);
}
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 vfwwcp ( int *iret )
/************************************************************************
* vfwwcp *
* *
* This program opens, creates and closes the WCP ( Watch Corner *
* Point - radar chart ) text product file. *
* *
* vfwwcp ( iret ) *
* *
* Input parameters: *
* *
* Output parameters: *
* *iret int Return Code *
* *
** *
* Log: *
* A. Hardy/GSC 5/00 Modified from VFWOUI *
* A. Hardy/GSC 12/00 Removed '&' from iret and ti_dayw *
* A. Hardy/GSC 5/01 Removed parameter 'vmin' from vfgtod *
* A. Hardy/SAIC 10/01 Changed 'MKC' to 'SPC' *
* R. Tian/SAIC 06/02 Modified to meet the SPC requirement *
* A. Hardy/NCEP 6/03 Added tmzn to CSS_DATE *
* B. Yin/SAIC 03/04 changed css_date calling sequences *
***********************************************************************/
{
FILE *ifpwcp;
char ifname[256], vorstr[400], locnam[15], type[4];
char ampm[3], zone1[4], ampm1[3];
char chmon[4], chdwk[4], tmzn[4];
float vorlat1, vorlon1, vorlat2, vorlon2, hdiff;
float newlat1, newlon1, newlat2, newlon2;
int ier, etime[5], newtm, time;
int newtime, earr[5];
int itmarr[5], iarr[5], vtime[5], varr[5], datwk;
int istyp, isyr, ismon, isday, ishr, ismin, issec, ijulian;
/*-------------------------------------------------------------------*/
ier = 0;
newtm = 0;
strcpy(locnam, "VOR");
strcpy(type, "WCP");
istyp = 1;
/*
* Create output file for appending.
*/
sprintf ( ifname, "WW%04d.WCP", spcinfo.wnum );
ifpwcp = cfl_wopn ( ifname, &ier );
/*
* storing the issue, valid and ending time.
*/
strcpy ( zone1, "UTC" );
strcpy ( chmon, " " );
time = atoi(spcinfo.itime.hour);
itmarr[0] = spcinfo.itime.year;
itmarr[1] = spcinfo.itime.month;
itmarr[2] = spcinfo.itime.day;
itmarr[3] = time / 100;
itmarr[4] = time % 100;
ti_dayw( itmarr, &datwk, &ier );
vfgdat ( itmarr[1], datwk, chmon, chdwk, &ier );
ti_tzdf ( itmarr, zone1, spcinfo.timzone, iarr, &hdiff, &ier,
strlen(zone1), strlen(spcinfo.timzone) );
vfampm ( iarr[3], &newtime, ampm, &ier );
if ( itmarr[2] != iarr[2] ) {
ti_dayw( iarr, &datwk, &ier);
vfgdat ( iarr[1], datwk, chmon, chdwk, &ier );
}
time = atoi(spcinfo.vtime.hour);
vtime[0] = spcinfo.vtime.year;
vtime[1] = spcinfo.vtime.month;
vtime[2] = spcinfo.vtime.day;
vtime[3] = time / 100;
vtime[4] = time % 100;
ti_tzdf ( vtime, zone1, spcinfo.timzone, varr, &hdiff, &ier,
strlen(zone1), strlen(spcinfo.timzone) );
vfampm ( varr[3], &newtime, ampm, &ier );
time = atoi(spcinfo.etime.hour);
etime[0] = spcinfo.etime.year;
etime[1] = spcinfo.etime.month;
etime[2] = spcinfo.etime.day;
etime[3] = time / 100;
etime[4] = time % 100;
ti_tzdf ( etime, zone1, spcinfo.timzone, earr, &hdiff, &ier,
strlen(zone1), strlen(spcinfo.timzone) );
vfampm ( earr[3], &newtm, ampm1, &ier );
vfgtod ( newtime, newtm, earr[4], ampm, ampm1, datwk,
spcinfo.genday, &ier);
/*
* Set up top three lines of information.
*/
css_date ( &istyp, &isyr, &ismon, &isday, &ishr, &ismin, &issec,
&ijulian, tmzn, &ier);
fprintf ( ifpwcp, "WOUS50 KSPC %02d%s\n", spcinfo.itime.day,
spcinfo.itime.hour);
fprintf ( ifpwcp, "SPCSEVSPC\n");
fprintf ( ifpwcp, "FILE CREATED %02d-%s-%02d AT %02d:%02d:%02d UTC\n\n",
isyr % 100 , chmon, isday, ishr, ismin, issec);
/*
* Set up effective time of day information section.
*/
if ( strcmp(spcinfo.wtype,"TORNADO") == 0 ) {
fprintf ( ifpwcp, "TORN %s WT0%d %s\n", spcinfo.itime.hour, spcinfo.wnum,
spcinfo.etime.hour);
}
if ( strcmp(spcinfo.wtype,"SEVERE THUNDERSTORM") == 0 ) {
fprintf ( ifpwcp, "SEVR %02d%02d%02d %s WT%04d %s\n", (iarr[0] % 10),
spcinfo.itime.month, spcinfo.itime.day, spcinfo.itime.hour,
spcinfo.wnum, spcinfo.etime.hour);
}
/*
* Locate the VOR corner points.
*/
vfvors ( locnam, type, vorstr, &vorlat1, &vorlon1, &vorlat2, &vorlon2,
iret);
/*
* Converting hundreths into minutes.
*/
vftomin ( spcinfo.wcpnt1.lat, spcinfo.wcpnt1.lon,
&(spcinfo.wcpnt1.newlat), &(spcinfo.wcpnt1.newlon), iret );
vftomin ( spcinfo.wcpnt2.lat, spcinfo.wcpnt2.lon,
&(spcinfo.wcpnt2.newlat), &(spcinfo.wcpnt2.newlon), iret );
vftomin ( vorlat2, vorlon2, &newlat2, &newlon2, iret );
vftomin ( spcinfo.wcpnt3.lat, spcinfo.wcpnt3.lon,
&(spcinfo.wcpnt3.newlat), &(spcinfo.wcpnt3.newlon), iret );
vftomin ( spcinfo.wcpnt4.lat, spcinfo.wcpnt4.lon,
&(spcinfo.wcpnt4.newlat), &(spcinfo.wcpnt4.newlon), iret );
vftomin ( vorlat1, vorlon1, &newlat1, &newlon1, iret );
/* The statement below will truncate the minutes at the 100's position.
* No rounding takes place.
*/
fprintf ( ifpwcp, "%05d.%05d %05d.%05d %05d.%05d %05d.%05d %05d.%05d %05d.%05d\n",
(int)(spcinfo.wcpnt1.newlat * 100.0F), (int)(spcinfo.wcpnt1.newlon * -100.0F),
(int)(spcinfo.wcpnt2.newlat * 100.0F), (int)(spcinfo.wcpnt2.newlon * -100.0F),
(int)(newlat2 * 100.0F), (int)(newlon2 * -100.0F),
(int)(spcinfo.wcpnt3.newlat * 100.0F), (int)(spcinfo.wcpnt3.newlon * -100.0F),
(int)(spcinfo.wcpnt4.newlat * 100.0F), (int)(spcinfo.wcpnt4.newlon * -100.0F),
(int)(newlat1 * 100.0F), (int)(newlon1 * -100.0F) );
/*
* Close output file.
*/
cfl_clos ( ifpwcp, &ier );
}
void pds_by10 ( const char *cvcrd, const char *wmotb, const char *nceptb,
unsigned char *byte10, int *ibyt10, int *iscale, int *iret )
/************************************************************************
* pds_by10 *
* *
* This subroutine uses the GEMPAK GRIB vertical coordinate lookup *
* tables to determine the value of PDS octet 10. *
* *
* pds_by10 ( cvcrd, wmotb, nceptb, byte10, ibyt10, iscale, iret ) *
* *
* Input parameters: *
* *cvcrd const char GEMPAK VCORD name string *
* *wmotb const char WMO GRIB VCORD LUT file name *
* *nceptb const char NCEP GRIB VCORD LUT file name *
* *
* Output parameters: *
* *byte10 unsigned char Byte with GRIB VCORD # stored *
* *ibyt10 int Integer value of byte 10 *
* *iscale int Power of 10 scaling in GEMPAK *
* *iret int Return code *
* 0 = normal return *
* -85 = VCORD not found *
* -86 = VCORD # is invalid *
** *
* Log: *
* K. Brill/HPC 7/99 *
* R. Tian/SAIC 10/06 Recoded from Fortran *
************************************************************************/
{
char filnam[2][LLMXLN], record[LLMXLN], prmnam[17], chkprm[17];
int found;
int ifile, iprm, iscl, ier;
FILE *fp;
/*----------------------------------------------------------------------*/
*iret = 0;
*byte10 = (unsigned char)( 255 );
*ibyt10 = 255;
*iscale = 0;
/*
* Check the tables.
*/
cst_lcuc ( (char *)cvcrd, chkprm, &ier );
strcpy ( filnam[0], wmotb );
strcpy ( filnam[1], nceptb );
found = G_FALSE;
ifile = 0;
while ( ifile < 2 && found == G_FALSE ) {
fp = cfl_tbop ( filnam[ifile++], "grid", &ier );
if ( ier != 0 ) continue;
while ( ! feof(fp) && found == G_FALSE ) {
cfl_trln ( fp, sizeof(record), record, &ier );
if ( ier != 0 ) continue;
sscanf ( record, "%d", &iprm );
sscanf ( &record[59], "%s %d", prmnam, &iscl );
if ( strcmp ( prmnam, chkprm ) == 0 ) {
found = G_TRUE;
*ibyt10 = iprm;
*iscale = iscl;
}
}
cfl_clos ( fp, &ier );
}
if ( found == G_FALSE ) {
*iret = -85;
} else if ( *ibyt10 < 255 && *ibyt10 > 0 ) {
*byte10 = (unsigned char)( *ibyt10 );
} else {
*iret = -86;
}
return;
}
void wclosp ( char *filnam, int *gfplot, int *iret )
/************************************************************************
* wclosp *
* *
* This function closes the current gif image. *
* *
* void wclosp ( filnam, gfplot, iret ) *
* *
* Input and output parameters: *
* *filnam char file name *
* *gfplot int *
* *
* Output parameters: *
* *iret int return value *
* *
** *
* Log: *
* D. Austin 5/96 *
* T. Lee/GSC 7/00 Renamed from gdr_closp; Used cfl_wopn *
* T. Piper/SAIC 1/02 Fixed memory leak; freed string *
* S. Jacobs/NCEP 1/02 Moved free of string *
* S. Danz/AWC 11/03 Check if *gfplot is set, not the ptr *
* Only attempt to free if Current is set *
* S. Jacobs/NCEP 7/13 Added file name to error output *
***********************************************************************/
{
char *space;
char *string;
int ier;
/*---------------------------------------------------------------------*/
*iret = G_NORMAL;
/*
* Check the file.
*/
if ( *gfplot && Current ) {
/*
* Make sure the new file's name is null terminated.
*/
string = strdup ( filnam );
space = (char *) strchr( string, ' ' );
*space = '\0';
/*
* Set the filename in the struct.
*/
Current->fname = string;
outfile = cfl_wopn ( Current->fname, &ier );
if ( outfile == NULL ) {
printf ( " Error: %d - Cannot open output file: %s\n",
ier, Current->fname );
exit (-1);
}
/*
* Free the temp string for the file name.
*/
free ( string );
/*
* Write the current imageout in GIF 89a format.
*/
gdImageGif ( Current_Im, outfile );
/*
* Close the file.
*/
cfl_clos ( outfile, &ier );
}
/*
* Free all resources.
*/
if ( Current ) {
free ( Current );
Current = NULL;
gdImageDestroy ( Current_Im );
Current_Im = NULL;
}
/*
* Reset the global pointers after closing the file.
*/
CurrentBGColorIndex = 0;
CurrentColorIndex = 999;
}
void dc_dlog ( char *messag, int *lenm, int *iret )
/************************************************************************
* dc_dlog *
* *
* This routine opens the decoder log file, writes the given message *
* and closes the file. *
* *
* dc_dlog ( messag, lenm, iret ) *
* *
* Input parameters: *
* *messag char Message to write to the log *
* *lenm int Number of chars in the message *
* *
* Output parameters: *
* *iret int Return code *
* 0 = normal return *
* -2 = error writing to log *
* *
** *
* Log: *
* S. Jacobs/NMC 7/95 *
* S. Jacobs/NCEP 6/96 Updated documentation; Removed check *
* for log file not opened; Changed to use *
* a FILE stream with CFL_WRIT *
* S. Jacobs/NCEP 7/96 Added open and close of log file *
* K. Tyle/GSC 1/97 Remove prog. name and dattim; remove *
* loglev variable *
* S. Jacobs/NCEP 2/01 Removed all references to ulog *
***********************************************************************/
{
char mesg[DCMXLN+8], tstr[12];
int lens, ier;
FILE *fplog;
/*---------------------------------------------------------------------*/
*iret = 0;
/*
** Start the output message with the process ID.
*/
cst_inch ( ipid, tstr, &ier );
strcpy ( mesg, "[" );
strcat ( mesg, tstr );
strcat ( mesg, "] " );
/*
** Concatenate the input message to the output string.
*/
strcat ( mesg, messag );
cst_lstr ( mesg, &lens, &ier );
/*
** Get the length of the message and add a Line Feed and
** a NULL to the end.
*/
if ( lens > (DCMXLN+8) - 2 ) {
mesg [lens-1] = CHLF;
mesg [lens] = CHNULL;
}
else {
mesg [lens] = CHLF;
mesg [++lens] = CHNULL;
}
/*
** Open the decoder log file.
*/
fplog = NULL;
if ( dcdlog[0] == '-' )
{
/*
** If the file name is "-", open standard error for logging.
*/
fplog = stderr;
}
else
{
/*
** Try to open the decoder log file.
*/
fplog = cfl_aopn ( dcdlog, &ier );
if ( ier != 0 )
{
/*
** If there is an error opening the file, open standard
** error for real-time processing, otherwise write an
** error message to the LDM log.
*/
if ( irltim )
{
fplog = stderr;
}
else
{
*iret = -3;
return;
}
}
}
/*
** Write the message to the log file.
*/
cfl_writ ( fplog, lens, (unsigned char *)mesg, &ier );
if ( ier != 0 ) {
*iret = -2;
}
/*
** Close the decoder log file.
*/
if ( fplog == stderr )
{
/*
** If standard error is being used for logging, do nothing.
*/
}
else if ( fplog != NULL )
{
/*
** Otherwise, close the log file.
*/
cfl_clos ( fplog, &ier );
}
}
void cvg_rdfilter ( int *iret )
/************************************************************************
* cvg_rdfilter *
* *
* This function reads in all valid entries in the filter table. *
* *
* cvg_rdfilter ( filter, iret ) *
* *
* Input parameters: *
* none *
* *
* Output parameters: *
* *iret int Return code *
* 0 = Normal *
* -1 = unable to open table file *
** *
* Log: *
* J. Wu/SAIC 06/06 initial coding *
***********************************************************************/
{
int ier;
char buff[256], filtype[12], str[256], filstr[8];
FILE *fp;
/*---------------------------------------------------------------------*/
*iret = 0;
/*
* Read the table only once.
*/
if ( filterLoaded ) return;
/*
* Initialize.
*/
nTblFilter = 0;
/*
* Set the flag to True.
*/
filterLoaded = True;
/*
* Open the filter table. If not found, return an error.
*/
fp = cfl_tbop ( FILTER_TBL, "pgen", &ier );
if ( fp == NULL || ier != 0 ) {
printf ( "not loaded ....\n" );
*iret = -1;
return;
}
/*
* Scan table line-by-line and load valid entries.
*/
while ( !feof(fp) ) {
cfl_trln ( fp, sizeof(buff), buff, &ier );
if ( ier == 0 ) {
sscanf ( buff, "%s %s", filstr, filtype );
if ( strcmp ( filstr, "FILTER" ) != 0 ) {
continue; /* Skip invalid lines */
}
if ( ( strcmp ( filtype, "TIME") == 0 ) &&
( nTblFilter < MAX_FILTER_NUM ) ) {
sscanf ( buff, "%*s %*s %s", str );
_fillStrArray ( MAX_FILTER_NUM, DSPLY_FILTER_SZ, str,
&nTblFilter, tblFilter );
}
}
}
cfl_clos ( fp, &ier );
}
int main ( int argc, char *argv[] )
/************************************************************************
* main *
* *
* Main program of shpcv. *
* *
* int main(argc, argv) *
* *
* Input parameters: *
* argc int number of parameters of command line *
* **argv char parameter array of command line *
* *
* Output parameters: *
* Return parameters: *
* NONE *
* *
** *
* Log: *
* R. Tian/SAIC 3/04 Initial coding *
* R. Tian/SAIC 2/05 Modified shp_mtyp *
* T. Piper/SAIC 01/06 Call ip_help if inputs incorrect *
* H. Zeng/SAIC 07/07 added calling to shp_rdException() *
* S. Jacobs/NCEP 3/11 Added debug_flag and print statements *
* S. Jacobs/NCEP 6/14 Moved split func to after dump output *
***********************************************************************/
{
dbf_header dbfhdr;
shx_record shxrec;
shp_record *reclst, *newrec, *currec;
shp_part *curprt;
char dbfnam[MAXSHP][LLPATH], shxnam[MAXSHP][LLPATH],
shpnam[MAXSHP][LLPATH];
FILE *dbffp, *shxfp, *shpfp;
long flen;
int ifld, nf, opt, rec, prt, file_code, nbin, ier;
float ratio, clat, clon;
int lfld, dump, rdpt, cbnd, ctbl, pagflg;
int numrec, numfil, ii;
int mode, istat, iunit, itype;
unsigned long shp_fips;
char device[8], proj[8], filnam[20], prognm[6];
float xsize, ysize, angle1, angle2, angle3, lllat, lllon, urlat,
urlon;
Boolean exception_found;
/*---------------------------------------------------------------------*/
lfld = G_FALSE;
dump = G_FALSE;
rdpt = G_FALSE;
cbnd = G_FALSE;
ctbl = G_FALSE;
pagflg = G_FALSE;
strcpy ( prognm, "shpcv" );
debug_flag = G_TRUE;
/*=================== Parse command line arguments ====================*/
while ( ( opt = getopt ( argc, argv, "r:btldh" ) ) != -1 ) {
switch ( opt ) {
case 'r': /* reduce points ratio */
ratio = atof ( optarg );
if ( ratio <= 0.0 ) {
ratio = 0.01;
}
rdpt = G_TRUE;
break;
case 'b': /* create bound and bound info */
cbnd = G_TRUE;
break;
case 't': /* create station table */
ctbl = G_TRUE;
break;
case 'l': /* list fields */
lfld = G_TRUE;
break;
case 'd': /* dump the shape file */
dump = G_TRUE;
break;
case 'h': /* display help */
default:
ip_help ( prognm, &pagflg, &ier, strlen(prognm) );
exit ( 0 );
break;
}
}
if ( optind == argc || argc - optind > MAXSHP ) {
ip_help ( prognm, &pagflg, &ier, strlen(prognm) );
exit ( -1 );
}
/*======================== Read the shape file ========================*/
/*
* Loop over input files.
*/
currec = NULL;
numrec = 0;
numfil = argc - optind;
for ( nf = 0; nf < numfil; nf++ ) {
/*
* Get the input names and open them.
*/
if ( debug_flag ) {
printf ( "File %d: %s\n", nf, argv[optind+nf] );
}
strcpy ( dbfnam[nf], argv[optind+nf] );
strcat ( dbfnam[nf], ".dbf" );
strcpy ( shxnam[nf], argv[optind+nf] );
strcat ( shxnam[nf], ".shx" );
strcpy ( shpnam[nf], argv[optind+nf] );
strcat ( shpnam[nf], ".shp" );
cfl_inqr ( dbfnam[nf], NULL, &flen, dbfnam[nf], &ier );
dbffp = cfl_ropn ( dbfnam[nf], NULL, &ier );
if ( ier != 0 ) {
fprintf ( stderr, "File %s does not exist.\n", dbfnam[nf] );
exit ( -1 );
}
cfl_inqr ( shxnam[nf], NULL, &flen, shxnam[nf], &ier );
shxfp = cfl_ropn ( shxnam[nf], NULL, &ier );
if ( ier != 0 ) {
fprintf ( stderr, "File %s does not exist.\n", shxnam[nf] );
exit ( -1 );
}
cfl_inqr ( shpnam[nf], NULL, &flen, shpnam[nf], &ier );
shpfp = cfl_ropn ( shpnam[nf], NULL, &ier );
if ( ier != 0 ) {
fprintf ( stderr, "File %s does not exist.\n", shpnam[nf] );
exit ( -1 );
}
/*
* Detect platform endian.
*/
cfl_read ( shpfp, INTEGER_SIZE, (unsigned char *)&file_code,
&nbin, &ier );
if ( file_code == 9994 ) {
mch_endian = BIG;
} else {
mch_endian = LITTLE;
}
/*
* Read database header.
*/
shp_rdbh ( dbffp, &dbfhdr, &ier );
numrec += dbfhdr.nrec;
if ( lfld == G_TRUE ) {
for ( ifld = 0; ifld < dbfhdr.nfld; ifld++ ) {
printf ( "Field: %s\n", dbfhdr.dbflds[ifld].name );
}
} else {
/*
* Read shape record and construct an internal list.
*/
for ( rec = 0; rec < dbfhdr.nrec; rec++ ) {
/*
* Read record field data.
*/
shp_rdbf ( dbffp, rec, &dbfhdr, &ier );
/*
* Read record index.
*/
shp_rshx ( shxfp, rec, &shxrec, &ier );
/*
* Read record data.
*/
shp_rshp ( shpfp, &dbfhdr, &shxrec,
&newrec, &ier );
/*
* Add the new record on record list.
*/
newrec->prvrec = currec;
if ( currec != NULL ) {
currec->nxtrec = newrec;
} else {
reclst = newrec;
}
currec = newrec;
}
}
/*
* Close up opened files.
*/
cfl_clos ( dbffp, &ier );
cfl_clos ( shxfp, &ier );
cfl_clos ( shpfp, &ier );
}
if ( lfld == G_TRUE ) {
shp_mfreeall ( );
exit ( 0 );
}
/*======================== Read the shape exception table =============*/
_shpException = NULL;
_numShpException = 0;
shp_rdException ( &ier );
/*======================= Starting Post-Process =======================*/
/*
* Dump shapefile records.
*/
if ( dump == G_TRUE ) {
for ( rec = 0, currec = reclst; rec < numrec;
rec++, currec = currec->nxtrec ) {
shp_wfld ( stdout, currec, &ier );
shp_wrec ( stdout, currec, &ier );
}
shp_mfreeall ( );
exit ( 0 );
}
/*
* Split record part if it has more than MAXOUT number of points
* or it crosses the international dateline.
*/
shp_splt ( reclst, numrec, &ier );
/*
* Detect the map type.
*/
shp_mtyp ( dbfnam, numfil, &ier );
if ( maptyp == 0 ) {
fprintf ( stderr, "Unknown Map Type.\n" );
exit ( -1 );
}
/*
* Delete not used records.
*/
shp_drec ( &reclst, &numrec, &ier );
/*
* Combine records that have the same key.
*/
shp_cmbn ( reclst, &numrec, &ier );
/*
* Compute record centroid.
*/
mode = 1;
iunit = itype = 1;
xsize = ysize = 1.0F;
strcpy ( device, "GN" );
strcpy ( filnam, "SHPCV" );
/*
* Use North STR projection.
*/
strcpy ( proj, "STR" );
angle1 = 90.0F;
angle2 = -90.0F;
angle3 = 0.0F;
lllat = -15.0F;
lllon = -135.0F;
urlat = -15.0F;
urlon = -135.0F;
ginitp ( &mode, &istat, &ier );
gsdeva ( device, &iunit, filnam, &itype, &xsize, &ysize, &ier,
strlen(device), strlen(filnam) );
gsmprj ( proj, &angle1, &angle2, &angle3,
&lllat, &lllon, &urlat, &urlon, &ier, strlen(proj) );
for ( currec = reclst, rec = 0; rec < numrec;
rec++, currec = currec->nxtrec ) {
/*
* Get the shape fips code, check if there is a match in
* Shape Exception Table. If yes, get manually set
* clon&clat value from the table directly.
*/
if ( sscanf(currec->fields[3].data, "%lu", &shp_fips) == 1 ) {
exception_found = FALSE;
for ( ii = 0; ii < _numShpException; ii++ ) {
if ( _shpException[ii].fips == shp_fips ) {
currec->cenlat = _shpException[ii].clat;
currec->cenlon = _shpException[ii].clon;
exception_found = TRUE;
break;
}
}
if ( exception_found ) continue;
}
/*
* Get the shape id, check if there is a match in
* Shape Exception Table. If yes, get manually set
* clon&clat value from the table directly.
*/
exception_found = FALSE;
for ( ii = 0; ii < _numShpException; ii++ ) {
if ( strcasecmp(currec->fields[0].data, _shpException[ii].id) == 0 ) {
currec->cenlat = _shpException[ii].clat;
currec->cenlon = _shpException[ii].clon;
exception_found = TRUE;
break;
}
}
if ( exception_found ) continue;
/*
* Calculate clon&clat mathematically from an algorithm.
*/
shp_gctr ( currec, &clon, &clat, &ier );
if ( ier == 0 ) {
currec->cenlat = clat;
currec->cenlon = clon;
} else {
currec->cenlat = RMISSD;
currec->cenlon = RMISSD;
}
} /* the end of for ( currec ... */
/*
* Reduce number of points.
*/
if ( rdpt == G_TRUE ) {
for ( rec = 0, currec = reclst; rec < numrec;
rec++, currec = currec->nxtrec ) {
for ( prt = 0, curprt = currec->shpart;
prt < currec->numprt;
prt++, curprt = curprt->nxtprt ) {
shp_thin ( curprt, ratio, &ier );
}
}
}
/*
* Create station table.
*/
if ( ctbl == G_TRUE ) {
shp_ctbl ( reclst, numrec, &ier );
}
/*
* Create bound and bound info.
*/
if ( cbnd == G_TRUE ) {
shp_cbnd ( reclst, numrec, &ier );
}
/*
* Clean up.
*/
shp_mfreeall ( );
return 0;
}
void csctbl ( char *tblnam, int *iret )
/************************************************************************
* csctbl *
* *
* This routine checks the GEMPAK graphic color table by searching the *
* local (current) dir and $GEMTBL/color directory then creates the *
* structure for colors currently used in driver. Default color table *
* is coltbl.xwp. *
* *
* csctbl (tblnam, iret) *
* *
* Input parameters: *
* *tblnam char color table file *
* *
* Output parameters: *
* *iret int return code *
* 0 for successful *
* -1 for file error *
* 2 for number of colors exceeded the *
* maximum *
* *
** *
* Log: *
* L. Williams 1/96 *
* G. Krueger/EAI 8/96 Changed CFL_TOPN->TBOP *
* S. Wang/GSC 11/97 Change coltbl.xw to coltbl.xwp *
* S. Jacobs/NCEP 12/97 Fixed check for NULL table name *
* T. Piper/SAIC 1/02 Initialized iret *
* T. Piper/SAIC 07/04 Used CLR_DIR and CLR_TBL *
***********************************************************************/
{
GmcColor *gmc;
FILE *fp;
char *token, buf[BUF_SIZE], fname[256], tgcname[16];
char tmpabv[4], tmpname[40], txname[40], xcolr[50];
int ary_index, c_element, found, ier, ii, in_range;
int pos, rgbval, rc;
/*---------------------------------------------------------------------*/
rc = 0;
ier = 0;
*iret = 0;
ary_index = 0;
gmc = &gemCmap.color[0];
/*
* If table name is NULL use the default name.
*/
if ( tblnam && tblnam[0] != '\0' ) {
strcpy(fname, tblnam);
}
else {
strcpy(fname, CLR_TBL);
}
/*
* open color file
*/
fp = cfl_tbop(fname, CLR_DIR, &ier);
if (ier != 0) {
*iret = -1;
return;
}
/*
* read and process each line
*/
while (fgets(buf, BUF_SIZE, fp) != NULL) {
if (ary_index > GRAPH_COLORS) {
ngemC = GRAPH_COLORS; /* array overflow */
fclose(fp);
*iret = 2;
return;
}
if ( (token=strtok(buf, TOKENDM)) == NULL )
continue; /* empty line */
if (*token == '#' || *token == ';' || *token == '!')
continue; /* comments */
c_element = 0;
in_range = 0;
rgbval = 1;
found = 0;
pos = 0;
while (token) {
switch ( c_element ) {
case CNAME: /* color name */
strcpy( gemColrs[ary_index].name, token );
break;
case GMC: /* abbreviated color name */
break;
case RED: /* red color component */
if ( (*token == 'N') || (*token == 'n') )
rgbval = 0;
else
gemColrs[ary_index].red = atoi ( token );
break;
case GREEN: /* green color component */
if ( (*token == 'N') || (*token == 'n') )
rgbval = 0;
else
gemColrs[ary_index].green = atoi ( token );
break;
case BLUE: /* blue color component */
if ( (*token == 'N') || (*token == 'n') )
rgbval = 0;
else
gemColrs[ary_index].blue = atoi ( token );
break;
default:
strncpy( &(xcolr[pos]), token, strlen(token));
pos = pos + strlen(token);
++pos;
xcolr[pos] = ' ';
break;
}
token = strtok(NULL, TOKENDM);
c_element++;
}
xcolr[pos-1] = '\0';
/*
* if RGB is avaliable check its range
*/
if ( rgbval ) {
if ( ( gemColrs[ary_index].red >= 0 &&
gemColrs[ary_index].red <= 255 ) &&
( gemColrs[ary_index].green >= 0 &&
gemColrs[ary_index].green <= 255 ) &&
( gemColrs[ary_index].blue >= 0 &&
gemColrs[ary_index].blue <= 255 ) ) {
in_range = 1;
}
}
/*
* Check if xw color name is in Gempak color table
*/
for (ii=0; ii < gemCmap.nc; ii++) {
cst_lcuc( gemColrs[ary_index].name, tmpname, &rc );
cst_lcuc( gmc[ii].gcname, tgcname, &rc);
cst_lcuc( gmc[ii].abvname, tmpabv, &rc );
cst_lcuc( gmc[ii].xname, txname, &rc );
if ( (strcmp( tmpname, tgcname ) == 0) ||
(strcmp( tmpname, tmpabv ) == 0) ||
(strcmp( tmpname, txname ) == 0) ) {
found = 1;
if ( ( in_range ) &&
( ( gemColrs[ary_index].red != gmc[ii].red ) ||
( gemColrs[ary_index].green != gmc[ii].green ) ||
( gemColrs[ary_index].blue != gmc[ii].blue ) ) ) {
gemColrs[ary_index].index = -1;
}
else {
gemColrs[ary_index].index = ii;
gemColrs[ary_index].red = -1;
gemColrs[ary_index].green = -1;
gemColrs[ary_index].blue = -1;
}
ary_index++;
break;
}
} /* end for loop */
/*
* color name not found in Gempak table
*/
if ( !found ) {
/*
* if range is ok set index
*/
if (in_range) {
gemColrs[ary_index].index = -1;
ary_index++;
}
}
} /* end while loop */
ngemC = ary_index;
if ( fp != NULL ) cfl_clos ( fp, &ier );
return;
}
void crarea ( char *imgnam, int *iret )
/************************************************************************
* crarea *
* *
* This subroutine reads the image data from a MCIDAS AREA file. *
* The full image is placed in memory pointed to by imgData. *
* *
* crarea ( imgnam, iret ) *
* *
* Input parameters: *
* *imgnam char Name of image file *
* *
* Output parameters: *
* *iret int Return code *
* G_NORMAL = normal return *
* G_NIDSIZ = invalid image depth *
* G_NIMGFL = cannot open/read img *
* G_NMEMRY = memory alloc failure *
** *
* Log: *
* J. Cowie/COMET 3/95 *
* J. Cowie/COMET 5/95 Modified to work with NAWIPS 5.2.1 *
* S. Jacobs/NCEP 1/97 Copied from XRAREA *
* J. Cowie/COMET 1/97 Changed common variable names *
* J. Cowie/COMET 12/97 Added cfl_clos if error on cfl_seek *
* S. Chiswell/Unidata 8/06 Added multibyte image check *
***********************************************************************/
{
FILE *fp;
char defdir[12];
long lofset;
unsigned int iboff;
int lstrt, ii, jj, kk, nbin, ier;
unsigned char *rwdptr, *imdptr, buf[8];
int isPNG = 0;
/*---------------------------------------------------------------------*/
if ( imdpth <= 0 ) {
*iret = G_NIDSIZ;
return;
}
/*
* Open the file and seek to data offset.
*/
defdir[0] = CHNULL;
fp = cfl_ropn ( imgnam, defdir, &ier );
if ( ier != 0 ) {
*iret = G_NIMGFL;
return;
}
else {
lofset = (long) imdoff;
cfl_seek ( fp, lofset, SEEK_SET, &ier );
if ( ier != 0 ) {
cfl_clos ( fp, &ier );
*iret = G_NIMGFL;
return;
}
/* See if this is a png compressed AREA file */
cfl_read ( fp, 8, buf, &nbin, &ier);
if ( ( *iret == 0 ) && ( nbin == 8 ) ) {
/*
** Check PNG magic word (8 first bytes):
** http://www.libpng.org/pub/png/spec/1.2/PNG-Rationale.html
** decimal - 137 80 78 71 13 10 26 10
** hexadecimal - 89 50 4e 47 0d 0a 1a 0a
** ASCII - \211 P N G \r \n \032 \n
*/
if ( buf[0] == (unsigned char)137 && buf[1] == (unsigned char) 80 &&
buf[2] == (unsigned char) 78 && buf[3] == (unsigned char) 71 &&
buf[4] == (unsigned char) 13 && buf[5] == (unsigned char) 10 &&
buf[6] == (unsigned char) 26 && buf[7] == (unsigned char) 10 ) {
isPNG = 1;
}
}
cfl_seek ( fp, lofset, SEEK_SET, &ier );
}
*iret = G_NORMAL;
/*
* If this file contains only one channel (band) and no line
* prefix data, read the raw data directly into imgData and exit.
*/
if ( imprsz == 0 && imnchl == 1 ) {
if ( isPNG )
png_read ( fp, imnpix, imnlin, imgData, &ier );
else
cfl_read ( fp, imldat, imgData, &nbin, &ier );
cfl_clos ( fp, &ier );
crarea_pixel ( imgData );
return;
}
else {
/*
* Allocate space for the raw image data.
*/
if ( ( rawData == (unsigned char *) NULL ) ||
( imldat > (int)last_rawsize) ) {
if ( rawData != (unsigned char *) NULL) {
free(rawData);
}
rawData = (unsigned char *) calloc ( imldat,
sizeof(unsigned char) );
if ( rawData == (unsigned char *) NULL ) {
*iret = G_NMEMRY;
return;
}
last_rawsize = imldat;
}
/*
* Read the raw image data.
*/
if ( isPNG )
png_read ( fp, imnpix, imnlin, imgData, &ier );
else
cfl_read ( fp, imldat, rawData, &nbin, &ier );
cfl_clos ( fp, &ier );
}
/*
* Process the prefix bytes and move data for the
* image channel into the imgData array.
*
* NOTE: This has been tested for images with prefix bytes.
* Have not tested any image files with multiple channels
* in the file.
*/
imdptr = imgData;
for ( ii = 0; ii < imnlin; ii++ ) {
/*
* Calculate the starting byte in rawData for this line.
*/
lstrt = ii * (imnpix * imdpth * imnchl + imprsz);
rwdptr = &rawData[lstrt];
/*
* Process prefix data to each line, if any.
* iboff = band offset in each element.
*/
iboff = 0;
if ( imprsz != 0 ) {
/*
* Skip 4 bytes of validity code.
*/
if ( imvald != 0 ) rwdptr += 4;
/*
* Skip documentation and calibration code.
*/
rwdptr += imdcsz + imclsz;
/*
* Process level map to get the band for each element,
* if necessary.
*/
if ( imnchl > 1) {
/*
* Get the band offset.
*/
for ( kk = 0; kk < imlvsz; kk ++ ) {
if ( *rawData == 8 ) {
iboff = kk;
rwdptr += imlvsz - kk;
break;
}
else {
rwdptr ++;
}
}
}
else {
/*
* Skip the level map.
*/
rwdptr += imlvsz;
}
} /* End of "if ( imprsz != 0 )" */
/*
* Get the image data.
*/
for ( jj = 0; jj < imnpix; jj++ ) {
for ( kk = 0; kk < imdpth; kk++ ) {
*imdptr++ = *(rwdptr + iboff);
rwdptr ++;
}
}
} /* End of loop over imnlin */
crarea_pixel ( imgData );
}
void vfcnsaw ( int *iret )
/************************************************************************
* vfcnsaw *
* *
* This program opens, creates and closes the Weather Watch cancel SAW *
* text product file. *
* *
* vfcnsaw ( iret ) *
* *
* Input parameters: *
* *
* Output parameters: *
* *iret int Return Code *
* *
** *
* Log: *
* A. Hardy/GSC 10/99 Created *
* A. Hardy/GSC 2/00 Extracted from SPCTXT *
* A. Hardy/GSC 5/00 Changed cfl_aopn to cfl_wopn; Use *
* AWIPS/WMO header ids.; removed 'NNNN' *
* A. Hardy/GSC 12/00 Added '&' to ier for vfgname,vfctim *
* A. Hardy/GSC 5/01 Initialized iret to 0 *
* A. Hardy/SAIC 10/01 Added check for old/new WMO header flag *
* R. Tian/SAIC 06/02 Modified to meet the SPC requirement *
* A. Hardy/NCEP 7/03 Added calls to UTL library *
* A. Hardy/NCEp 11/03 Added watch status check for 'TEST' *
***********************************************************************/
{
FILE *ifpsaw;
char ifname[256];
int ier, leni;
/*-------------------------------------------------------------------*/
*iret = 0;
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.CNL", spcinfo.wnum );
ifpsaw = cfl_wopn ( ifname, &ier );
/*
* Get current GEMPAK time for issue time of cancel product.
*/
leni = sizeof(spcinfo.curtim);
utl_ctim ( leni, spcinfo.curtim, &ier );
/*
* Set up header information.
*/
spcinfo.sssnum = spcinfo.wnum % 10;
fprintf ( ifpsaw, "WWUS30 KWNS %s\n", spcinfo.curtim);
fprintf( ifpsaw, "SAW%d\n", spcinfo.sssnum);
fprintf ( ifpsaw, "%cSPC AWW %s\n", CHRS, spcinfo.curtim);
/*
* Set up cancelled line.
* Check if watch has been issued as a 'TEST'.
*/
if ( strcmp (spcinfo.status, "TEST") == 0 ) {
fprintf ( ifpsaw, "WW %d TEST %s CANCELLED\n\n",
spcinfo.wnum, spcinfo.wtype);
}
else {
fprintf ( ifpsaw, "WW %d %s CANCELLED\n\n",
spcinfo.wnum, spcinfo.wtype);
}
/*
* Close output file.
*/
cfl_clos ( ifpsaw, &ier );
}
void _getrpt ( srchinfo_t *srchinfo, char *report, int *iret )
/************************************************************************
* _getrpt *
* *
* This routine will retrieve the report for the requested location. *
* *
* _getrpt ( srchinfo, report, iret ) *
* *
* Input parameters: *
* *srchinfo srchinfo_t Search info structure *
* *
* Output parameters: *
* *report char Report *
* *iret int Return code *
* *
* *
** *
* Log: *
* L. Williams/EAI 6/96 modified from srchb_fosdFndrepWW *
* S. Jacobs/NCEP 12/98 Changed fclose to cfl_clos *
* S. Chiswell/UCAR 04/01 Changed strchr to memchr *
* R.Tian/SAIC 1/02 Avoid possible overflow report *
* R. Tian/SAIC 04/02 Query file size before open it *
***********************************************************************/
{
int rep_len;
long flen;
char dumyname[133];
char *iepos, *ispos, *text;
/*---------------------------------------------------------------------*/
/*
* Get the size of the new file. If the size is 0, skip it.
*/
cfl_inqr(srchinfo->file_info.filnam, NULL, &flen, dumyname, iret);
if ( *iret != 0 || flen == 0 ) {
report[0] = '\0';
*iret = -1;
return; /* error in query file */
}
srchinfo->file_info.file_len = (int)flen;
/*
* Open the new file.
*/
srchinfo->file_info.fptr = cfl_ropn(
srchinfo->file_info.filnam,
NULL, iret );
if ( *iret != 0 ) {
report[0] = '\0';
*iret = -1;
return; /* error in opening file */
}
/*
* Allocate enough space to hold the entire contents of the file.
*/
text = (char *) malloc((size_t)(srchinfo->file_info.file_len + 1) *
sizeof(char) );
/*
* Read the contents of the file into the TEXT string.
*/
if ( fread( text, (size_t)srchinfo->file_info.file_len, 1,
srchinfo->file_info.fptr) != (size_t)1 ){
/*
* reading error
*/
report[0] = '\0';
*iret = -1;
free( text );
return;
}
/*
* Copy the report from string text to string report
*/
ispos = &text[reportInfo[srchinfo->current].position];
iepos = memchr( &text[reportInfo[srchinfo->current].position],
CHCTLC, (size_t)(srchinfo->file_info.file_len -
reportInfo[srchinfo->current].position));
if ( iepos != NULL )
rep_len = G_MIN((iepos - ispos), (REPMAX - 1));
else
rep_len = 0;
strncpy( report, &text[reportInfo[srchinfo->current].position], (size_t)rep_len
);
report[rep_len] = '\0';
free( text );
/*
* Close the data file.
*/
if ( srchinfo->file_info.fptr != NULL ) {
cfl_clos ( srchinfo->file_info.fptr, iret );
srchinfo->file_info.fptr = NULL;
}
}
void tb_nidsdb ( char *prdnam, char *res, int *iprod, int *iret )
/************************************************************************
* tb_nidsdb *
* *
* This subroutine returns information about the radar image from the *
* NIDS product table file. *
* *
* void tb_nidsdb ( prdnam, res, iprod, iret ) *
* *
* Input parameters: *
* *prdnam char Product name *
* *res char Data resolution in km *
* *
* Output parameters: *
* *iprod int NIDS product ID *
* *iret int Return code *
* 0 = normal return *
* +3 = No entry found for image *
* -7 = Could not open imtyp table*
** *
* Log: *
* m.gamazaychikov/CWS 01/10 Created *
***********************************************************************/
{
int found, ier, ier1, loglev=2;
float ares;
char *grp="TB", line[128];
size_t ii;
static int nr;
static FILE *fptr=NULL;
static Radtbl_t *radtbl=NULL;
/*---------------------------------------------------------------------*/
/*
* Initialize output variables.
*/
*iprod = 0;
*iret = 33; /* Not found */
cst_crnm ( res, &ares, &ier );
/*
* If table not yet read into memory; open the image type table file.
*/
if ( fptr == NULL ) {
fptr = cfl_tbop ( NIDPRD_TBL, "rad", &ier );
if ( ier != 0 ) {
*iret = -7;
er_lmsg (&loglev, grp, iret, NIDPRD_TBL, &ier1, strlen(grp), strlen(NIDPRD_TBL));
return;
}
/*
* Load the structure.
*/
cfl_tbnr (fptr, &nr, &ier );
if ( ier != 0 || nr == 0 ) {
*iret = -7;
er_lmsg (&loglev, grp, iret, NIDPRD_TBL, &ier1, strlen(grp), strlen(NIDPRD_TBL));
cfl_clos(fptr, &ier);
return;
}
G_MALLOC(radtbl, Radtbl_t, nr, "tb_nidsdb: radtbl");
for (ii = 0; ii < (size_t)nr; ii++ ) {
/*
* Read the next record.
*/
cfl_trln ( fptr, 127, line, &ier );
if ( ier == 0 ) {
sscanf(line,"%s %s %i %i %s %f %s",
radtbl[ii].type, radtbl[ii].name, &radtbl[ii].prod,
&radtbl[ii].lvls, radtbl[ii].units,
&radtbl[ii].res, radtbl[ii].desc);
}
} /* end of 'for (ii = 0; ii < nr; ii++ )' */
cfl_clos(fptr, &ier);
} /* end of 'if ( *fptr == NULL )' */
ii = 0;
found = G_FALSE;
/*
* Retrieve the product ID for the specified
* product name and the resolution.
*/
while ( !found && ii < (size_t)nr ) {
//if ( strstr (radtbl[ii].name, prdnam) != NULL ) {
if ( strcmp (prdnam, radtbl[ii].name) == 0 ) {
if ( G_DIFF(ares, radtbl[ii].res) ) {
found = G_TRUE;
*iprod = radtbl[ii].prod;
*iret = G_NORMAL;
}
}
ii++;
}
}
void ctb_g2rdvar ( char *tbname, G2vars_t *vartbl, int *iret )
/************************************************************************
* ctb_g2rdvar *
* *
* This routine will read a GRIB2 Parameter *
* table into an array of structures. *
* The table is allocated locally and a pointer to the new table is *
* passed back to the user in argument vartbl. The user is resposible *
* for freeing this memory, when the table is no longer needed, by *
* free(vartbl.info) *
* *
* ctb_g2rdvar ( tbname, vartbl, iret ) *
* *
* Input parameters: *
* *tbname char Filename of the table to read *
* *
* Output parameters: *
* *vartbl G2vars_t Pointer to list of table entries *
* *iret int Return code *
* 0 = Successful *
* -1 = Could not open *
* -2 = Could not get count of *
* of table entries. *
** *
* Log: *
* S. Gilbert/NCEP 11/04 Modified from ctb_g2rdcntr to read a *
* GRIB2 Parameter Table. *
***********************************************************************/
{
FILE *fp = NULL;
int n, blen, nr, ier;
char buffer[256];
char name[33], gname[13], unts[21];
int disc, cat, parm, pdtn, scl, ihzrmp, idrct;
float msng;
const int ncoln=110;
/*---------------------------------------------------------------------*/
*iret = G_NORMAL;
/*
* Open the table. If not found return an error.
*/
fp = cfl_tbop( tbname, "grid", &ier);
if ( fp == NULL || ier != 0 ) {
if (fp)
fclose(fp);
*iret = -1;
return;
}
cfl_tbnr(fp, &nr, &ier);
if ( ier != 0 || nr == 0 ) {
*iret = -2;
cfl_clos(fp, &ier);
return;
}
vartbl->info = malloc((size_t)nr*sizeof(G2Vinfo));
if (vartbl->info == NULL) {
*iret = -1;
cfl_clos(fp, &ier);
return;
}
vartbl->nlines = nr;
n = 0;
while ( n < nr ) {
cfl_trln( fp, 256, buffer, &ier );
if ( ier != 0 ) {
free(vartbl->info);
break;
}
cst_lstr ( buffer, &blen, &ier );
if ( blen > ncoln ) {
sscanf( buffer,
"%12d %12d %12d %12d %32c %20c %12s %12d %20f %12d %12d",
&disc, &cat, &parm, &pdtn,
name, unts, gname,
&scl, &msng, &ihzrmp, &idrct );
}
else {
sscanf( buffer, "%12d %12d %12d %12d %32c %20c %12s %12d %20f",
&disc, &cat, &parm, &pdtn,
name, unts, gname,
&scl, &msng);
ihzrmp = 0;
idrct = 0;
}
name[32] = '\0';
unts[20] = '\0';
gname[12] = '\0';
vartbl->info[n].discpln=disc;
vartbl->info[n].categry=cat;
vartbl->info[n].paramtr=parm;
vartbl->info[n].pdtnmbr=pdtn;
strcpy(vartbl->info[n].name, name);
strcpy(vartbl->info[n].units, unts);
strcpy(vartbl->info[n].gemname, gname);
vartbl->info[n].scale=scl;
vartbl->info[n].missing=msng;
vartbl->info[n].hzremap = ihzrmp;
vartbl->info[n].direction = idrct;
n++;
}
cfl_clos(fp, &ier);
}
int main ( int argc, char **argv )
/************************************************************************
* mdp *
* *
* This program generates the mesoscale discussion latlon pairings. *
* Pairings will be written to a file whose filename is based on the *
* input filename (filename extension, if exists, is replaced w/ "mdp").*
* *
* Example: *
* mdp input_vgf_file.vgf *
* Produces latlon pairings in the ASCII file *
* output_vgf_file.mdp *
* *
* main(argc, argv) *
* *
* Input parameters: *
* argc int number of parameters of command line *
* argv char** parameter array of command line *
* *
* Output parameters: *
* Return parameters: *
* NONE *
* *
** *
* Log: *
* D.W.Plummer/NCEP 6/02 *
* D.W.Plummer/NCEP 8/02 Bug fix for lons > 99.995 and < 100.0 *
* m.gamazaychikov/SAIC 3/03 Made mdp work only on scallop lines *
* added WFOs and STATES to output text *
* m.gamazaychikov/SAIC 3/03 Made mdp work on lines grouped or not *
* grouped with WFOs and/or STATES *
* Made MDP exit upon encountering first *
* scallop line in VGF file *
* Made changes to format of output text *
* T. Piper/SAIC 12/05 Updated cst_wrap for CSC *
* J. Wu/SAIC 04/06 Added parameter in cst_wrap *
***********************************************************************/
{
int ii, ix, iy, pagflg, ier;
int ilen, npts;
char vg_class, vg_type;
char blank[2]={' '}, errgrp[8], infile[128], ifname[128], outfile[128];
float x, y;
long ifilesize;
int ne1, more1, curpos1;
char buffer[1024], str[20], *cptr;
int wrtoutfg, wrtwfofg, wrtsttfg;
int grpnumbr1, grpnumbr2;
int lintyp, jj, narea, areatype;
int ne2, more2, curpos2;
char strwfo[480], strstt[480], bufferlat[1024];
VG_DBStruct el;
FILE *ifptr, *ofptr;
/*---------------------------------------------------------------------*/
/*
* Check if number of input arguments is correct.
*/
if ( argc < 2 ) {
pagflg = G_FALSE;
strcpy ( errgrp, "MDP" );
ip_help ( errgrp, &pagflg, &ier,
strlen(errgrp) );
exit (0);
}
/*
* First input on command line is input vgf file name.
*/
strcpy ( infile, argv[1] );
cfl_inqr ( infile, NULL, &ifilesize, ifname, &ier );
ifptr = (FILE *) cfl_ropn(ifname, "", &ier);
if ( ier != 0 ) {
printf("Error opening VGF file %s\n", infile );
exit (0);
}
/*
* Output filename is input filename w/ "mdp" filename extension.
*/
strcpy ( outfile, infile );
cptr = strrchr( outfile, '.' );
if ( cptr != (char *)NULL ) {
cptr[0] = '\0';
}
strcat( outfile, ".mdp" );
/*
* Loop through all the elements until a line is found.
*/
ne1 = 0;
more1 = G_TRUE;
curpos1 = 0;
buffer[0] = '\0';
bufferlat[0] = '\0';
while ( ne1 < MAX_EDITABLE_ELEMS && more1 == G_TRUE ) {
wrtoutfg = G_FALSE;
wrtsttfg = G_FALSE;
wrtwfofg = G_FALSE;
cvg_rdrecnoc( ifname, ifptr, curpos1, &el, &ier );
if ( ier < 0 ) {
more1 = G_FALSE;
}
else {
curpos1 += el.hdr.recsz;
vg_class = el.hdr.vg_class;
vg_type = el.hdr.vg_type;
grpnumbr1 = el.hdr.grpnum;
if ( (int)vg_class == CLASS_LINES ) {
/*
* Open output file.
*/
ofptr = (FILE *)cfl_wopn ( outfile, &ier );
if ( ier != 0 ) {
printf("Error opening/creating output file %s\n", outfile );
exit (0);
}
if ((int)vg_type == SPLN_ELM ) {
/*
* type of special line
*/
lintyp = el.elem.spl.info.spltyp;
if (lintyp == 3 ) {
/*
* number of points in a line
*/
npts = el.elem.spl.info.numpts;
/*
* Format lats and lons into buffer.
*/
for ( ii = 0; ii < npts; ii++ ) {
x = el.elem.spl.latlon[ii];
y = -el.elem.spl.latlon[ii+npts];
/*
* Make sure lats and lons are rounded to 100ths of deg.
*/
x = ((int)(x*100)) / 100.0F;
y = ((int)(y*100)) / 100.0F;
if ( y >= 100.0F ) y -= 100.0F;
ix = G_NINT(x*100.0F);
iy = G_NINT(y*100.0F);
sprintf( str, "%04d%04d ", ix, iy );
strcat ( bufferlat, str );
/*
* this flag is here to ensure exit as soon
* as a line is found
*/
more1 = G_FALSE;
/*
* this flag is here to ensure that lat-lon
* pairs are written out even without wfo and states
* grouped with it
*/
wrtoutfg = G_TRUE;
}
ne2 = 0;
curpos2 = 0;
more2 = G_TRUE;
while ( ne2 < MAX_EDITABLE_ELEMS && more2 == G_TRUE ) {
cvg_rdrecnoc( ifname, ifptr, curpos2, &el, &ier );
if ( ier < 0 ) {
more2 = G_FALSE;
}
else {
curpos2 += el.hdr.recsz;
vg_class = el.hdr.vg_class;
vg_type = el.hdr.vg_type;
grpnumbr2 = el.hdr.grpnum;
if (grpnumbr2 == grpnumbr1 && grpnumbr2 != 0) {
if ((int)vg_type == LIST_ELM ) {
areatype = 0;
areatype = el.elem.lst.info.subtyp;
if (areatype == 3) {
wrtwfofg = G_TRUE;
narea = el.elem.lst.data.nitems;
strwfo[0] = '\0';
strcat( strwfo, "ATTN...WFO...");
jj = 0;
for (jj = 0; jj < narea; jj++) {
strcpy (str, el.elem.lst.data.item[jj]);
strcat (strwfo, str);
strcat (strwfo, "..." );
if ((jj+1)%9 == 0) {
strcat (strwfo, "\n");
}
}
strcat (strwfo, "\n");
}
if (areatype == 4) {
wrtsttfg = G_TRUE;
narea = el.elem.lst.data.nitems;
strstt[0] = '\0';
jj = 0;
for (jj = 0; jj < narea; jj++) {
strcpy (str, el.elem.lst.data.item[jj]);
strcat (strstt, str);
strcat (strstt, "Z000-" );
}
strcat (strstt, "\n");
}
}
}
}
ne2++;
}
}
}
}
}
ne1++;
/*
* Write to output file.
*/
if (wrtoutfg == G_TRUE) {
/*
* Wrap bufferlat such that only 6 pairs of lat,lons on one line
*/
ilen = 55;
cst_wrap( bufferlat, blank, &ilen, "\n", (char *)NULL, bufferlat, &ier );
if (wrtsttfg == G_TRUE) {
/*
* Wrap strstt such that only 7 STATE IDs on one line
* and dump strstt into buffer for further output
*/
ilen = 49;
cst_wrap( strstt, blank, &ilen, "\n", (char *)NULL, strstt, &ier );
strcat ( buffer, strstt );
strcat ( buffer, "\n");
}
if (wrtwfofg == G_TRUE) {
/*
* Wrap strwfo such that only 9 WFOs on one line
* and dump strswo into buffer for further output
*/
ilen = 67;
cst_wrap( strwfo, blank, &ilen, "\n", (char *)NULL, strwfo, &ier );
strcat ( buffer, strwfo );
strcat ( buffer, "\n");
}
strcat ( buffer, bufferlat);
strcat ( buffer, "\n");
cfl_writ( ofptr, (int)strlen(buffer), (unsigned char *)buffer, &ier );
bufferlat[0] = '\0';
}
}
/*
* If no line is found, close files and exit.
*/
cfl_clos ( ifptr, &ier );
cfl_clos ( ofptr, &ier );
return(0);
}
void na_gtbl ( const char *cpyfil, char *name, char *proj, int *nxgd,
int *nygd, float *garea, float *rnvblk, float *anlblk,
int *iret )
/************************************************************************
* na_gtbl *
* *
* This subroutine finds grid INNAME (a numerical or character *
* identifier prefaced by '#') in a grid navigation table, then makes *
* the navigation and analysis blocks. The grid navigation is set up *
* in GEMPLT in order to check its validity. *
* *
* na_gtbl ( cpyfil, name, proj, nxgd, nygd, garea, rnvblk, anlblk, *
* iret ) *
* *
* Input parameters: *
* *cpyfil const char Input for CPYFIL *
* *
* Output parameters: *
* *name char Name of selected grid *
* *proj char Grid projection *
* *nxgd int Number of points in x dir *
* *nygd int Number of points in y dir *
* *garea float Grid corners *
* *rnvblk float Grid navigation block *
* *anlblk float Grid analysis block *
* *iret int Return code *
* +1 = EXIT entered *
* 0 = normal return *
* -4 = invalid navigation *
* -9 = grid not found in table *
** *
* Log: *
* S. Jacobs/EAI 7/93 Copied from GDCTBL *
* D. Keiser/GSC 12/95 Changed FL_TOPN to FL_TBOP *
* R. Tian/SAIC 7/06 Recoded from Fortran *
* S. Gilbert/NCEP 10/06 Added call to GR_VNAV *
************************************************************************/
{
char gntrec[81], namgd[5], c2name[9], buffer[LLMXLN];
float angl1, angl2, angl3, dbnds[4], deln;
int angflg, found, valid;
int iebnds[4], ingrdn, numgd, extnd, ier, ier1, iernum, navsz, i;
FILE *lungrd;
/*----------------------------------------------------------------------*/
*iret = 0;
name[0] = '\0';
/*
* Get the grid number (INGRDN) out of NAME; a conversion error
* sets IERNUM .ne. 0 and it is assumed that NAME is a type.
*/
cst_lcuc ( (char *)cpyfil, c2name, &ier );
strcpy ( name, &c2name[1] );
cst_numb ( name, &ingrdn, &iernum );
/*
* Open the table of valid grid types.
*/
lungrd = cfl_tbop ( "grdnav.tbl", "grid", &ier );
if ( ier != 0 ) {
er_wmsg ( "CFL", &ier, "grdnav.tbl", &ier1,
strlen("CFL"), strlen("grdnav.tbl") );
*iret = -9;
return;
}
/*
* List the table contents for the user, if requested.
*/
if ( strcmp ( name, "LIST" ) == 0 ) {
while ( ! feof ( lungrd) ) {
cfl_trln ( lungrd, sizeof(gntrec), gntrec, &ier );
if ( ier != 0 ) break;
printf ( "%-79.79s\n", gntrec );
}
/*
* Rewind the table file.
*/
cfl_seek ( lungrd, 0, SEEK_SET, &ier );
/*
* Prompt user for grid choice.
*/
printf ( "Enter grid id or number or type EXIT: " );
scanf ( " %s", name );
if ( name[0] == 'e' || name[0] == 'E' ) {
*iret = +1;
return;
}
cst_lcuc ( name, name, &ier );
cst_numb ( name, &ingrdn, &iernum );
}
/*
* Read through the list of valid grid types/numbers to get
* navigation/analysis information.
*/
found = G_FALSE;
while ( ! feof ( lungrd ) ) {
cfl_trln ( lungrd, sizeof(buffer), buffer, &ier );
if ( ier != 0 ) break;
sscanf ( buffer, "%s %d %s %f %f %f %f %f %f %f %d %d %f %d",
namgd, &numgd, proj, &angl1, &angl2, &angl3,
&garea[0], &garea[1], &garea[2], &garea[3],
nxgd, nygd, &deln, &extnd );
if ( strcmp ( name, namgd ) == 0 || ingrdn == numgd ) {
found = G_TRUE;
break;
}
}
cfl_clos ( lungrd, &ier );
/*
* Bail out if NAME wasn't found in the table.
*/
if ( found == G_FALSE ) {
*iret = -9;
return;
}
/*
* Fill navigation block.
*/
angflg = G_TRUE;
gr_vnav ( proj, nxgd, nygd, &garea[0], &garea[1],
&garea[2], &garea[3], &angl1, &angl2, &angl3,
&angflg, &valid, &ier, strlen(proj) );
if ( ier == 0 )
grc_mnav ( proj, nxgd, nygd, &garea[0], &garea[1],
&garea[2], &garea[3], &angl1, &angl2, &angl3,
&angflg, rnvblk, &ier );
else {
*iret = -2;
return;
}
/*
* Set up navigation in GEMPLT to check validity.
*/
navsz = 13;
grc_snav ( &navsz, rnvblk, &ier );
if ( ier != 0 ) {
*iret = -4;
return;
}
/*
* Make an analysis block.
*/
for ( i = 0; i < 4; i++ ) {
iebnds[i] = extnd;
dbnds [i] = RMISSD;
}
grc_mbn2 ( &deln, iebnds, dbnds, rnvblk, anlblk, &ier );
return;
}
int main ( void )
/************************************************************************
* GDGRIB2 *
* *
* This program encodes a selected GEMPAK grid into a GRIB2 message. *
* *
* Command line: *
* gdgrib2 *
** *
* Log: *
* S. Gilbert/NCEP 5/2005 Orig *
* S. Gilbert/NCEP 3/2006 Replaced dg_clal with dg_nend *
* T. Piper/SAIC 01/08 Added GD_INIT; removed from IN_BDTA *
* B. Yin/ERT 09/15 Added bulk processing from table *
***********************************************************************/
{
int respond, ret, ier, mode=1, done, skip, j;
int g2len; /* Length of GRIB2 message */
unsigned char *g2msg; /* GRIB2 message */
char cur_gbfile[LLMXLN]="";
char chdr[22]; /* WMO Header */
FILE *gbfptr=0;
GDG2_input input; /* user input variables */
GDG2_gemgrid gemgrid; /* GEMPAK grid and info */
/*---------------------------------------------------------------------*/
/*
* Initialize TAE.
*/
ip_init ( &respond, &ret );
if ( ret == 0 ) {
ip_idnt ( "GDGRIB2", &done, 7 );
/*
* Initialize GEMPLT.
*/
gg_init ( &mode, &ret );
if ( ret == 0 ) {
/*
* Initialize grid library common area grdcmn.cmn
*/
gd_init ( &ier );
/*
* Initialize the DG library
*/
dg_intl ( &ret );
done = 0;
skip = 1;
}
else {
done = 1;
}
}
else {
done = 1;
}
/*
* Process next request, if user has one.
*/
while ( done == 0 ) {
/*
* Wait for user input, if not first time through this loop
*/
if ( skip == 0 ) ip_dynm( &done, &ret );
skip = 0;
if ( done != 0 ) break; /* Exit out of interactive loop */
/*
* Get user input info
*/
gdg2in( &input, &ret );
if ( ret != 0 ) {
er_wmsg("GDGRIB2",&ret," ",&ier,7,1);
continue;
}
else if ((strlen(input.g2conv) != (size_t)0) && (ret == 0)) {
/*
* Skip program prompt and get input from conversion table
*/
skip = 1;
}
if ( strlen(input.g2file) == (size_t)0 ) {
ret=-28;
er_wmsg("GDGRIB2",&ret," ",&ier,7,1);
continue;
}
/*
* Get requested grid
*/
gdgetgrid( &input, &gemgrid, &ret );
if ( ret != 0 ) {
er_wmsg("GDGRIB2",&ret," ",&ier,7,1);
continue;
}
/*
* Make GRIB2 field
*/
gdmakeg2( &input, &gemgrid, &g2msg, &g2len, &ret );
if ( ret != 0 ) {
er_wmsg("GDGRIB2",&ret," ",&ier,7,1);
continue;
}
/*
* Open GRIB2 file, if not already open.
*/
if ( strncmp(input.g2file, cur_gbfile, LLMXLN) != 0 ) {
/*
* If output GRIB file is different, must close previous one first
*/
if ( strlen(cur_gbfile) != (size_t)0 ) {
cfl_clos( gbfptr, &ret);
gbfptr=0;
}
/*
* Open GRIB file
*/
gbfptr = cfl_aopn( input.g2file, &ret);
if ( ret == 0 ) {
strncpy( cur_gbfile, input.g2file, LLMXLN);
}
else {
er_wmsg("CFL",&ret,input.g2file,&ier,7,strlen(input.g2file));
ret = -24;
er_wmsg("GDGRIB2",&ret," ",&ier,7,1);
gbfptr = 0;
continue;
}
}
/*
* Write out WMO Header, if requested
*/
gdmakewmo( &input, &gemgrid, chdr, &ret );
if ( strlen(chdr) == (size_t)21 ) {
cfl_writ( gbfptr, strlen(chdr), (unsigned char*)chdr, &ret );
}
/*
* Write out GRIB2 message.
*/
cfl_writ( gbfptr, g2len, g2msg, &ret );
if ( ret != 0 ) {
er_wmsg("CFL",&ret,input.g2file,&ier,7,strlen(input.g2file));
ret = -25;
er_wmsg("GDGRIB2",&ret," ",&ier,7,1);
continue;
}
/*
* Free no longer needed allocated space
*/
if ( gemgrid.grid != 0 ) free(gemgrid.grid);
if ( g2msg != 0 ) free(g2msg);
}
/*
* Clean up files
*/
dg_nend( &ret );
if ( gbfptr != 0 ) cfl_clos( gbfptr, &ret);
/*
* Exit the GEMPAK user interface
*/
ip_exit( &ret );
return(0);
}
void ctb_g2read ( int *iret )
/************************************************************************
* ctb_g2read *
* *
* This routine will read a grib2 table into an array of structures. *
* *
* ctb_g2read ( iret ) *
* *
* Input parameters: *
* *
* Output parameters: *
* *iret int Return code *
** *
* Log: *
* m.gamazaychikov/SAIC 5/03 *
* m.gamazaychikov/SAIC 5/03 added parameter pdtnmbr to the table *
* M. Li/SAIC 4/04 added hzremap, and direction *
***********************************************************************/
{
FILE *fp = NULL;
int n, nr, blen, ier;
char buffer[256];
int disc, cat, parm, pdtn, scl, ihzrmp, idrct;
char name[33], unts[21], gname[13];
float msng;
/*---------------------------------------------------------------------*/
*iret = G_NORMAL;
if ( Gr2Readin == 1 ) return;
/*
* Open the table. If not found return an error.
*/
fp = cfl_tbop( G2VARS_TBL, "grid", &ier);
if ( fp == NULL || ier != 0 ) {
if (fp)
fclose(fp);
*iret = -1;
return;
}
cfl_tbnr(fp, &nr, &ier);
if ( ier != 0 || nr == 0 ) {
*iret = -2;
cfl_clos(fp, &ier);
return;
}
Gr2Tbl.info = (G2Vinfo *)malloc((size_t)nr*sizeof(G2Vinfo));
n = 0;
while ( n < nr ) {
cfl_trln( fp, 256, buffer, &ier );
if ( ier != 0 ) break;
cst_lstr ( buffer, &blen, &ier );
if ( blen > NCOLN ) {
sscanf( buffer, "%12d %12d %12d %12d %32c %20c %s %12d %f %12d %12d",
&disc, &cat, &parm, &pdtn,
name, unts, gname,
&scl, &msng, &ihzrmp, &idrct );
}
else {
sscanf( buffer, "%12d %12d %12d %12d %32c %20c %s %12d %20f",
&disc, &cat, &parm, &pdtn,
name, unts, gname,
&scl, &msng);
ihzrmp = 0;
idrct = 0;
}
name[32] = '\0';
unts[20] = '\0';
Gr2Tbl.info[n].discpln=disc;
Gr2Tbl.info[n].categry=cat;
Gr2Tbl.info[n].paramtr=parm;
Gr2Tbl.info[n].pdtnmbr=pdtn;
strcpy(Gr2Tbl.info[n].name, name);
strcpy(Gr2Tbl.info[n].units, unts);
strcpy(Gr2Tbl.info[n].gemname, gname);
Gr2Tbl.info[n].scale=scl;
Gr2Tbl.info[n].missing=msng;
Gr2Tbl.info[n].hzremap = ihzrmp;
Gr2Tbl.info[n].direction = idrct;
n++;
}
cfl_clos(fp, &ier);
Gr2Tbl.nlines = n;
Gr2Readin = 1;
}
void gg_rtrk ( char *filtyp, char *filnam, char *stime, char *etime,
int *itmclr, int *iskip, int *iret )
/************************************************************************
* gg_rtrk *
* *
* This routine reads the data from a Altimeter Ground Track Prediction *
* file and plots it. *
* *
* gg_rtrk ( filtyp, filnam, stime, etime, itmclr, iskip, iret ) *
* *
* *
* Input parameters: *
* *filtyp char Data type *
* *filnam char Data file name *
* *stime char Start time of data *
* *etime char End time of data *
* *itmclr int Time stamp color *
* *iskip int Skip value *
* *
* Output parameters: *
* *iret int Return code *
** *
* Log: *
* G. McFadden/SAIC 12/08 Modeled after gg_qsrd *
* S. Jacobs/NCEP 6/10 Removed underscore on function name *
***********************************************************************/
{
int ier, incr, itarr[5], iyoff = 0,
ixoff = -10, ntime, np2, pcount, gyear, ymd, hm;
FILE *fptr;
char buffer[256], textstr[8], final_ts[9], ymd_string[7], hm_string[5];
char gempak_dt[12];
char *cp, underscore[2];
float lat, lon, rotat = 0.0F;
double dlat, dlon, dalt;
size_t two = 2;
/*---------------------------------------------------------------------*/
/*
* Open the data file.
*/
fptr = cfl_ropn ( filnam, NULL, &ier );
if ( fptr == NULL || ier != 0 ) {
*iret = -1;
return;
}
*iret = 0;
underscore[0] = '_';
underscore[1] = '\0';
/*
* Set the skip factor.
*/
if ( *iskip <= 0 ) {
incr = 1;
}
else {
incr = *iskip + 1;
}
pcount = incr;
while ( ier == 0 ) {
/*
* Read this prediction's data.
*/
cfl_trln( fptr, 256, buffer, &ier );
if ( ier != 0 ) {
/*
* Bad read...close the file and exit.
*/
cfl_clos ( fptr, &ier );
return;
}
/*
* Extract this prediction's data.
*/
sscanf( buffer, "%d %d %d %d %d %lf %lf %lf",
&itarr[0], &itarr[1], &itarr[2], &itarr[3],
&itarr[4], &dlat, &dlon, &dalt );
lat = (float)dlat;
lon = (float)dlon;
/*
* Get the gempak date/time of this prediction
*/
gyear = itarr[0] - 2000;
ymd = gyear * 10000 + itarr[1] * 100 + itarr[2];
sprintf(ymd_string, "%6.6d", ymd );
hm = itarr[3] * 100 + itarr[4];
sprintf(hm_string, "%4.4d", hm );
gempak_dt[0] = '\0';
strcat(gempak_dt,ymd_string);
strcat(gempak_dt,"/");
strcat(gempak_dt,hm_string);
/*
* The longitude is stored as 0 -> 360. PRNLON will correct the longitude to
* the range -180 -> 180.
*/
np2 = 1;
prnlon( &np2, &lon, &ier );
/*
* Plot the prediction if it is not skipped and if it is within the valid
* time range...plot "DD_HHMM" on the screen.
*/
ntime = itarr[2] * 10000 + itarr[3] * 100 + itarr[4];
sprintf(textstr, "%6.6d", ntime);
final_ts[0] = '\0';
strncpy(final_ts,textstr,two);
final_ts[2] = '\0';
strcat(final_ts,underscore);
cp = textstr + 2;
strcat(final_ts,cp);
gscolr ( itmclr, &ier);
if ( pcount % incr == 0 && PathTimeCheck( gempak_dt, stime, etime) ) {
gtext ( sys_M, &lat, &lon, final_ts, &rotat, &ixoff, &iyoff,
&ier, strlen(sys_M), strlen(final_ts) );
}
pcount++;
}
/*
* Close the file.
*/
cfl_clos ( fptr, &ier );
}
void ces_rtbl ( int *iret )
/************************************************************************
* ces_rtbl *
* *
* This function reads the setting table and loads the settings *
* structure. *
* *
* ces_rtbl ( iret ) *
* *
* Input parameters: *
* *
* Output parameters: *
* *iret int Return code *
* 2 = Bad read. Ignore record. *
* 1 = Setting array siz exceeded*
* -1 = No setting table *
** *
* Log: *
* D. Keiser/GSC 7/97 Rewrote using union structure *
* E. Wehner/EAi 8/97 Adopted from cpg_rstng *
* C. Lin/EAi 9/97 Change default table name *
* G. Krueger/EAI 10/97 CST_xLST: Removed RSPTB; Add str limit *
* C. Lin/EAi 10/97 modify to remove cst_clst(), cleanup *
* C. Lin/EAi 10/97 modify WBOX_ELM *
* M. Linda/GSC 10/97 Corrected the prologue format *
* C. Lin/EAi 11/97 use CLASS_WATCHES for WBOX_ELM *
* C. Lin/EAi 11/97 add front strength and wind line width *
* S. Law/GSC 03/98 Changed scanned values for CLASS_WINDS *
* F. J. Yen/NCEP 4/98 Renamed from ces_rstng. Cleaned up. *
* F. J. Yen/NCEP 4/98 Set hdsiz for BARB_ELM to 1. *
* W. Li/EAI 04/98 Add darr and hash in CLASS_WINDS *
* S. Jacobs/NCEP 6/98 Changed front pip size to type float *
* W. Li/EAI 07/98 Added txt_attrib's text value setting *
* C. Lin/EAI 09/98 Add smoothing level for line/front *
* A. Hardy/GSC 10/98 Added CMBSY_ELM *
* S. Jacobs/NCEP 12/98 Fixed typo *
* A. Hardy/GSC 12/98 Added CIRCLE_ELM *
* E. Safford/GSC 02/99 set default for wndtyp to 114 (cleared) *
* W. Li/EAI 03/99 added latitude/longitude for symbols *
* S. Law/GSC 03/99 added filled/closed = 0 *
* W. Li/EAI 04/99 added MARK_ELM, removed lat/long symbol *
* S. Law/GSC 05/99 Added CLASS_TRACKS *
* S. Law/GSC 07/99 Added CLASS_SIGMETS *
* S. Law/GSC 08/99 added remaining SIGMETs *
* S. Law/GSC 02/00 added CCF *
* H. Zeng/EAI 02/01 added group type info. *
* E. Safford/SAIC 02/02 added initialization for new_subtyp *
* J. Wu/SAIC 11/02 add class LIST *
* M. Li/SAIC 01/03 delete vgstruct.h *
* H. Zeng/XTRIA 01/03 added marker info. for Watch *
* H. Zeng/XTRIA 03/03 added layer_flag *
* D.W.Plummer/NCEP 06/03 added ASHCLD_ELM and VOLC_ELM *
* J. Wu/SAIC 09/03 add CLASS_MET -> JET_ELM *
* J. Wu/SAIC 01/04 add CLASS_MET -> GFA_ELM *
* B. Yin/SAIC 02/04 added CLASS_MET -> TCA_ELM *
* J. Wu/SAIC 05/04 add barb/hash color into JET_ELM *
* J. Wu/SAIC 05/04 add initialization for "ppid" *
* H. Zeng/SAIC 07/04 added check for ialign value *
* J. Wu/SAIC 09/04 add text type for jet barb text *
* J. Wu/SAIC 10/04 remove line width from GFA_ELM *
* T. Piper/SAIC 12/05 redone with new Setting_t structure *
* B. Yin/SAIC 12/05 added line width for GFA *
* S. Jacobs 03/06 add initialization of special text (bug)*
* S. Danz/AWC 04/06 initialized jet->barb[]spt.text *
* B. Yin/SAIC 07/06 added line type and line elem for GFA *
* L. Hinson/AWC 12/06 added text color, size, font, hw, width *
* alignment, and text Layout for GFA *
* L. Hinson/AWC 06/07 added arrow size for GFA *
* L. Hinson/AWC 07/09 Add color, fills, linetype, szarrow, *
* text size, font, hw, width, alignment, *
* and text Layout to CCF *
* L. Hinson/AWC 01/12 Add CLASS_MET -> SGWX_ELM *
***********************************************************************/
{
char tstr[256], vg_classstr[64], vg_typestr[64], tmpstr[256];
int one=1, smooth, loglev, quit, ier1, ier, jj, align_val;
int ii, tmpwid[3], tmpclr[3], ityp, ifnt, ithw, ialign, nn;
char grp[4], *ptr;
float tmpsiz, tmpsz[3];
FILE *fp;
/*---------------------------------------------------------------------*/
*iret = G_NORMAL;
/*
* Open the setting table. If not found, return an error.
*/
if ( (fp = (FILE * )cfl_tbop(SETTING_TBL, "pgen", &ier)) == NULL) {
*iret = -1;
loglev = 2;
strcpy(grp, "CES");
er_lmsg (&loglev, grp, iret, SETTING_TBL, &ier1, strlen(grp),
strlen(SETTING_TBL));
return;
}
/*
* For every line in the setting table list, read in the record,
* parse out the fields, and compare to input type.
*/
jj = num_set = 0;
quit = G_FALSE;
while ( ( !quit ) && ( jj < MAX_SET ) ) {
cfl_trln ( fp, sizeof(tstr), tstr, &ier );
if ( ier == 4 ) {
/*
* Here for end of file.
*/
quit = G_TRUE;
}
else if ( ier != 0 ) {
/*
* Here for a bad read; record is ignored.
*/
loglev = 2;
strcpy(grp, "CES");
ier = 2;
er_lmsg ( &loglev, grp, &ier, SETTING_TBL, &ier1,
strlen(grp), strlen(SETTING_TBL) );
}
else {
/*
* Here to process a good record.
*/
sscanf(tstr, "%s %s", vg_classstr, vg_typestr);
num_set++;
G_REALLOC(set, Setting_t, num_set, "set");
set[jj].smooth = 0;
set[jj].filled = 0;
set[jj].closed = 0;
/*
* +++++++++++++++++++++++++++++++++++++++++++
* HANDLE FRONTS CLASS
* +++++++++++++++++++++++++++++++++++++++++++
*/
if ( strcmp(vg_classstr, "CLASS_FRONTS" ) == 0 ) {
set[jj].vg_class = CLASS_FRONTS;
G_MALLOC(set[jj].info.frt, FrontInfo, one, "set[jj].info.frt");
sscanf(tstr, "%*s %*s %d %d %d %d %f %d %d %s",
&(set[jj].subtyp), &(set[jj].maj_col),
&(set[jj].min_col), &smooth, &tmpsiz,
&(set[jj].info.frt->fpipdr),
&(set[jj].info.frt->fwidth),
set[jj].grp_typ );
set[jj].info.frt->fpipsz = (int)(tmpsiz * 100.0F);
set[jj].info.frt->fcode = set[jj].subtyp;
set[jj].info.frt->fpipst = 1;
if ( smooth < 0 || smooth > 2 )
smooth = 0;
set[jj].smooth = smooth;
if ( strcmp(vg_typestr, "FRONT_ELM" ) == 0 ) {
set[jj].vg_type = FRONT_ELM;
}
else if ( strcmp(vg_typestr, "-99" ) == 0 ) {
set[jj].vg_type = DEFLTSET;
}
}
/*
* +++++++++++++++++++++++++++++++++++++++++++
* HANDLE CIRCLE CLASS
* +++++++++++++++++++++++++++++++++++++++++++
*/
else if ( strcmp(vg_classstr, "CLASS_CIRCLE") == 0 ) {
set[jj].vg_class = CLASS_CIRCLE;
G_MALLOC(set[jj].info.cir, LineInfo, one, "set[jj].info.cir");
if (strcmp(vg_typestr, "CIRCLE_ELM") == 0) {
set[jj].vg_type = CIRCLE_ELM;
sscanf(tstr, "%*s %*s %d %d %d %d %d %d %d %s",
&(set[jj].subtyp),
&(set[jj].maj_col), &(set[jj].min_col),
&(set[jj].info.cir->lintyp),
&(set[jj].info.cir->lthw),
&(set[jj].info.cir->width),
&(set[jj].info.cir->lwhw),
set[jj].grp_typ );
}
}
/*
* +++++++++++++++++++++++++++++++++++++++++++
* HANDLE LINES CLASS
* +++++++++++++++++++++++++++++++++++++++++++
*/
else if ( strcmp(vg_classstr, "CLASS_LINES") == 0 ) {
set[jj].vg_class = CLASS_LINES;
if (strcmp(vg_typestr, "LINE_ELM") == 0) {
set[jj].vg_type = LINE_ELM;
G_MALLOC(set[jj].info.lin, LineInfo, one, "set[jj].info.lin");
sscanf(tstr, "%*s %*s %d %d %d %d %d %d %d %d %s",
&(set[jj].subtyp),
&(set[jj].maj_col), &(set[jj].min_col),
&smooth,
&(set[jj].info.lin->lintyp),
&(set[jj].info.lin->lthw),
&(set[jj].info.lin->width),
&(set[jj].info.lin->lwhw),
set[jj].grp_typ );
}
else if (strcmp(vg_typestr, "SPLN_ELM") == 0) {
set[jj].vg_type = SPLN_ELM;
G_MALLOC(set[jj].info.spl, SpLineInfo, one, "set[jj].info.spl");
set[jj].info.spl->splstr = 1;
sscanf(tstr, "%*s %*s %d %d %d %d %d %d %f %d %s",
&(set[jj].subtyp),
&(set[jj].maj_col), &(set[jj].min_col),
&smooth,
&(set[jj].info.spl->spltyp),
&(set[jj].info.spl->spldir),
&(set[jj].info.spl->splsiz),
&(set[jj].info.spl->splwid),
set[jj].grp_typ );
}
if (smooth < 0 || smooth > 2)
smooth = 0;
set[jj].smooth = smooth;
}
/*
* +++++++++++++++++++++++++++++++++++++++++++
* HANDLE SYMBOLS CLASS
* +++++++++++++++++++++++++++++++++++++++++++
*/
else if ( strcmp(vg_classstr, "CLASS_SYMBOLS") == 0 ) {
set[jj].vg_class = CLASS_SYMBOLS;
G_MALLOC(set[jj].info.sym, SymType, one, "set[jj].info.sym");
if ( strcmp(vg_typestr, "WXSYM_ELM") == 0) {
set[jj].vg_type = WXSYM_ELM;
}
else if ( strcmp(vg_typestr, "CTSYM_ELM") == 0) {
set[jj].vg_type = CTSYM_ELM;
}
else if ( strcmp(vg_typestr, "ICSYM_ELM") == 0) {
set[jj].vg_type = ICSYM_ELM;
}
else if ( strcmp(vg_typestr, "PTSYM_ELM") == 0) {
set[jj].vg_type = PTSYM_ELM;
}
else if ( strcmp(vg_typestr, "PWSYM_ELM") == 0) {
set[jj].vg_type = PWSYM_ELM;
}
else if ( strcmp(vg_typestr, "SKSYM_ELM") == 0) {
set[jj].vg_type = SKSYM_ELM;
}
else if ( strcmp(vg_typestr, "SPSYM_ELM") == 0) {
set[jj].vg_type = SPSYM_ELM;
}
else if ( strcmp(vg_typestr, "TBSYM_ELM") == 0) {
set[jj].vg_type = TBSYM_ELM;
}
else if ( strcmp(vg_typestr, "CMBSY_ELM") == 0) {
set[jj].vg_type = CMBSY_ELM;
}
else if ( strcmp(vg_typestr, "MARK_ELM" ) == 0 ) {
set[jj].vg_type = MARK_ELM;
}
else if (strcmp(vg_typestr, "-99" ) == 0 ) {
set[jj].vg_type = DEFLTSET;
}
sscanf(tstr, "%*s %*s %d %d %d %d %f %s",
&(set[jj].subtyp),
&(set[jj].maj_col),
&(set[jj].min_col),
&(set[jj].info.sym->info.width),
&(set[jj].info.sym->info.size),
set[jj].grp_typ );
}
/*
* +++++++++++++++++++++++++++++++++++++++++++
* HANDLE WINDS CLASS
* +++++++++++++++++++++++++++++++++++++++++++
*/
else if ( strcmp(vg_classstr, "CLASS_WINDS") == 0 ) {
set[jj].vg_class = CLASS_WINDS;
G_MALLOC(set[jj].info.wnd, WindInfo, one, "set[jj].info.wnd");
if ( strcmp(vg_typestr, "ARROW_ELM") == 0 ) {
set[jj].vg_type = ARROW_ELM;
sscanf(tstr, "%*s %*s %d %d %d %d %f %f %s",
&(set[jj].subtyp),
&(set[jj].maj_col), &(set[jj].min_col),
&(set[jj].info.wnd->width),
&(set[jj].info.wnd->size),
&(set[jj].info.wnd->hdsiz), set[jj].grp_typ );
set[jj].info.wnd->wndtyp = 114;
}
else if ( strcmp(vg_typestr, "BARB_ELM") == 0 ) {
set[jj].vg_type = BARB_ELM;
sscanf(tstr, "%*s %*s %d %d %d %d %f %s",
&(set[jj].subtyp), &(set[jj].maj_col),
&(set[jj].min_col), &(set[jj].info.wnd->width),
&(set[jj].info.wnd->size), set[jj].grp_typ );
set[jj].info.wnd->hdsiz = 1.0F;
set[jj].info.wnd->wndtyp = 114;
}
else if ( strcmp(vg_typestr, "DARR_ELM") == 0 ) {
set[jj].vg_type = DARR_ELM;
sscanf(tstr, "%*s %*s %d %d %d %d %f %f %s",
&(set[jj].subtyp),
&(set[jj].maj_col), &(set[jj].min_col),
&(set[jj].info.wnd->width),
&(set[jj].info.wnd->size),
&(set[jj].info.wnd->hdsiz), set[jj].grp_typ );
set[jj].info.wnd->wndtyp = 114;
}
else if ( strcmp(vg_typestr, "HASH_ELM") == 0 ) {
set[jj].vg_type = HASH_ELM;
sscanf(tstr, "%*s %*s %d %d %d %d %f %s",
&(set[jj].subtyp),
&(set[jj].maj_col), &(set[jj].min_col),
&(set[jj].info.wnd->width),
&(set[jj].info.wnd->size),
set[jj].grp_typ );
set[jj].info.wnd->hdsiz = 1.0F;
set[jj].info.wnd->wndtyp = 1;
}
}
/*
* +++++++++++++++++++++++++++++++++++++++++++
* HANDLE WBOX CLASS
* +++++++++++++++++++++++++++++++++++++++++++
*/
else if ( strcmp(vg_classstr, "CLASS_WATCHES") == 0 ) {
set[jj].vg_class = CLASS_WATCHES;
G_MALLOC(set[jj].info.wbx, WboxAttr, one, "set[jj].info.wbx");
sscanf (tstr, "%*s %*s %d %d %d %d %d %f %d %s",
&(set[jj].subtyp),
&(set[jj].maj_col), &(set[jj].min_col),
&(set[jj].info.wbx->w_type),
&(set[jj].info.wbx->w_mrktyp),
&(set[jj].info.wbx->w_mrksiz),
&(set[jj].info.wbx->w_mrkwid), set[jj].grp_typ );
set[jj].info.wbx->w_number = -9999;
if (strcmp(vg_typestr, "WBOX_ELM") == 0) {
set[jj].vg_type = WBOX_ELM;
}
else if (strcmp(vg_typestr, "-99") == 0) {
set[jj].vg_type = DEFLTSET;
}
}
/*
* +++++++++++++++++++++++++++++++++++++++++++
* HANDLE TEXT CLASS
* +++++++++++++++++++++++++++++++++++++++++++
*/
else if ( strcmp(vg_classstr, "CLASS_TEXT") == 0 ) {
set[jj].vg_class = CLASS_TEXT;
if (strcmp(vg_typestr, "TEXT_ELM") == 0) {
set[jj].vg_type = TEXT_ELM;
G_MALLOC(set[jj].info.txt, TextType, one, "set[jj].info.txt");
sscanf (tstr, "%*s %*s %d %d %d %f %f %d %d %d %s",
&(set[jj].subtyp),
&(set[jj].maj_col), &(set[jj].min_col),
&(set[jj].info.txt->info.rotn),
&(set[jj].info.txt->info.sztext),
&(set[jj].info.txt->info.itxfn),
&(set[jj].info.txt->info.iwidth),
&(set[jj].info.txt->info.ialign),
set[jj].grp_typ );
set[jj].info.txt->info.ithw = set[jj].subtyp;
set[jj].info.txt->text[0] = CHNULL;
/*
* Make sure ialign value is among (-1, 0, 1).
*/
align_val = set[jj].info.txt->info.ialign;
if ( align_val != -1 && align_val != 0 &&
align_val != 1 ) {
set[jj].info.txt->info.ialign = 0;
}
}
else if (strcmp(vg_typestr, "TEXTC_ELM") == 0) {
set[jj].vg_type = TEXTC_ELM;
G_MALLOC(set[jj].info.txt, TextType, one, "set[jj].info.txt");
sscanf (tstr, "%*s %*s %d %d %d %f %f %d %d %d %s",
&(set[jj].subtyp),
&(set[jj].maj_col), &(set[jj].min_col),
&(set[jj].info.txt->info.rotn),
&(set[jj].info.txt->info.sztext),
&(set[jj].info.txt->info.itxfn),
&(set[jj].info.txt->info.iwidth),
&(set[jj].info.txt->info.ialign),
set[jj].grp_typ );
set[jj].info.txt->info.ithw = set[jj].subtyp;
set[jj].info.txt->text[0] = CHNULL;
/*
* Make sure ialign value is among (-1, 0, 1).
*/
align_val = set[jj].info.txt->info.ialign;
if ( align_val != -1 && align_val != 0 &&
align_val != 1 ) {
set[jj].info.txt->info.ialign = 0;
}
}
else if (strcmp(vg_typestr, "SPTX_ELM") == 0) {
set[jj].vg_type = SPTX_ELM;
G_MALLOC(set[jj].info.spt, SpTxtAttr, one, "set[jj].info.spt");
sscanf (tstr, "%*s %*s %d %d %d %f %f %d %d %d %d %d %s",
&(set[jj].subtyp),
&(set[jj].maj_col), &(set[jj].min_col),
&(set[jj].info.spt->text.info.rotn),
&(set[jj].info.spt->text.info.sztext),
&(set[jj].info.spt->text.info.turbsym),
&(set[jj].info.spt->text.info.itxfn),
&(set[jj].info.spt->text.info.ithw),
&(set[jj].info.spt->text.info.iwidth),
&(set[jj].info.spt->text.info.ialign),
set[jj].grp_typ );
set[jj].info.spt->text.info.sptxtyp = set[jj].subtyp;
strcpy ( set[jj].info.spt->ppid, DEFLTPPID );
set[jj].info.spt->text.text[0] = CHNULL;
/*
* Make sure ialign value is among (-1, 0, 1).
*/
align_val = set[jj].info.spt->text.info.ialign;
if ( align_val != -1 && align_val != 0 &&
align_val != 1 ) {
set[jj].info.spt->text.info.ialign = 0;
}
}
}
/*
* +++++++++++++++++++++++++++++++++++++++++++
* HANDLE TRACKS CLASS
* +++++++++++++++++++++++++++++++++++++++++++
*/
else if ( strcmp(vg_classstr, "CLASS_TRACKS") == 0 ) {
set[jj].vg_class = CLASS_TRACKS;
G_MALLOC(set[jj].info.trk, TrackInfo, one, "set[jj].info.trk");
if ( strcmp(vg_typestr, "TRKSTORM_ELM" ) == 0 ) {
set[jj].vg_type = TRKSTORM_ELM;
}
else if ( strcmp(vg_typestr, "-99" ) == 0 ) {
set[jj].vg_type = DEFLTSET;
}
sscanf(tstr, "%*s %*s %d %d %d %d %d %d %d %d %d %s",
&(set[jj].subtyp),
&(set[jj].maj_col), &(set[jj].min_col),
&(set[jj].info.trk->ltype1), &(set[jj].info.trk->ltype2),
&(set[jj].info.trk->mtype1), &(set[jj].info.trk->mtype2),
&(set[jj].info.trk->width), &(set[jj].info.trk->incr),
set[jj].grp_typ );
}
/*
* +++++++++++++++++++++++++++++++++++++++++++
* HANDLE SIGMETS CLASS
* +++++++++++++++++++++++++++++++++++++++++++
*/
else if ( strcmp(vg_classstr, "CLASS_SIGMETS") == 0 ) {
set[jj].vg_class = CLASS_SIGMETS;
if ( strcmp(vg_typestr, "SIGAIRM_ELM" ) == 0 ) {
set[jj].vg_type = SIGAIRM_ELM;
}
else if ( strcmp(vg_typestr, "SIGCONV_ELM" ) == 0 ) {
set[jj].vg_type = SIGCONV_ELM;
}
else if ( strcmp(vg_typestr, "SIGINTL_ELM" ) == 0 ) {
set[jj].vg_type = SIGINTL_ELM;
}
else if ( strcmp(vg_typestr, "SIGNCON_ELM" ) == 0 ) {
set[jj].vg_type = SIGNCON_ELM;
}
else if ( strcmp(vg_typestr, "SIGOUTL_ELM" ) == 0 ) {
set[jj].vg_type = SIGOUTL_ELM;
}
else if ( strcmp(vg_typestr, "SIGCCF_ELM" ) == 0 ) {
set[jj].vg_type = SIGCCF_ELM;
}
else if ( strcmp(vg_typestr, "ASHCLD_ELM" ) == 0 ) {
set[jj].vg_type = ASHCLD_ELM;
}
else if ( strcmp(vg_typestr, "VOLC_ELM" ) == 0 ) {
set[jj].vg_type = VOLC_ELM;
}
else if ( strcmp(vg_typestr, "-99" ) == 0 ) {
set[jj].vg_type = DEFLTSET;
}
if (set[jj].vg_type == SIGCCF_ELM) {
G_MALLOC(set[jj].info.ccf, CcfAttr, one, "set[jj].info.ccf");
sscanf(tstr, "%*s %*s %d %d %d %d %d %d %d %d %f %f %d %d %d %d %s %s",
&(set[jj].subtyp), &(set[jj].smooth),
&(set[jj].maj_col), &(set[jj].min_col),
&(set[jj].info.ccf->fillhi),
&(set[jj].info.ccf->fillmed),
&(set[jj].info.ccf->filllow),
&(set[jj].info.ccf->linetype),
&(set[jj].info.ccf->szarrow),
&(set[jj].info.ccf->info.sztext),
&(set[jj].info.ccf->info.itxfn),
&(set[jj].info.ccf->info.ithw),
&(set[jj].info.ccf->info.iwidth),
&(set[jj].info.ccf->info.ialign),
set[jj].info.ccf->textLayout,
set[jj].grp_typ );
/* printf("subtyp = %d, smooth=%d, maj_col=%d, min_col=%d, fillhi=%d, fillmed=%d, filllow=%d\n",
set[jj].subtyp, set[jj].smooth, set[jj].maj_col, set[jj].min_col,
set[jj].info.ccf->fillhi, set[jj].info.ccf->fillmed, set[jj].info.ccf->filllow);
printf("linetype=%d, szarrow=%f, sztext=%f, itxfn=%d, ithw=%d, iwidth=%d ialign=%d\n",
set[jj].info.ccf->linetype, set[jj].info.ccf->szarrow,
set[jj].info.ccf->info.sztext,
set[jj].info.ccf->info.itxfn, set[jj].info.ccf->info.ithw, set[jj].info.ccf->info.iwidth,
set[jj].info.ccf->info.ialign);
printf("tlayout=%s grptyp=%s\n",set[jj].info.ccf->textLayout, set[jj].grp_typ); */
}
else if (set[jj].vg_type == ASHCLD_ELM) {
G_MALLOC(set[jj].info.ash, SigAttr, one, "set[jj].info.ash");
sscanf(tstr, "%*s %*s %d %d %d %d %s",
&(set[jj].subtyp), &(set[jj].maj_col),
&(set[jj].min_col), &(set[jj].smooth),
set[jj].grp_typ );
}
else if (set[jj].vg_type == VOLC_ELM) {
G_MALLOC(set[jj].info.vol, VolAttr, one, "set[jj].info.vol");
sscanf(tstr, "%*s %*s %d %d %d %d %f %s",
&(set[jj].subtyp), &(set[jj].maj_col),
&(set[jj].min_col),&(set[jj].info.vol->width),
&(set[jj].info.vol->size), set[jj].grp_typ );
}
else {
G_MALLOC(set[jj].info.sig, SigAttr, one, "set[jj].info.sig");
sscanf(tstr, "%*s %*s %d %d %d %d %d %s",
&(set[jj].subtyp),
&(set[jj].maj_col), &(set[jj].min_col),
&(set[jj].info.sig->lintyp),
&(set[jj].info.sig->linwid),
set[jj].grp_typ );
}
}
/*
* +++++++++++++++++++++++++++++++++++++++++++
* HANDLE LIST CLASS
* +++++++++++++++++++++++++++++++++++++++++++
*/
else if ( strcmp(vg_classstr, "CLASS_LIST") == 0 ) {
set[jj].vg_class = CLASS_LIST;
G_MALLOC(set[jj].info.lst, ListInfo, one, "set[jj].info.lst");
if ( strcmp(vg_typestr, "LIST_ELM") == 0 ) {
set[jj].vg_type = LIST_ELM;
sscanf ( tstr, "%*s %*s %d %d %d %d %f %d %s",
&(set[jj].subtyp),
&(set[jj].maj_col),
&(set[jj].min_col),
&(set[jj].info.lst->mrktyp),
&(set[jj].info.lst->mrksiz),
&(set[jj].info.lst->mrkwid),
set[jj].grp_typ );
set[jj].info.lst->subtyp = set[jj].subtyp;
}
}
/*
* +++++++++++++++++++++++++++++++++++++++++++
* HANDLE MET CLASS
* +++++++++++++++++++++++++++++++++++++++++++
*/
else if ( strcmp(vg_classstr, "CLASS_MET") == 0 ) {
set[jj].vg_class = CLASS_MET;
if ( strcmp(vg_typestr, "JET_ELM") == 0 ) {
set[jj].vg_type = JET_ELM;
G_MALLOC(set[jj].info.jet, JetInfo, one, "set[jj].info.jet");
/*
* Check the number of items in setting.tbl.
* ( 22 - version 5.7.4 & later; 21 for earlier versions.
*/
strcpy ( tmpstr, tstr );
cst_nocc ( tmpstr, '!', 1, 0, &nn, &ier );
if ( ier == 0 ) {
tmpstr[nn] = '\0';
cst_lstr ( tmpstr, &nn, &ier );
tmpstr[nn] = '\0';
}
nn = 0;
ptr = strtok ( tmpstr, " " );
while ( (ptr != (char *)NULL) ) {
ptr = strtok ( NULL, " " );
nn++;
}
if ( nn < 22 ) { /* Version 5.7.3 & before */
sscanf ( tstr, "%*s %*s %d %d %d %d %d %f %d %d %f %d %f %d %d %d %d %d %f %d %s",
&(set[jj].subtyp),
&(set[jj].maj_col), &(set[jj].min_col), &smooth,
&(set[jj].info.jet->line.spltyp),
&(set[jj].info.jet->line.splsiz),
&(set[jj].info.jet->line.splwid),
&tmpclr[0], &tmpsz[0], &tmpwid[0], /* Barb */
&tmpsz[1], &ifnt, &ithw, &tmpwid[1], &ialign, /* Text */
&tmpclr[1], &tmpsz[2], &tmpwid[2], /* Hash */
set[jj].grp_typ );
ityp = 0;
}
else { /* Version 5.7.4 and later */
sscanf ( tstr, "%*s %*s %d %d %d %d %d %f %d %d %f %d %d %f %d %d %d %d %d %f %d %s",
&(set[jj].subtyp),
&(set[jj].maj_col), &(set[jj].min_col), &smooth,
&(set[jj].info.jet->line.spltyp),
&(set[jj].info.jet->line.splsiz),
&(set[jj].info.jet->line.splwid),
&tmpclr[0], &tmpsz[0], &tmpwid[0], /* Barb */
&ityp, &tmpsz[1], &ifnt, &ithw, &tmpwid[1], &ialign, /* Text */
&tmpclr[1], &tmpsz[2], &tmpwid[2], /* Hash */
set[jj].grp_typ );
}
if (smooth < 0 || smooth > 2) smooth = 0;
set[jj].smooth = smooth;
set[jj].info.jet->splcol = set[jj].maj_col;
set[jj].info.jet->line.splstr = 1;
set[jj].info.jet->line.spldir = 0;
for ( ii = 0; ii < MAX_JETPTS; ii++ ) {
set[jj].info.jet->barb[ii].wndcol = tmpclr[0];
set[jj].info.jet->barb[ii].wnd.info.size = tmpsz[0];
set[jj].info.jet->barb[ii].wnd.info.width = tmpwid[0];
set[jj].info.jet->barb[ii].wnd.info.wndtyp = 114;
set[jj].info.jet->barb[ii].wnd.info.hdsiz = 1.0F;
set[jj].info.jet->barb[ii].sptcol = tmpclr[0];
set[jj].info.jet->barb[ii].spt.info.sztext = tmpsz[1];
set[jj].info.jet->barb[ii].spt.info.itxfn = ifnt;
set[jj].info.jet->barb[ii].spt.info.ithw = ithw;
set[jj].info.jet->barb[ii].spt.info.iwidth = tmpwid[1];
set[jj].info.jet->barb[ii].spt.info.ialign = ialign;
set[jj].info.jet->barb[ii].spt.info.rotn = 0.0F;
set[jj].info.jet->barb[ii].spt.info.sptxtyp = ityp;
set[jj].info.jet->barb[ii].spt.info.turbsym = 0;
set[jj].info.jet->barb[ii].spt.info.txtcol = tmpclr[0];
set[jj].info.jet->barb[ii].spt.info.filcol = tmpclr[0];
set[jj].info.jet->barb[ii].spt.info.lincol = tmpclr[0];
set[jj].info.jet->barb[ii].spt.text[0] = CHNULL;
set[jj].info.jet->hash[ii].wndcol = tmpclr[1];
set[jj].info.jet->hash[ii].wnd.info.size = tmpsz[2];
set[jj].info.jet->hash[ii].wnd.info.width = tmpwid[2];
set[jj].info.jet->hash[ii].wnd.info.wndtyp = 1;
set[jj].info.jet->hash[ii].wnd.info.hdsiz = 1.0F;
}
}
else if ( strcmp(vg_typestr, "GFA_ELM") == 0 ) {
set[jj].vg_type = GFA_ELM;
G_MALLOC(set[jj].info.gfa, GfaAttr, one, "set[jj].info.gfa");
sscanf(tstr, "%*s %*s %d %d %d %d %d %d %f %d %f %d %d %d %d %s %s",
&(set[jj].subtyp), &(set[jj].maj_col),
&(set[jj].min_col), &(set[jj].info.gfa->linelm),
&(set[jj].info.gfa->lintyp),&(set[jj].info.gfa->linwid),
&(set[jj].info.gfa->szarrow),
&(set[jj].info.gfa->info.txtcol),
&(set[jj].info.gfa->info.sztext),
&(set[jj].info.gfa->info.itxfn),
&(set[jj].info.gfa->info.ithw),
&(set[jj].info.gfa->info.iwidth),
&(set[jj].info.gfa->info.ialign),
set[jj].info.gfa->textLayout,
set[jj].grp_typ );
}
else if ( strcmp(vg_typestr, "SGWX_ELM") == 0 ) {
set[jj].vg_type = SGWX_ELM;
G_MALLOC(set[jj].info.sgwx, SgwxAttr, one, "set[jj].info.sgwx");
sscanf(tstr, "%*s %*s %d %d %d %d %d %d %d %f %f %d %d %d %d %s",
&(set[jj].subtyp), &(set[jj].smooth),
&(set[jj].maj_col), &(set[jj].min_col),
&(set[jj].info.sgwx->lineelm),
&(set[jj].info.sgwx->linetype),
&(set[jj].info.sgwx->linewidth),
&(set[jj].info.sgwx->szarrow),
&(set[jj].info.sgwx->info.sztext),
&(set[jj].info.sgwx->info.itxfn),
&(set[jj].info.sgwx->info.ithw),
&(set[jj].info.sgwx->info.iwidth),
&(set[jj].info.sgwx->info.ialign),
set[jj].grp_typ );
}
else if ( strcmp(vg_typestr, "TCA_ELM") == 0 ) {
set[jj].vg_type = TCA_ELM;
G_MALLOC(set[jj].info.tca, TcaInfo, one, "set[jj].info.tca");
sscanf(tstr, "%*s %*s %d %d %d %d %s",
&set[jj].subtyp, &set[jj].maj_col, &set[jj].min_col,
&set[jj].info.tca->wwNum, set[jj].grp_typ );
}
}
/*
* ++++++++++++++++++++++++++++++++++++++++++++++++++++++
* DIDN'T RECOGNIZE THE CLASS; BAD READ, IGNORE RECORD
* ++++++++++++++++++++++++++++++++++++++++++++++++++++++
*/
else {
*iret = 2;
loglev = 2;
strcpy(grp, "CES");
er_lmsg (&loglev, grp, iret, SETTING_TBL, &ier1, strlen(grp),
strlen(SETTING_TBL));
}
/*
* Set layer_flag according to set[jj].grp_typ
*/
cst_lcuc(set[jj].grp_typ, set[jj].grp_typ, &ier1);
if ( strstr ( set[jj].grp_typ, "/LAYER" ) != NULL ) {
set[jj].cds_or_ces.layer_flag = TRUE;
}
else {
set[jj].cds_or_ces.layer_flag = FALSE;
}
/*
* Increment jj
*/
jj++;
}
}
if ( !quit ) {
/*
* Setting array (set) size exceeded. MAX_SET should
* be increased.
*/
*iret = 1;
loglev = 2;
strcpy(grp, "CES");
er_lmsg (&loglev, grp, iret, SETTING_TBL, &ier1, strlen(grp),
strlen(SETTING_TBL));
}
/* close the settings file */
cfl_clos(fp, &ier);
}
int main ( int argc, char **argv )
/************************************************************************
* clipvgf *
* *
* This program clips elements in a VGF file based on a bounds *
* specification. By default, a simple clipping algorithm is used *
* where element points either inside or outside the polygon are kept *
* or thrown away based on an input flag. Alternatively, an exact *
* algorithm may be requested which clips precisely at the borders. *
* *
* The bound definition must be in the format: *
* bound_name|<area_tag_name>area_tag_value *
* and must be enclosed w/ quotes so the shell will ignore directives. *
* *
* Examples: *
* clipvgf input.vgf "STATE_BNDS|<STATE>WY" keep output.vgf rough *
* clipvgf input.vgf "STATE_BNDS|<STATE>WY" keep output.vgf exact *
* Where "rough" uses the simple clipping algorithm and "exact" yields *
* precise clipping at the bounds borders. *
* *
* The following element classes are not processed: *
* CLASS_WATCHES, CLASS_TRACKS, CLASS_SIGMETS *
* *
* main(argc, argv) *
* *
* Input parameters: *
* argc int number of parameters of command line *
* argv char** parameter array of command line *
* *
* Output parameters: *
* Return parameters: *
* NONE *
* *
** *
* Log: *
* D.W.Plummer/NCEP 2/02 *
* D.W.Plummer/NCEP 5/02 Added exact clipping and label moving *
* D.W.Plummer/NCEP 8/02 Account for text grouped with symbol *
* D.W.Plummer/NCEP 8/02 Create output VGF, even if it is empty *
* H. Zeng/XTRIA 02/03 converted CLASS_CIRCLE to CLASS LINES *
* D.W.Plummer/NCEP 8/03 Bug fix - add pt to closed lines *
* R. Tian/SAIC 11/04 Added clip jet element *
* S. Danz/AWC 07/06 Update to new cvg_writef() parameter *
* T. Piper/SAIC 03/07 Added ninout-- for closed line case *
* L. Hinson/AWC 07/07 Added clip code for GFA elements *
* L. Hinson/AWC 07/07 Add recalcGFAtLblArwLoc function *
for GFA elements *
* X.Guo/CWS 10/10 Bug fix - Low level graphic don't make *
* it all the way north in central US *
* L. Hinson/AWC 09/13 Fixed improperly clipped JET_ELM Barbs *
* and hashes *
***********************************************************************/
{
int ii, jj, ip, ibeg, iend, loc, ne, found, found_txt, joffset, kept, ier;
int wrtflg, pagflg;
int minpts, maxpts, npts, numpts, npoly;
char vg_class, vg_type;
char bnd[128], keep[32], bnd_name[64], bnd_tag[64];
char infile[128], ifname[128], outfile[128];
char *cptr;
long ifilesize;
int more, curpos;
float flat, flon, filt, px[LLMXPT], py[LLMXPT];
float plat[LLMXPT], plon[LLMXPT], *ptrlat, *ptrlon;
float tlat[LLMXPT], tlon[LLMXPT];
float fltmin, fltmax, flnmin, flnmax;
int inout[LLMXPT], tinout[LLMXPT];
char device[8], dfilnam[128], pro[32];
float xsize, ysize, lllat, lllon, urlat, urlon;
float prjang1, prjang2, prjang3;
int mode, istat, iunit, itype;
char errgrp[8];
int ninout;
float xinout[LLMXPT], yinout[LLMXPT];
char precision[8];
int tltpts, nbarb, nhash;
int tmaxpts, tnpts, tnclip;
char hazList[ STD_STRLEN ];
VG_DBStruct el, el_t, el_q, el_lin;
FILE *ifptr;
int ninxarr, inxarr[100];
/*---------------------------------------------------------------------*/
/*
* First check if number of input arguments is correct.
*/
if ( argc < 5 ) {
pagflg = G_FALSE;
strcpy ( errgrp, "CLIPVGF" );
ip_help ( errgrp, &pagflg, &ier,
strlen(errgrp) );
exit (0);
}
/*
* First input on command line is input vgf file name.
*/
strcpy ( infile, argv[1] );
wrtflg = 0;
cvg_open ( infile, wrtflg, &(ifptr), &ier );
if ( ier != 0 ) {
printf("Error opening VGF file %s\n", infile );
exit (0);
}
cfl_inqr ( infile, NULL, &ifilesize, ifname, &ier );
/*
* Second input on command line is bounds name.
*/
clo_init ( &ier );
strcpy ( bnd, argv[2] );
cptr = cst_split( bnd, '|', sizeof(bnd_name), bnd_name, &ier );
clo_bstype ( bnd_name, &ier );
if ( ier != 0 ) {
printf("Error finding bounds type %s\n", bnd_name );
exit (0);
}
if ( cptr != (char *)NULL ) {
strcpy ( bnd_tag, cptr );
clo_bstag ( bnd_tag, &ier );
}
fltmin = -90.0F;
fltmax = 90.0F;
flnmin = -180.0F;
flnmax = 180.0F;
clo_bsarea ( &fltmin, &flnmin, &fltmax, &flnmax, &ier );
minpts = 3;
maxpts = sizeof(px)/sizeof(float);
filt = 0.0F;
clo_bgnext ( &minpts, &maxpts, &filt, &npoly, px, py, &ier );
if ( ier < 0 ) {
printf("Error retrieving bound area %s|%s\n", bnd_name, bnd_tag );
exit (0);
}
/*
* Third input on command line is keep flag.
*/
strcpy ( keep, argv[3] );
/*
* Fourth input on command line is output vgf file name; create it.
*/
strcpy ( outfile, argv[4] );
cvg_crvgf ( outfile, &ier );
/*
* Fifth input on command line is clip precision = "rough" or "exact"
*/
if ( argv[5] != (char *)NULL )
strcpy ( precision, argv[5] );
else
strcpy ( precision, "ROUGH" );
cst_lcuc ( precision, precision, &ier );
/*
* All input checks out OK; set up GAREA and PROJ for inpoly.
*/
mode = 1;
ginitp ( &mode, &istat, &ier );
strcpy ( device, "GN" );
iunit = 1;
strcpy ( dfilnam, "CLIPVGF" );
itype = 1;
xsize = 500.0F;
ysize = 500.0F;
gsdeva ( device, &iunit, dfilnam, &itype, &xsize, &ysize, &ier,
strlen(device), strlen(dfilnam));
/*
* Something more sophisticated may be needed here in the future
* to set up a proper proj and garea based on the clip area.
* For instance, the following definitions probably won't work
* on a clipping bound equivalent to Antartica.
*/
lllat = 0.0F;
lllon = -135.0F;
urlat = 0.0F;
urlon = 45.0F;
strcpy ( pro, "str" );
prjang1 = 90.0F;
prjang2 = -105.0F;
prjang3 = 0.0F;
gsmprj ( pro, &prjang1, &prjang2, &prjang3,
&lllat, &lllon, &urlat, &urlon, &ier, strlen(pro));
/*
* Loop through all the elements to set the range records.
*/
crg_init ( &ier );
ne = 0;
more = G_TRUE;
curpos = 0;
ifptr = (FILE *) cfl_ropn(ifname, "", &ier);
while ( ne < MAX_EDITABLE_ELEMS && more == G_TRUE ) {
cvg_rdrecnoc ( ifname, ifptr, curpos, &el, &ier );
if ( ier < 0 ) {
more = G_FALSE;
}
else {
crg_set ( &el, curpos, 1, &ier );
curpos += el.hdr.recsz;
ne++;
}
}
cfl_clos ( ifptr, &ier );
/*
* Loop through all the elements.
*/
ne = 0;
more = G_TRUE;
curpos = 0;
ifptr = (FILE *) cfl_ropn(ifname, "", &ier);
while ( ne < MAX_EDITABLE_ELEMS && more == G_TRUE ) {
cvg_rdrecnoc( ifname, ifptr, curpos, &el, &ier );
if ( ier < 0 ) {
more = G_FALSE;
}
else if ( el.hdr.recsz > 0 ) {
crg_gginx( el.hdr.grptyp, el.hdr.grpnum,
sizeof(inxarr)/sizeof(inxarr[0]),
inxarr, &ninxarr, &ier );
/*
* Increment file pointer now because element hdrsz may change.
*/
curpos += el.hdr.recsz;
vg_class = el.hdr.vg_class;
vg_type = el.hdr.vg_type;
switch ( (int)vg_class ) {
case CLASS_SYMBOLS:
case CLASS_TEXT:
case CLASS_WINDS:
case CLASS_COMSYM:
case CLASS_MARKER:
switch ( (int)vg_type ) {
case TEXT_ELM:
case TEXTC_ELM:
flat = el.elem.txt.info.lat;
flon = el.elem.txt.info.lon;
break;
case SPTX_ELM:
flat = el.elem.spt.info.lat;
flon = el.elem.spt.info.lon;
break;
case BARB_ELM:
case ARROW_ELM:
case DARR_ELM:
case HASH_ELM:
flat = el.elem.wnd.data.latlon[0];
flon = el.elem.wnd.data.latlon[1];
break;
case WXSYM_ELM:
case CTSYM_ELM:
case ICSYM_ELM:
case PTSYM_ELM:
case PWSYM_ELM:
case SKSYM_ELM:
case SPSYM_ELM:
case TBSYM_ELM:
case MARK_ELM:
case CMBSY_ELM:
flat = el.elem.sym.data.latlon[0];
flon = el.elem.sym.data.latlon[1];
break;
}
npts = 1;
cgr_inpoly ( "M", &npts, &flat, &flon, "M", &npoly, px, py,
inout, &ier );
if ( ( inout[0] == 1 && strcmp(keep,"keep") == 0 ) ||
( inout[0] == 0 && strcmp(keep,"keep") != 0 ) ) {
/*
* Check if element is TEXT grouped with a SYMBOL. If this text was going
* to be kept but it's symbol was going to be throw away, throw it away also.
*/
if ( (int)vg_class == CLASS_TEXT &&
(int)el.hdr.grptyp != 0 && ninxarr > 1 ) {
found = G_FALSE;
ii = 0;
while ( ii < ninxarr && found == G_FALSE ) {
crg_goffset ( inxarr[ii], &joffset, &ier );
cvg_rdrecnoc( ifname, ifptr, joffset, &el_q, &ier );
if ( el_q.hdr.vg_class == CLASS_SYMBOLS ) {
found = G_TRUE;
flat = el_q.elem.sym.data.latlon[0];
flon = el_q.elem.sym.data.latlon[1];
npts = 1;
cgr_inpoly ( "M", &npts, &flat, &flon, "M",
&npoly, px, py, inout, &ier );
if ((inout[0] == 1 && strcmp(keep,"keep") == 0) ||
(inout[0] == 0 && strcmp(keep,"keep") != 0)) {
cvg_writef( &el, -1, el.hdr.recsz, outfile,
FALSE, &loc, &ier );
kept = G_TRUE;
}
else {
kept = G_FALSE;
}
}
ii++;
}
if ( found == G_FALSE ) {
cvg_writef( &el, -1, el.hdr.recsz, outfile,
FALSE, &loc, &ier );
kept = G_TRUE;
}
}
else {
/*
* non-TEXT -- keep it.
*/
cvg_writef( &el, -1, el.hdr.recsz, outfile, FALSE, &loc, &ier );
kept = G_TRUE;
}
}
else {
/*
* Element is not to be kept.
*/
kept = G_FALSE;
}
/*
* Check if element was kept and is a SYMBOL element grouped with TEXT;
* make sure any text elements are saved off they were going to be thrown away.
*/
if ( kept == G_TRUE && (int)vg_class == CLASS_SYMBOLS &&
(int)el.hdr.grptyp != 0 && ninxarr > 1 ) {
ii = 0;
while ( ii < ninxarr ) {
crg_goffset ( inxarr[ii], &joffset, &ier );
cvg_rdrecnoc( ifname, ifptr, joffset,
&el_q, &ier );
if ( el_q.hdr.vg_class == CLASS_TEXT ) {
el_t = el_q;
switch ( (int)el_t.hdr.vg_type ) {
case TEXT_ELM:
case TEXTC_ELM:
flat = el_t.elem.txt.info.lat;
flon = el_t.elem.txt.info.lon;
break;
case SPTX_ELM:
flat = el_t.elem.spt.info.lat;
flon = el_t.elem.spt.info.lon;
break;
}
npts = 1;
cgr_inpoly ( "M", &npts, &flat, &flon, "M",
&npoly, px, py, inout, &ier );
if ( ( kept == G_TRUE ) &&
( ( inout[0] == 1 && strcmp(keep,"keep") == 0 ) ||
( inout[0] == 0 && strcmp(keep,"keep") != 0 ) ) ) {
}
else {
cvg_writef ( &el_t, -1, el_t.hdr.recsz, outfile,
FALSE, &loc, &ier );
}
}
ii++;
}
}
break;
case CLASS_CIRCLE:
case CLASS_LINES:
case CLASS_FRONTS:
/*
* convert a circle element to a line element
*/
if ( vg_class == CLASS_CIRCLE ) {
cvg_cir2lin ( &el, 10, &el_lin, &ier );
el = el_lin;
vg_class = el.hdr.vg_class;
vg_type = el.hdr.vg_type;
}
switch ( (int)vg_type ) {
case LINE_ELM:
npts = el.elem.lin.info.numpts;
ptrlat = &(el.elem.lin.latlon[ 0]);
ptrlon = &(el.elem.lin.latlon[npts]);
break;
case SPLN_ELM:
npts = el.elem.spl.info.numpts;
ptrlat = &(el.elem.spl.latlon[ 0]);
ptrlon = &(el.elem.spl.latlon[npts]);
break;
case FRONT_ELM:
npts = el.elem.frt.info.numpts;
ptrlat = &(el.elem.frt.latlon[ 0]);
ptrlon = &(el.elem.frt.latlon[npts]);
break;
}
memcpy ( plat, ptrlat, (size_t)npts*sizeof(float) );
memcpy ( plon, ptrlon, (size_t)npts*sizeof(float) );
if ( el.hdr.closed == 1 ) {
plat[npts] = plat[0];
plon[npts] = plon[0];
npts++;
}
if ( strcmp(precision,"EXACT") == 0 ) {
clip_line ( npoly, px, py, npts, plat, plon,
(int)el.hdr.closed, sizeof(xinout)/sizeof(float),
&ninout, xinout, yinout, inout, &ier );
}
else if ( strcmp(precision,"ROUGH") == 0 ) {
cgr_inpoly ( "M", &npts, plat, plon, "M", &npoly, px, py,
inout, &ier );
ninout = npts;
memcpy ( xinout, plat, (size_t)ninout*sizeof(float) );
memcpy ( yinout, plon, (size_t)ninout*sizeof(float) );
}
/*
* If element is closed, and some points are to be kept and others are not,
* then rotate the locations arrays such that a transition point is the first point.
*/
if ( el.hdr.closed == 1 ) {
ip = 0;
ninout--;
while ( inout[ip] == inout[0] && ip < ninout ) ip++;
if ( ip != ninout ) {
if (( inout[0] == 1 && strcmp(keep,"keep") == 0 ) ||
( inout[0] == 0 && strcmp(keep,"keep") != 0 ) ) {
memcpy ( tlat, xinout, (size_t)ninout*sizeof(float) );
memcpy ( tlon, yinout, (size_t)ninout*sizeof(float) );
memcpy ( tinout, inout, (size_t)ninout*sizeof(float) );
for ( ii = 0; ii < ninout; ii++ ) {
xinout[ii] = tlat[(ii+ip) % ninout];
yinout[ii] = tlon[(ii+ip) % ninout];
inout[ii] = tinout[(ii+ip) % ninout];
}
}
}
}
ip = 0;
while ( ip < ninout ) {
ibeg = ip;
iend = ip;
while ( inout[ip] == inout[ibeg] && ip < ninout ) ip++;
iend = ip - 1;
numpts = iend - ibeg + 1;
/*
* If element is closed, and some points are to be kept and others are not,
* then reset the closed flag.
*/
if ( el.hdr.closed == 1 && numpts != ninout )
el.hdr.closed = 0;
if ( numpts > 1 ) {
if (( inout[ibeg] == 1 && strcmp(keep,"keep") == 0 ) ||
( inout[ibeg] == 0 && strcmp(keep,"keep") != 0 ) ) {
switch ( (int)vg_type ) {
case LINE_ELM:
el.elem.lin.info.numpts = numpts;
ptrlat = &(el.elem.lin.latlon[ 0]);
ptrlon = &(el.elem.lin.latlon[numpts]);
el.hdr.recsz = ( (int)((sizeof(float) * 2 * (size_t)numpts) +
sizeof(VG_HdrStruct) +
sizeof(LineInfo) ));
break;
case SPLN_ELM:
el.elem.spl.info.numpts = numpts;
ptrlat = &(el.elem.spl.latlon[ 0]);
ptrlon = &(el.elem.spl.latlon[numpts]);
el.hdr.recsz = ( (int)((sizeof(float) * 2 * (size_t)numpts) +
sizeof(VG_HdrStruct) +
sizeof(SpLineInfo) ));
break;
case FRONT_ELM:
el.elem.frt.info.numpts = numpts;
ptrlat = &(el.elem.frt.latlon[ 0]);
ptrlon = &(el.elem.frt.latlon[numpts]);
el.hdr.recsz = ( (int)((sizeof(float) * 2 * (size_t)numpts) +
sizeof(VG_HdrStruct) +
sizeof(FrontInfo) ));
break;
}
memcpy(ptrlat, &(xinout[ibeg]), (size_t)numpts*sizeof(float));
memcpy(ptrlon, &(yinout[ibeg]), (size_t)numpts*sizeof(float));
cvg_writef ( &el, -1, el.hdr.recsz, outfile,
FALSE, &loc, &ier );
if ( (int)el.hdr.grptyp != 0 && ninxarr > 1 ) {
found = G_FALSE;
found_txt = G_FALSE;
ii = 0;
while ( ii < ninxarr && found == G_FALSE ) {
crg_goffset ( inxarr[ii], &joffset, &ier );
cvg_rdrecnoc( ifname, ifptr, joffset,
&el_q, &ier );
if ( el_q.hdr.vg_class == CLASS_TEXT ) {
found_txt = G_TRUE;
el_t = el_q;
switch ( (int)el_t.hdr.vg_type ) {
case TEXT_ELM:
case TEXTC_ELM:
flat = el_t.elem.txt.info.lat;
flon = el_t.elem.txt.info.lon;
break;
case SPTX_ELM:
flat = el_t.elem.spt.info.lat;
flon = el_t.elem.spt.info.lon;
break;
}
npts = 1;
cgr_inpoly ( "M", &npts, &flat, &flon, "M",
&npoly, px, py, inout, &ier );
if ( ( inout[0] == 1 && strcmp(keep,"keep") == 0 ) ||
( inout[0] == 0 && strcmp(keep,"keep") != 0 ) ) {
found = G_TRUE;
break;
}
}
ii++;
}
if ( found == G_FALSE && ii == ninxarr &&
found_txt == G_TRUE ) {
switch ( (int)vg_type ) {
case LINE_ELM:
flat = ( el.elem.lin.latlon[0] +
el.elem.lin.latlon[1] ) / 2.0F;
flon = ( el.elem.lin.latlon[numpts] +
el.elem.lin.latlon[numpts+1] ) / 2.0F;
break;
case SPLN_ELM:
flat = ( el.elem.spl.latlon[0] +
el.elem.spl.latlon[1] ) / 2.0F;
flon = ( el.elem.spl.latlon[numpts] +
el.elem.spl.latlon[numpts+1] ) / 2.0F;
break;
case FRONT_ELM:
flat = ( el.elem.frt.latlon[0] +
el.elem.frt.latlon[1] ) / 2.0F;
flon = ( el.elem.frt.latlon[numpts] +
el.elem.frt.latlon[numpts+1] ) / 2.0F;
break;
}
switch ( (int)el_t.hdr.vg_type ) {
case TEXT_ELM:
case TEXTC_ELM:
el_t.elem.txt.info.lat = flat;
el_t.elem.txt.info.lon = flon;
break;
case SPTX_ELM:
el_t.elem.spt.info.lat = flat;
el_t.elem.spt.info.lon = flon;
break;
}
cvg_writef ( &el_t, -1, el_t.hdr.recsz, outfile,
FALSE, &loc, &ier );
}
}
}
}
}
break;
case CLASS_MET:
switch ( (int)vg_type ) {
case JET_ELM:
npts = tltpts = el.elem.jet.line.spl.info.numpts;
ptrlat = &(el.elem.jet.line.spl.latlon[ 0]);
ptrlon = &(el.elem.jet.line.spl.latlon[npts]);
memcpy ( plat, ptrlat, (size_t)npts*sizeof(float) );
memcpy ( plon, ptrlon, (size_t)npts*sizeof(float) );
if ( strcmp(precision,"EXACT") == 0 ) {
clip_line ( npoly, px, py, npts, plat, plon,
(int)el.hdr.closed, sizeof(xinout)/sizeof(float),
&ninout, xinout, yinout, inout, &ier );
}
else if ( strcmp(precision,"ROUGH") == 0 ) {
cgr_inpoly ( "M", &npts, plat, plon, "M", &npoly, px, py, inout, &ier );
ninout = npts;
memcpy ( xinout, plat, (size_t)ninout*sizeof(float) );
memcpy ( yinout, plon, (size_t)ninout*sizeof(float) );
}
ip = 0;
while ( ip < ninout ) {
ibeg = ip;
iend = ip;
while ( inout[ip] == inout[ibeg] && ip < ninout )
ip++;
iend = ip - 1;
numpts = iend - ibeg + 1;
if ( numpts > 1 ) {
if (( inout[ibeg] == 1 && strcmp(keep,"keep") == 0 ) ||
( inout[ibeg] == 0 && strcmp(keep,"keep") != 0 ) ) {
memcpy ( &(el_t.hdr), &(el.hdr), sizeof(VG_HdrStruct) );
el_t.elem.jet.line.splcol = el.elem.jet.line.splcol;
memcpy ( &(el_t.elem.jet.line.spl.info), &(el.elem.jet.line.spl.info), sizeof(SpLineInfo) );
el_t.elem.jet.line.spl.info.numpts = numpts;
ptrlat = &(el_t.elem.jet.line.spl.latlon[ 0]);
ptrlon = &(el_t.elem.jet.line.spl.latlon[numpts]);
memcpy(ptrlat, &(xinout[ibeg]), (size_t)numpts*sizeof(float));
memcpy(ptrlon, &(yinout[ibeg]), (size_t)numpts*sizeof(float));
nbarb = 0;
for ( ii = 0; ii < el.elem.jet.nbarb; ii++ ) {
flat = el.elem.jet.barb[ii].wnd.data.latlon[0];
flon = el.elem.jet.barb[ii].wnd.data.latlon[1];
npts = 1;
cgr_inpoly ( "M", &npts, &flat, &flon, "M", &npoly, px, py, tinout, &ier );
if (( tinout[0] == 1 && strcmp(keep,"keep") == 0 ) ||
( tinout[0] == 0 && strcmp(keep,"keep") != 0 ) ) {
memcpy ( &(el_t.elem.jet.barb[nbarb]), &(el.elem.jet.barb[ii]), sizeof(BarbAttr) );
nbarb++;
}
}
el_t.elem.jet.nbarb = nbarb;
nhash = 0;
for ( ii = 0; ii < el.elem.jet.nhash; ii++ ) {
flat = el.elem.jet.hash[ii].wnd.data.latlon[0];
flon = el.elem.jet.hash[ii].wnd.data.latlon[1];
npts = 1;
cgr_inpoly ( "M", &npts, &flat, &flon, "M", &npoly, px, py, tinout, &ier );
if (( tinout[0] == 1 && strcmp(keep,"keep") == 0 ) ||
( tinout[0] == 0 && strcmp(keep,"keep") != 0 ) ) {
memcpy ( &(el_t.elem.jet.hash[nhash]), &(el.elem.jet.hash[ii]), sizeof(HashAttr) );
nhash++;
}
}
el_t.elem.jet.nhash = nhash;
cvg_writef ( &el_t, -1, el.hdr.recsz, outfile,
FALSE, &loc, &ier );
}
}
}
break;
case GFA_ELM:
/* Get the Hazard Type... */
cvg_getFld ( &el, TAG_GFA_AREATYPE, hazList, &ier );
npts = el.elem.gfa.info.npts;
ptrlat = &(el.elem.gfa.latlon[0]);
ptrlon = &(el.elem.gfa.latlon[npts]);
memcpy ( plat, ptrlat, (size_t)npts*sizeof(float) );
memcpy ( plon, ptrlon, (size_t)npts*sizeof(float) );
if ( el.hdr.closed == 1 ) {
plat[npts] = plat[0];
plon[npts] = plon[0];
npts++;
}
if(strcmp(hazList,"FZLVL")==0) { /* Is this a Freezing Level? */
if ( strcmp(precision,"EXACT") == 0 ) {
clip_line ( npoly, px, py, npts, plat, plon,
(int)el.hdr.closed,
sizeof(xinout)/sizeof(float),
&ninout, xinout, yinout, inout, &ier );
} else if (strcmp(precision,"ROUGH") == 0 ) {
cgr_inpoly ( "M", &npts, plat, plon, "M", &npoly, px, py,
inout, &ier );
ninout = npts;
memcpy ( xinout, plat, (size_t)ninout*sizeof(float) );
memcpy ( yinout, plon, (size_t)ninout*sizeof(float) );
}
if ( el.hdr.closed == 1 ) {
ip = 0;
ninout--;
while ( inout[ip] == inout[0] && ip < ninout ) ip++;
if ( ip != ninout ) {
if (( inout[0] == 1 && strcmp(keep,"keep") == 0 ) ||
( inout[0] == 0 && strcmp(keep,"keep") != 0 ) ) {
memcpy ( tlat, xinout, (size_t)ninout*sizeof(float) );
memcpy ( tlon, yinout, (size_t)ninout*sizeof(float) );
memcpy ( tinout, inout, (size_t)ninout*sizeof(float) );
for ( ii = 0; ii < ninout; ii++ ) {
xinout[ii] = tlat[(ii+ip) % ninout];
yinout[ii] = tlon[(ii+ip) % ninout];
inout[ii] = tinout[(ii+ip) % ninout];
}
}
}
}
ip = 0;
while ( ip < ninout ) {
ibeg = ip;
iend = ip;
while ( inout[ip] == inout[ibeg] && ip < ninout ) ip++;
iend = ip - 1;
numpts = iend - ibeg + 1;
if (el.hdr.closed == 1 && numpts != ninout )
el.hdr.closed = 0;
if ( numpts > 1 ) {
if (( inout[ibeg] == 1 && strcmp(keep,"keep") == 0 ) ||
( inout[ibeg] == 0 && strcmp(keep,"keep") != 0 )) {
el.elem.gfa.info.npts = numpts;
ptrlat = &(el.elem.gfa.latlon[ 0]);
ptrlon = &(el.elem.gfa.latlon[numpts]);
memcpy(ptrlat, &(xinout[ibeg]),
(size_t)numpts*sizeof(float));
memcpy(ptrlon, &(yinout[ibeg]),
(size_t)numpts*sizeof(float));
/* Recompute Default Text Label & Arrow location */
recalcGFAtLblArwLoc( &el );
el.hdr.recsz = (int) (sizeof(VG_HdrStruct) +
sizeof(int)*2 + sizeof(char)* STD_STRLEN *
el.elem.gfa.info.nblocks ) + sizeof(float)*numpts*2;
cvg_writef ( &el, -1, el.hdr.recsz, outfile,
FALSE, &loc, &ier );
}
}
}
} else {
/* We have a GFA object (that's not a freezing level)
to be clipped */
/* Use clo_clip to clip the GFA Polygon against the specified
bounds area. The resulting number of clipped areas (tnclips),
and max points (tmaxpts) is returned */
clo_clip(&npts, plat, plon, sys_M, bnd_name, bnd_tag, &tnclip,
&tmaxpts, &ier);
/* Foreach of the clipped areas, get the clipped area, and write
it out to the VGF file */
for (ii = 0; ii < tnclip; ii++) {
clo_clipget(&ii, &tnpts, tlat, tlon, &ier);
el.elem.gfa.info.npts = tnpts;
ptrlat = &(el.elem.gfa.latlon[ 0]);
ptrlon = &(el.elem.gfa.latlon[tnpts]);
/* Re-Initialize the latlon struct. */
for (jj =0; jj < MAXPTS*2; jj++) {
el.elem.gfa.latlon[jj] = 0.00;
}
memcpy(ptrlat, &(tlat[0]),
(size_t)tnpts*sizeof(float));
memcpy(ptrlon, &(tlon[0]),
(size_t)tnpts*sizeof(float));
/* Recompute Default Text Label & Arrow location */
recalcGFAtLblArwLoc( &el );
el.hdr.recsz = (int) (sizeof(VG_HdrStruct) +
sizeof(int)*2 + sizeof(char)* STD_STRLEN *
el.elem.gfa.info.nblocks ) + sizeof(float)*tnpts*2;
cvg_writef (&el, -1, el.hdr.recsz, outfile,
FALSE, &loc, &ier );
}
/* Free up memory left over from the clo routines */
clo_clipdone(&ier);
}
break;
}
break;
}
}
ne++;
}
cfl_clos ( ifptr, &ier );
return(0);
}
