Example #1
0
/* Help and usage message */
void usage(void)
{
  show_version();

  puts("\nUsage: t50 <host[/cidr]> [options]");

  general_help();
  gre_help();
  tcp_udp_dccp_help();
  tcp_help();
  ip_help();
  icmp_help();
  egp_help();
  rip_help();
  dccp_help();
  rsvp_help();
  ipsec_help();
  eigrp_help();
  ospf_help();

  puts("Some considerations while running this program:\n"
       " 1. There is no limitation of using as many options as possible.\n"
       " 2. Report " PACKAGE " bugs at " PACKAGE_URL ".\n"
       " 3. Some header fields with default values MUST be set to \'0\' for RANDOM.\n"
       " 4. Mandatory arguments to long options are mandatory for short options too.\n"
       " 5. Be nice when using " PACKAGE ", the author DENIES its use for DoS/DDoS purposes.\n"
       " 6. Running " PACKAGE " with \'--protocol T50\' option sends ALL protocols sequentially.");

  exit(EXIT_FAILURE);
}
Example #2
0
void dc_init ( char *prgnam, int argc, char **argv, int numexp, 
				char parms[][DCMXLN], int *num, int *iret )
/************************************************************************
 * dc_init								*
 *                                                                      *
 * This routine initializes the bridge and decoder parameters and	*
 * processes the command line options.					*
 *                                                                      *
 * dc_init ( prgnam, argc, argv, numexp, parms, num, iret )		*
 *                                                                      *
 * Input parameters:							*
 *	*prgnam		char		Program name			*
 *	argc		int		Number of command line args	*
 *	**argv		char		Command line arguments		*
 *	numexp		int		Number of expected parameters	*
 *                                                                      *
 * Output parameters:							*
 *	parms[][DCMXLN]	char		Parameters found on command line*
 *	*num		int		Number of parameters found	*
 *	*iret		int		Return code			*
 *					   0 = normal return		*
 *					 -11 = no command line args	*
 *                                                                      *
 **                                                                     *
 * Log:                                                                 *
 * A. Chang/EAi		 5/95						*
 * S. Jacobs/NMC	 7/95	Update and clean up			*
 * S. Jacobs/NCEP	 6/96	Updated documentation; Changed atoi to	*
 *				cst_numb; Removed the +3 return	code;	*
 *				Changed ldfd to a FILE stream - fplog	*
 * S. Jacobs/NCEP	 7/96	Reorganized the source code		*
 * K. Tyle/GSC		 7/96	NT_HELP --> IP_HELP			*
 * S. Jacobs/NCEP	 7/96	Removed log file open			*
 * K. Tyle/GSC		 1/97	Added calls to IN_BDTA and ER_STAT;	*
 *				changed numerr in startup dc_wclg call	*
 * K. Tyle/GSC		 1/97	Use iflg in call to ER_STAT		*
 * D. Kidwell/NCEP	 9/97	Added version number to help option     *
 * I. Durham/GSC	 5/98	Changed underscore decl. to an include	*
 * S. Jacobs/NCEP	 1/00	Added command line input of env vars	*
 * S. Jacobs/NCEP	 2/01	Removed all references to ulog		*
 * R. Tian/SAIC		 8/02	Added version to log file		*
 * m.gamazaychikov/SAIC	07/05	Added -w input parameter		*
 * H. Zeng/SAIC		08/05	Added second station table		*
 * L. Hinson/AWC        06/08   Add -r circular flag switch             *
 * S. Jacobs/NCEP	 3/12	Add $HOME to the logs directory		*
 * S. Jacobs/NCEP	12/13	Added more options for log location	*
 ***********************************************************************/
{
	int	ch, i, errflg, ier;
	int	pagflg = G_FALSE;
	int	iflg   = G_TRUE;

/*
**	These variables are used for logging errors and notices.
*/
	char	tdclog[DCMXLN];
	int	logflg, ibuf;
	char	errstr[DCMXLN];
	char	version[128];

/*
**	These variables are used by getopt. Unset the error reporting.
*/
	char		optver[20];

/*---------------------------------------------------------------------*/
	*iret = 0;

/*
**	Set the process ID for log messages.
*/
	ipid = (int) getpid ();

/*
**	Initialize the bulletin counter.
*/
	nbull = 0;

/*
**	Save the program name as a global variable.
*/
	strcpy ( cprgnm, prgnam );

/*
**	Set up the signal handlers.
*/
	dc_sgnl ( );
    
/*
**	Get and process the command line options.
**
**	Set the default values for parsing the command line.
*/
	strcpy ( curtim, "SYSTEM" );
	cst_uclc ( cprgnm, tdclog, &ier );
	strcat ( tdclog, ".log" );
	logflg    = G_FALSE;
	itmout    = DCDFTM;
	irltim    = G_TRUE;
	txtflg    = G_TRUE;
        circflg   = G_FALSE;
	ivrblv    = 0;
	prmfil[0] = CHNULL;
	stntbl[0] = CHNULL;
	iadstn    = IMISSD;
	maxtim    = IMISSD;
	nhours    = IMISSD;
	iwndht    = IMISSD;

/*
**	Get the valid options from the command line.
**	The valid options are:
**		-v	Set the level of verbosity for the logs
**		-c	Set the "current" time
**		-b	Number of hours to decode prior to "current" time
**		-d	Set the decoder log file name
**		-t	Set the interval for the time out
**		-p	Set the parameter packing table
**		-s	Set the station table
**		-S	Set the second station table
**		-a	Set the number of additional stations
**		-m	Set the max number of times
**		-e	Set an environment variable=value
**		-n	Set a flag to NOT save the text data
**              -r      Set a flag to force circular files
**		-w	Set the cutoff "close-to-the-surface" height
**		-h	Print the help file, then exit the program
*/
	opterr = 1;
	errflg = 0;
	while ( ( ch = getopt ( argc, argv,
				"v:c:b:d:t:p:s:S:a:m:e:w:nhr" ) ) != EOF ) {
	    switch ( ch ) {
		case 'v':
			cst_numb ( optarg, &ivrblv, &ier );
			if  ( ivrblv < 0 )  ivrblv = 0;
			break;
		case 'c':
			strcpy ( curtim, optarg );
			irltim = G_FALSE;
			break;
		case 'b':
			cst_numb ( optarg, &nhours, &ier );
			break;
		case 'd':
			strcpy ( tdclog, optarg );
			logflg = G_TRUE;
			break;
		case 't':
			cst_numb ( optarg, &itmout, &ier );
			if  ( itmout < 1 )  itmout = DCDFTM;
			break;
		case 'p':
			strcpy ( prmfil, optarg );
			break;
		case 's':
			strcpy ( stntbl, optarg );
			break;
		case 'S':
			strcpy ( stntb2, optarg );
			break;
		case 'a':
			cst_numb ( optarg, &iadstn, &ier );
			break;
		case 'm':
			cst_numb ( optarg, &maxtim, &ier );
			break;
		case 'e':
			envobj = (envlist *) malloc ( sizeof(envlist) );
			envobj->env = malloc ( strlen(optarg)+1 );
			strcpy ( envobj->env, optarg );
			envobj->env[strlen(optarg)] = '\0';
			envobj->next = envhead;
			envhead = envobj;
			break;
		case 'n':
			txtflg = G_FALSE;
			break;
		case 'w':
			cst_numb ( optarg, &iwndht, &ier );
			break;
                case 'r':
                        circflg = G_TRUE;
                        break;
		case 'h':
			ip_help ( cprgnm, &pagflg, &ier,
				  strlen(cprgnm) );
			strcpy ( cprgnm, "DECODE" );
			ip_help ( cprgnm, &pagflg, &ier,
				  strlen(cprgnm) );
			ss_vers ( optver, &ier,
				  sizeof (optver) );
			printf ( ">%s<\n", optver );
			exit ( 0 );
			break;
		case '?':
			errflg++;
			break;
	    }
	}

/*
**	Initialize GEMPAK and set error reporting parameters.
*/
	in_bdta ( &ier );
	ibuf = 1;
	er_stat ( &ivrblv, &ibuf, &iflg, &ier );

/*
**	Open the decoder log.
**
**	If the processing is in real-time add the directory to the 
**	file name.
*/
	if  ( !logflg && irltim )
	{
	    if ( tdclog[0] == '/' ) {
		strcpy ( dcdlog, tdclog );
	    }
	    else if ( getenv("GEMPAK_DECODER_LOGS") ) {
		strcpy ( dcdlog, "$GEMPAK_DECODER_LOGS/" );
		strcat ( dcdlog, tdclog );
	    }
	    else {
		strcpy ( dcdlog, "$HOME/" );
		strcat ( dcdlog, tdclog );
	    }
	}
	else
	{
	    strcpy ( dcdlog, tdclog );
	}

/*
**	Send a start up message to the decoder log.
*/
	ss_vers ( version, &ier, sizeof(version) );
	dc_wclg ( 0, "DCINIT", 3, version, &ier );

/*
**	Set all of the environment variables.
*/
	envobj = envhead;
	while ( envobj != NULL ) {
	    if  ( putenv ( envobj->env ) != 0 )  {
		strcpy ( errstr, envobj->env );
		dc_wclg ( 0, "DCINIT", -17, errstr, &ier );
	    }
	    envobj = envobj->next;
	}

/*
**	Adjust argc and argv by the option index.
*/
	argc -= optind;
	argv += optind;

/*
**	Initialize the output string array.
*/
	for ( i = 0; i < numexp; i++ )
	    strcpy ( parms[i], " " );

/*
**	Get the decoder specific parameters.
*/
	*num = argc;

	if  ( *num == 0 )
	{
/*
**	    If there are no parameters write a message and return
**	    with an error.
*/
	    *iret = -11;
	    dc_wclg ( 0, "DCINIT", *iret, " ", &ier );
	}
	else
	{
/*
**	    Otherwise, set the parameters to be returned.
*/
	    for ( i = 0; i < *num; i++ )
		if  ( i < numexp )  strcpy ( parms[i], argv[i] );
	}
}
Example #3
0
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;
}
Example #4
0
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);
}
Example #5
0
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);

}
Example #6
0
int main ( int argc, char *argv[] )
/************************************************************************
 * sigavgf                                                              *
 *                                                                      *
 * This program reads Significant Weather ASCII files and encodes the   *
 * information into a VG file format.   	                        *
 *                                                                      *
 * command line:                                                        *
 *      sigavgf dattim hh                                               *
 *              dattim      GEMPAK date/time string                     *
 *              hh          Valid time (hours) - must be 18 or 24       *
 **                                                                     *
 * Log:                                                                 *
 * A. Hardy/SAIC     3/02      Created					* 
 * A. Hardy/SAIC     5/02      Added optional input file name; changed  *
 * 			       default input file name			*
 * M. Li/SAIC	     7/04      Removed grpch from sigajet		*
 * M. Li/SAIC	     9/04      Add idcent, chbase and chtop to cas_rdhdr*
 * M. Li/SAIC	     1/05      Process SWM 				*
 * M. Li/SAIC	    10/05      Checked for new format of jet info	*
 ***********************************************************************/
{
    int 	ier, numerr, leverr, pagflg, grpid, iret;
    int         itime[5], jtime[5], idcent;
    float	chbase, chtop;
    int         numtrp, rnum, lnum, hnum, membx, memhi, memlo;
    int         memcld, memmcld, memfrt, memjet, memstm, memtur, memvlr;
    int         numcld, nummcld, numfrt, numjet, numstm, numtur, numvlr;

    char 	fhour [3], fname[256], gtstr[12], grpch, chlvl[10];
    char	errgrp[8], cc[50], casgrp[4];
    char	path[256];
    char	newflvl[10];
    long	size;


    cloud_t     *ptrc, *head,  *ptr2;
    mcloud_t    *ptrm, *headm, *ptr2m;
    jets_t      *ptrj, *headj, *ptr2j;
    front_t     *ptrf, *headf, *ptr2f;
    turb_t      *ptrb, *headb, *ptr2b;
    storm_t     *ptrs, *heads, *ptr2s;
    volrad_t    *ptrv, *headv, *ptr2v;
    trop_t      *ptrr, *headr, *ptr2r;
    trophi_t    *ptrh, *headh, *ptr2h;
    troplo_t    *ptrl, *headl, *ptr2l;

    Boolean     readflg;

    FILE *ifpout;
    /*---------------------------------------------------------------------*/
 
    iret    = 0;
    leverr  = 0;
    readflg = True;
    ifpout  = NULL;

    strcpy ( errgrp, "SIGAVGF" );
    strcpy ( casgrp, "CAS");
    strcpy ( cc, " " );

    rnum   = lnum   = hnum   = 0;
    membx  = memhi  = memlo  = 0;
    memcld = memmcld = memfrt = memjet = memstm = memtur = memvlr = 0;
    numcld = nummcld = numfrt = numjet = numstm = numtur = numvlr = 0;

    ptrc   =  NULL;
    ptrm   =  NULL;
    ptrj   =  NULL;
    ptrf   =  NULL;
    ptrb   =  NULL;
    ptrs   =  NULL;
    ptrv   =  NULL;
    ptrr   =  NULL;
    ptrh   =  NULL;
    ptrl   =  NULL;

    in_bdta ( &ier );

   /*
    * If the forecast hour is not on the command line, print help 
    * and exit.
    */

    if ( argc < 3 ) {
        pagflg = G_FALSE;
        ip_help ( errgrp, &pagflg, &ier, 
                  strlen(errgrp) );
        numerr = -1;
        er_lmsg ( &leverr, errgrp, &numerr, cc, &ier,
                  strlen(errgrp), strlen(cc) );
        exit (1);
    }

    strcpy ( fhour, argv[2] );
    if  ( strcmp ( fhour, "24") != 0 ) { 
        if ( strcmp ( fhour, "18") != 0 ) {
            numerr = -2;
            er_lmsg ( &leverr, errgrp, &numerr, fhour, &ier,
                      strlen(errgrp), strlen(fhour) );
            exit (1);
	}
    }

   /*
    *  Check for input file.
    */

    if ( argv[3] != NULL ) {
        strcpy ( fname, argv[3] );
    }
    else {
       
       /*
	* If an input file is not specified, check for the existence of 
	* either SIGWXHI.txt or SIGWXMID.txt.
	*/

        sprintf ( fname, "SIGWXHI.txt" );
	cfl_inqr ( fname, NULL, &size, path, &ier );
	if ( ier != 0 ) {
	    sprintf ( fname, "SIGWXMID.txt" );
            cfl_inqr ( fname, NULL, &size, path, &ier );
	    if ( ier != 0 ) {
		numerr = -3;
                er_lmsg ( &leverr, errgrp, &numerr, fname, &ier,
                          strlen(errgrp), strlen(fname) );
                exit (1);
            }
	}

    }
    ifpout = cas_open ( fname, readflg, &ier );

   /*
    * If input ASCII file failed to open, exit program.
    */

    if ( ier != 0 ) {
         numerr = -3;
         er_lmsg ( &leverr, errgrp, &numerr, fname, &ier,
                      strlen(errgrp), strlen(fname) );
         exit (1);
    }

   /*
    * Read in the input ASCII file into the CAS structures.
    */

    cas_rdhdr ( ifpout, itime, jtime, &idcent, &chbase, &chtop, &ier );

    rewind (ifpout);
    if ( G_ABS ( HI_BASE - chbase ) < 0.5F &&
         G_ABS ( HI_TOP  - chtop  ) < 0.5F ) {
	strcpy ( chlvl, "SWH" );
        cas_rdcld ( ifpout, &numcld, &ptrc, &memcld, &ier );
    } else if ( G_ABS ( MID_BASE - chbase ) < 0.5F &&
                G_ABS ( MID_TOP  - chtop  ) < 0.5F ) {
        strcpy ( chlvl, "SWM" );
   	cas_rdmcld ( ifpout, &nummcld, &ptrm, &memmcld, &ier );
    }

    rewind (ifpout);
    cas_rdjets ( ifpout, &numjet, &ptrj, &memjet, &ier );

    rewind (ifpout);
    cas_rdturb ( ifpout, &numtur, &ptrb, &memtur, &ier );

    rewind (ifpout);
    cas_rdfrt ( ifpout, &numfrt, &ptrf, &memfrt, &ier);

    rewind (ifpout);
    cas_rdtrop ( ifpout, &numtrp, &ptrr, &membx, &rnum,
                 &ptrl, &memlo, &lnum, &ptrh, &memhi,
		 &hnum, &ier );

    rewind (ifpout);
    cas_rdstm ( ifpout, &numstm, &ptrs, &memstm, &ier );

    rewind (ifpout);
    cas_rdvlrd ( ifpout, &numvlr, &ptrv, &memvlr, &ier );

   /*
    * Close input file.
    */

    cas_clos ( ifpout, &ier );
    
   /*
    * If ASCII file failed to close, write error message.
    */

    if ( ier != 0 ) {
         numerr = -4;
         er_lmsg ( &leverr, casgrp, &numerr, fname, &ier,
                      strlen(casgrp), strlen(fname) );
    }

   /*
    * Initialize the group type table.
    */

    ces_gtrtbl ( &iret );

   /*
    * Call appropriate VG file encoding subroutines.
    *
    * Create cloud VG file.
    */

    strcpy ( gtstr, "CLOUD");
    ces_gtgid (gtstr, &grpid, &ier);
    grpch = (char) grpid;
    if ( strcmp ( chlvl, "SWH" ) == 0 ) {
        sigacld ( fhour, numcld, ptrc, itime, grpch, &ier );
    }
    else {
	sigamcld ( fhour, nummcld, ptrm, itime, grpch, &ier );
    }

   /*
    * Create jets VG file.
    */

    ctb_rdprf ( "prefs.tbl", "config", "SIGWX_FLIGHT_LEVELS", newflvl, &ier );
    sigajet ( fhour, numjet, ptrj, itime, chlvl, newflvl, &ier );

   /*
    * Create turbulence VG file.
    */

    strcpy ( gtstr, "TURB");
    ces_gtgid (gtstr, &grpid, &ier);
    grpch = (char) grpid;
    sigatur ( fhour, numtur, ptrb, itime, grpch, chlvl, &ier );

   /*
    * Create front VG file.
    */

    strcpy ( gtstr, "FRONT");
    ces_gtgid (gtstr, &grpid, &ier);
    grpch = (char) grpid;
    sigafrt ( fhour, numfrt, ptrf, itime, grpch, chlvl, &ier );

   /*
    * Create tropopause VG file.
    */

    sigatrp ( fhour, rnum, ptrr, hnum, ptrh, lnum, ptrl, 
	      itime, chlvl, &ier );

   /*
    * Create symbol VG file.
    */

    strcpy ( gtstr, "LABEL");
    ces_gtgid (gtstr, &grpid, &ier);
    grpch = (char) grpid;
    sigavts ( fhour, numstm, ptrs, numvlr, ptrv, 
                       itime, grpch, chlvl, &ier );

   /*
    *  Free all created linked lists.
    */

    /* Free cloud */
    if ( memcld ) {
        head = ptrc;
        ptr2 = head -> next;
        while ( ptr2 != NULL ) {
            free (head);
            head = ptr2;
            ptr2 = ptr2 -> next;
        }
        free ( head );
    }

    /* Free mcloud */
    if ( memmcld ) {
        headm = ptrm;
        ptr2m = headm -> next;
        while ( ptr2m != NULL ) {
            free (headm);
            headm = ptr2m;
            ptr2m = ptr2m -> next;
        }
        free ( headm );
    }


    /* Free jet */
    if ( memjet ) {
        headj = ptrj;
        ptr2j = headj -> next;
        while ( ptr2j != NULL ) {
            free (headj);
            headj = ptr2j;
            ptr2j = ptr2j -> next;
        }
        free ( headj );
    }

    /* Free turb */
    if ( memtur ) {
        headb = ptrb;
        ptr2b = headb -> next;
        while ( ptr2b != NULL ) {
            free (headb);
            headb = ptr2b;
            ptr2b = ptr2b -> next;
        }
        free ( headb );
    }

    /* Free front*/
    if ( memfrt ) {
        headf = ptrf;
        ptr2f = headf -> next;
        while ( ptr2f != NULL ) {
            free (headf);
            headf = ptr2f;
            ptr2f = ptr2f -> next;
        }
        free ( headf );
    }
    /* Free trop*/
    if ( membx ) {
        headr = ptrr;
        ptr2r = headr -> next;
        while ( ptr2r != NULL ) {
            free ( headr );
            headr = ptr2r;
            ptr2r = ptr2r -> next;
        }
        free ( headr );
    }
    if ( memhi ) {
        headh = ptrh;
        ptr2h = headh -> next;
        while ( ptr2h != NULL ) {
            free ( headh );
            headh = ptr2h;
            ptr2h = ptr2h -> next;
        }
        free ( headh );
    }
    if ( memlo ) {
        headl = ptrl;
        ptr2l = headl -> next;
        while ( ptr2l != NULL ) {
            free ( headl );
            headl = ptr2l;
            ptr2l = ptr2l -> next;
        }
        free ( headl );
    }

    if ( memstm ) {
        heads = ptrs;
        ptr2s = heads -> next;
        while ( ptr2s != NULL ) {
            free ( heads );
            heads = ptr2s;
            ptr2s = ptr2s -> next;
        }
        free ( heads );
    }
    if ( memvlr ) {
        headv = ptrv;
        ptr2v = headv -> next;
        while ( ptr2v != NULL ) {
            free ( headv );
            headv = ptr2v;
            ptr2v = ptr2v -> next;
        }
        free ( headv );
    }

    return 0;
}
Example #7
0
int main ( void )
/************************************************************************
 * TESTGPC								*
 *									*
 * This program tests the GPC contributed library public functions.	*
 *									*
 **									*
 * Log:									*
 * D.W.Plummer/NCEP	 2/04						*
 * D.W.Plummer/NCEP	10/06	Added GPC_SET_EPSILON			*
 ***********************************************************************/
{
int		ii, cont, numsub, which, ier;
int		operation, readholeflag, writeholeflag, hole;
int		nverts=0;
double		e;
char		select[8];
float		xv[LLMXPT], yv[LLMXPT];
char		filnam[256], buffer[80];
int		pagflg;
char    	errgrp[8];
FILE		*fpread, *fpwrite;
gpc_polygon	subject_polygon, clip_polygon, result_polygon;
gpc_vertex_list	contour;
/*---------------------------------------------------------------------*/
    cont = G_FALSE;

    /*
     * Structure initializations.
     */
    subject_polygon.num_contours = 0;
    subject_polygon.hole         = (int*)NULL;
    subject_polygon.contour      = (gpc_vertex_list*)NULL;
    clip_polygon.num_contours    = 0;
    result_polygon.num_contours  = 0;
    contour.vertex 		 = (gpc_vertex*)NULL;
    contour.num_vertices 	 = 0;

    while ( cont == G_FALSE ) {
        printf ( "\n\n" );
        printf ( "*** ORIGINAL GPC PUBLIC FUNCTIONS ***\n");
        printf ( "   1 = GPC_READ_POLYGON    2 = GPC_WRITE_POLYGON \n");
        printf ( "   3 = GPC_ADD_CONTOUR     4 = GPC_POLYGON_CLIP \n");
        printf ( "   5 = GPC_FREE_POLYGON     \n");
        printf ( "*** GPC PUBLIC FUNCTION ADD-ONS ***\n");
        printf ( "  11 = GPC_CREATE_VERTEX_LIST   \n");
	printf ( "  12 = GPC_GET_VERTEX_LIST      \n");
	printf ( "  13 = GPC_GET_VERTEX_AREA      \n");
	printf ( "  14 = GPC_SET_EPSILON      \n");
        printf ( "*** HELP ***\n");
	printf ( "  99 = HELP on INPUT FILE FORMATS \n");
        printf ( "\n" );
        printf ( "Select a subroutine number or type EXIT: " );
        scanf ( " %s", select );
        switch ( select[0] ) {
    	    case 'e':
    	    case 'E':
    		cont = G_TRUE;
    	    default:
    		numsub = atoi ( select );
    		break;
        }

/*---------------------------------------------------------------------*/
        if ( numsub == 1 ) {

	    printf("Make sure your polygon file is in the proper format:\n");

	    printf("<num-contours>\n");
	    printf("<num-vertices-in-first-contour>\n");
	    printf("[<first-contour-hole-flag>]\n");
	    printf("<vertex-list>\n");
	    printf("<num-vertices-in-second-contour>\n");
	    printf("[<second-contour-hole-flag>]\n");
	    printf("<vertex-list> \n");
	    printf("etc...\n");

	    printf ( "Enter filename to read polygon from : \n");
	    scanf ( " %s", filnam );

	    printf ( "Enter whether file format contains hole flags (%d-FALSE,%d-TRUE) :\n",
		  G_FALSE, G_TRUE );
	    scanf ( " %d", &readholeflag );

	    printf ( "Enter which polygon (%d-SUBJECT,%d-CLIP) :\n",
		  SUBJECT, CLIP );
	    scanf ( " %d", &which );

	    fpread = (FILE *)cfl_ropn ( filnam, "", &ier );
	    if ( ier == G_NORMAL )  {
	      if ( which == SUBJECT )
	        gpc_read_polygon ( fpread, readholeflag, &subject_polygon );
	      else if ( which == CLIP )
	        gpc_read_polygon ( fpread, readholeflag, &clip_polygon );
	      else
		printf("Invalid polygon type\n");
	      cfl_clos ( fpread, &ier );
	    }
	    else  {
	      printf("Unable to open file %s\n", filnam );
	    }

        }
/*---------------------------------------------------------------------*/
        if ( numsub == 2 ) {

	    printf ( "Enter filename to write polygon to : \n");
	    scanf ( " %s", filnam );

	    printf ( "Enter the write hole flag (%d-FALSE,%d-TRUE):\n",
		  G_FALSE, G_TRUE );
	    scanf ( " %d", &writeholeflag );

	    printf ( "Enter which polygon (%d-SUBJECT,%d-CLIP,%d-RESULT):\n",
		  SUBJECT, CLIP, RESULT );
	    scanf ( " %d", &which );

	    fpwrite = (FILE *)cfl_wopn ( filnam, &ier );
	    if ( ier == G_NORMAL )  {
	      if ( which == SUBJECT )
	        gpc_write_polygon ( fpwrite, writeholeflag, &subject_polygon );
	      else if ( which == CLIP )
	        gpc_write_polygon ( fpwrite, writeholeflag, &clip_polygon );
	      else if ( which == RESULT )
	        gpc_write_polygon ( fpwrite, writeholeflag, &result_polygon );
	      else
		printf("Invalid polygon type\n");
	      cfl_clos ( fpwrite, &ier );
	    }
	    else  {
	      printf("Unable to open file %s\n", filnam );
	    }


        }
/*---------------------------------------------------------------------*/
	if ( numsub == 3 ) {

	    if ( nverts == 0 )  {
		printf("Must first create a vertex list (option 11)\n");
	    }
	    else  {

	        printf ( "Enter which polygon (%d-SUBJECT,%d-CLIP,%d-RESULT) to add vertex list to:\n",
		      SUBJECT, CLIP, RESULT );
	        scanf ( " %d", &which );

	        printf ( "Enter the hole flag (%d-HOLE,%d-NOT A HOLE):\n",
		      G_TRUE, G_FALSE );
	        scanf ( " %d", &hole );

	        if ( which == SUBJECT )  {
		    gpc_add_contour ( &subject_polygon, &contour, hole );
		}
		else if ( which == CLIP )  {
		    gpc_add_contour ( &clip_polygon, &contour, hole );
		}
		else {
		    printf("Invalid polygon\n");
		}
	    }

	}
/*---------------------------------------------------------------------*/
	if ( numsub == 4 ) {

	    printf ( "Enter operation (%d-GPC_DIFF,%d-GPC_INT,%d-GPC_XOR,%d-GPC_UNION):\n",
		  GPC_DIFF, GPC_INT, GPC_XOR, GPC_UNION );
	    scanf ( " %d", &operation );

	    gpc_polygon_clip ( operation, &subject_polygon,
		    &clip_polygon, &result_polygon );

	}
/*---------------------------------------------------------------------*/
        if ( numsub == 5 ) {

	    printf ( "Enter which polygon (%d-SUBJECT,%d-CLIP,%d-RESULT,%d-ALL) to free contours:\n ",
		  SUBJECT, CLIP, RESULT, ALL );
	    scanf ( " %d", &which );

	    if ( which == SUBJECT || which == ALL )  {
    	        if ( subject_polygon.num_contours != 0 )
		    gpc_free_polygon ( &subject_polygon );
	    }
	    else if ( which == CLIP || which == ALL )  {
    	        if ( clip_polygon.num_contours != 0 )
        	    gpc_free_polygon ( &clip_polygon );
	    }
	    else if ( which == RESULT || which == ALL )  {
    	        if ( result_polygon.num_contours != 0 )
        	    gpc_free_polygon ( &result_polygon );
            }


        }
/*---------------------------------------------------------------------*/
        if ( numsub == 11 ) {

	    printf ( "Enter either the number of points in polygon (to be followed by entering the points), or a filename to read points from: \n");
	    scanf ( " %s", filnam );

	    cst_numb ( filnam, &nverts, &ier );

	    if ( ier == 0 )  {
	        for ( ii = 0; ii < nverts; ii++ )
		    scanf ( "%f %f", &(xv[ii]), &(yv[ii]) );
    	        if ( contour.vertex != (gpc_vertex*)NULL )
		    free ( contour.vertex );
	        gpc_cvlist ( nverts, xv, yv, &contour, &ier );
	    }
	    else  {
	        printf ( "Note that the file format is simply a list of coordinate pairs separated by whitespace.\nThe number of points will be counted automatically. For instance, a file containing:\n0 0\n0 1\n1 1\nyields a vertex list of three points.\n\n");
		nverts = 0;
	        fpread = (FILE *)cfl_tbop ( filnam, "", &ier );
	        if ( ier == G_NORMAL )  {
		    cfl_trln ( fpread, sizeof(buffer), buffer, &ier );
		    while ( ier == 0 )  {
			sscanf ( buffer, "%f %f", 
			    &(xv[nverts]), &(yv[nverts]) );
			    nverts += 1;
			cfl_trln ( fpread, sizeof(buffer), buffer, &ier );
		    }
		    printf("EOF reached in file %s, number of vertices = %d\n", 
			    filnam, nverts );
		    cfl_clos( fpread, &ier );
    	            if ( contour.vertex != (gpc_vertex*)NULL )
		    	free ( contour.vertex );
	            gpc_cvlist ( nverts, xv, yv, &contour, &ier );
		}
	    }

        }
/*---------------------------------------------------------------------*/
        if ( numsub == 12 ) {

	    gpc_gvlist ( &contour, &nverts, xv, yv, &ier );

	    printf("gpc_gvlist, ier = %d\n", ier );

	    printf("Number of vertices = %d\n", nverts );
	    for ( ii = 0; ii < nverts; ii++ )
		printf ( "%d - %f %f\n", ii, xv[ii], yv[ii] );

        }
/*---------------------------------------------------------------------*/
        if ( numsub == 13 ) {

	    printf ( "Area of contour is %f\n", gpc_gvarea(&contour) );

        }
/*---------------------------------------------------------------------*/
        if ( numsub == 14 ) {

	    scanf ( " %lf", &e );

	    gpc_set_epsilon ( e );

        }
/*---------------------------------------------------------------------*/
        if ( numsub == 99 ) {

	    pagflg = G_FALSE;
	    strcpy ( errgrp, "TESTGPC" );
	    ip_help ( errgrp, &pagflg, &ier, strlen(errgrp) );

        }
/*---------------------------------------------------------------------*/
    }

    if ( subject_polygon.num_contours != 0 )
	gpc_free_polygon ( &subject_polygon );
    if ( clip_polygon.num_contours != 0 )
        gpc_free_polygon ( &clip_polygon );
    if ( result_polygon.num_contours != 0 )
        gpc_free_polygon ( &result_polygon );
    if ( contour.vertex != (gpc_vertex*)NULL )
	free ( contour.vertex );

    return(0);

}
Example #8
0
int main ( int argc, char *argv[] )
/************************************************************************
 * main                                                                 *
 *                                                                      *
 * Main program of ssfgsf.                                              *
 *                                                                      *
 * int main ( argc, argv )                                              *
 *                                                                      *
 * Input parameters:                                                    *
 *      argc            int		Number of arguments             *
 *      **argv          char            arguments array                 *
 *                                                                      *
 * Output parameters:                                                   *
 * Return parameters:                                                   *
 *                      NONE                                            *
 *                                                                      *
 **                                                                     *
 * Log:                                                                 *
 * R. Tian/SAIC          2/06           Initial coding                  *
 ***********************************************************************/
{
    char infile[MXFLSZ], outfil[MXFLSZ], window[MXFLSZ], prognm[7];
    int opt, hasgsf, pagflg, iret;
/*---------------------------------------------------------------------*/
    strcpy ( prognm, "ssfgsf" );
    hasgsf = G_FALSE;
    pagflg = G_FALSE;

    /*
     * Set default subset window.
     */
    strcpy ( window, "-9999.;-9999.;-9999.;-9999." );

    /*
     * Parse command line arguments.
     */
    while ( ( opt = getopt ( argc, argv, "o:w:h" ) ) != -1 ) {
        switch ( opt ) {
	    case 'o':
	        strcpy ( outfil, optarg );
		hasgsf = G_TRUE;
	    break;

	    case 'w':
	        strcpy ( window, optarg );
	    break;

	    case 'h':
	    default:
		ip_help ( prognm, &pagflg, &iret, strlen(prognm) );
		exit (0);
	    break;
	}
    }

    /*
     * Check for any input error.
     */
    if ( argc - optind != 1 || hasgsf == G_FALSE ) {
	ip_help ( prognm, &pagflg, &iret, strlen(prognm) );
	exit (-1);
    }

    /*
     * Get input SSF file name.
     */
    strcpy ( infile, argv[optind] );

    /*
     * Call Fortran subroutine to do the job.
     */
    map_ssfgsf ( infile, outfil, window, &iret,
                 strlen(infile), strlen(outfil), strlen(window) );

    /*
     * Remove intermediate files.
     */
    remove ( DAFILE );
    remove ( SQFILE );

    return 0;
}
Example #9
0
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	*
 * G. Grosshans/SPC	11/02	Updated to decode multi-scalloped lines *
 * G. Grosshans/SPC	12/02	Updated to compute WFO/State		*
 * S. Jacobs/NCEP	 5/03	Clean up unused variables and headers	*
 * G. Grosshans/SPC     10/03   Updated for precision                   *
 * T. Piper/SAIC	12/05	Updated cst_wrap for CSC		*
 * J. Wu/SAIC		04/06	Added parameter in cst_wrap 		*
 * G. Grosshans/SPC	08/08	Updated for SCN 08-45 to add LAT...LON  *
 * 				and list first point as last point      *
 * 				to indicate a closed polygon.  Add      *
 *				word wrapping for ATTN...WFO...		*
 ***********************************************************************/
{
int		ii, ix, iy, ixfirst, iyfirst, pagflg, ne, ilen,
	        npts, ier, iret, nitems, more, curpos;

long		ifilesize;

float		x, y, flat[MAXLISTITEMS], flon[MAXLISTITEMS];

char		vg_class, vg_type, buffer[2048], bufferfinal[2048],
		bufferfinalwfo[2048],str[20], *cptr, errgrp[12], infile[128],
		ifname[128], outfile[128], info[2048], stpo[4],
		cstl_list[1000], cstl_liststate[1000],
		newLineStr[13]="            "; /* 13 spaces */

char		blank[2]={' '}, device[13], dfilnam[73], pro[80];
int		mode, istat, iunit, itype;
float		xsize, ysize, lllat, lllon, urlat, urlon,
		prjang1, prjang2, prjang3;

VG_DBStruct	el;

FILE		*ifptr, *ofptr;

const int line_len = 66;

/*---------------------------------------------------------------------*/

    /* 
     * Set defaults for gsdeva and gsmprj
     */
    mode = 1;
    strcpy ( device, "GN" );
    iunit = 1;
    strcpy ( dfilnam, "MDPSPC" );
    itype = 1;
    xsize = 500.0F;
    ysize = 500.0F;
    lllat = 10.0F;
    lllon = -120.0F;
    urlat = 50.0F;
    urlon = -50.0F;
    strcpy ( pro, "str" );
    prjang1 =   90.0F;
    prjang2 = -105.0F;
    prjang3 =    0.0F;
    cstl_list[0] = '\0';
    cstl_liststate[0] = '\0';

    in_bdta ( &ier );
    ginitp ( &mode, &istat, &ier);
    gsdeva (device, &iunit, dfilnam, &itype, &xsize, &ysize, &iret,
	    strlen(device), strlen(dfilnam));
    gsmprj ( pro, &prjang1, &prjang2, &prjang3, 
	     &lllat, &lllon, &urlat, &urlon, &iret, strlen(pro));
    clo_init ( &ier );

    /*
     *  Check if number of input arguments is correct.
     */
    if ( argc < 2 )  {
	pagflg = G_FALSE;
	strcpy ( errgrp, "MDPSPC" );
        ip_help ( errgrp, &pagflg, &ier,
                  strlen(errgrp) );
	gendp (&mode, &ier);
	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 );
	gendp (&mode, &ier);
	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.
     */
    ne = 0;
    more = G_TRUE;
    curpos = 0;
    buffer[0] = '\0';
    bufferfinal[0] = '\0';
    bufferfinalwfo[0] = '\0';
    strcat ( buffer, "LAT...LON   " );
    while ( ne < MAX_EDITABLE_ELEMS && more == G_TRUE )  {
	cvg_rdrecnoc( ifname, ifptr, curpos, &el, &ier );

	if ( ier < 0 )  {
	    more = G_FALSE;
	}
	else  {

	    curpos += el.hdr.recsz;

	    vg_class = el.hdr.vg_class;
	    vg_type  = el.hdr.vg_type;

            if ( ( (int)vg_class == CLASS_LINES ) &&
	    	 ( el.hdr.vg_type == SPLN_ELM ) &&
		 ( (int)el.elem.spl.info.spltyp == 3 ) )  {

		/*
		 *  Open output file.
		 */
		ofptr = (FILE *)cfl_wopn ( outfile, &ier );
		if ( ier != 0 )  {
		    printf("Error opening/creating output file %s\n",
		    	    outfile );
	            gendp (&mode, &ier);
		    exit (0);
    		}

	       /*
		* Find FIPS bounded by the closed line
		*/

		npts = el.elem.spl.info.numpts;

		/*  FIND WHAT STATES ARE IN MD AREA */

		clo_binpoly ( "CNTY_BNDS", npts, el.elem.spl.latlon,
                              &(el.elem.spl.latlon[npts]), &ier );
		clo_tgltln ( "CNTY_BNDS", MAXLISTITEMS, &nitems,
			      flat, flon, &ier);

		for ( ii = 0; ii < nitems; ii++ )  {
		  clo_bginfo( "CNTY_BNDS", ii, info, &ier );
		  cst_gtag( "STATE", info, "?", stpo, &ier);
		  
		  if (strstr(cstl_liststate, stpo)==NULL) {
		    strcat(cstl_liststate, stpo);
		    strcat(cstl_liststate, " ");		  
		  }
		}


		/*  FIND WHAT WFOs ARE IN MD AREA */
		clo_binpoly ( "CWA_BNDS", npts, el.elem.spl.latlon,
                              &(el.elem.spl.latlon[el.elem.spl.info.numpts]),
			      &ier );
		clo_tgltln ( "CWA_BNDS", MAXLISTITEMS, &nitems,
			      flat, flon, &ier);

		for ( ii = 0; ii < nitems; ii++ )  {
		  clo_bginfo( "CWA_BNDS", ii, info, &ier );
		  cst_gtag( "WFO", info, "?", stpo, &ier);
		  strcat(cstl_list, stpo);
		  strcat(cstl_list, "...");		  
		}

		/*
		 *  Format lats and lons into buffer.
		 */
		if ( (int)vg_type == LINE_ELM )  {
		    npts = el.elem.lin.info.numpts;
		}
		else if ( (int)vg_type == SPLN_ELM )  {
		    npts = el.elem.spl.info.numpts;
		}
		for ( ii = 0; ii < npts; ii++ )  {
		    if ( (int)vg_type == LINE_ELM )  {
		        x = el.elem.lin.latlon[ii];
		        y = -el.elem.lin.latlon[ii+npts];
		    }
		    else if ( (int)vg_type == SPLN_ELM )  {
		        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.0F)) / 100.0F;
		    y = ((int)(y*100.0F)) / 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 ( buffer, str );
		    if ( ii == 0 ) {
                        ixfirst = ix;
			iyfirst = iy;
                    }
		}
		/*
		 *   Repeat first lat/lon point as last lat/lon point 
		 *   to indicate a closed polygon.
		 */


		sprintf( str, "%04d%04d ", ixfirst, iyfirst);
		strcat ( buffer, str );

		sprintf( str, "\n\n" );
		strcat ( buffer, str );

		/*
		 *  Wrap buffer such that only 6 pairs of lat,lons 
		 *  on one line.
		 *  ilen = 55;
		 *  cst_wrap( buffer, blank, &ilen, "\n", (char *)NULL, buffer, &ier );
		 */
		ilen = 66;
		cst_wrap( buffer, blank, &ilen, "\n", newLineStr, buffer, &ier );

	    }

	}
	ne++;
    }

    /*
     * wrap the ATTN...WFO... line
     */
    strcat ( bufferfinalwfo, "ATTN...WFO..." );
    strcat ( bufferfinalwfo, cstl_list );
    cst_wrap( bufferfinalwfo, "...", &line_len, "\n", (char *)NULL, bufferfinalwfo, &ier );

    /*
     * build the output file string and add the ATTN...WFO... string
     */
    strcat ( bufferfinal,"STATES=" );
    strcat ( bufferfinal, cstl_liststate );
    strcat ( bufferfinal, "\n\n" );
    strcat ( bufferfinal, bufferfinalwfo );
/*
    strcat ( bufferfinal,"ATTN...WFO..." );
    strcat ( bufferfinal, cstl_list );
*/
    strcat ( bufferfinal, "\n\n" );
    strcat ( bufferfinal, buffer );

    /*
     *  Write to output file.
     */
    cfl_writ ( ofptr, (int)strlen(bufferfinal),
    	       (unsigned char *)bufferfinal, &ier );

    /*
     *  close files and exit.
     */
    cfl_clos ( ifptr, &ier );
    cfl_clos ( ofptr, &ier );
    gendp (&mode, &ier);
    return(0);

}