Пример #1
0
void clip_line ( int npoly, float *px, float *py, int npts, float *plat,
                 float *plon, int closed, int maxpts,
                 int *ninout, float *xinout, float *yinout, int *inout,
                 int *iret )
/************************************************************************
 * clip_line								*
 *									*
 * This program clips a single line against a single polygon.		*
 *                                                                      *
 * clip_line( npoly, px, py, npts, plat, plon, closed, maxpts, ninout, 	*
 *				xinout, yinout, inout, iret )		*
 *                                                                      *
 * Input parameters:                                                    *
 *  npoly	int	number of points in clipping polygon		*
 *  *px		float	array of x-coords in clipping polygon		*
 *  *py		float	array of y-coords in clipping polygon		*
 *  npts	int	number of points in line to be clipped		*
 *  *plat	float	array of latitudes in line to be clipped        *
 *  *plon	float	array of longitudes in line to be clipped       *
 *  closed	int	flag indicating if line is closed or not	*
 *  maxpts	int	maximum number of points returned		*
 *                                                                      *
 * Output parameters:                                                   *
 *  *ninout	int	number of returned points			*
 *  *xinout	float	array of x points				*
 *  *yinout	float	array of y points				*
 *  *inout	int	array of indicators as to in or out		*
 *  *iret	int	Return code					*
 *                                                                      *
 **                                                                     *
 * Log:                                                                 *
 * D.W.Plummer/NCEP	 3/02						*
 * X.Guo/CWS		10/10 	Missed calculating some intersection pts*
 *                              between line and polygon                *
 ***********************************************************************/
{
    int	ii, jj, kk, ll, nint, ier;
    int	intrsct, tinout[LLMXPT];
    float	xint, yint, temp;
    float	fxint[LLMXPT], fyint[LLMXPT], dist[LLMXPT];
    float	Nplat[LLMXPT], Nplon[LLMXPT], Npx[LLMXPT], Npy[LLMXPT];
    float   x11[2], y11[2];
    /*---------------------------------------------------------------------*/

    *iret = 0;

    cgr_inpoly ( "M", &npts, plat, plon, "M", &npoly, px, py, tinout, &ier );

    gtrans ( sys_M, sys_N, &npts, plat, plon, Nplat, Nplon, &ier,
             strlen(sys_N), strlen(sys_N) );
    gtrans ( sys_M, sys_N, &npoly, px, px, Npx, Npy, &ier,
             strlen(sys_N), strlen(sys_N) );

    *ninout = 0;
    for ( ii = 0; ii < npts-1; ii++ )  {
        xinout[*ninout] = plat[ii];
        yinout[*ninout] = plon[ii];
        inout[*ninout] = tinout[ii];
        (*ninout)++;
        nint = 0;
        for ( jj = 0; jj < npoly; jj++ )  {
            if ( jj == npoly - 1 ) {
                x11[0] = px[jj];
                x11[1] = px[0];
                y11[0] = py[jj];
                y11[1] = py[0];
            }
            else {
                x11[0] = px[jj];
                x11[1] = px[jj+1];
                y11[0] = py[jj];
                y11[1] = py[jj+1];
            }
            cgr_segint ( sys_M, &(plat[ii%npts]), &(plon[ii%npts]),
                         sys_M, x11, y11,
                         sys_M, &xint, &yint, &intrsct, &ier );
            if ( intrsct == G_TRUE )  {
                fxint[nint] = xint;
                fyint[nint] = yint;
                nint++;
            }
        }
        if ( nint > 0 )  {
            clo_dist ( &(plat[ii]), &(plon[ii]), &nint, fxint, fyint,
                       dist, &ier );
            for ( kk = 0; kk < nint-1; kk++ )  {
                for ( ll = 0; ll < nint-kk-1; ll++ )  {
                    if ( dist[ll] > dist[ll+1] )  {
                        temp = fxint[ll];
                        fxint[ll] = fxint[ll+1];
                        fxint[ll+1] = temp;
                        temp = fyint[ll];
                        fyint[ll] = fyint[ll+1];
                        fyint[ll+1] = temp;
                        temp = dist[ll];
                        dist[ll] = dist[ll+1];
                        dist[ll+1] = temp;
                    }
                }
            }
            for ( kk = 0; kk < nint; kk++ )  {
                xinout[*ninout] = fxint[kk];
                yinout[*ninout] = fyint[kk];
                inout[*ninout] = inout[(*ninout)-1];
                (*ninout)++;
                xinout[*ninout] = fxint[kk];
                yinout[*ninout] = fyint[kk];
                if ( inout[(*ninout)-1] == 0 )  inout[*ninout] = 1;
                if ( inout[(*ninout)-1] == 1 )  inout[*ninout] = 0;
                (*ninout)++;
            }
        }
    }
    xinout[*ninout] = plat[npts-1];
    yinout[*ninout] = plon[npts-1];
    inout[*ninout] = tinout[npts-1];
    (*ninout)++;
}
Пример #2
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);
}
Пример #3
0
void cgr_polylink  ( int *npin0, float *xin0, float *yin0,
	             int *npin1, float *xin1, float *yin1, int *maxnpo,
		     int *npo, float *xo, float *yo, int *iret )

/************************************************************************
 * cgr_polylink								*
 *									*
 * This function 'links' two polygons together.				*
 *									*
 * Cartesian (Device, sys_D) coordinates are assumed with the first and	*
 * last points not being equal.						*
 *									*
 * Both incoming polygon's points are assumed to be ordered counter-	*
 * clockwise 								*
 *									*
 * If the link cannot be found, as in the case of embedded polygons,	*
 * then the encompassing polygon is returned.				*
 *									*
 * cgr_polylink ( npin0, xin0, yin0, npin1, xin1, yin1, maxnpo,		*
 * 		   npo, xo, yo, iret )					*
 *									*
 * Input parameters:							*
 * *npin0    	    int     Number of points in polygon1                *
 * *xin0     	    float   X coordinates of polygon 1                  *
 * *yin0     	    float   Y coordinates of polygon 1                  *
 * *npin1    	    int     Number of points in polygon2                *
 * *xin1     	    float   X coordinates of polygon 2                  *
 * *yin1     	    float   Y coordinates of polygon 2                  *
 * *maxnpo   	    int     Maximum number of output points		*
 *									*
 * Output parameters:							*
 * *npo      	    int     Number of points in output polygon          *
 * *xo       	    float   X coordinates of output polygon             *
 * *yo       	    float   Y coordinates of output polygon             *
 * *iret     	    int     Return code					*
 * 			    = G_NORMAL - normal				*
 * 			    = +1 - embedded polygon, returned outermost	*
 * 			    = -2 - one or both polygons <= 2 points	*
 *									*
 **									*
 * Log:									*
 * D.W.Plummer/NCEP	11/03						*
 ***********************************************************************/
{
int		ii, found, *inout, ier;
POLYGON		poly_0, poly_1, poly_link;
/*---------------------------------------------------------------------*/

    *iret = G_NORMAL;

    if ( *npin0 <= 2 || *npin1 <= 2 )  {
	*iret = -2;
	return;
    }

    /*
     * Create the two POLYGON structures.
     */
    poly_0.first = polyp_create ( npin0, xin0, yin0 );
    poly_1.first = polyp_create ( npin1, xin1, yin1 );

    /*
     * Process them into a 'linked' POLYGON.
     */
    poly_link.first = NULL_POLYPOINT;
    polyp_link ( &poly_0, &poly_1, &poly_link, &ier );

    /*
     * Free the memory from the original POLYGON structures.
     */
    polyp_destroy ( poly_1.first );
    polyp_destroy ( poly_0.first );

    if ( ier == 0 )  {

        /*
	 * Retrieve the points from the 'linked' POLYGON.
         */
	polyp_getpts  ( poly_link.first, npo, xo, yo );

	/*
	 * Free 'linked' POLYGON memory.
	 */
	if ( poly_link.first != NULL_POLYPOINT )  {
	    polyp_destroy ( poly_link.first );
	}

    }
    else  {

        inout = NEW ( int, ((*npin0)*(*npin1)) );

	/*
	 * Test polygon #0 points against polygon #1
	 */
        cgr_inpoly ( sys_D, npin0, xin0, yin0, sys_D, npin1, xin1, yin1,
		     inout, &ier );

        found = G_FALSE;
        ii = 0;
        while ( !found && ii < *npin0 )  {
	    if ( inout[ii] == OUT )  {
	        found = G_TRUE;
	        break;
	    }
	    ii++;
        }

	if ( !found )  {

	    /*
	     * None of polygon #0 points are outside polygon #1;
	     * return polygon #1.
	     */
	    *npo = *npin1;
	    for ( ii = 0; ii < *npin1; ii++ )  {
		xo[ii] = xin1[ii];
		yo[ii] = yin1[ii];
	    }
	}
	else  {

	    /*
	     * Return polygon #0 for all other cases.
	     */
	    *npo = *npin0;
	    for ( ii = 0; ii < *npin0; ii++ )  {
		xo[ii] = xin0[ii];
		yo[ii] = yin0[ii];
	    }

	}

        free ( inout );

	*iret = +1;

    }

    return;

}
Пример #4
0
void cds_ccf ( VG_DBStruct *el, int indx, int *iret )
/************************************************************************
 * cds_ccf								*
 *									*
 * This function displays CCFs to the output device.			*
 *									*
 * cds_ccf (el, indx, iret)						*
 *									*
 * Input parameters:							*
 * 	*el		VG_DBStruct	Pointer to VG record structure	*
 *	indx		int		Index into user attribute table *
 *									*
 * Output parameters:							*
 *	*iret		int		Return code			*
 *									*
 **									*
 * Log:									*
 * D.W.Plummer/NCEP	 7/99	Copied from cds_sig			*
 * S. Law/GSC		02/00	added smoothing				*
 * S. Law/GSC		05/00	added fill, moved color setting to pgen	*
 * A. Hardy/GSC         11/00   renamed output coord. system declaration*
 * J. Wu/GSC            02/01   Modified 'unused1' in VG to 'smooth'	*
 * D.W.Plummer/NCEP	 5/01	Added check for cdsColor		*
 * M. Li/SAIC		01/03	delete vgstruct.h			*
 * H. Zeng/SAIC		02/05	assigned iftyp with a new value		*
 * L. Hinson/AWC        07/09   Add Setting/Uattrib tbl functionality   *
 *                              Add Connector, if needed, from text box *
 *                              to polygon.  Add motion vector/speed    *
 * L. Hinson/AWC        02/10   Fix uninitialized 'ifilled' on Lines    *
 ***********************************************************************/
{
    int		ii, np, ier, istyp, width, lintyp, lthw, lwhw;
    int         iltypx, ilthwx, iwidthx, iwhwx, icolrx, iftypx;
    int		ifilled, iftyp;
    float	szfilx, szfil, lat[MAX_SIGMET], lon[MAX_SIGMET];
    int idx;
    VG_DBStruct el_tmp;
    CCFType	*pccf;
    
    int npts, npls, *inout;
    float *xpt, *ypt, *xpl, *ypl;
    
    float areadir, areaspd, xcent, ycent, minangle, V1x, V1y, V2u, V2v;
    float angle, latmv[2], lonmv[2];
    int i, motionvertexnum, foundmotionvertex;
    char    textLayoutStr[256];
    Boolean textLayoutNIL = False;
    
/*---------------------------------------------------------------------*/

    *iret = 0;

    /*
     *  Save plot attributes.
     */
    gqcolr (&icolrx, &ier);
    gqline (&iltypx, &ilthwx, &iwidthx, &iwhwx, &ier);
    gqfill (&szfilx, &iftypx, &ier);
   
    /*
     * setup basic information
     */
    lintyp = 1;
    lthw  = 0;
    width = 3;
    lwhw  = 0;
    gsline (&lintyp, &lthw, &width, &lwhw, &ier);
    
    pccf  = &(el->elem.ccf);
    np    = pccf->info.npts;
    /*
     * Set the color for the feature.
     */
    if (cdsColor == 0) {
      if ( cdsUattr[indx].maj_col == 0 ) {
        if (pccf->info.prob == (CCFLVL_HIGH + 1)) { /*1 = High, 2= Low */
          gscolr ( &(el->hdr.maj_col), &ier);
	}
	else {
          gscolr ( &(el->hdr.min_col), &ier);
	}
      }
      else {
        /* Use the Uattrib table */
        if (pccf->info.prob == (CCFLVL_HIGH + 1)) {
          gscolr ( &cdsUattr[indx].maj_col, &ier);
          el->hdr.maj_col = cdsUattr[indx].maj_col; /* Colors everything else */
        } else {
          gscolr ( &cdsUattr[indx].min_col, &ier);
          el->hdr.maj_col = cdsUattr[indx].min_col;  /* Colors everything else */
        }
      }
    } else {
      gscolr ( &cdsColor, &ier);
    }

    /*
     *  Set the smoothing level_tmp
     */
    ii = (cdsUattr[indx].smooth == -1) ?
	 (int) el->hdr.smooth : cdsUattr[indx].smooth;
    istyp = (ii == 0) ? 0 : 2;
    gssmth (&istyp, &cdsSmthDens[ii], &ier);

    /*
     * If fill is set, fill the polygon.
     */
    ifilled=0;
    if (cdsUattr[indx].filled == 0) {
      ifilled = (int) el->hdr.filled;
    } else {
      if (pccf->info.subtype == SIGTYP_AREA) {      
        if (pccf->info.cover == CCFLVL_HIGH + 1) {
          ifilled =  cdsUattr[indx].info.ccf->fillhi;
        }
        if (pccf->info.cover == CCFLVL_MEDIUM + 1) {
          ifilled = cdsUattr[indx].info.ccf->fillmed;
        }
        if (pccf->info.cover == CCFLVL_LOW + 1) {
          ifilled = cdsUattr[indx].info.ccf->filllow;
        }
      }
    }
    
    if (ifilled >= 1 && cdsFill == 1) {
	iftyp = ifilled;
	szfil = 1.0F;
	gsfill (&szfil, &iftyp, &ier);

	gfill (sys_M, &np, pccf->latlon, &(pccf->latlon[np]),
	       &ier, strlen (sys_M));

	iftyp = 1;
	gsfill (&szfil, &iftyp, &ier);
    }
    
    if (cdsUattr[indx].info.ccf->linetype == 0) {
      lintyp = el->elem.ccf.info.linetype;
    } else {
      lintyp = cdsUattr[indx].info.ccf->linetype;
    }
        
    switch (pccf->info.subtype)  {

      case	SIGTYP_LINE_HIGH:		/* line		*/
        gsline (&lintyp, &lthw, &width, &lwhw, &ier);
	for (ii = 0; ii < np; ii++)  {
	    lat[ii] = pccf->latlon[ii];
	    lon[ii] = pccf->latlon[ii+np];
	}

	gline (sys_M, &np, lat, lon, &ier, strlen (sys_M));

	break;

      case      SIGTYP_LINE_MED:               /* line         */
        gsline (&lintyp, &lthw, &width, &lwhw, &ier);
        for (ii = 0; ii < np; ii++)  {
	    lat[ii] = pccf->latlon[ii];
	    lon[ii] = pccf->latlon[ii+np];
	}

	gline (sys_M, &np, lat, lon, &ier, strlen (sys_M));

        break;
        
      case	SIGTYP_AREA:		/* area		*/
        gsline (&lintyp, &lthw, &width, &lwhw, &ier);

	for ( ii = 0; ii < np; ii++ )  {
	    lat[ii] = pccf->latlon[ii];
	    lon[ii] = pccf->latlon[ii+np];
	}
	lat[np] = pccf->latlon[0];
	lon[np] = pccf->latlon[np];
	np++;

	gline (sys_M, &np, lat, lon, &ier, strlen (sys_M));

	break;

    }
    
    /* Check to see if textLayoutString for CCF Text contains NIL */
    /* If so, set the variable textLayoutNIL to TRUE. */
    
    if ( cdsUattr[indx].info.ccf->textLayout[0] == '\0' ) {
      strcpy(textLayoutStr, el->elem.ccf.textLayout);
    } else {
      strcpy(textLayoutStr, cdsUattr[indx].info.ccf->textLayout);
    }
    if (strstr(textLayoutStr, "NIL") != NULL) {
      textLayoutNIL = True;
    }

    /*
     * Reset smooth level to 0
     */
    if (istyp > 0) {
	istyp = 0;
	gssmth (&istyp, &cdsSmthDens[0], &ier);
    }
    
    /*
     *  Restore the saved plot attribute values
     */
    gsline ( &iltypx, &ilthwx, &iwidthx, &iwhwx, &ier );
    gscolr ( &icolrx, &ier );
    gsfill (&szfilx, &iftypx, &ier);
        
    if (! (pccf->info.subtype == SIGTYP_LINE_HIGH || pccf->info.subtype == SIGTYP_LINE_MED)) {
      /* Create an arrow if the text box is outside the CCF polygon*/
      cds_getinx( el, &idx, &ier);  /* Get the idx to the arrow size */
      npts = 1;
      G_MALLOC( xpt, float, npts, "cds_ccf: xpt" );
      G_MALLOC( ypt, float, npts, "cds_ccf: ypt" );
      G_MALLOC( inout, int, npts, "cds_ccf: inout" );
      xpt[0] = el->elem.ccf.info.textlat;
      ypt[0] = el->elem.ccf.info.textlon;
      npls = el->elem.ccf.info.npts;
      G_MALLOC( xpl, float, npls, "cds_ccf: xpl" );
      G_MALLOC( ypl, float, npls, "cds_ccf: ypl" );
      for ( ii = 0; ii < npls; ii++ ) {
          xpl[ii] = el->elem.ccf.latlon[ii];
          ypl[ii] = el->elem.ccf.latlon[ii+npls];
      }
      cgr_inpoly ( sys_M, &npts, xpt, ypt, sys_M, &npls, xpl, ypl, inout, &ier );
      /*
       * If the center of the text box is outside of GFA polygon, and TextLayoutNIL
       * not set display an arrowed line.
       */
      if ( inout[0] == 0  && textLayoutNIL == False) {
        el_tmp.hdr.delete   = 0;
        el_tmp.hdr.vg_type  = SPLN_ELM;
        el_tmp.hdr.vg_class = (char)CLASS_LINES;
        el_tmp.hdr.filled   = 0;
        el_tmp.hdr.closed   = 0;
        el_tmp.hdr.smooth   = 0;
        el_tmp.hdr.version  = 0;
        el_tmp.hdr.grptyp   = 0;
        el_tmp.hdr.grpnum   = 0;
        el_tmp.hdr.maj_col  = el->hdr.maj_col;
        el_tmp.hdr.min_col  = el->hdr.min_col;
        el_tmp.hdr.recsz    = 0;
        el_tmp.hdr.range_min_lat = 0;
        el_tmp.hdr.range_min_lon = 0;
        el_tmp.hdr.range_max_lat = 0;
        el_tmp.hdr.range_max_lon = 0;

        el_tmp.elem.spl.info.numpts = 2;
        el_tmp.elem.spl.info.spltyp = 4;
        el_tmp.elem.spl.info.splstr = 0.5;
        el_tmp.elem.spl.info.spldir = 1;
        el_tmp.elem.spl.info.splsiz = 1.0;
        el_tmp.elem.spl.info.splsiz = el->elem.ccf.info.szarrow;
        /* Set the Arrow Size from the settings table... */
        if ( fabs (cdsUattr[idx].info.ccf->szarrow < 0.01) ) {
          el_tmp.elem.spl.info.splsiz = el->elem.ccf.info.szarrow;
        } else {
          el_tmp.elem.spl.info.splsiz = cdsUattr[idx].info.ccf->szarrow;
        }
                        
        el_tmp.elem.spl.latlon[0] = el->elem.ccf.info.textlat;
        el_tmp.elem.spl.latlon[1] = el->elem.ccf.info.arrowlat;
        el_tmp.elem.spl.latlon[2] = el->elem.ccf.info.textlon;
        el_tmp.elem.spl.latlon[3] = el->elem.ccf.info.arrowlon;
        el_tmp.elem.spl.info.splwid = 3;
        el_tmp.hdr.maj_col = el_tmp.hdr.min_col = 31;        
        cds_dspelm(&el_tmp, &ier);
        el_tmp.elem.spl.info.splwid = 1;
        el_tmp.hdr.maj_col = el_tmp.hdr.min_col = 32;
        cds_dspelm(&el_tmp, &ier);

      }
Пример #5
0
void cpcg_srch ( char *tblnam, char *fname, int *nstn, 
			int *istnm, int *iflag, int *iclr, int *iret )
/************************************************************************
 * cpcg_srch                                              		*
 *                                                                      *
 * This function searches which stations are located inside the         *
 * given polygon. If the polygon is open, construct a closed polygon	*
 * using the open polygon and the US bounds.				*  
 *                                                                      *
 * cpcg_srch (tblnam, fname, nstn, istnm, iflag, iclr, iret)		* 
 *                                                                      *
 * Input parameters:                                                    *
 *	*tblnam		char	Station table file name			*
 *	*fname		char	Polygon vg file name			*
 *									*
 * Output parameters:                                                   *
 *	*nstn		int	Number of station in the table		*
 *	*istnm		int	Station number				*
 *	*iflag		int	Array of in or out results		*
 *				1 = station inside polygon		*
 *				0 = station outside polygon		*
 *	*iclr		int	Color of polygon			*
 *      *iret    int    Return code                                     *
 *                                                                      *
 **                                                                     *
 * Log:                                                                 *
 * M. Li/SAIC		08/01   Created                                 *
 ***********************************************************************/
{
int  	ii, jj, kk, nbnd, maxstn, np3, ier;
int     ispri[LLSTFL], npts[MAXPTS], lnpts[MAXPTS];
int     nlin, lcolr[MXBND], close[MXBND], inout[LLSTFL];

float   slat[LLSTFL], slon[LLSTFL], selv[LLSTFL];
float   blat[MXBND][LLMXPT], blon[MXBND][LLMXPT];
float   llat[MXBND][MAXPTS], llon[MXBND][MAXPTS];
float   xp3[MAXPTS], yp3[MAXPTS];

char    stid[LLSTFL][9], stnnam[LLSTFL][33], stat[LLSTFL][3],
        coun[LLSTFL][3], tbchrs[LLSTFL][21];

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

    *iret = 0;

    /*
     *  Read the station table
     */
    maxstn = LLSTFL;
    ctb_astn ( tblnam, STNFILDIR, &maxstn, nstn, stid, stnnam,
                        istnm, stat, coun, slat, slon, selv,
                        ispri, tbchrs, &ier );

    if ( ier != 0 || *nstn <= 0 ) {
        *iret = -3;
        return;
    }

    for (ii = 0; ii < *nstn; ii++) {
	iflag[ii] = 0;
	iclr[ii] = 0;
    }

    /*
     *  Read bounds US bounds
     */
    cpcg_rdbnd(BNDTYP, &nbnd, npts, blat, blon, &ier);
    if ( ier != 0 || nbnd <= 0 ) {
	*iret = -4;
        return;
    }    

    /*
     *  Read vg files
     */
    cpcg_rdln(fname, &nlin, lnpts, lcolr, close, llat, llon, &ier);

    if ( ier != 0 ) {
        *iret = -2;
        return;
    } 

    /*
     * Check if the stations are inside the polygons
     */
    for (ii = 0; ii < nlin; ii++) {
	/*
	 * Close polygon
	 */
  	if ( close[ii] ) {
	    np3 = lnpts[ii];
	    for (kk = 0; kk < np3; kk++) {
		xp3[kk] = llat[ii][kk];
		yp3[kk] = llon[ii][kk];
	    } 
	}

	/*
	 * For open polygon, construct a closed polygon with the US bounds
         */ 
	else {
	   for (jj = 0; jj < nbnd; jj++) {
	       cpcg_newpoly(&lnpts[ii], llat[ii], llon[ii], &npts[jj], blat[jj], blon[jj],
			   &np3, xp3, yp3, &ier); 

	       if (ier == 0) break;
	   }
	}

	cgr_inpoly (sys_M, nstn, slat, slon, sys_M,
                        &np3, xp3, yp3, inout, &ier);

   	for (kk = 0; kk < *nstn; kk++) {
	    if ( iflag[kk] == 0 && inout[kk] == 1 ) {
	        iflag[kk] = 1;
	        iclr[kk] = lcolr[ii];
	    }
	}

    }

}