void boundry_segs(long int offset, int npts, char *bndtbl, int col1, int col2,
int ltype, int lwidth)
{
FILE *fp;
int iret;
int nsegs,i,j,k;
float mxlat,mnlat,mxlon,mnlon;
float *X,*Y;
float lt[4],ln[4];
char buf[256];
static char bounddir[]="bounds";
fp = (FILE *)cfl_tbop(bndtbl,bounddir,&iret);
if(iret == 0)
cfl_seek(fp,offset,SEEK_SET,&iret);
else
{
printf("open failed %d\n",iret);
return;
}
if(iret == 0)
{
X = (float *)malloc(npts*sizeof(float));
Y = (float *)malloc(npts*sizeof(float));
cfl_rdln(fp,255,buf,&iret);
/*printf("look cfl_rdln %d %s\n",iret,buf);*/
i = 0;
if(iret == 0)
{
sscanf(buf,"%d %f %f %f %f %f %f",&nsegs,&mxlat,&mnlat,&mxlon,&mnlon,X,Y);
i++;
while((i < nsegs/2)&&(iret == 0))
{
cfl_rdln(fp,255,buf,&iret);
if(iret == 0)
{
j = sscanf(buf,"%f %f %f %f %f %f %f %f",
lt,ln,lt+1,ln+1,lt+2,ln+2,lt+3,ln+3);
for(k=0;k<j;k+=2)
{
X[i] = lt[k/2]; Y[i] = ln[k/2]; i++;
}
}
}
}
bounds_fill(X,Y,nsegs/2,col1);
bounds_line(X, Y, nsegs/2, col2, ltype, lwidth);
free(X); free(Y);
}
cfl_clos(fp,&iret);
}
void gb_ges ( int *iret )
/************************************************************************
* gb_ges *
* *
* This function gets the GRIB information from GB_ENDS and passes *
* that information back to a function as independent variables. *
* *
* gb_ges ( iret ) *
* *
* Output parameters: *
* *iret int Return code *
* -19 = error on message *
** *
* Log: *
* J. Chou/EAI 7/93 *
* S. Jacobs/EAI 1/94 Clean up; Rename variables *
* L. Williams/EAI 7/94 Reformat header *
* L. Sager 8/95 Fix memory allocation error *
* S. Jacobs/NCEP 1/96 Changed DA_READ to CFL_READ *
* D.W.Plummer/NCEP 3/96 Changed cfl_ call sequence *
* M. Linda/GSC 10/97 Corrected the prologue format *
***********************************************************************/
{
int offset, ret, nbytes;
unsigned char *buffer;
/*---------------------------------------------------------------------*/
*iret = 0;
offset = cursor + ISLENGTH + pdslength + gdslength +
bmslength + bdslength;
buffer = (unsigned char *)
malloc ( 4 * sizeof(unsigned char) );
cfl_seek ( gbfile.fptr, offset, SEEK_SET, &ret );
cfl_read ( gbfile.fptr, 4, buffer, &nbytes, &ret );
if ( ret != 0 ) {
*iret = -19;
return;
}
gb_ends ( buffer );
free ( buffer );
}
void cvg_rdele ( VG_DBStruct *el, int el_start, int el_size,
FILE *fp, int *iret )
/************************************************************************
* cvg_rdele *
* *
* This function reads a VG element from an open VG file. *
* *
* Note: It is assumed that the *el contains a loaded header. *
* *
* cvg_rdele ( el, el_start, el_size, fp, iret ) *
* *
* Input parameters: *
* *el VG_DBStruct element structure *
* el_start int File offset to start of element *
* el_size int size of element to read in Bytes*
* *fp FILE Handle to open file *
* *
* Output parameters: *
* *iret int Return code *
* 3 = VG element too large *
* -3 = seek to a bad location *
* -8 = no VG file is open *
* -24 = no VG header loaded *
* *
** *
* Log: *
* E. Wehner/EAi 10/96 Created *
* D. Keiser/GSC 1/97 Clean up and rename *
* D.W.Plummer/NCEP 9/97 Changes for new vgstruct header file *
* C. Lin/EAI 12/97 text element alignment remapping *
* G. Krueger/EAI 1/98 Truncate too long elements. *
* G. Krueger/EAI 4/98 Truncate too long elements to MAXPTS-1. *
* S. Jacobs/NCEP 6/98 Added check for small front pips *
* A. Hardy/GSC 12/98 Added CLASS_CIRCLE *
* E. Safford/GSC 04/99 fix no return value compiler warning *
* D.W.Plummer/NCEP 12/99 add call to cvg_rdwbx *
* M. Li/GSC 12/99 Added cvg_swap and mv_swp4 *
* F. J. Yen/NCEP 08/00 Added call to cvg_rdsig *
* R. Curtis/EAI 10/00 Added CCF check to Sigmet class check *
* J. Wu/GSC 11/00 Removed cvd_rdsym, cvd_rdwnd, cvg_rdcir *
* E. Safford/GSC 12/00 rename params, clean up duplicate reads *
* J. Wu/GSC 02/01 Replaced cvg_rdwbx & cvg_rdsig with new *
* cvg_rdoldele() and added version control*
* J. Wu/GSC 02/01 Modified 'unused2' to 'version' in VG *
* S. Jacobs/NCEP 2/01 Added machine type MTLNUX *
* D.W.Plummer/NCEP 06/03 chgs for ASHCLD_ELM and VOLC_ELM *
* J. Wu/GSC 09/03 add LIST_ELM & JET_ELM *
* T. Lee/SAIC 11/03 used cvgcmn.h *
* J. Wu/GSC 01/04 add cvg_rdgfa for new GFA_ELM *
* B. Yin/SAIC 02/04 added cvg_rdtca for TCA_ELM *
* B. Yin/SAIC 05/04 redefined MAX_TCA_SZ *
* B. Yin/SAIC 08/04 removed MAX_TCA_SZ for water and islands*
* J. Wu/SAIC 10/04 remove MAX_GFA_SZ *
* S. Danz/AWC 03/06 Add check for placement information *
* m.gamazaychikov/SAIC 04/07 add cvg_rdtce, cvg_rdtct and cvg_rdtcb *
* L. Hinson/AWC 01/12 Add SGWX_ELM *
***********************************************************************/
{
int *pnpts, ier, nbin, nbinfo, itrunc, max_version;
int info_pos, lon_pos, ierr;
int one = 1;
int tmp;
int max_sz, info_sz;
unsigned char *pinfo, *el_lon;
/*---------------------------------------------------------------------*/
*iret = 0;
info_pos = el_start + HDR_SZ;
/*
* Determine the latest version # for VG elements.
*/
max_version = 0; /* Latest version # for most VG element types */
if ( el->hdr.vg_class == CLASS_WATCHES ) max_version = CUR_WBX_VER;
if ( ( el->hdr.vg_class == CLASS_SIGMETS ) &&
el->hdr.vg_type != SIGCCF_ELM &&
el->hdr.vg_type != VOLC_ELM &&
el->hdr.vg_type != ASHCLD_ELM ) max_version = CUR_SIG_VER;
/*
* Read old versions VG elements (only WATCHES & SIGMETS have old
* versions currently).
*/
if ( (int)el->hdr.version < max_version ) {
cvg_rdoldele( el, el_start, el->hdr.recsz, fp, iret );
}
else {
/*
* Read current version of VG elements.
*/
pnpts = NULL;
itrunc = G_FALSE;
pinfo = (void *) &(el->elem);
nbinfo = el_size - HDR_SZ;
/*
* Lines and fronts may have more than MAXPTS in their latlon array
* if they were created through the vg driver. If they do, they will
* be truncated to MAXPTS, and an iret of +3 returned.
*
* All other types will be checked against their maximum size, and
* an error reported if they exceed this.
*/
switch ( el->hdr.vg_class ) {
case CLASS_LINES:
if (el->hdr.vg_type == LINE_ELM) {
max_sz = MAX_LINE_SZ;
pnpts = &(el->elem.lin.info.numpts);
info_sz = sizeof(LineInfo);
el_lon = (void *)el->elem.lin.latlon;
}
else {
max_sz = MAX_SPLINE_SZ;
pnpts = &(el->elem.spl.info.numpts);
info_sz = sizeof(SpLineInfo);
el_lon = (void *)el->elem.spl.latlon;
}
if (el_size > max_sz) {
itrunc = G_TRUE;
el_lon += MAX_PTS_SZ;
nbinfo = info_sz + MAX_PTS_SZ;
el->hdr.recsz = max_sz;
}
break;
case CLASS_FRONTS:
if (el_size > MAX_FRONT_SZ) {
itrunc = G_TRUE;
pnpts = &(el->elem.frt.info.numpts);
el_lon = (void *)el->elem.frt.latlon;
el_lon += MAX_PTS_SZ;
nbinfo = MAX_FRONT_SZ - HDR_SZ;
el->hdr.recsz = MAX_FRONT_SZ;
}
pnpts = &(el->elem.frt.info.numpts);
break;
case CLASS_SYMBOLS:
if (el->hdr.recsz > MAX_SYM_SZ) {
*iret = -11;
}
break;
case CLASS_WINDS:
if (el->hdr.recsz > MAX_WIND_SZ) {
*iret = -11;
}
break;
case CLASS_TEXT:
if (el->hdr.recsz > MAX_SPTEXT_SZ) {
*iret = -11;
}
break;
case CLASS_CIRCLE:
if (el->hdr.recsz > MAX_CIRCLE_SZ) {
*iret = -11;
}
break;
case CLASS_SIGMETS:
if ( ( ( el->hdr.vg_type != SIGCCF_ELM &&
el->hdr.vg_type != ASHCLD_ELM &&
el->hdr.vg_type != VOLC_ELM ) &&
el->hdr.recsz > MAX_SIGMET_SZ ) ||
( el->hdr.vg_type == SIGCCF_ELM && el->hdr.recsz > MAX_CCF_SZ ) ||
( el->hdr.vg_type == ASHCLD_ELM && el->hdr.recsz > MAX_ASH_SZ ) ||
( el->hdr.vg_type == VOLC_ELM && el->hdr.recsz > MAX_VOL_SZ ) ) {
*iret = -11;
}
break;
case CLASS_TRACKS:
if (el->hdr.recsz > MAX_TRACK_SZ) {
*iret = -11;
}
break;
case CLASS_WATCHES:
if (el->hdr.recsz > MAX_WATCHBOX_SZ) {
*iret = -11;
}
break;
case CLASS_LIST:
if (el->hdr.recsz > MAX_LIST_SZ) {
*iret = -11;
}
break;
case CLASS_MET:
if (el->hdr.vg_type == JET_ELM &&
el->hdr.recsz > MAX_JET_SZ) {
*iret = -11;
} else if (el->hdr.vg_type == SGWX_ELM &&
el->hdr.recsz > MAX_SGWX_SZ) {
*iret = -11;
}
break;
default:
break;
} /* end of switch */
if ( *iret < 0 ) {
return;
}
/*
* Read the element data. This read will not include the lon
* array if the element has > MAXPTS. The lons will be read using
* the "if ( itrunc )" condition statements below.
*/
if ( el->hdr.vg_type == GFA_ELM ) {
cvg_rdgfa ( fp, (long)info_pos, el, &ier );
}
else if ( el->hdr.vg_type == TCA_ELM ) {
cvg_rdtca ( fp, (long)info_pos, el, &ier );
}
else if ( el->hdr.vg_type == TCERR_ELM ) {
cvg_rdtce ( fp, (long)info_pos, el, &ier );
}
else if ( el->hdr.vg_type == TCTRK_ELM ) {
cvg_rdtct ( fp, (long)info_pos, el, &ier );
}
else if ( el->hdr.vg_type == TCBKL_ELM ) {
cvg_rdtcb ( fp, (long)info_pos, el, &ier );
}
else {
cfl_seek( fp, (long)info_pos, 0, &ier );
cfl_read( fp, nbinfo, (void *)( pinfo ), &nbin, &ier );
}
/*
* Read the lons for truncated elements.
*/
if ( itrunc ) {
/*
* Set element characteristics to reasonable values, considering
* that the line is truncated. Set iret = 3 to signal truncation.
*/
*iret = 3;
*pnpts = MAXPTS;
el->hdr.closed = 0;
el->hdr.filled = 0;
lon_pos = info_pos + info_sz +
( (el_size - HDR_SZ - info_sz) / 2 );
cfl_seek ( fp, (long)lon_pos, 0, &ier );
cfl_read ( fp, MAX_PTS_SZ, (void *)(el_lon), &nbin, &ier);
}
if ( MTMACH == MTULTX ||
MTMACH == MTALPH ||
MTMACH == MTLNUX ) {
if ( itrunc ) {
mv_swp4 (&one, pnpts, &tmp );
*pnpts = tmp;
}
cvg_swap( SWPINF, G_TRUE, *el, el, &ierr );
}
}
/*
* If the object is in the set of placed data, adjust the coordinates
*/
cvg_eladj(el_start, el, &ierr);
}
void na_gtbl ( const char *cpyfil, char *name, char *proj, int *nxgd,
int *nygd, float *garea, float *rnvblk, float *anlblk,
int *iret )
/************************************************************************
* na_gtbl *
* *
* This subroutine finds grid INNAME (a numerical or character *
* identifier prefaced by '#') in a grid navigation table, then makes *
* the navigation and analysis blocks. The grid navigation is set up *
* in GEMPLT in order to check its validity. *
* *
* na_gtbl ( cpyfil, name, proj, nxgd, nygd, garea, rnvblk, anlblk, *
* iret ) *
* *
* Input parameters: *
* *cpyfil const char Input for CPYFIL *
* *
* Output parameters: *
* *name char Name of selected grid *
* *proj char Grid projection *
* *nxgd int Number of points in x dir *
* *nygd int Number of points in y dir *
* *garea float Grid corners *
* *rnvblk float Grid navigation block *
* *anlblk float Grid analysis block *
* *iret int Return code *
* +1 = EXIT entered *
* 0 = normal return *
* -4 = invalid navigation *
* -9 = grid not found in table *
** *
* Log: *
* S. Jacobs/EAI 7/93 Copied from GDCTBL *
* D. Keiser/GSC 12/95 Changed FL_TOPN to FL_TBOP *
* R. Tian/SAIC 7/06 Recoded from Fortran *
* S. Gilbert/NCEP 10/06 Added call to GR_VNAV *
************************************************************************/
{
char gntrec[81], namgd[5], c2name[9], buffer[LLMXLN];
float angl1, angl2, angl3, dbnds[4], deln;
int angflg, found, valid;
int iebnds[4], ingrdn, numgd, extnd, ier, ier1, iernum, navsz, i;
FILE *lungrd;
/*----------------------------------------------------------------------*/
*iret = 0;
name[0] = '\0';
/*
* Get the grid number (INGRDN) out of NAME; a conversion error
* sets IERNUM .ne. 0 and it is assumed that NAME is a type.
*/
cst_lcuc ( (char *)cpyfil, c2name, &ier );
strcpy ( name, &c2name[1] );
cst_numb ( name, &ingrdn, &iernum );
/*
* Open the table of valid grid types.
*/
lungrd = cfl_tbop ( "grdnav.tbl", "grid", &ier );
if ( ier != 0 ) {
er_wmsg ( "CFL", &ier, "grdnav.tbl", &ier1,
strlen("CFL"), strlen("grdnav.tbl") );
*iret = -9;
return;
}
/*
* List the table contents for the user, if requested.
*/
if ( strcmp ( name, "LIST" ) == 0 ) {
while ( ! feof ( lungrd) ) {
cfl_trln ( lungrd, sizeof(gntrec), gntrec, &ier );
if ( ier != 0 ) break;
printf ( "%-79.79s\n", gntrec );
}
/*
* Rewind the table file.
*/
cfl_seek ( lungrd, 0, SEEK_SET, &ier );
/*
* Prompt user for grid choice.
*/
printf ( "Enter grid id or number or type EXIT: " );
scanf ( " %s", name );
if ( name[0] == 'e' || name[0] == 'E' ) {
*iret = +1;
return;
}
cst_lcuc ( name, name, &ier );
cst_numb ( name, &ingrdn, &iernum );
}
/*
* Read through the list of valid grid types/numbers to get
* navigation/analysis information.
*/
found = G_FALSE;
while ( ! feof ( lungrd ) ) {
cfl_trln ( lungrd, sizeof(buffer), buffer, &ier );
if ( ier != 0 ) break;
sscanf ( buffer, "%s %d %s %f %f %f %f %f %f %f %d %d %f %d",
namgd, &numgd, proj, &angl1, &angl2, &angl3,
&garea[0], &garea[1], &garea[2], &garea[3],
nxgd, nygd, &deln, &extnd );
if ( strcmp ( name, namgd ) == 0 || ingrdn == numgd ) {
found = G_TRUE;
break;
}
}
cfl_clos ( lungrd, &ier );
/*
* Bail out if NAME wasn't found in the table.
*/
if ( found == G_FALSE ) {
*iret = -9;
return;
}
/*
* Fill navigation block.
*/
angflg = G_TRUE;
gr_vnav ( proj, nxgd, nygd, &garea[0], &garea[1],
&garea[2], &garea[3], &angl1, &angl2, &angl3,
&angflg, &valid, &ier, strlen(proj) );
if ( ier == 0 )
grc_mnav ( proj, nxgd, nygd, &garea[0], &garea[1],
&garea[2], &garea[3], &angl1, &angl2, &angl3,
&angflg, rnvblk, &ier );
else {
*iret = -2;
return;
}
/*
* Set up navigation in GEMPLT to check validity.
*/
navsz = 13;
grc_snav ( &navsz, rnvblk, &ier );
if ( ier != 0 ) {
*iret = -4;
return;
}
/*
* Make an analysis block.
*/
for ( i = 0; i < 4; i++ ) {
iebnds[i] = extnd;
dbnds [i] = RMISSD;
}
grc_mbn2 ( &deln, iebnds, dbnds, rnvblk, anlblk, &ier );
return;
}
void shp_rdbh ( FILE *fp, dbf_header *dbfhdr, int *iret )
/************************************************************************
* shp_rdbh *
* *
* This function reads information from the database header. *
* *
* shp_rdbh ( fp, dbfhdr, iret ) *
* *
* Input parameters: *
* *fp FILE Database file pointer *
* *
* Output parameters: *
* *dbfhdr dbf_header Database header sturcture *
* *iret int Return code *
* 0 = Normal *
** *
* Log: *
* R. Tian/SAIC 12/03 Initial coding *
* S. Jacobs/NCEP 3/11 Enhance error messages *
* S. Jacobs/NCEP 6/14 Added debug prints and field type char *
***********************************************************************/
{
dbf_hdrmap hdrmap;
dbf_fldmap fldmap;
int numflds, nbin, ier, ifld;
/*---------------------------------------------------------------------*/
*iret = 0;
/*
* Position to the beginning of the database file.
*/
cfl_seek ( fp, 0, SEEK_SET, &ier );
/*
* Map the database header to the header map structure, and extract
* those corresponding fields.
*/
cfl_read ( fp, DBF_HEADER_SIZE, (unsigned char *)&hdrmap,
&nbin, &ier );
if ( debug_flag ) {
printf ( "DBF_HEADER_SIZE = %ld\n", DBF_HEADER_SIZE );
printf ( "DBF Version # = 0x%02x\n", hdrmap.dbf_vers );
printf ( "File Date = %04d %02d %02d\n",
hdrmap.dbf_date[0]+1900, hdrmap.dbf_date[1],
hdrmap.dbf_date[2] );
/* Extra debug for checking the header */
/*
int jj;
for ( jj = 0; jj < (int)sizeof(hdrmap.dbf_stub); jj++ ) {
printf ( "Reserved %02d = 0x%02x\n", jj, hdrmap.dbf_stub[jj]);
}
*/
}
dbfhdr->nrec = (int)( shp_get_llong ( hdrmap.dbf_nrec ) );
dbfhdr->hlen = (int)( shp_get_lshort ( hdrmap.dbf_hlen ) );
dbfhdr->rlen = (int)( shp_get_lshort ( hdrmap.dbf_rlen ) );
numflds = (int)((dbfhdr->hlen - DBF_HEADER_SIZE)/DBF_FIELD_SIZE);
dbfhdr->nfld = numflds;
if ( debug_flag ) {
printf ( "Number of records = %d\n", dbfhdr->nrec );
printf ( "Header length = %d\n", dbfhdr->hlen );
printf ( "Record length = %d\n", dbfhdr->rlen );
printf ( "Number of fields = %d\n", dbfhdr->nfld );
}
if ( numflds > MAXFLD ) {
fprintf ( stderr, "Number of fields (%d) exceeds MAXFLD. "
"Increase MAXFLD in shpprm.h\n", numflds );
exit (-1);
}
if ( dbfhdr->rlen > MAXRECLEN ) {
fprintf ( stderr, "Record length (%d) exceeds MAXRECLEN. "
"Increase MAXRECLEN in shpprm.h\n", dbfhdr->rlen );
exit (-1);
}
/*
* Map each database field to the field map structure, and extract
* those corresponding fields.
*/
for ( ifld = 0; ifld < numflds; ifld++ ) {
cfl_read ( fp, DBF_FIELD_SIZE, (unsigned char *)&fldmap,
&nbin, &ier );
strncpy ( dbfhdr->dbflds[ifld].name, (char *)fldmap.fld_name,
FLD_NAMELEN );
dbfhdr->dbflds[ifld].name[FLD_NAMELEN-1] = CHNULL;
dbfhdr->dbflds[ifld].type = fldmap.fld_type;
dbfhdr->dbflds[ifld].lens = fldmap.fld_lens;
dbfhdr->dbflds[ifld].decs = fldmap.fld_decs;
}
if ( debug_flag ) {
printf ( " Field name type code length decimal_count\n" );
for ( ifld = 0; ifld < numflds; ifld++ ) {
printf ( " %-11.11s %4d %c %6d %6d\n",
dbfhdr->dbflds[ifld].name,
dbfhdr->dbflds[ifld].type,
dbfhdr->dbflds[ifld].type,
dbfhdr->dbflds[ifld].lens,
dbfhdr->dbflds[ifld].decs );
}
}
}
void nexr_list_lev ( char *filnam, int *lenfnam,
char *radparm, int *lenparm, int *ier)
{
int i, nbin, iret;
long flen, lofset = 20;
char cfil[LLPATH], cprm[LLMXLN];
char stid[]="KFTG", callid[5];
Radar *radar=NULL;
FILE *fp;
*ier = 0;
strncpy(cfil, filnam, *lenfnam);
strncpy(cprm, radparm, *lenparm);
cfil[*lenfnam] = '\0';
cprm[*lenparm] = '\0';
/* get actual file name to use in rsl call */
cfl_inqr ( cfil, NULL, &flen, cfil, &iret);
RSL_select_fields(cprm, NULL);
/*
if ( cprm[0] == 'd' )
VINDEX = DZ_INDEX;
else if ( cprm[0] == 's' )
VINDEX = SW_INDEX;
else if ( cprm[0] == 'v' )
VINDEX = VR_INDEX;
*/
/*
* see if we can get the station ID from bytes 21-24, otherwise, just use any ID
*/
fp = cfl_ropn ( cfil, NULL, &iret );
if ( iret != 0 ) {
printf("failed to open %s\n",cfil);
*ier = -1;
return;
}
else {
cfl_seek ( fp, lofset, SEEK_SET, &iret );
if ( iret != 0 ) {
*ier = -1;
cfl_clos ( fp, &iret );
return;
}
}
cfl_read ( fp, 4, (unsigned char *)callid, &nbin, &iret );
cfl_clos ( fp, &iret );
if (( nbin < 4 )||(callid[0] < 'A')||(callid[0] > 'Z')) /* use a safe station ID....we aren't plotting lat/lon anyhow */
strcpy(callid,stid);
else
callid[4] = '\0';
/*RSL_radar_verbose_on();*/
RSL_read_these_sweeps("all", NULL);
radar = RSL_wsr88d_to_radar(cfil, callid);
/*RSL_radar_verbose_off();*/
if ( radar == NULL )
{
printf("failed to open %s\n",cfil);
*ier = -1;
return;
}
for (i=0; i<radar->h.nvolumes; i++) {
if (radar->v[i]) {
printf("Volume %s: Sweeps available %d\n", cprm, radar->v[i]->h.nsweeps);
print_header_for_volume(radar->v[i]);
}
}
RSL_free_radar(radar);
}
void crarea ( char *imgnam, int *iret )
/************************************************************************
* crarea *
* *
* This subroutine reads the image data from a MCIDAS AREA file. *
* The full image is placed in memory pointed to by imgData. *
* *
* crarea ( imgnam, iret ) *
* *
* Input parameters: *
* *imgnam char Name of image file *
* *
* Output parameters: *
* *iret int Return code *
* G_NORMAL = normal return *
* G_NIDSIZ = invalid image depth *
* G_NIMGFL = cannot open/read img *
* G_NMEMRY = memory alloc failure *
** *
* Log: *
* J. Cowie/COMET 3/95 *
* J. Cowie/COMET 5/95 Modified to work with NAWIPS 5.2.1 *
* S. Jacobs/NCEP 1/97 Copied from XRAREA *
* J. Cowie/COMET 1/97 Changed common variable names *
* J. Cowie/COMET 12/97 Added cfl_clos if error on cfl_seek *
* S. Chiswell/Unidata 8/06 Added multibyte image check *
***********************************************************************/
{
FILE *fp;
char defdir[12];
long lofset;
unsigned int iboff;
int lstrt, ii, jj, kk, nbin, ier;
unsigned char *rwdptr, *imdptr, buf[8];
int isPNG = 0;
/*---------------------------------------------------------------------*/
if ( imdpth <= 0 ) {
*iret = G_NIDSIZ;
return;
}
/*
* Open the file and seek to data offset.
*/
defdir[0] = CHNULL;
fp = cfl_ropn ( imgnam, defdir, &ier );
if ( ier != 0 ) {
*iret = G_NIMGFL;
return;
}
else {
lofset = (long) imdoff;
cfl_seek ( fp, lofset, SEEK_SET, &ier );
if ( ier != 0 ) {
cfl_clos ( fp, &ier );
*iret = G_NIMGFL;
return;
}
/* See if this is a png compressed AREA file */
cfl_read ( fp, 8, buf, &nbin, &ier);
if ( ( *iret == 0 ) && ( nbin == 8 ) ) {
/*
** Check PNG magic word (8 first bytes):
** http://www.libpng.org/pub/png/spec/1.2/PNG-Rationale.html
** decimal - 137 80 78 71 13 10 26 10
** hexadecimal - 89 50 4e 47 0d 0a 1a 0a
** ASCII - \211 P N G \r \n \032 \n
*/
if ( buf[0] == (unsigned char)137 && buf[1] == (unsigned char) 80 &&
buf[2] == (unsigned char) 78 && buf[3] == (unsigned char) 71 &&
buf[4] == (unsigned char) 13 && buf[5] == (unsigned char) 10 &&
buf[6] == (unsigned char) 26 && buf[7] == (unsigned char) 10 ) {
isPNG = 1;
}
}
cfl_seek ( fp, lofset, SEEK_SET, &ier );
}
*iret = G_NORMAL;
/*
* If this file contains only one channel (band) and no line
* prefix data, read the raw data directly into imgData and exit.
*/
if ( imprsz == 0 && imnchl == 1 ) {
if ( isPNG )
png_read ( fp, imnpix, imnlin, imgData, &ier );
else
cfl_read ( fp, imldat, imgData, &nbin, &ier );
cfl_clos ( fp, &ier );
crarea_pixel ( imgData );
return;
}
else {
/*
* Allocate space for the raw image data.
*/
if ( ( rawData == (unsigned char *) NULL ) ||
( imldat > (int)last_rawsize) ) {
if ( rawData != (unsigned char *) NULL) {
free(rawData);
}
rawData = (unsigned char *) calloc ( imldat,
sizeof(unsigned char) );
if ( rawData == (unsigned char *) NULL ) {
*iret = G_NMEMRY;
return;
}
last_rawsize = imldat;
}
/*
* Read the raw image data.
*/
if ( isPNG )
png_read ( fp, imnpix, imnlin, imgData, &ier );
else
cfl_read ( fp, imldat, rawData, &nbin, &ier );
cfl_clos ( fp, &ier );
}
/*
* Process the prefix bytes and move data for the
* image channel into the imgData array.
*
* NOTE: This has been tested for images with prefix bytes.
* Have not tested any image files with multiple channels
* in the file.
*/
imdptr = imgData;
for ( ii = 0; ii < imnlin; ii++ ) {
/*
* Calculate the starting byte in rawData for this line.
*/
lstrt = ii * (imnpix * imdpth * imnchl + imprsz);
rwdptr = &rawData[lstrt];
/*
* Process prefix data to each line, if any.
* iboff = band offset in each element.
*/
iboff = 0;
if ( imprsz != 0 ) {
/*
* Skip 4 bytes of validity code.
*/
if ( imvald != 0 ) rwdptr += 4;
/*
* Skip documentation and calibration code.
*/
rwdptr += imdcsz + imclsz;
/*
* Process level map to get the band for each element,
* if necessary.
*/
if ( imnchl > 1) {
/*
* Get the band offset.
*/
for ( kk = 0; kk < imlvsz; kk ++ ) {
if ( *rawData == 8 ) {
iboff = kk;
rwdptr += imlvsz - kk;
break;
}
else {
rwdptr ++;
}
}
}
else {
/*
* Skip the level map.
*/
rwdptr += imlvsz;
}
} /* End of "if ( imprsz != 0 )" */
/*
* Get the image data.
*/
for ( jj = 0; jj < imnpix; jj++ ) {
for ( kk = 0; kk < imdpth; kk++ ) {
*imdptr++ = *(rwdptr + iboff);
rwdptr ++;
}
}
} /* End of loop over imnlin */
crarea_pixel ( imgData );
}
void cvg_writeD ( VG_DBStruct *el, int start, int numbytes,
FILE *fp, int *iret )
/************************************************************************
* cvg_writeD *
* *
* This function writes an element record to an opened VG file. *
* *WITHOUT* consideration of placement. This gives the option of using*
* VG files without needing device transformations (which placement *
* will need to get the meta data populated). *
* NOTE: This is actually the original cvg_write, so the log has been *
* kept from that version. *
* *
* cvg_writeD ( el, start, numbytes, fp, iret ) *
* *
* Input parameters: *
* *el VG_DBStruct Pointer toVG record structure *
* start int Offset to start VG record *
* numbytes int Number of bytes to be written *
* *fp FILE file pointer to VG file *
* *
* Output parameters: *
* *iret int Return code *
* -3 = seek to a bad location *
* -17 = error writing to VG file *
* -30 = invalid color(s) *
* -47 = no proper file specified *
* *
** *
* Log: *
* J. Wu/GSC 02/01 Created based on cvg_writelm() *
* S. Jacobs/NCEP 2/01 Added machine type MTLNUX *
* E. Safford/GSC 07/01 add frees for all error returns *
* J. Wu/SAIC 10/02 use memcpy() to speed up performance *
* T. Piper/SAIC 12/02 Only use tmp_el when necessary *
* T. Piper/SAIC 12/02 Added -2 option for start *
* T. Lee/SAIC 11/03 used cvgcmn.h *
* J. Wu/SAIC 01/04 add cvg_writgfa for GFA_ELM *
* B. Yin/SAIC 02/04 added cvg_writtca for TCA_ELM *
* B. Yin/SAIC 05/04 copy entire el to tmp_el *
* B. Yin/SAIC 07/04 Fixed a bug when grouping TCA *
* E. Safford/SAIC 06/07 pass lower level cvg error code upward *
***********************************************************************/
{
int ier;
VG_DBStruct *tmp_el;
Boolean cflError = False;
/*---------------------------------------------------------------------*/
/*
* Verify the file pointer.
*/
if ( fp == NULL )
{
*iret = -47;
return;
}
/*
* Check the proper color settings.
*/
if ( el->hdr.maj_col < 0 || el->hdr.maj_col > 32 ||
el->hdr.maj_col < 0 || el->hdr.min_col > 32 ) {
*iret = -30;
return;
}
/*
* Seek to the specified location.
*/
if ( start == -2 ) {
ier = 0;
}
else if ( start == -1 ) {
cfl_seek( fp, 0, SEEK_END, &ier );
}
else {
cfl_seek( fp, (long)start, SEEK_SET, &ier );
}
if ( ier != 0 ) {
*iret = -3;
return;
}
*iret = G_NORMAL;
/*
* Swap bit order of VG elements if necessary.
* Use tmp_el to avoid actually changing data in el when swapping.
*/
if ( MTMACH == MTULTX ||
MTMACH == MTALPH ||
MTMACH == MTLNUX ) {
tmp_el = (VG_DBStruct *) malloc ( sizeof(VG_DBStruct) );
memcpy ( tmp_el, el, sizeof(VG_DBStruct) );
if ( numbytes == sizeof( VG_HdrStruct ) ) {
cvg_swap( SWPHDR, G_FALSE, *tmp_el, tmp_el, &ier );
}
else {
cvg_swap( SWPALL, G_FALSE, *tmp_el, tmp_el, &ier );
}
if ( el->hdr.vg_type == GFA_ELM ) {
cvg_writgfa ( fp, tmp_el, &ier );
}
else if ( ( el->hdr.vg_type == TCA_ELM )
&& ( numbytes != sizeof( VG_HdrStruct ) ) ) {
cvg_writtca ( fp, tmp_el, &ier );
}
else if ( ( el->hdr.vg_type == TCERR_ELM )
&& ( numbytes != sizeof( VG_HdrStruct ) ) ) {
cvg_writtce ( fp, tmp_el, &ier );
}
else if ( ( el->hdr.vg_type == TCTRK_ELM )
&& ( numbytes != sizeof( VG_HdrStruct ) ) ) {
cvg_writtct ( fp, tmp_el, &ier );
}
else if ( ( el->hdr.vg_type == TCBKL_ELM )
&& ( numbytes != sizeof( VG_HdrStruct ) ) ) {
cvg_writtcb ( fp, tmp_el, &ier );
}
else {
cfl_writ( fp, numbytes, (unsigned char *)tmp_el, &ier);
if( ier < 0 ) {
cflError = True;
}
}
free(tmp_el);
}
else {
if ( el->hdr.vg_type == GFA_ELM ) {
cvg_writgfa ( fp, el, &ier );
}
else if ( ( el->hdr.vg_type == TCA_ELM )
&& ( numbytes != sizeof( VG_HdrStruct ) ) ) {
cvg_writtca ( fp, el, &ier );
}
else if ( ( el->hdr.vg_type == TCERR_ELM )
&& ( numbytes != sizeof( VG_HdrStruct ) ) ) {
cvg_writtce ( fp, el, &ier );
}
else if ( ( el->hdr.vg_type == TCTRK_ELM )
&& ( numbytes != sizeof( VG_HdrStruct ) ) ) {
cvg_writtct ( fp, el, &ier );
}
else if ( ( el->hdr.vg_type == TCBKL_ELM )
&& ( numbytes != sizeof( VG_HdrStruct ) ) ) {
cvg_writtcb ( fp, el, &ier );
}
else {
cfl_writ( fp, numbytes, (unsigned char *)el, &ier);
if( ier < 0 ) {
cflError = True;
}
}
}
if ( ier < 0 ) {
if( !cflError ) {
*iret = ier;
}
else {
*iret = -17;
}
}
}
