static char *
has_c_format_att(
int ncid, /* netcdf id */
int varid /* variable id */
)
{
nc_type cfmt_type;
int cfmt_len;
#define C_FMT_NAME "C_format" /* name of C format attribute */
#define MAX_CFMT_LEN 100 /* max length of C format attribute */
static char cfmt[MAX_CFMT_LEN];
/* we expect nc_inq_att to fail if there is no "C_format" attribute */
int old_nc_opts;
int nc_stat;
old_nc_opts = ncopts;
ncopts = 0;
nc_stat = ncattinq(ncid, varid, "C_format", &cfmt_type, &cfmt_len);
ncopts = old_nc_opts;
if (nc_stat == -1) {
return 0;
}
if (cfmt_type == NC_CHAR && cfmt_len != 0 && cfmt_len < MAX_CFMT_LEN) {
nc_stat = ncattget(ncid, varid, "C_format", cfmt);
if(nc_stat != 1)
nc_advise("Getting 'C_format' attribute", nc_stat, "");
return &cfmt[0];
}
return 0;
}
MNCAPI int
MI2attget(int fd, int varid, const char *attnm, void *value)
{
if (MI2_ISH5OBJ(fd)) {
return (hdf_attget(fd, varid, attnm, value));
}
else {
return (ncattget(fd, varid, attnm, value));
}
}
static DOUBLE
Add_Offset (
int cdfid,
int varid
)
{
int status;
nc_type datatype;
int len;
char value[32];
DOUBLE d;
d = 0.0;
if ((status = ncattinq(cdfid, varid, "add_offset", &datatype, &len)) == -1) {
}
else if ((status = ncattget(cdfid, varid, "add_offset", value)) == -1) {
}
else {
switch (RepairBadDataType(datatype)) {
case NC_BYTE:
d = (DOUBLE) *((signed char *) value);
break;
case NC_CHAR:
d = (DOUBLE) *((char *) value);
break;
case NC_SHORT:
d = (DOUBLE) *((short *) value);
break;
case NC_LONG:
d = (DOUBLE) *((nclong *) value);
break;
case NC_FLOAT:
d = (DOUBLE) *((float *) value);
break;
case NC_DOUBLE:
d = (DOUBLE) *((double *) value);
break;
default:
break;
}
}
return (d);
}
/* ----------------------------- MNI Header -----------------------------------
@NAME : UpdateHistory
@INPUT : ChildCDF - the MINC file which will have TimeStamp prepended
to its history attribute
TimeStamp - string to be added to history attribute in ChildCDF
@OUTPUT : (none)
@RETURNS : (void)
@DESCRIPTION: Update the history of a MINC file by appending a string
to it. The history attribute will be created if it does
not exist in the file specified by CDF; otherwise, its
current value will be read in, the string TimeStamp will
be appended to it, and it will be re-written.
@METHOD :
@GLOBALS :
@CALLS : NetCDF, MINC libraries
@CREATED : 93-10-27, Greg Ward (from MW's code formerly in micreate)
@MODIFIED : 93-11-16, Greg Ward: removed references to parent file; the
attribute should now be copied from the parent file before
UpdateHistory is ever called.
---------------------------------------------------------------------------- */
void UpdateHistory (int ChildCDF, char *TimeStamp)
{
nc_type HistType;
int HistLen;
#ifdef DEBUG
printf ("UpdateHistory:\n");
#endif
/* Update the history of the child file */
if (ncattinq (ChildCDF,NC_GLOBAL,MIhistory,&HistType,&HistLen) == MI_ERROR)
{
#ifdef DEBUG
printf (" creating history attribute\n");
#endif
ncattput (ChildCDF, NC_GLOBAL, MIhistory, NC_CHAR,
strlen(TimeStamp), TimeStamp);
}
else
{
char *OldHist;
char *NewHist;
#ifdef DEBUG
printf (" adding to history attribute\n");
#endif
OldHist = (char *) malloc ((size_t) (HistLen*sizeof(char) + 1));
ncattget (ChildCDF, NC_GLOBAL, MIhistory, OldHist);
NewHist = (char *) malloc
((size_t) (HistLen*sizeof(char) + strlen(TimeStamp)*sizeof(char) + 1));
strcpy (NewHist, OldHist);
strcat (NewHist, TimeStamp);
ncattput (ChildCDF, NC_GLOBAL, MIhistory, NC_CHAR,
strlen(NewHist), NewHist);
free (NewHist);
free (OldHist);
}
} /* UpdateHistory () */
int ex_inquire (int exoid,
int req_info,
int *ret_int,
void *ret_float,
char *ret_char)
{
int dimid, varid, i, tmp_num, *ids;
long ldum, num_sets, start[2], count[2];
nclong *stat_vals;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
switch (req_info)
{
case EX_INQ_FILE_TYPE:
/* obsolete call */
/*returns "r" for regular EXODUS II file or "h" for history EXODUS file*/
*ret_char = '\0';
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: file type inquire is obsolete");
ex_err("ex_inquire",errmsg,exerrval);
return (EX_WARN);
case EX_INQ_API_VERS:
/* returns the EXODUS II API version number */
if (ncattget (exoid, NC_GLOBAL, ATT_API_VERSION, ret_float) == -1)
{ /* try old (prior to db version 2.02) attribute name */
if (ncattget (exoid, NC_GLOBAL, ATT_API_VERSION_BLANK,ret_float) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get EXODUS API version for file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
}
break;
case EX_INQ_DB_VERS:
/* returns the EXODUS II database version number */
if (ncattget (exoid, NC_GLOBAL, ATT_VERSION, ret_float) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get EXODUS database version for file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
break;
case EX_INQ_LIB_VERS:
/* returns the EXODUS II Library version number */
flt_cvt((float *)ret_float, EX_API_VERS);
break;
case EX_INQ_TITLE:
/* returns the title of the database */
if (ncattget (exoid, NC_GLOBAL, ATT_TITLE, ret_char) == -1)
{
*ret_char = '\0';
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get database title for file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
break;
case EX_INQ_DIM:
/* returns the dimensionality (2 or 3, for 2-d or 3-d) of the database */
if ((dimid = ncdimid (exoid, DIM_NUM_DIM)) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate database dimensionality in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get database dimensionality for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
*ret_int = ldum;
break;
case EX_INQ_NODES:
/* returns the number of nodes */
if ((dimid = ncdimid (exoid, DIM_NUM_NODES)) == -1)
{
*ret_int = 0;
} else {
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of nodes for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
*ret_int = ldum;
}
break;
case EX_INQ_ELEM:
/* returns the number of elements */
if ((dimid = ncdimid (exoid, DIM_NUM_ELEM)) == -1)
{
*ret_int = 0;
} else {
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of elements for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
*ret_int = ldum;
}
break;
case EX_INQ_ELEM_BLK:
/* returns the number of element blocks */
if ((dimid = ncdimid (exoid, DIM_NUM_EL_BLK)) == -1)
{
*ret_int = 0;
} else {
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of element blocks for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
*ret_int = ldum;
}
break;
case EX_INQ_NODE_SETS:
/* returns the number of node sets */
if ((dimid = ncdimid (exoid, DIM_NUM_NS)) < 0)
*ret_int = 0; /* no node sets defined */
else
{
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of node sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
*ret_int = ldum;
}
break;
case EX_INQ_NS_NODE_LEN:
/* returns the length of the concatenated node sets node list */
*ret_int = 0; /* default value if no node sets are defined */
if ((dimid = ncdimid (exoid, DIM_NUM_NS)) != -1 )
{
if (ncdiminq (exoid, dimid, (char *) 0, &num_sets) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of node sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (!(ids = malloc(num_sets*sizeof(int))))
{
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for node set ids for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (ex_get_node_set_ids (exoid, ids) == EX_FATAL)
{
sprintf(errmsg,
"Error: failed to get node sets in file id %d",
exoid);
/* pass back error code from ex_get_node_set_ids (in exerrval) */
ex_err("ex_inquire",errmsg,exerrval);
free (ids);
return (EX_FATAL);
}
/* allocate space for stat array */
if (!(stat_vals = malloc((int)num_sets*sizeof(nclong))))
{
exerrval = EX_MEMFAIL;
free (ids);
sprintf(errmsg,
"Error: failed to allocate memory for node set status array for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
/* get variable id of status array */
if ((varid = ncvarid (exoid, VAR_NS_STAT)) != -1)
{
/* if status array exists, use it, otherwise assume, object exists
to be backward compatible */
start[0] = 0;
start[1] = 0;
count[0] = num_sets;
count[1] = 0;
if (ncvarget (exoid, varid, start, count, (void *)stat_vals) == -1)
{
exerrval = ncerr;
free (ids);
free(stat_vals);
sprintf(errmsg,
"Error: failed to get node set status array from file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
}
else /* default: status is true */
for(i=0;i<num_sets;i++)
stat_vals[i]=1;
for (i=0; i<num_sets; i++)
{
if (stat_vals[i] == 0) /* is this object null? */
continue;
if ((dimid = ncdimid (exoid, DIM_NUM_NOD_NS(i+1))) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of nodes in node set %d in file id %d",
ids[i],exoid);
ex_err("ex_inquire",errmsg,exerrval);
free (ids);
free (stat_vals);
return (EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of nodes in node set %d in file id %d",
ids[i],exoid);
ex_err("ex_inquire",errmsg,exerrval);
free (stat_vals);
free (ids);
return (EX_FATAL);
}
*ret_int += ldum;
}
free (stat_vals);
free (ids);
}
break;
case EX_INQ_NS_DF_LEN:
/* returns the length of the concatenated node sets dist factor list */
/*
Determine the concatenated node sets distribution factor length:
1. Get the node set ids list.
2. Check see if the dist factor variable for a node set id exists.
3. If it exists, goto step 4, else the length is zero.
4. Get the dimension of the number of nodes in the node set -0
use this value as the length as by definition they are the same.
5. Sum the individual lengths for the total list length.
*/
*ret_int = 0; /* default value if no node sets defined */
if ((dimid = ncdimid (exoid, DIM_NUM_NS)) != -1)
{
if (ncdiminq (exoid, dimid, (char *) 0, &num_sets) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of node sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (!(ids = malloc(num_sets*sizeof(int))))
{
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for node set ids for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (ex_get_node_set_ids (exoid, ids) == EX_FATAL)
{
sprintf(errmsg,
"Error: failed to get node sets in file id %d",
exoid);
/* pass back error code from ex_get_node_set_ids (in exerrval) */
ex_err("ex_inquire",errmsg,exerrval);
free (ids);
return (EX_FATAL);
}
for (i=0; i<num_sets; i++)
{
if (ncvarid (exoid, VAR_FACT_NS(i+1)) == -1)
{
if (ncerr == NC_ENOTVAR)
{
ldum = 0; /* this dist factor doesn't exist */
}
else
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of dist fact for node set %d in file id %d",
ids[i], exoid);
ex_err("ex_inquire",errmsg,exerrval);
free (ids);
return (EX_FATAL);
}
}
else
{
if ((dimid = ncdimid (exoid, DIM_NUM_NOD_NS(i+1))) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of nodes in node set %d in file id %d",
ids[i], exoid);
ex_err("ex_inquire",errmsg,exerrval);
free (ids);
return (EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of nodes in node set %d in file id %d",
ids[i],exoid);
ex_err("ex_inquire",errmsg,exerrval);
free(ids);
return (EX_FATAL);
}
}
*ret_int += ldum;
}
free(ids);
}
break;
case EX_INQ_SIDE_SETS:
/* returns the number of side sets */
*ret_int = 0; /* default return value */
if ((dimid = ncdimid (exoid, DIM_NUM_SS)) != -1)
{
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of side sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
*ret_int = ldum;
}
break;
case EX_INQ_SS_NODE_LEN:
/* returns the length of the concatenated side sets node list */
*ret_int = 0; /* default return value */
if ((dimid = ncdimid (exoid, DIM_NUM_SS)) != -1)
{
if (ncdiminq (exoid, dimid, (char *) 0, &num_sets) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of side sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (!(ids = malloc(num_sets*sizeof(int))))
{
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for side set ids for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (ex_get_side_set_ids (exoid, ids) == EX_FATAL)
{
sprintf(errmsg,
"Error: failed to get side set ids in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
free(ids);
return (EX_FATAL);
}
/* allocate space for stat array */
if (!(stat_vals = malloc((int)num_sets*sizeof(nclong))))
{
exerrval = EX_MEMFAIL;
free (ids);
sprintf(errmsg,
"Error: failed to allocate memory for side set status array for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
/* get variable id of status array */
if ((varid = ncvarid (exoid, VAR_SS_STAT)) != -1)
{
/* if status array exists, use it, otherwise assume, object exists
to be backward compatible */
start[0] = 0;
start[1] = 0;
count[0] = num_sets;
count[1] = 0;
if (ncvarget (exoid, varid, start, count, (void *)stat_vals) == -1)
{
exerrval = ncerr;
free (ids);
free(stat_vals);
sprintf(errmsg,
"Error: failed to get element block status array from file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
}
else /* default: status is true */
for(i=0;i<num_sets;i++)
stat_vals[i]=1;
/* walk id list, get each side set node length and sum for total */
for (i=0; i<num_sets; i++)
{
if (stat_vals[i] == 0) /* is this object null? */
continue;
if (ex_get_side_set_node_list_len(exoid, ids[i], &tmp_num) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to side set %d node length in file id %d",
ids[i],exoid);
ex_err("ex_inquire",errmsg,exerrval);
free(stat_vals);
free(ids);
return (EX_FATAL);
}
*ret_int += tmp_num;
}
free(stat_vals);
free (ids);
}
break;
case EX_INQ_SS_ELEM_LEN:
/* returns the length of the concatenated side sets element list */
EX_GET_CONCAT_SET_LEN(ret_int,"side",EX_SIDE_SET,DIM_NUM_SS,VAR_SS_STAT,DIM_NUM_SIDE_SS,0);
break;
case EX_INQ_SS_DF_LEN:
/* returns the length of the concatenated side sets dist factor list */
/*
Determine the concatenated side sets distribution factor length:
1. Get the side set ids list.
2. Check see if the dist factor dimension for a side set id exists.
3. If it exists, goto step 4, else set the individual length to zero.
4. Sum the dimension value into the running total length.
*/
*ret_int = 0;
/* first check see if any side sets exist */
if ((dimid = ncdimid (exoid, DIM_NUM_SS)) != -1)
{
if (ncdiminq (exoid, dimid, (char *) 0, &num_sets) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of side sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (!(ids = malloc(num_sets*sizeof(int))))
{
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for side set ids for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (ex_get_side_set_ids (exoid, ids) == EX_FATAL)
{
sprintf(errmsg,
"Error: failed to get side sets in file id %d",
exoid);
/* pass back error code from ex_get_side_set_ids (in exerrval) */
ex_err("ex_inquire",errmsg,exerrval);
free (ids);
return (EX_FATAL);
}
for (i=0; i<num_sets; i++)
{
if ((dimid = ncdimid (exoid, DIM_NUM_DF_SS(i+1))) == -1)
{
if (ncerr == NC_EBADDIM)
{
ldum = 0; /* this dist factor doesn't exist */
}
else
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of dist fact for side set %d in file id %d",
ids[i], exoid);
ex_err("ex_inquire",errmsg,exerrval);
free (ids);
return (EX_FATAL);
}
}
else
{
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of dist factors in side set %d in file id %d",
ids[i], exoid);
ex_err("ex_inquire",errmsg,exerrval);
free (ids);
return (EX_FATAL);
}
}
*ret_int += ldum;
}
free (ids);
}
break;
case EX_INQ_QA:
/* returns the number of QA records */
if ((dimid = ncdimid (exoid, DIM_NUM_QA)) < 0)
*ret_int = 0; /* no QA records stored */
else
{
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of QA records in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
*ret_int = ldum;
}
break;
case EX_INQ_INFO:
/* returns the number of information records */
if ((dimid = ncdimid (exoid, DIM_NUM_INFO)) < 0)
*ret_int = 0; /* no information records stored */
else
{
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of info records in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
*ret_int = ldum;
}
break;
case EX_INQ_TIME:
/* returns the number of time steps stored in the database; we find
* this out by inquiring the maximum record number of the "unlimited"
* dimension
*/
if ((dimid = ncdimid (exoid, DIM_TIME)) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate time dimension in file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get time dimension in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
*ret_int = ldum;
break;
case EX_INQ_EB_PROP:
/* returns the number of element block properties */
*ret_int = ex_get_num_props (exoid, EX_ELEM_BLOCK);
break;
case EX_INQ_NS_PROP:
/* returns the number of node set properties */
*ret_int = ex_get_num_props (exoid, EX_NODE_SET);
break;
case EX_INQ_SS_PROP:
/* returns the number of side set properties */
*ret_int = ex_get_num_props (exoid, EX_SIDE_SET);
break;
case EX_INQ_ELEM_MAP:
/* returns the number of element maps */
if ((dimid = ncdimid (exoid, DIM_NUM_EM)) == -1)
{
/* no element maps so return 0 */
*ret_int = 0;
return (EX_NOERR);
}
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of element maps for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
*ret_int = ldum;
break;
case EX_INQ_EM_PROP:
/* returns the number of element map properties */
*ret_int = ex_get_num_props (exoid, EX_ELEM_MAP);
break;
case EX_INQ_NODE_MAP:
/* returns the number of node maps */
if ((dimid = ncdimid (exoid, DIM_NUM_NM)) == -1)
{
/* no node maps so return 0 */
*ret_int = 0;
return (EX_NOERR);
}
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of node maps for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
*ret_int = ldum;
break;
case EX_INQ_NM_PROP:
/* returns the number of element map properties */
*ret_int = ex_get_num_props (exoid, EX_NODE_MAP);
break;
case EX_INQ_EDGE:
/* returns the number of edges (defined across all edge blocks). */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_EDGE, 1);
break;
case EX_INQ_EDGE_BLK:
/* returns the number of edge blocks. */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_ED_BLK, 1);
break;
case EX_INQ_EDGE_SETS:
/* returns the number of edge sets. */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_ES, 1);
break;
case EX_INQ_ES_LEN:
/* returns the length of the concatenated edge set edge list. */
EX_GET_CONCAT_SET_LEN(ret_int,"edge",EX_EDGE_SET,DIM_NUM_ES,VAR_ES_STAT,DIM_NUM_EDGE_ES,0);
break;
case EX_INQ_ES_DF_LEN:
/* returns the length of the concatenated edge set distribution factor list. */
EX_GET_CONCAT_SET_LEN(ret_int,"edge",EX_EDGE_SET,DIM_NUM_ES,VAR_ES_STAT,DIM_NUM_DF_ES,1);
break;
case EX_INQ_EDGE_PROP:
/* returns the number of integer properties stored for each edge block. This includes the "ID" property. */
*ret_int = ex_get_num_props( exoid, EX_EDGE_BLOCK );
break;
case EX_INQ_ES_PROP:
/* returns the number of integer properties stored for each edge set.. This includes the "ID" property */
*ret_int = ex_get_num_props( exoid, EX_EDGE_SET );
break;
case EX_INQ_FACE:
/* returns the number of faces (defined across all face blocks). */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_FACE, 1);
break;
case EX_INQ_FACE_BLK:
/* returns the number of edge blocks. */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_FA_BLK, 1);
break;
case EX_INQ_FACE_SETS:
/* returns the number of edge sets. */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_FS, 1);
break;
case EX_INQ_FS_LEN:
/* returns the length of the concatenated edge set edge list. */
EX_GET_CONCAT_SET_LEN(ret_int,"face",EX_FACE_SET,DIM_NUM_FS,VAR_FS_STAT,DIM_NUM_FACE_FS,0);
break;
case EX_INQ_FS_DF_LEN:
/* returns the length of the concatenated edge set distribution factor list. */
EX_GET_CONCAT_SET_LEN(ret_int,"face",EX_FACE_SET,DIM_NUM_FS,VAR_FS_STAT,DIM_NUM_DF_FS,1);
break;
case EX_INQ_FACE_PROP:
/* returns the number of integer properties stored for each edge block. This includes the "ID" property. */
*ret_int = ex_get_num_props( exoid, EX_FACE_BLOCK );
break;
case EX_INQ_FS_PROP:
/* returns the number of integer properties stored for each edge set.. This includes the "ID" property */
*ret_int = ex_get_num_props( exoid, EX_FACE_SET );
break;
case EX_INQ_ELEM_SETS:
/* returns the number of element sets. */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_ELS, 1);
break;
case EX_INQ_ELS_LEN:
/* returns the length of the concatenated element set element list. */
EX_GET_CONCAT_SET_LEN(ret_int,"element",EX_ELEM_SET,DIM_NUM_ELS,VAR_ELS_STAT,DIM_NUM_ELE_ELS,0);
break;
case EX_INQ_ELS_DF_LEN:
/* returns the length of the concatenated element set distribution factor list. */
EX_GET_CONCAT_SET_LEN(ret_int,"element",EX_ELEM_SET,DIM_NUM_ELS,VAR_ELS_STAT,DIM_NUM_DF_ELS,1);
break;
case EX_INQ_ELS_PROP:
/* returns the number of integer properties stored for each element set. */
*ret_int = ex_get_num_props( exoid, EX_ELEM_SET );
break;
case EX_INQ_EDGE_MAP:
/* returns the number of edge sets. */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_EDM, 1);
break;
case EX_INQ_FACE_MAP:
/* returns the number of edge sets. */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_FAM, 1);
break;
default:
*ret_int = 0;
exerrval = EX_FATAL;
sprintf(errmsg, "Error: invalid inquiry %d", req_info);
ex_err("ex_inquire",errmsg,exerrval);
return(EX_FATAL);
}
return (EX_NOERR);
}
int ex_get_elem_block (int exoid,
int elem_blk_id,
char *elem_type,
int *num_elem_this_blk,
int *num_nodes_per_elem,
int *num_attr)
{
int dimid, connid, len, elem_blk_id_ndx;
long lnum_elem_this_blk, lnum_nodes_per_elem, lnum_attr;
char *ptr;
char errmsg[MAX_ERR_LENGTH];
nc_type dummy;
exerrval = 0;
/* First, locate index of element block id in VAR_ID_EL_BLK array */
elem_blk_id_ndx = ex_id_lkup(exoid,VAR_ID_EL_BLK,elem_blk_id);
if (exerrval != 0)
{
if (exerrval == EX_NULLENTITY) /* NULL element block? */
{
strcpy(elem_type, "NULL"); /* NULL element type name */
*num_elem_this_blk = 0; /* no elements */
*num_nodes_per_elem = 0; /* no nodes */
*num_attr = 0; /* no attributes */
return (EX_NOERR);
}
else
{
sprintf(errmsg,
"Error: failed to locate element block id %d in %s array in file id %d",
elem_blk_id,VAR_ID_EL_BLK,exoid);
ex_err("ex_get_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
}
/* inquire values of some dimensions */
if ((dimid = ncdimid (exoid, DIM_NUM_EL_IN_BLK(elem_blk_id_ndx))) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of elements in block %d in file id %d",
elem_blk_id,exoid);
ex_err("ex_get_elem_block",errmsg, exerrval);
return(EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &lnum_elem_this_blk) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of elements in block %d in file id %d",
elem_blk_id, exoid);
ex_err("ex_get_elem_block",errmsg, exerrval);
return(EX_FATAL);
}
*num_elem_this_blk = lnum_elem_this_blk;
if ((dimid = ncdimid (exoid, DIM_NUM_NOD_PER_EL(elem_blk_id_ndx))) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of nodes/element in block %d in file id %d",
elem_blk_id,exoid);
ex_err("ex_get_elem_block",errmsg, exerrval);
return(EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &lnum_nodes_per_elem) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of nodes/element in block %d in file id %d",
elem_blk_id, exoid);
ex_err("ex_get_elem_block",errmsg, exerrval);
return(EX_FATAL);
}
*num_nodes_per_elem = lnum_nodes_per_elem;
if ((dimid = ncdimid (exoid, DIM_NUM_ATT_IN_BLK(elem_blk_id_ndx))) == -1)
*num_attr = 0; /* dimension is undefined */
else
{
if (ncdiminq (exoid, dimid, (char *) 0, &lnum_attr) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of attributes in block %d in file id %d",
elem_blk_id, exoid);
ex_err("ex_get_elem_block",errmsg, exerrval);
return(EX_FATAL);
}
*num_attr = lnum_attr;
}
/* look up connectivity array for this element block id */
if ((connid = ncvarid (exoid, VAR_CONN(elem_blk_id_ndx))) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate connectivity array for element block %d in file id %d",
elem_blk_id,exoid);
ex_err("ex_get_elem_block",errmsg, exerrval);
return(EX_FATAL);
}
if (ncattinq (exoid, connid, ATT_NAME_ELB, &dummy, &len) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get element block %d type in file id %d",
elem_blk_id,exoid);
ex_err("ex_get_elem_block",errmsg, exerrval);
return(EX_FATAL);
}
if (len > (MAX_STR_LENGTH+1))
{
len = MAX_STR_LENGTH;
sprintf (errmsg,
"Warning: element block %d type will be truncated to %d chars",
elem_blk_id,len);
ex_err("ex_get_elem_block",errmsg,EX_MSG);
}
/* get the element type name */
if (ncattget (exoid, connid, ATT_NAME_ELB, elem_type) == -1)
{
exerrval = ncerr;
sprintf(errmsg,"Error: failed to get element block %d type in file id %d",
elem_blk_id, exoid);
ex_err("ex_get_elem_block",errmsg, exerrval);
return(EX_FATAL);
}
/* get rid of trailing blanks */
ptr = elem_type;
/* fprintf(stderr,"[exgelb] %s, len: %d\n",ptr,len); */
while (ptr < elem_type + len && *ptr != ' ')
{
ptr++;
}
*(ptr) = '\0';
return (EX_NOERR);
}
int
main(int argc, char **argv)
{
/* NIFTI stuff */
nifti_image *nii_ptr;
nifti_image nii_rec;
int nii_dimids[MAX_NII_DIMS];
int nii_dir[MAX_NII_DIMS];
int nii_map[MAX_NII_DIMS];
unsigned long nii_lens[MAX_NII_DIMS];
int nii_ndims;
static int nifti_filetype;
static int nifti_datatype;
static int nifti_signed = 1;
/* MINC stuff */
int mnc_fd; /* MINC file descriptor */
nc_type mnc_type; /* MINC data type as read */
int mnc_ndims; /* MINC image dimension count */
int mnc_dimids[MAX_VAR_DIMS]; /* MINC image dimension identifiers */
long mnc_dlen; /* MINC dimension length value */
double mnc_dstep; /* MINC dimension step value */
int mnc_icv; /* MINC image conversion variable */
int mnc_vid; /* MINC Image variable ID */
long mnc_start[MAX_VAR_DIMS]; /* MINC data starts */
long mnc_count[MAX_VAR_DIMS]; /* MINC data counts */
int mnc_signed; /* MINC if output voxels are signed */
double real_range[2]; /* MINC real range (min, max) */
double input_valid_range[2]; /* MINC valid range (min, max) */
double output_valid_range[2]; /* Valid range of output data. */
double nifti_slope; /* Slope to be applied to output voxels. */
double nifti_inter; /* Intercept to be applied to output voxels. */
double total_valid_range; /* Overall valid range (max - min). */
double total_real_range; /* Overall real range (max - min). */
/* Other stuff */
char out_str[1024]; /* Big string for filename */
char att_str[1024]; /* Big string for attribute values */
int i; /* Generic loop counter the first */
int j; /* Generic loop counter the second */
char *str_ptr; /* Generic ASCIZ string pointer */
int r; /* Result code. */
static int vflag = 0; /* Verbose flag (default is quiet) */
static ArgvInfo argTable[] = {
{NULL, ARGV_HELP, NULL, NULL,
"Output voxel data type specification"},
{"-byte", ARGV_CONSTANT, (char *)DT_INT8, (char *)&nifti_datatype,
"Write voxel data in 8-bit signed integer format."},
{"-short", ARGV_CONSTANT, (char *)DT_INT16, (char *)&nifti_datatype,
"Write voxel data in 16-bit signed integer format."},
{"-int", ARGV_CONSTANT, (char *)DT_INT32, (char *)&nifti_datatype,
"Write voxel data in 32-bit signed integer format."},
{"-float", ARGV_CONSTANT, (char *)DT_FLOAT32, (char *)&nifti_datatype,
"Write voxel data in 32-bit floating point format."},
{"-double", ARGV_CONSTANT, (char *)DT_FLOAT64, (char *)&nifti_datatype,
"Write voxel data in 64-bit floating point format."},
{"-signed", ARGV_CONSTANT, (char *)1, (char *)&nifti_signed,
"Write integer voxel data in signed format."},
{"-unsigned", ARGV_CONSTANT, (char *)0, (char *)&nifti_signed,
"Write integer voxel data in unsigned format."},
{NULL, ARGV_HELP, NULL, NULL,
"Output file format specification"},
{"-dual", ARGV_CONSTANT, (char *)FT_NIFTI_DUAL,
(char *)&nifti_filetype,
"Write NIfTI-1 two-file format (.img and .hdr)"},
{"-ASCII", ARGV_CONSTANT, (char *)FT_NIFTI_ASCII,
(char *)&nifti_filetype,
"Write NIfTI-1 ASCII header format (.nia)"},
{"-nii", ARGV_CONSTANT, (char *)FT_NIFTI_SINGLE,
(char *)&nifti_filetype,
"Write NIfTI-1 one-file format (.nii)"},
{"-analyze", ARGV_CONSTANT, (char *)FT_ANALYZE,
(char *)&nifti_filetype,
"Write an Analyze two-file format file (.img and .hdr)"},
{NULL, ARGV_HELP, NULL, NULL,
"Other options"},
{"-quiet", ARGV_CONSTANT, (char *)0,
(char *)&vflag,
"Quiet operation"},
{"-verbose", ARGV_CONSTANT, (char *)1,
(char *)&vflag,
"Quiet operation"},
{NULL, ARGV_END, NULL, NULL, NULL}
};
ncopts = 0; /* Clear global netCDF error reporting flag */
/* Default NIfTI file type is "NII", single binary file
*/
nifti_filetype = FT_UNSPECIFIED;
nifti_datatype = DT_UNKNOWN;
if (ParseArgv(&argc, argv, argTable, 0) || (argc < 2)) {
fprintf(stderr, "Too few arguments\n");
return usage();
}
if (!nifti_signed) {
switch (nifti_datatype) {
case DT_INT8:
nifti_datatype = DT_UINT8;
break;
case DT_INT16:
nifti_datatype = DT_UINT16;
break;
case DT_INT32:
nifti_datatype = DT_UINT32;
break;
}
}
switch (nifti_datatype){
case DT_INT8:
case DT_UINT8:
mnc_type = NC_BYTE;
break;
case DT_INT16:
case DT_UINT16:
mnc_type = NC_SHORT;
break;
case DT_INT32:
case DT_UINT32:
mnc_type = NC_INT;
break;
case DT_FLOAT32:
mnc_type = NC_FLOAT;
break;
case DT_FLOAT64:
mnc_type = NC_DOUBLE;
break;
}
if (argc == 2) {
strcpy(out_str, argv[1]);
str_ptr = strrchr(out_str, '.');
if (str_ptr != NULL && !strcmp(str_ptr, ".mnc")) {
*str_ptr = '\0';
}
}
else if (argc == 3) {
strcpy(out_str, argv[2]);
str_ptr = strrchr(out_str, '.');
if (str_ptr != NULL) {
/* See if a recognized file extension was specified. If so,
* we trim it off and set the output file type if none was
* specified. If the extension is not recognized, assume
* that we will form the filename by just adding the right
* extension for the selected output format.
*/
if (!strcmp(str_ptr, ".nii")) {
if (nifti_filetype == FT_UNSPECIFIED) {
nifti_filetype = FT_NIFTI_SINGLE;
}
*str_ptr = '\0';
}
else if (!strcmp(str_ptr, ".img") ||
!strcmp(str_ptr, ".hdr")) {
if (nifti_filetype == FT_UNSPECIFIED) {
nifti_filetype = FT_NIFTI_DUAL;
}
*str_ptr = '\0';
}
else if (!strcmp(str_ptr, ".nia")) {
if (nifti_filetype == FT_UNSPECIFIED) {
nifti_filetype = FT_NIFTI_ASCII;
}
*str_ptr = '\0';
}
}
}
else {
fprintf(stderr, "Filename argument required\n");
return usage();
}
/* Open the MINC file. It needs to exist.
*/
mnc_fd = miopen(argv[1], NC_NOWRITE);
if (mnc_fd < 0) {
fprintf(stderr, "Can't find input file '%s'\n", argv[1]);
return (-1);
}
/* Find the MINC image variable. If we can't find it, there is no
* further processing possible...
*/
mnc_vid = ncvarid(mnc_fd, MIimage);
if (mnc_vid < 0) {
fprintf(stderr, "Can't locate the image variable (mnc_vid=%d)\n", mnc_vid);
return (-1);
}
/* Find out about the MINC image variable - specifically, how many
* dimensions, and which dimensions.
*/
r = ncvarinq(mnc_fd, mnc_vid, NULL, NULL, &mnc_ndims, mnc_dimids, NULL);
if (r < 0) {
fprintf(stderr, "Can't read information from image variable\n");
return (-1);
}
if (mnc_ndims > MAX_NII_DIMS) {
fprintf(stderr, "NIfTI-1 files may contain at most %d dimensions\n",
MAX_NII_DIMS);
return (-1);
}
/* Initialize the NIfTI structure
*/
nii_ptr = &nii_rec;
init_nifti_header(nii_ptr);
/* For now we just use the mnc2nii command line as the description
* field. Probably we should use something better, perhaps a
* combination of some other standard MINC fields that might
* provide more information.
*/
str_ptr = nii_ptr->descrip;
for (i = 0; i < argc; i++) {
char *arg_ptr = argv[i];
if ((str_ptr - nii_ptr->descrip) >= MAX_NII_DESCRIP) {
break;
}
if (i != 0) {
*str_ptr++ = ' ';
}
while (*arg_ptr != '\0' &&
(str_ptr - nii_ptr->descrip) < MAX_NII_DESCRIP) {
*str_ptr++ = *arg_ptr++;
}
*str_ptr = '\0';
}
nii_ptr->fname = malloc(strlen(out_str) + 4 + 1);
nii_ptr->iname = malloc(strlen(out_str) + 4 + 1);
strcpy(nii_ptr->fname, out_str);
strcpy(nii_ptr->iname, out_str);
switch (nifti_filetype) {
case FT_ANALYZE:
strcat(nii_ptr->fname, ".hdr");
strcat(nii_ptr->iname, ".img");
break;
case FT_NIFTI_SINGLE:
strcat(nii_ptr->fname, ".nii");
strcat(nii_ptr->iname, ".nii");
break;
case FT_NIFTI_DUAL:
strcat(nii_ptr->fname, ".hdr");
strcat(nii_ptr->iname, ".img");
break;
case FT_NIFTI_ASCII:
strcat(nii_ptr->fname, ".nia");
strcat(nii_ptr->iname, ".nia");
break;
default:
fprintf(stderr, "Unknown output file type %d\n", nifti_filetype);
return (-1);
}
/* Get real voxel range for the input file.
*/
miget_image_range(mnc_fd, real_range);
/* Get the actual valid voxel value range.
*/
miget_valid_range(mnc_fd, mnc_vid, input_valid_range);
/* Find the default range for the output type. Our output file
* will use the full legal range of the output type if it is
* an integer.
*/
if (nifti_datatype == DT_UNKNOWN) {
nii_ptr->datatype = DT_FLOAT32; /* Default */
mnc_type = NC_FLOAT;
mnc_signed = 1;
}
else {
nii_ptr->datatype = nifti_datatype;
mnc_signed = nifti_signed;
}
if (vflag) {
fprintf(stderr, "MINC type %d signed %d\n", mnc_type, mnc_signed);
}
miget_default_range(mnc_type, mnc_signed, output_valid_range);
total_valid_range = input_valid_range[1] - input_valid_range[0];
total_real_range = real_range[1] - real_range[0];
if ((output_valid_range[1] - output_valid_range[0]) > total_valid_range) {
/* Empirically, forcing the valid range to be the nearest power
* of two greater than the existing valid range seems to improve
* the behavior of the conversion. This is at least in part because
* of the limited precision of the NIfTI-1 voxel scaling fields.
*/
double new_range = nearest_power_of_two(total_valid_range);
if (new_range - 1.0 >= total_valid_range) {
new_range -= 1.0;
}
if (output_valid_range[1] > total_valid_range) {
output_valid_range[0] = 0;
output_valid_range[1] = new_range;
}
else {
output_valid_range[1] = output_valid_range[0] + new_range;
}
}
else {
/* The new range can't fully represent the input range. Use the
* full available range, and warn the user that they may have a
* problem.
*/
printf("WARNING: Range of input exceeds range of output format.\n");
}
if (vflag) {
printf("Real range: %f %f Input valid range: %f %f Output valid range: %f %f\n",
real_range[0], real_range[1],
input_valid_range[0], input_valid_range[1],
output_valid_range[0], output_valid_range[1]);
}
/* If the output type is not floating point, we may need to scale the
* voxel values.
*/
if (mnc_type != NC_FLOAT && mnc_type != NC_DOUBLE) {
/* Figure out how to map pixel values into the range of the
* output datatype.
*/
nifti_slope = ((real_range[1] - real_range[0]) /
(output_valid_range[1] - output_valid_range[0]));
if (nifti_slope == 0.0) {
nifti_slope = 1.0;
}
nifti_inter = real_range[0] - (output_valid_range[0] * nifti_slope);
/* One problem with NIfTI-1 is the limited precision of the
* scl_slope and scl_inter fields (they are just 32-bits). So
* we look for possible issues and warn about that here.
*/
if (nifti_inter != (float) nifti_inter ||
nifti_slope != (float) nifti_slope) {
double epsilon_i = nifti_inter - (float) nifti_inter;
double epsilon_s = nifti_slope - (float) nifti_slope;
/* If the loss in precision is more than one part per thousand
* of the real range, flag this as a problem!
*/
if ((epsilon_i > total_real_range / 1.0e3) ||
(epsilon_s > total_real_range / 1.0e3)) {
fprintf(stderr, "ERROR: Slope and intercept cannot be represented in the NIfTI-1 header.\n");
fprintf(stderr, " slope %f (%f), intercept %f (%f)\n",
nifti_slope, (float) nifti_slope,
nifti_inter, (float) nifti_inter);
return (-1);
}
}
}
else {
nifti_slope = 0.0;
}
nii_ptr->scl_slope = nifti_slope;
nii_ptr->scl_inter = nifti_inter;
nii_ptr->nvox = 1; /* Initial value for voxel count */
/* Find all of the dimensions of the MINC file, in the order they
* will be listed in the NIfTI-1/Analyze file. We use this to build
* a map for restructuring the data according to the normal rules
* of NIfTI-1.
*/
nii_ndims = 0;
for (i = 0; i < MAX_NII_DIMS; i++) {
if (dimnames[i] == NULL) {
nii_dimids[nii_ndims] = -1;
continue;
}
nii_dimids[nii_ndims] = ncdimid(mnc_fd, dimnames[i]);
if (nii_dimids[nii_ndims] == -1) {
continue;
}
/* Make sure the dimension is actually used to define the image.
*/
for (j = 0; j < mnc_ndims; j++) {
if (nii_dimids[nii_ndims] == mnc_dimids[j]) {
nii_map[nii_ndims] = j;
break;
}
}
if (j < mnc_ndims) {
mnc_dlen = 1;
mnc_dstep = 0;
ncdiminq(mnc_fd, nii_dimids[nii_ndims], NULL, &mnc_dlen);
ncattget(mnc_fd, ncvarid(mnc_fd, dimnames[i]), MIstep, &mnc_dstep);
if (mnc_dstep < 0) {
nii_dir[nii_ndims] = -1;
mnc_dstep = -mnc_dstep;
}
else {
nii_dir[nii_ndims] = 1;
}
nii_lens[nii_ndims] = mnc_dlen;
nii_ndims++;
}
nii_ptr->dim[dimmap[i]] = (int) mnc_dlen;
nii_ptr->nvox *= mnc_dlen;
nii_ptr->pixdim[dimmap[i]] = (float) mnc_dstep;
}
/* Here we do some "post-processing" of the results. Make certain that
* the nt value is never zero, and make certain that ndim is set to
* 4 if there is a time dimension and 5 if there is a vector dimension
*/
if (nii_ptr->dim[3] > 1 && nii_ndims < 4) {
nii_ndims = 4;
}
if (nii_ptr->dim[4] > 1) {
nii_ptr->intent_code = NIFTI_INTENT_VECTOR;
nii_ndims = 5;
}
nii_ptr->ndim = nii_ndims; /* Total number of dimensions in file */
nii_ptr->nx = nii_ptr->dim[0];
nii_ptr->ny = nii_ptr->dim[1];
nii_ptr->nz = nii_ptr->dim[2];
nii_ptr->nt = nii_ptr->dim[3];
nii_ptr->nu = nii_ptr->dim[4];
nii_ptr->dx = nii_ptr->pixdim[0];
nii_ptr->dy = nii_ptr->pixdim[1];
nii_ptr->dz = nii_ptr->pixdim[2];
nii_ptr->dt = nii_ptr->pixdim[3];
nii_ptr->du = 1; /* MINC files don't define a sample size for a vector_dimension */
nii_ptr->nifti_type = nifti_filetype;
/* Load the direction_cosines and start values into the NIfTI-1
* sform structure.
*
*/
for (i = 0; i < MAX_SPACE_DIMS; i++) {
int id = ncvarid(mnc_fd, mnc_spatial_names[i]);
double start;
double step;
double dircos[MAX_SPACE_DIMS];
int tmp;
if (id < 0) {
continue;
}
/* Set default values */
start = 0.0;
step = 1.0;
dircos[DIM_X] = dircos[DIM_Y] = dircos[DIM_Z] = 0.0;
dircos[i] = 1.0;
miattget(mnc_fd, id, MIstart, NC_DOUBLE, 1, &start, &tmp);
miattget(mnc_fd, id, MIstep, NC_DOUBLE, 1, &step, &tmp);
miattget(mnc_fd, id, MIdirection_cosines, NC_DOUBLE, MAX_SPACE_DIMS,
dircos, &tmp);
ncdiminq(mnc_fd, ncdimid(mnc_fd, mnc_spatial_names[i]), NULL,
&mnc_dlen);
if (step < 0) {
step = -step;
start = start - step * (mnc_dlen - 1);
}
nii_ptr->sto_xyz.m[0][i] = step * dircos[0];
nii_ptr->sto_xyz.m[1][i] = step * dircos[1];
nii_ptr->sto_xyz.m[2][i] = step * dircos[2];
nii_ptr->sto_xyz.m[0][3] += start * dircos[0];
nii_ptr->sto_xyz.m[1][3] += start * dircos[1];
nii_ptr->sto_xyz.m[2][3] += start * dircos[2];
miattgetstr(mnc_fd, id, MIspacetype, sizeof(att_str), att_str);
/* Try to set the S-transform code correctly.
*/
if (!strcmp(att_str, MI_TALAIRACH)) {
nii_ptr->sform_code = NIFTI_XFORM_TALAIRACH;
}
else if (!strcmp(att_str, MI_CALLOSAL)) {
/* TODO: Not clear what do do here... */
nii_ptr->sform_code = NIFTI_XFORM_SCANNER_ANAT;
}
else { /* MI_NATIVE or unknown */
nii_ptr->sform_code = NIFTI_XFORM_SCANNER_ANAT;
}
}
/* So the last row is right... */
nii_ptr->sto_xyz.m[3][0] = 0.0;
nii_ptr->sto_xyz.m[3][1] = 0.0;
nii_ptr->sto_xyz.m[3][2] = 0.0;
nii_ptr->sto_xyz.m[3][3] = 1.0;
nii_ptr->sto_ijk = nifti_mat44_inverse(nii_ptr->sto_xyz);
nifti_datatype_sizes(nii_ptr->datatype,
&nii_ptr->nbyper, &nii_ptr->swapsize);
if (vflag) {
nifti_image_infodump(nii_ptr);
}
/* Now load the actual MINC data. */
nii_ptr->data = malloc(nii_ptr->nbyper * nii_ptr->nvox);
if (nii_ptr->data == NULL) {
fprintf(stderr, "Out of memory.\n");
return (-1);
}
mnc_icv = miicv_create();
miicv_setint(mnc_icv, MI_ICV_TYPE, mnc_type);
miicv_setstr(mnc_icv, MI_ICV_SIGN, (mnc_signed) ? MI_SIGNED : MI_UNSIGNED);
miicv_setdbl(mnc_icv, MI_ICV_VALID_MAX, output_valid_range[1]);
miicv_setdbl(mnc_icv, MI_ICV_VALID_MIN, output_valid_range[0]);
miicv_setdbl(mnc_icv, MI_ICV_IMAGE_MAX, real_range[1]);
miicv_setdbl(mnc_icv, MI_ICV_IMAGE_MIN, real_range[0]);
miicv_setdbl(mnc_icv, MI_ICV_DO_NORM, TRUE);
miicv_setdbl(mnc_icv, MI_ICV_USER_NORM, TRUE);
miicv_attach(mnc_icv, mnc_fd, mnc_vid);
/* Read in the entire hyperslab from the file.
*/
for (i = 0; i < mnc_ndims; i++) {
ncdiminq(mnc_fd, mnc_dimids[i], NULL, &mnc_count[i]);
mnc_start[i] = 0;
}
r = miicv_get(mnc_icv, mnc_start, mnc_count, nii_ptr->data);
if (r < 0) {
fprintf(stderr, "Read error\n");
return (-1);
}
/* Shut down the MINC stuff now that it has done its work.
*/
miicv_detach(mnc_icv);
miicv_free(mnc_icv);
miclose(mnc_fd);
if (vflag) {
/* Debugging stuff - just to check the contents of these arrays.
*/
for (i = 0; i < nii_ndims; i++) {
printf("%d: %ld %d %d\n",
i, nii_lens[i], nii_map[i], nii_dir[i]);
}
printf("bytes per voxel %d\n", nii_ptr->nbyper);
printf("# of voxels %ld\n", nii_ptr->nvox);
}
/* Rearrange the data to correspond to the NIfTI dimension ordering.
*/
restructure_array(nii_ndims,
nii_ptr->data,
nii_lens,
nii_ptr->nbyper,
nii_map,
nii_dir);
if (vflag) {
/* More debugging stuff - check coordinate transform.
*/
test_xform(nii_ptr->sto_xyz, 0, 0, 0);
test_xform(nii_ptr->sto_xyz, 10, 0, 0);
test_xform(nii_ptr->sto_xyz, 0, 10, 0);
test_xform(nii_ptr->sto_xyz, 0, 0, 10);
test_xform(nii_ptr->sto_xyz, 10, 10, 10);
}
if (vflag) {
fprintf(stdout, "Writing NIfTI-1 file...");
}
nifti_image_write(nii_ptr);
if (vflag) {
fprintf(stdout, "done.\n");
}
return (0);
}
int ex_get_prop_array (int exoid,
int obj_type,
const char *prop_name,
int *values)
{
int num_props, i, propid, dimid, iresult;
int found = FALSE;
long start[1], count[1], num_obj;
nclong *longs;
char name[MAX_VAR_NAME_LENGTH+1];
char tmpstr[MAX_VAR_NAME_LENGTH+1];
char obj_stype[MAX_VAR_NAME_LENGTH+1];
char dim_name[MAX_VAR_NAME_LENGTH+1];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* open appropriate variable, depending on obj_type and prop_name */
num_props = ex_get_num_props(exoid, obj_type);
switch (obj_type)
{
case EX_ELEM_BLOCK:
strcpy (obj_stype, VAR_ID_EL_BLK);
strcpy (dim_name, DIM_NUM_EL_BLK);
break;
case EX_NODE_SET:
strcpy (obj_stype, VAR_NS_IDS);
strcpy (dim_name, DIM_NUM_NS);
break;
case EX_SIDE_SET:
strcpy (obj_stype, VAR_SS_IDS);
strcpy (dim_name, DIM_NUM_SS);
break;
case EX_ELEM_MAP:
strcpy (obj_stype, VAR_EM_PROP(1));
strcpy (dim_name, DIM_NUM_EM);
break;
case EX_NODE_MAP:
strcpy (obj_stype, VAR_NM_PROP(1));
strcpy (dim_name, DIM_NUM_NM);
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_get_prop_array",errmsg,exerrval);
return (EX_FATAL);
}
for (i=1; i<=num_props; i++)
{
switch (obj_type){
case EX_ELEM_BLOCK:
strcpy (name, VAR_EB_PROP(i));
break;
case EX_NODE_SET:
strcpy (name, VAR_NS_PROP(i));
break;
case EX_SIDE_SET:
strcpy (name, VAR_SS_PROP(i));
break;
case EX_ELEM_MAP:
strcpy (name, VAR_EM_PROP(i));
break;
case EX_NODE_MAP:
strcpy (name, VAR_NM_PROP(i));
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_get_prop_array",errmsg,exerrval);
return(EX_FATAL);
}
if ((propid = ncvarid (exoid, name)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate property array %s in file id %d",
name, exoid);
ex_err("ex_get_prop_array",errmsg,exerrval);
return (EX_FATAL);
}
/* compare stored attribute name with passed property name */
memset(tmpstr, 0, MAX_VAR_NAME_LENGTH+1);
if ((ncattget (exoid, propid, ATT_PROP_NAME, tmpstr)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get property name in file id %d", exoid);
ex_err("ex_get_prop_array",errmsg,exerrval);
return (EX_FATAL);
}
if (strcmp(tmpstr, prop_name) == 0)
{
found = TRUE;
break;
}
}
/* if property is not found, return warning */
if (!found)
{
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: object type %d, property %s not defined in file id %d",
obj_type, prop_name, exoid);
ex_err("ex_get_prop_array",errmsg,exerrval);
return (EX_WARN);
}
if ((dimid = ncdimid (exoid, dim_name)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of objects in file id %d",
exoid);
ex_err("ex_get_prop_array",errmsg, exerrval);
return(EX_FATAL);
}
/* get number of objects */
if (ncdiminq (exoid, dimid, dim_name, &num_obj) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of %s objects in file id %d",
obj_stype, exoid);
ex_err("ex_get_prop_array",errmsg, exerrval);
return (EX_FATAL);
}
/* read num_obj values from property variable */
/* application code has allocated an array of ints but netcdf is expecting
a pointer to nclongs; if ints are different sizes than nclongs,
we must allocate an array of nclongs then convert them to ints with ltoi */
start[0] = 0;
count[0] = num_obj;
if (sizeof(int) == sizeof(nclong)) {
iresult = ncvarget (exoid, propid, start, count, values);
} else {
if (!(longs = static_cast<nclong*>(malloc(num_obj * sizeof(nclong))))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for %s property array for file id %d",
obj_stype, exoid);
ex_err("ex_get_prop_array",errmsg,exerrval);
return (EX_FATAL);
}
iresult = ncvarget (exoid, propid, start, count, longs);
}
if (iresult == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to read values in %s property array in file id %d",
obj_stype, exoid);
ex_err("ex_get_prop_array",errmsg,exerrval);
return (EX_FATAL);
}
if (sizeof(int) != sizeof(nclong)) {
ltoi (longs, values, num_obj);
free (longs);
}
return (EX_NOERR);
}
int ex_get_init (int exoid,
char *title,
int *num_dim,
int *num_nodes,
int *num_elem,
int *num_elem_blk,
int *num_node_sets,
int *num_side_sets)
{
int dimid;
long lnum_dim, lnum_nodes, lnum_elem, lnum_elem_blk, lnum_node_sets;
long lnum_side_sets;
char errmsg[MAX_ERR_LENGTH];
int title_len;
nc_type title_type;
exerrval = 0; /* clear error code */
if (ncattinq (exoid, NC_GLOBAL, ATT_TITLE, &title_type, &title_len) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to inquire title in file id %d", exoid);
ex_err("ex_get_init",errmsg,exerrval);
return (EX_FATAL);
}
/* Check title length to avoid overrunning clients memory space;
include trailing null */
if (title_len > MAX_LINE_LENGTH+1) {
sprintf(errmsg,
"Error: Title is too long (%d characters) in file id %d",
title_len-1, exoid);
exerrval = -1;
ex_err("ex_get_init",errmsg,exerrval);
return (EX_FATAL);
}
/* printf("[ex_get_init] title length: %d\n",title_len); */
if (ncattget (exoid, NC_GLOBAL, ATT_TITLE, title) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get title in file id %d", exoid);
ex_err("ex_get_init",errmsg,exerrval);
return (EX_FATAL);
}
/* printf("[ex_get_init] title: %s\n",title); */
if ((dimid = ncdimid (exoid, DIM_NUM_DIM)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of dimensions in file id %d",
exoid);
ex_err("ex_get_init",errmsg,exerrval);
return (EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &lnum_dim) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of dimensions in file id %d",
exoid);
ex_err("ex_get_init",errmsg,exerrval);
return (EX_FATAL);
}
*num_dim = lnum_dim;
/* Handle case with zero-nodes */
if ((dimid = ncdimid (exoid, DIM_NUM_NODES)) == -1) {
*num_nodes = 0;
} else {
if (ncdiminq (exoid, dimid, (char *) 0, &lnum_nodes) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of nodes in file id %d",
exoid);
ex_err("ex_get_init",errmsg,exerrval);
return (EX_FATAL);
}
*num_nodes = lnum_nodes;
}
if ((dimid = ncdimid (exoid, DIM_NUM_ELEM)) == -1) {
*num_elem = 0;
} else {
if (ncdiminq (exoid, dimid, (char *) 0, &lnum_elem) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of elements in file id %d",
exoid);
ex_err("ex_get_init",errmsg,exerrval);
return (EX_FATAL);
}
*num_elem = lnum_elem;
}
if (*num_elem > 0) {
if ((dimid = ncdimid (exoid, DIM_NUM_EL_BLK)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of element blocks in file id %d",
exoid);
ex_err("ex_get_init",errmsg,exerrval);
return (EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &lnum_elem_blk) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of element blocks in file id %d",
exoid);
ex_err("ex_get_init",errmsg,exerrval);
return (EX_FATAL);
}
*num_elem_blk = lnum_elem_blk;
} else {
*num_elem_blk = 0;
}
/* node sets are optional */
if ((dimid = ncdimid (exoid, DIM_NUM_NS)) == -1)
*num_node_sets = 0;
else
{
if (ncdiminq (exoid, dimid, (char *) 0, &lnum_node_sets) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of node sets in file id %d",
exoid);
ex_err("ex_get_init",errmsg,exerrval);
return (EX_FATAL);
}
*num_node_sets = lnum_node_sets;
}
/* side sets are optional */
if ((dimid = ncdimid (exoid, DIM_NUM_SS)) == -1)
*num_side_sets = 0;
else
{
if (ncdiminq (exoid, dimid, (char *) 0, &lnum_side_sets) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of side sets in file id %d",
exoid);
ex_err("ex_get_init",errmsg,exerrval);
return (EX_FATAL);
}
*num_side_sets = lnum_side_sets;
}
return (EX_NOERR);
}
int ex_get_prop_names (int exoid,
int obj_type,
char **prop_names)
{
int i, num_props, propid;
char var_name[12];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0;
/* determine which type of object property names are desired for */
num_props = ex_get_num_props (exoid, obj_type);
for (i=0; i<num_props; i++)
{
switch (obj_type)
{
case EX_ELEM_BLOCK:
strcpy (var_name, VAR_EB_PROP(i+1));
break;
case EX_NODE_SET:
strcpy (var_name, VAR_NS_PROP(i+1));
break;
case EX_SIDE_SET:
strcpy (var_name, VAR_SS_PROP(i+1));
break;
case EX_ELEM_MAP:
strcpy (var_name, VAR_EM_PROP(i+1));
break;
case EX_NODE_MAP:
strcpy (var_name, VAR_NM_PROP(i+1));
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_get_prop_names",errmsg,EX_BADPARAM);
return(EX_FATAL);
}
if ((propid = ncvarid (exoid, var_name)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate property array %s in file id %d",
var_name, exoid);
ex_err("ex_get_prop_names",errmsg,exerrval);
return (EX_FATAL);
}
/* for each property, read the "name" attribute of property array variable */
if ((ncattget (exoid, propid, ATT_PROP_NAME, prop_names[i])) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get property name in file id %d", exoid);
ex_err("ex_get_prop_names",errmsg,exerrval);
return (EX_FATAL);
}
}
return (EX_NOERR);
}
/*
* TODO, lots of declared, but unused variables here
*/
static void do_netcdfquery_proc(Widget, XtPointer, XtPointer)
{
int setno, src;
char xvar[256], yvar[256];
char buf[256], fname[512];
XmString xms;
XmString *s, cs;
int *pos_list;
int i, j, pos_cnt, cnt;
char *cstr;
int cdfid; /* netCDF id */
int ndims, nvars, ngatts, recdim;
int var_id;
long start[2];
long count[2];
char varname[256];
nc_type datatype = 0;
int dim[100], natts;
long dimlen[100];
long len;
int x_id, y_id;
nc_type xdatatype = 0;
nc_type ydatatype = 0;
int xndims, xdim[10], xnatts;
int yndims, ydim[10], ynatts;
long nx, ny;
int atlen;
char attname[256];
char atcharval[256];
extern int ncopts;
ncopts = 0; /* no crash on error */
set_wait_cursor();
strcpy(fname, xv_getstr(netcdf_file_item));
if ((cdfid = ncopen(fname, NC_NOWRITE)) == -1)
{
errwin("Can't open file.");
goto out2;
}
if (XmListGetSelectedPos(netcdf_listx_item, &pos_list, &pos_cnt))
{
XtVaGetValues(netcdf_listx_item,
XmNselectedItemCount, &cnt,
XmNselectedItems, &s,
NULL);
cs = XmStringCopy(*s);
if (XmStringGetLtoR(cs, charset, &cstr))
{
strcpy(xvar, cstr);
XtFree(cstr);
}
XmStringFree(cs);
}
else
{
errwin("Need to select X, either variable name or INDEX");
goto out1;
}
if (XmListGetSelectedPos(netcdf_listy_item, &pos_list, &pos_cnt))
{
XtVaGetValues(netcdf_listy_item,
XmNselectedItemCount, &cnt,
XmNselectedItems, &s,
NULL);
cs = XmStringCopy(*s);
if (XmStringGetLtoR(cs, charset, &cstr))
{
strcpy(yvar, cstr);
XtFree(cstr);
}
XmStringFree(cs);
}
else
{
errwin("Need to select Y");
goto out1;
}
if (strcmp(xvar, "INDEX") == 0)
{
stufftext("X is the index of the Y variable\n", STUFF_START);
}
else
{
if ((x_id = ncvarid(cdfid, xvar)) == -1)
{
char ebuf[256];
sprintf(ebuf, "do_query(): No such variable %s for X", xvar);
errwin(ebuf);
goto out1;
}
ncvarinq(cdfid, x_id, NULL, &xdatatype, &xndims, xdim, &xnatts);
ncdiminq(cdfid, xdim[0], NULL, &nx);
sprintf(buf, "X is %s, data type %s \t length [%d]\n", xvar, getcdf_type(xdatatype), nx);
stufftext(buf, STUFF_TEXT);
sprintf(buf, "\t%d Attributes:\n", xnatts);
stufftext(buf, STUFF_TEXT);
for (i = 0; i < xnatts; i++)
{
atcharval[0] = 0;
ncattname(cdfid, x_id, i, attname);
ncattinq(cdfid, x_id, attname, &datatype, &atlen);
switch (datatype)
{
case NC_CHAR:
ncattget(cdfid, x_id, attname, (void *)atcharval);
break;
}
sprintf(buf, "\t\t%s: %s\n", attname, atcharval);
stufftext(buf, STUFF_TEXT);
}
}
if ((y_id = ncvarid(cdfid, yvar)) == -1)
{
char ebuf[256];
sprintf(ebuf, "do_query(): No such variable %s for Y", yvar);
errwin(ebuf);
goto out1;
}
ncvarinq(cdfid, y_id, NULL, &ydatatype, &yndims, ydim, &ynatts);
ncdiminq(cdfid, ydim[0], NULL, &ny);
sprintf(buf, "Y is %s, data type %s \t length [%d]\n", yvar, getcdf_type(ydatatype), ny);
stufftext(buf, STUFF_TEXT);
sprintf(buf, "\t%d Attributes:\n", ynatts);
stufftext(buf, STUFF_TEXT);
for (i = 0; i < ynatts; i++)
{
atcharval[0] = 0;
ncattname(cdfid, y_id, i, attname);
ncattinq(cdfid, y_id, attname, &datatype, &atlen);
switch (datatype)
{
case NC_CHAR:
ncattget(cdfid, y_id, attname, (void *)atcharval);
break;
}
sprintf(buf, "\t\t%s: %s\n", attname, atcharval);
stufftext(buf, STUFF_TEXT);
}
out1:
;
ncclose(cdfid);
out2:
;
stufftext("\n", STUFF_STOP);
unset_wait_cursor();
}
int ex_put_prop (int exoid,
int obj_type,
int obj_id,
const char *prop_name,
int value)
{
int found = FALSE;
int num_props, i, dimid, propid, dims[1];
long start[1];
nclong ldum;
char name[MAX_VAR_NAME_LENGTH+1];
char obj_stype[MAX_VAR_NAME_LENGTH+1];
char obj_vtype[MAX_VAR_NAME_LENGTH+1];
char tmpstr[MAX_VAR_NAME_LENGTH+1];
char dim_name[MAX_VAR_NAME_LENGTH+1];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* check if property has already been created */
num_props = ex_get_num_props(exoid, obj_type);
switch (obj_type)
{
case EX_ELEM_BLOCK:
strcpy (obj_vtype, VAR_ID_EL_BLK);
strcpy (obj_stype, "element block");
break;
case EX_NODE_SET:
strcpy (obj_vtype, VAR_NS_IDS);
strcpy (obj_stype, "node set");
break;
case EX_SIDE_SET:
strcpy (obj_vtype, VAR_SS_IDS);
strcpy (obj_stype, "side set");
break;
case EX_ELEM_MAP:
strcpy (obj_vtype, VAR_EM_PROP(1));
strcpy (obj_stype, "element map");
break;
case EX_NODE_MAP:
strcpy (obj_vtype, VAR_NM_PROP(1));
strcpy (obj_stype, "node map");
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return(EX_FATAL);
}
if (num_props > 1) /* any properties other than the default 1? */
{
for (i=1; i<=num_props; i++)
{
switch (obj_type)
{
case EX_ELEM_BLOCK:
strcpy (name, VAR_EB_PROP(i));
break;
case EX_NODE_SET:
strcpy (name, VAR_NS_PROP(i));
break;
case EX_SIDE_SET:
strcpy (name, VAR_SS_PROP(i));
break;
case EX_ELEM_MAP:
strcpy (name, VAR_EM_PROP(i));
break;
case EX_NODE_MAP:
strcpy (name, VAR_NM_PROP(i));
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return(EX_FATAL);
}
if ((propid = ncvarid (exoid, name)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get property array id in file id %d",
exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return (EX_FATAL);
}
/* compare stored attribute name with passed property name */
if ((ncattget (exoid, propid, ATT_PROP_NAME, tmpstr)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get property name in file id %d", exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return (EX_FATAL);
}
if (strcmp(tmpstr, prop_name) == 0)
{
found = TRUE;
break;
}
}
}
/* if property array has not been created, create it */
if (!found)
{
/* put netcdf file into define mode */
if (ncredef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,"Error: failed to place file id %d into define mode",exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return (EX_FATAL);
}
/* create a variable with a name xx_prop#, where # is the new number */
/* of the property */
switch (obj_type){
case EX_ELEM_BLOCK:
strcpy (name, VAR_EB_PROP(num_props+1));
strcpy (dim_name, DIM_NUM_EL_BLK);
break;
case EX_NODE_SET:
strcpy (name, VAR_NS_PROP(num_props+1));
strcpy (dim_name, DIM_NUM_NS);
break;
case EX_SIDE_SET:
strcpy (name, VAR_SS_PROP(num_props+1));
strcpy (dim_name, DIM_NUM_SS);
break;
case EX_ELEM_MAP:
strcpy (name, VAR_EM_PROP(num_props+1));
strcpy (dim_name, DIM_NUM_EM);
break;
case EX_NODE_MAP:
strcpy (name, VAR_NM_PROP(num_props+1));
strcpy (dim_name, DIM_NUM_NM);
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_put_prop",errmsg,exerrval);
goto error_ret; /* Exit define mode and return */
}
/* inquire id of previously defined dimension (number of objects) */
if ((dimid = ncdimid (exoid, dim_name)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of objects in file id %d",
exoid);
ex_err("ex_put_prop",errmsg, exerrval);
goto error_ret; /* Exit define mode and return */
}
dims[0] = dimid;
ncsetfill(exoid, NC_FILL); /* fill with zeros per routine spec */
if ((propid = ncvardef (exoid, name, NC_LONG, 1, dims)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to create property array variable in file id %d",
exoid);
ex_err("ex_put_prop",errmsg,exerrval);
goto error_ret; /* Exit define mode and return */
}
ncsetfill(exoid, NC_NOFILL); /* default: nofill */
/* store property name as attribute of property array variable */
if ((ncattput (exoid, propid, ATT_PROP_NAME, NC_CHAR,
strlen(prop_name)+1, prop_name)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store property name %s in file id %d",
prop_name,exoid);
ex_err("ex_put_prop",errmsg,exerrval);
goto error_ret; /* Exit define mode and return */
}
/* leave define mode */
if (ncendef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to leave define mode in file id %d",
exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return (EX_FATAL);
}
}
/* find index into property array using obj_id; put value in property */
/* array at proper index; ex_id_lkup returns an index that is 1-based,*/
/* but netcdf expects 0-based arrays so subtract 1 */
/* special case: property name ID - check for duplicate ID assignment */
if (strcmp("ID",prop_name) == 0)
{
start[0] = ex_id_lkup (exoid, obj_vtype, value);
if (exerrval != EX_LOOKUPFAIL) /* found the id */
{
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: attempt to assign duplicate %s ID %d in file id %d",
obj_stype, value, exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return (EX_WARN);
}
}
start[0] = ex_id_lkup (exoid, obj_vtype, obj_id);
if (exerrval != 0)
{
if (exerrval == EX_NULLENTITY)
{
sprintf(errmsg,
"Warning: no properties allowed for NULL %s id %d in file id %d",
obj_stype, obj_id,exoid);
ex_err("ex_put_prop",errmsg,EX_MSG);
return (EX_WARN);
}
else
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to find value %d in %s property array in file id %d",
obj_id, obj_stype, exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return (EX_FATAL);
}
}
start[0] = start[0] - 1;
ldum = (nclong)value;
if (ncvarput1 (exoid, propid, start, &ldum) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store property value in file id %d",
exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
ncsetfill(exoid, NC_NOFILL); /* default: nofill */
if (ncendef (exoid) == -1) /* exit define mode */
{
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_prop",errmsg,exerrval);
}
return (EX_FATAL);
}
int main()
{
/*
* Declare variables for the HLU routine calls.
*/
int appid, workid, field1, con1;
int srlist, i, j, k;
ng_size_t icount[2];
float cmap[NCOLORS][3];
/*
* Declare variables for getting information from netCDF file.
*/
int ncid, lon_id, lat_id, level_id, temp_id;
float temp[10][33], special_value;
float lon[36], lat[33], level[10];
float min_lat, min_level, max_lat, max_level;
long start[4], count[4], lonlen, latlen, levellen;
char filename[256], string[50];
const char *dir = _NGGetNCARGEnv("data");
/*
* Default is to create an NCGM file.
*/
char const *wks_type = "ncgm";
/*
* Initialize the HLU library and set up resource template.
*/
NhlInitialize();
srlist = NhlRLCreate(NhlSETRL);
/*
* Create Application object.
*/
NhlRLClear(srlist);
NhlRLSetString(srlist,NhlNappDefaultParent,"True");
NhlRLSetString(srlist,NhlNappUsrDir,"./");
NhlCreate(&appid,"cn08",NhlappClass,NhlDEFAULT_APP,srlist);
cmap[0][0] = 0.0; cmap[0][1] = 0.0; cmap[0][2] = 0.0;
cmap[1][0] = 1.0; cmap[1][1] = 1.0; cmap[1][2] = 1.0;
cmap[2][0] = 1.0; cmap[2][1] = 1.0; cmap[2][2] = 1.0;
cmap[3][0] = 1.0; cmap[3][1] = 0.0; cmap[3][2] = 0.0;
cmap[4][0] = 0.0; cmap[4][1] = 1.0; cmap[4][2] = 0.0;
cmap[5][0] = 0.0; cmap[5][1] = 0.0; cmap[5][2] = 1.0;
cmap[6][0] = 1.0; cmap[6][1] = 1.0; cmap[6][2] = 0.0;
cmap[7][0] = 0.0; cmap[7][1] = 1.0; cmap[7][2] = 1.0;
cmap[8][0] = 1.0; cmap[8][1] = 0.0; cmap[8][2] = 1.0;
cmap[9][0] = 0.5; cmap[9][1] = 0.0; cmap[9][2] = 0.0;
cmap[10][0] = 0.5; cmap[10][1] = 1.0; cmap[10][2] = 1.0;
cmap[11][0] = 0.0; cmap[11][1] = 0.0; cmap[11][2] = 0.5;
cmap[12][0] = 1.0; cmap[12][1] = 1.0; cmap[12][2] = 0.5;
cmap[13][0] = 0.5; cmap[13][1] = 0.0; cmap[13][2] = 1.0;
cmap[14][0] = 1.0; cmap[14][1] = 0.5; cmap[14][2] = 0.0;
cmap[15][0] = 0.0; cmap[15][1] = 0.5; cmap[15][2] = 1.0;
cmap[16][0] = 0.5; cmap[16][1] = 1.0; cmap[16][2] = 0.0;
cmap[17][0] = 0.5; cmap[17][1] = 0.0; cmap[17][2] = 0.5;
cmap[18][0] = 0.5; cmap[18][1] = 1.0; cmap[18][2] = 0.5;
cmap[19][0] = 1.0; cmap[19][1] = 0.5; cmap[19][2] = 1.0;
cmap[20][0] = 0.0; cmap[20][1] = 0.5; cmap[20][2] = 0.0;
cmap[21][0] = 0.5; cmap[21][1] = 0.5; cmap[21][2] = 1.0;
cmap[22][0] = 1.0; cmap[22][1] = 0.0; cmap[22][2] = 0.5;
icount[0] = NCOLORS;
icount[1] = 3;
if (!strcmp(wks_type,"ncgm") || !strcmp(wks_type,"NCGM")) {
/*
* Create a meta file object.
*/
NhlRLClear(srlist);
NhlRLSetMDFloatArray(srlist,NhlNwkColorMap,&cmap[0][0],2,icount);
NhlRLSetString(srlist,NhlNwkMetaName,"./cn08c.ncgm");
NhlCreate(&workid,"cn08Work",NhlncgmWorkstationClass,
NhlDEFAULT_APP,srlist);
}
else if (!strcmp(wks_type,"x11") || !strcmp(wks_type,"X11")) {
/*
* Create an X11 workstation.
*/
NhlRLClear(srlist);
NhlRLSetMDFloatArray(srlist,NhlNwkColorMap,&cmap[0][0],2,icount);
NhlRLSetString(srlist,NhlNwkPause,"True");
NhlCreate(&workid,"cn08Work",NhlcairoWindowWorkstationClass,
NhlDEFAULT_APP,srlist);
}
else if (!strcmp(wks_type,"oldps") || !strcmp(wks_type,"OLDPS")) {
/*
* Create an older-style PostScript workstation.
*/
NhlRLClear(srlist);
NhlRLSetMDFloatArray(srlist,NhlNwkColorMap,&cmap[0][0],2,icount);
NhlRLSetString(srlist,NhlNwkPSFileName,"./cn08c.ps");
NhlCreate(&workid,"cn08Work",NhlpsWorkstationClass,
NhlDEFAULT_APP,srlist);
}
else if (!strcmp(wks_type,"oldpdf") || !strcmp(wks_type,"OLDPDF")) {
/*
* Create an older-style PDF workstation.
*/
NhlRLClear(srlist);
NhlRLSetMDFloatArray(srlist,NhlNwkColorMap,&cmap[0][0],2,icount);
NhlRLSetString(srlist,NhlNwkPDFFileName,"./cn08c.pdf");
NhlCreate(&workid,"cn08Work",NhlpdfWorkstationClass,
NhlDEFAULT_APP,srlist);
}
else if (!strcmp(wks_type,"pdf") || !strcmp(wks_type,"PDF") ||
!strcmp(wks_type,"ps") || !strcmp(wks_type,"PS")) {
/*
* Create a cairo PS/PDF workstation.
*/
NhlRLClear(srlist);
NhlRLSetMDFloatArray(srlist,NhlNwkColorMap,&cmap[0][0],2,icount);
NhlRLSetString(srlist,NhlNwkFileName,"./cn08c");
NhlRLSetString(srlist,NhlNwkFormat,(char*)wks_type);
NhlCreate(&workid,"cn08Work",NhlcairoDocumentWorkstationClass,
NhlDEFAULT_APP,srlist);
}
else if (!strcmp(wks_type,"png") || !strcmp(wks_type,"PNG")) {
/*
* Create a cairo PNG workstation.
*/
NhlRLClear(srlist);
NhlRLSetMDFloatArray(srlist,NhlNwkColorMap,&cmap[0][0],2,icount);
NhlRLSetString(srlist,NhlNwkFileName,"./cn08c");
NhlRLSetString(srlist,NhlNwkFormat,(char*)wks_type);
NhlCreate(&workid,"cn08Work",NhlcairoImageWorkstationClass,
NhlDEFAULT_APP,srlist);
}
/*
* Open data file containing grid of global temperatures.
*/
sprintf( filename, "%s/cdf/contour.cdf", dir );
ncid = ncopen(filename,NC_NOWRITE);
/*
* Get the lat/lon/level dimensions.
*/
lat_id = ncdimid(ncid,"lat");
lon_id = ncdimid(ncid,"lon");
level_id = ncdimid(ncid,"level");
ncdiminq(ncid,lat_id,(char *)0,&latlen);
ncdiminq(ncid,lon_id,(char *)0,&lonlen);
ncdiminq(ncid,level_id,(char *)0,&levellen);
/*
* Read in temperature values and convert from degrees F to degrees K.
*/
temp_id = ncvarid(ncid,"T");
start[0] = start[1] = start[2] = start[3] = 0;
count[0] = 1; count[1] = levellen; count[2] = latlen; count[3] = 1;
ncvarget(ncid,temp_id,(long const *)start,(long const *)count,temp);
ncattget(ncid,temp_id,"_FillValue",&special_value);
for( j = 0; j < levellen; j++ ) {
for( k = 0; k < latlen; k++ ) {
temp[j][k] = (temp[j][k] - 273.15) * 9./5. + 32.;
}
}
/*
* Read in lat/lon/level values.
*/
lat_id = ncvarid(ncid,"lat");
count[0] = latlen;
ncvarget(ncid,lat_id,(long const *)start,(long const *)count,lat);
lon_id = ncvarid(ncid,"lon");
count[0] = lonlen;
ncvarget(ncid,lon_id,(long const *)start,(long const *)count,lon);
level_id = ncvarid(ncid,"level");
count[0] = levellen;
ncvarget(ncid,level_id,(long const *)start,(long const *)count,level);
/*
* Set up initial scalar field with longitude of temperature data.
*/
icount[0] = levellen; icount[1] = latlen;
NhlRLClear(srlist);
NhlRLSetMDFloatArray(srlist,NhlNsfDataArray,&temp[0][0],2,icount);
NhlRLSetFloat(srlist,NhlNsfMissingValueV,special_value);
NhlRLSetFloat(srlist,NhlNsfXCStartV,lat[0]);
NhlRLSetFloat(srlist,NhlNsfXCEndV,lat[latlen-1]);
NhlRLSetFloatArray(srlist,NhlNsfXArray,lat,latlen);
NhlRLSetFloatArray(srlist,NhlNsfYArray,level,levellen);
NhlCreate(&field1,"field1",NhlscalarFieldClass,appid,srlist);
/*
* Determine extents of grid
*/
if(lat[0] < lat[latlen-1]) {
min_lat = lat[0];
max_lat = lat[latlen-1];
}
else {
max_lat = lat[0];
min_lat = lat[latlen-1];
}
if(level[0] < level[levellen-1]) {
min_level = level[0];
max_level = level[levellen-1];
}
else {
max_level = level[0];
min_level = level[levellen-1];
}
/*
* Create contour using manual spacing.
*/
NhlRLClear(srlist);
NhlRLSetFloat(srlist,NhlNvpXF,.2);
NhlRLSetFloat(srlist,NhlNvpYF,.8);
NhlRLSetFloat(srlist,NhlNvpWidthF, .6);
NhlRLSetFloat(srlist,NhlNvpHeightF, .6);
NhlRLSetString(srlist,NhlNcnFillOn, "True");
NhlRLSetInteger(srlist,NhlNcnScalarFieldData, field1);
NhlRLSetString(srlist,NhlNcnLevelSelectionMode, "ManualLevels");
NhlRLSetInteger(srlist,NhlNcnMaxLevelCount, 25);
NhlRLSetFloat(srlist,NhlNcnMinLevelValF, -80.0);
NhlRLSetFloat(srlist,NhlNcnMaxLevelValF, 110.0);
NhlRLSetFloat(srlist,NhlNcnLevelSpacingF, 10.0);
NhlRLSetFloat(srlist,NhlNtrXMinF, min_lat);
NhlRLSetFloat(srlist,NhlNtrXMaxF, max_lat);
NhlRLSetFloat(srlist,NhlNtrYMinF, min_level);
NhlRLSetFloat(srlist,NhlNtrYMaxF, max_level);
NhlRLSetString(srlist,NhlNtrYReverse, "True");
sprintf(string,"Longitude %g Degrees", lon[0] );
NhlRLSetString(srlist,NhlNtiMainString,string);
NhlCreate(&con1,"con1",NhlcontourPlotClass,workid,srlist);
/*
* Draw first step
*/
NhlDraw(con1);
NhlFrame(workid);
/*
* Loop on remaining longitude values and reset the title every
* iteration.
*/
for( i = 1; i <= lonlen-1; i++ ) {
/*
* Read in temperature values and convert from degrees F to degrees K.
*/
start[0] = start[1] = start[2] = 0;
start[3] = i;
count[0] = 1; count[1] = levellen;
count[2] = latlen; count[3] = 1;
ncvarget(ncid,temp_id,(long const *)start,(long const *)count,
temp);
for( j = 0; j < levellen; j++ ) {
for( k = 0; k < latlen; k++ ) {
temp[j][k] = (temp[j][k] - 273.15) * 9./5. + 32.;
}
}
NhlRLClear(srlist);
icount[0] = levellen; icount[1] = latlen;
NhlRLSetMDFloatArray(srlist,NhlNsfDataArray,&temp[0][0],2,icount);
/*
* Create new scalar field.
*/
NhlSetValues(field1,srlist);
NhlRLClear(srlist);
sprintf(string,"Longitude %g Degrees", lon[i] );
NhlRLSetString(srlist,NhlNtiMainString,string);
NhlSetValues(con1,srlist);
NhlDraw(con1);
NhlFrame(workid);
}
/*
* Close the netCDF file.
*/
ncclose(ncid);
/*
* NhlDestroy destroys the given id and all of its children.
*/
NhlRLDestroy(srlist);
NhlDestroy(appid);
/*
* Restores state.
*/
NhlClose();
exit(0);
}
int main(int argc, char *argv[])
{
char *pname;
char *filename, *tempfile, *newfile;
char string[1024];
char *variable_name, *attribute_name;
int created_tempfile;
int done_redef;
int iatt;
int mincid, varid;
int variable_exists, attribute_exists;
nc_type attribute_type, new_type;
int attribute_length, new_length;
void *new_value;
int total_length, alloc_length, ival;
char *zeros;
int old_ncopts;
/* Parse the command line */
pname=argv[0];
if (ParseArgv(&argc, argv, argTable, 0) || (argc != 2)) {
(void) fprintf(stderr, "\nUsage: %s [<options>] <file.mnc>\n",
pname);
(void) fprintf(stderr, " %s [-help]\n\n", pname);
exit(EXIT_FAILURE);
}
filename = argv[1];
/* Create temp file name. First try looking for minc extension, then
a compression extension. Chop off the unwanted extension. */
(void) strncpy(string, filename, sizeof(string)-1);
tempfile = strstr(string, MINC_EXTENSION);
if (tempfile != NULL) {
tempfile += strlen(MINC_EXTENSION);
if (*tempfile == '\0')
tempfile = NULL;
}
else {
tempfile = strstr(string, GZIP_EXTENSION);
if (tempfile == NULL)
tempfile = strstr(string, BZIP_EXTENSION);
if (tempfile == NULL)
tempfile = strstr(string, BZIP2_EXTENSION);
if (tempfile == NULL)
tempfile = strstr(string, COMPRESS_EXTENSION);
if (tempfile == NULL)
tempfile = strstr(string, PACK_EXTENSION);
if (tempfile == NULL)
tempfile = strstr(string, ZIP_EXTENSION);
}
if (tempfile != NULL) {
*tempfile = '\0';
tempfile = string;
}
/* If tempfile == NULL, then either we have a minc file or we don't know
how to edit the file in place. Check that it is a minc file. */
if (tempfile == NULL) {
newfile = miexpand_file(filename, tempfile, TRUE, &created_tempfile);
if (created_tempfile) {
if (newfile != NULL) {
(void) remove(newfile);
free(newfile);
}
(void) fprintf(stderr, "Cannot edit file \"%s\" in place.\n",
filename);
exit(EXIT_FAILURE);
}
}
/* Expand the file. */
newfile = miexpand_file(filename, tempfile, FALSE, &created_tempfile);
if (newfile == NULL) {
(void) fprintf(stderr, "Error decompressing file \"%s\"\n",
filename);
exit(EXIT_FAILURE);
}
/* If a new file was created, get rid of the old one */
if (created_tempfile) {
(void) remove(filename);
}
/* Open the file */
mincid = miopen(newfile, NC_WRITE);
/* Loop through attribute list, modifying values */
done_redef = FALSE;
ncopts = NC_VERBOSE;
zeros = NULL;
alloc_length = 0;
for (iatt=0; iatt < attribute_list_size; iatt++) {
/* Get variable and attribute name */
variable_name = attribute_list[iatt].variable;
attribute_name = attribute_list[iatt].attribute;
/* Check for attribute existence */
if (strlen(variable_name) == 0) {
varid = NC_GLOBAL;
variable_exists = TRUE;
}
else {
old_ncopts = ncopts; ncopts = 0;
varid = ncvarid(mincid, variable_name);
ncopts = old_ncopts;
variable_exists = (varid != MI_ERROR);
}
attribute_type = NC_CHAR;
attribute_length = 0;
if (variable_exists) {
old_ncopts = ncopts; ncopts = 0;
attribute_exists =
(ncattinq(mincid, varid, attribute_name,
&attribute_type, &attribute_length) != MI_ERROR);
ncopts = old_ncopts;
}
else
attribute_exists = FALSE;
/* Are we inserting or deleting? */
switch (attribute_list[iatt].action) {
case Insert_attribute:
case Append_attribute:
if (attribute_list[iatt].value != NULL) {
new_type = NC_CHAR;
new_length = strlen(attribute_list[iatt].value)+1;
new_value = (void *) attribute_list[iatt].value;
}
else {
new_type = NC_DOUBLE;
new_length = attribute_list[iatt].num_doubles;
new_value = (void *) attribute_list[iatt].double_values;
}
/* For append we have to copy the entire attribute, if it
* already exists.
*/
if (attribute_list[iatt].action == Append_attribute &&
attribute_exists) {
char *tmp_value;
/* Verify that the existing type matches the newly
* requested type. Don't allow a -dappend on a
* string attribute, for example.
*/
if (new_type != attribute_type) {
fprintf(stderr,
"Can't append %s data to %s attribute %s:%s.\n",
(new_type == NC_DOUBLE) ? "double" : "string",
(attribute_type == NC_DOUBLE) ? "double" : "string",
variable_name, attribute_name);
exit(EXIT_FAILURE);
}
new_type = attribute_type;
tmp_value = malloc((attribute_length + new_length) * nctypelen(new_type));
ncattget(mincid, varid, attribute_name, tmp_value);
/* For string attributes, remove any trailing null
* character before appending.
*/
if (new_type == NC_CHAR && tmp_value[attribute_length-1] == 0) {
attribute_length--;
}
memcpy(tmp_value + attribute_length * nctypelen(new_type),
new_value,
new_length * nctypelen(new_type));
new_length += attribute_length;
new_value = (void *) tmp_value;
}
total_length = attribute_length*nctypelen(attribute_type);
if (!attribute_exists ||
(total_length < new_length*nctypelen(new_type))) {
if (! done_redef) {
done_redef = TRUE;
(void) ncredef(mincid);
}
}
else if (!done_redef && attribute_exists && (total_length > 0)) {
if (total_length > alloc_length) {
if (zeros != NULL) free(zeros);
zeros = malloc(total_length);
alloc_length = total_length;
for (ival=0; ival < alloc_length; ival++)
zeros[ival] = '\0';
}
(void) ncattput(mincid, varid, attribute_name, NC_CHAR,
total_length, zeros);
(void) ncsync(mincid);
}
if (!variable_exists) {
old_ncopts = ncopts; ncopts = 0;
varid = micreate_group_variable(mincid, variable_name);
ncopts = old_ncopts;
if (varid == MI_ERROR) {
varid = ncvardef(mincid, variable_name, NC_INT,
0, NULL);
}
variable_exists = (varid != MI_ERROR);
}
if (variable_exists) {
(void) ncattput(mincid, varid, attribute_name,
new_type, new_length, new_value);
}
break;
case Delete_attribute:
if (attribute_exists) {
if (! done_redef) {
done_redef = TRUE;
(void) ncredef(mincid);
}
(void) ncattdel(mincid, varid, attribute_name);
}
break;
default:
(void) fprintf(stderr, "Program error: unknown action %d\n",
(int) attribute_list[iatt].action);
exit(EXIT_FAILURE);
}
}
ncopts = NC_VERBOSE | NC_FATAL;
/* Close the file */
(void) miclose(mincid);
/* Free stuff */
free(newfile);
if (zeros != NULL) free(zeros);
exit(EXIT_SUCCESS);
}
void
mexFunction (
INT nlhs,
Matrix * plhs[],
INT nrhs,
const Matrix * prhs[]
)
{
char * opname;
OPCODE opcode;
Matrix * mat;
int status;
char * path;
int cmode;
int mode;
int cdfid;
int ndims;
int nvars;
int natts;
int recdim;
char * name;
long length;
int dimid;
nc_type datatype;
int * dim;
int varid;
long * coords;
VOIDP value;
long * start;
long * count;
int * intcount;
long * stride;
long * imap;
long recnum;
int nrecvars;
int * recvarids;
long * recsizes;
VOIDPP datap; /* pointers for record access. */
int len;
int incdf;
int invar;
int outcdf;
int outvar;
int attnum;
char * attname;
char * newname;
int fillmode;
int i;
int m;
int n;
char * p;
char buffer[MAX_BUFFER];
DOUBLE * pr;
DOUBLE addoffset;
DOUBLE scalefactor;
int autoscale; /* do auto-scaling if this flag is non-zero. */
/* Disable the NC_FATAL option from ncopts. */
if (ncopts & NC_FATAL) {
ncopts -= NC_FATAL;
}
/* Display usage if less than one input argument. */
if (nrhs < 1) {
Usage();
return;
}
/* Convert the operation name to its opcode. */
opname = Mat2Str(prhs[0]);
for (i = 0; i < strlen(opname); i++) {
opname[i] = (char) tolower((int) opname[i]);
}
p = opname;
if (strncmp(p, "nc", 2) == 0) { /* Trim away "nc". */
p += 2;
}
i = 0;
opcode = NONE;
while (ops[i].opcode != NONE) {
if (!strcmp(p, ops[i].opname)) {
opcode = ops[i].opcode;
if (ops[i].nrhs > nrhs) {
mexPrintf("MEXCDF: opname = %s\n", opname);
mexErrMsgTxt("MEXCDF: Too few input arguments.\n");
}
else if (0 && ops[i].nlhs > nlhs) { /* Disabled. */
mexPrintf("MEXCDF: opname = %s\n", opname);
mexErrMsgTxt("MEXCDF: Too few output arguments.\n");
}
break;
}
else {
i++;
}
}
if (opcode == NONE) {
mexPrintf("MEXCDF: opname = %s\n", opname);
mexErrMsgTxt("MEXCDF: No such operation.\n");
}
Free((VOIDPP) & opname);
/* Extract the cdfid by number. */
switch (opcode) {
case USAGE:
case CREATE:
case OPEN:
case TYPELEN:
case SETOPTS:
case ERR:
case PARAMETER:
break;
default:
cdfid = Scalar2Int(prhs[1]);
break;
}
/* Extract the dimid by number or name. */
switch (opcode) {
case DIMINQ:
case DIMRENAME:
if (mxIsNumeric(prhs[2])) {
dimid = Scalar2Int(prhs[2]);
}
else {
name = Mat2Str(prhs[2]);
dimid = ncdimid(cdfid, name);
Free((VOIDPP) & name);
}
break;
default:
break;
}
/* Extract the varid by number or name. */
switch (opcode) {
case VARINQ:
case VARPUT1:
case VARGET1:
case VARPUT:
case VARGET:
case VARPUTG:
case VARGETG:
case VARRENAME:
case VARCOPY:
case ATTPUT:
case ATTINQ:
case ATTGET:
case ATTCOPY:
case ATTNAME:
case ATTRENAME:
case ATTDEL:
if (mxIsNumeric(prhs[2])) {
varid = Scalar2Int(prhs[2]);
}
else {
name = Mat2Str(prhs[2]);
varid = ncvarid(cdfid, name);
Free((VOIDPP) & name);
if (varid == -1) {
varid = Parameter(prhs[2]);
}
}
break;
default:
break;
}
/* Extract the attname by name or number. */
switch (opcode) {
case ATTPUT:
case ATTINQ:
case ATTGET:
case ATTCOPY:
case ATTRENAME:
case ATTDEL:
if (mxIsNumeric(prhs[3])) {
attnum = Scalar2Int(prhs[3]);
attname = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
status = ncattname(cdfid, varid, attnum, attname);
}
else {
attname = Mat2Str(prhs[3]);
}
break;
default:
break;
}
/* Extract the "add_offset" and "scale_factor" attributes. */
switch (opcode) {
case VARPUT1:
case VARGET1:
case VARPUT:
case VARGET:
case VARPUTG:
case VARGETG:
addoffset = Add_Offset(cdfid, varid);
scalefactor = Scale_Factor(cdfid, varid);
if (scalefactor == 0.0) {
scalefactor = 1.0;
}
break;
default:
break;
}
/* Perform the NetCDF operation. */
switch (opcode) {
case USAGE:
Usage();
break;
case CREATE:
path = Mat2Str(prhs[1]);
if (nrhs > 2) {
cmode = Parameter(prhs[2]);
}
else {
cmode = NC_NOCLOBBER; /* Default. */
}
cdfid = nccreate(path, cmode);
plhs[0] = Int2Scalar(cdfid);
plhs[1] = Int2Scalar((cdfid >= 0) ? 0 : -1);
Free((VOIDPP) & path);
break;
case OPEN:
path = Mat2Str(prhs[1]);
if (nrhs > 2) {
mode = Parameter(prhs[2]);
}
else {
mode = NC_NOWRITE; /* Default. */
}
cdfid = ncopen(path, mode);
plhs[0] = Int2Scalar(cdfid);
plhs[1] = Int2Scalar((cdfid >= 0) ? 0 : -1);
Free((VOIDPP) & path);
break;
case REDEF:
status = ncredef(cdfid);
plhs[0] = Int2Scalar(status);
break;
case ENDEF:
status = ncendef(cdfid);
plhs[0] = Int2Scalar(status);
break;
case CLOSE:
status = ncclose(cdfid);
plhs[0] = Int2Scalar(status);
break;
case INQUIRE:
status = ncinquire(cdfid, & ndims, & nvars, & natts, & recdim);
if (nlhs > 1) {
plhs[0] = Int2Scalar(ndims);
plhs[1] = Int2Scalar(nvars);
plhs[2] = Int2Scalar(natts);
plhs[3] = Int2Scalar(recdim);
plhs[4] = Int2Scalar(status);
}
else { /* Default to 1 x 5 row vector. */
plhs[0] = mxCreateFull(1, 5, REAL);
pr = mxGetPr(plhs[0]);
if (status == 0) {
pr[0] = (DOUBLE) ndims;
pr[1] = (DOUBLE) nvars;
pr[2] = (DOUBLE) natts;
pr[3] = (DOUBLE) recdim;
}
pr[4] = (DOUBLE) status;
}
break;
case SYNC:
status = ncsync(cdfid);
plhs[0] = Int2Scalar(status);
break;
case ABORT:
status = ncabort(cdfid);
plhs[0] = Int2Scalar(status);
break;
case DIMDEF:
name = Mat2Str(prhs[2]);
length = Parameter(prhs[3]);
dimid = ncdimdef(cdfid, name, length);
plhs[0] = Int2Scalar(dimid);
plhs[1] = Int2Scalar((dimid >= 0) ? 0 : dimid);
Free((VOIDPP) & name);
break;
case DIMID:
name = Mat2Str(prhs[2]);
dimid = ncdimid(cdfid, name);
plhs[0] = Int2Scalar(dimid);
plhs[1] = Int2Scalar((dimid >= 0) ? 0 : dimid);
Free((VOIDPP) & name);
break;
case DIMINQ:
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
status = ncdiminq(cdfid, dimid, name, & length);
plhs[0] = Str2Mat(name);
plhs[1] = Long2Scalar(length);
plhs[2] = Int2Scalar(status);
Free((VOIDPP) & name);
break;
case DIMRENAME:
name = Mat2Str(prhs[3]);
status = ncdimrename(cdfid, dimid, name);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & name);
break;
case VARDEF:
name = Mat2Str(prhs[2]);
datatype = (nc_type) Parameter(prhs[3]);
ndims = Scalar2Int(prhs[4]);
if (ndims == -1) {
ndims = Count(prhs[5]);
}
dim = Mat2Int(prhs[5]);
varid = ncvardef(cdfid, name, datatype, ndims, dim);
Free((VOIDPP) & name);
plhs[0] = Int2Scalar(varid);
plhs[1] = Int2Scalar((varid >= 0) ? 0 : varid);
break;
case VARID:
name = Mat2Str(prhs[2]);
varid = ncvarid(cdfid, name);
Free((VOIDPP) & name);
plhs[0] = Int2Scalar(varid);
plhs[1] = Int2Scalar((varid >= 0) ? 0 : varid);
break;
case VARINQ:
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
plhs[0] = Str2Mat(name);
plhs[1] = Int2Scalar(datatype);
plhs[2] = Int2Scalar(ndims);
plhs[3] = Int2Mat(dim, 1, ndims);
plhs[4] = Int2Scalar(natts);
plhs[5] = Int2Scalar(status);
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
break;
case VARPUT1:
coords = Mat2Long(prhs[3]);
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
if (datatype == NC_CHAR) {
mat = SetNum(prhs[4]);
}
else {
mat = prhs[4];
}
if (mat == NULL) {
mat = prhs[4];
}
pr = mxGetPr(mat);
autoscale = (nrhs > 5 && Scalar2Int(prhs[5]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
status = Convert(opcode, datatype, 1, buffer, scalefactor, addoffset, pr);
status = ncvarput1(cdfid, varid, coords, buffer);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & coords);
break;
case VARGET1:
coords = Mat2Long(prhs[3]);
autoscale = (nrhs > 4 && Scalar2Int(prhs[4]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
mat = Int2Scalar(0);
pr = mxGetPr(mat);
status = ncvarget1(cdfid, varid, coords, buffer);
status = Convert(opcode, datatype, 1, buffer, scalefactor, addoffset, pr);
if (datatype == NC_CHAR) {
plhs[0] = SetStr(mat);
}
else {
plhs[0] = mat;
}
if (plhs[0] == NULL) {
/* prhs[0] = mat; */
plhs[0] = mat; /* ZYDECO 24Jan2000 */
}
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & coords);
break;
case VARPUT:
start = Mat2Long(prhs[3]);
count = Mat2Long(prhs[4]);
autoscale = (nrhs > 6 && Scalar2Int(prhs[6]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
if (datatype == NC_CHAR) {
mat = SetNum(prhs[5]);
}
else {
mat = prhs[5];
}
if (mat == NULL) {
mat = prhs[5];
}
pr = mxGetPr(mat);
for (i = 0; i < ndims; i++) {
if (count[i] == -1) {
status = ncdiminq(cdfid, dim[i], name, & count[i]);
count[i] -= start[i];
}
}
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
len = 0;
if (ndims > 0) {
len = 1;
for (i = 0; i < ndims; i++) {
len *= count[i];
}
}
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr);
status = ncvarput(cdfid, varid, start, count, value);
Free((VOIDPP) & value);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & start);
Free((VOIDPP) & count);
break;
case VARGET:
start = Mat2Long(prhs[3]);
count = Mat2Long(prhs[4]);
intcount = Mat2Int(prhs[4]);
autoscale = (nrhs > 5 && Scalar2Int(prhs[5]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
for (i = 0; i < ndims; i++) {
if (count[i] == -1) {
status = ncdiminq(cdfid, dim[i], name, & count[i]);
count[i] -= start[i];
}
}
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
m = 0;
n = 0;
if (ndims > 0) {
m = count[0];
n = count[0];
for (i = 1; i < ndims; i++) {
n *= count[i];
if (count[i] > 1) {
m = count[i];
}
}
n /= m;
}
len = m * n;
if (ndims < 2) {
m = 1;
n = len;
}
for (i = 0; i < ndims; i++) {
intcount[i] = count[ndims-i-1]; /* Reverse order. */
}
if (MEXCDF_4 || ndims < 2) {
mat = mxCreateFull(m, n, mxREAL); /* mxCreateDoubleMatrix */
}
# if MEXCDF_5
else {
mat = mxCreateNumericArray(ndims, intcount, mxDOUBLE_CLASS, mxREAL);
}
# endif
pr = mxGetPr(mat);
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = ncvarget(cdfid, varid, start, count, value);
status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr);
Free((VOIDPP) & value);
if (datatype == NC_CHAR) {
plhs[0] = SetStr(mat);
}
else {
plhs[0] = mat;
}
if (plhs[0] == NULL) {
plhs[0] = mat;
}
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & intcount);
Free((VOIDPP) & count);
Free((VOIDPP) & start);
break;
case VARPUTG:
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
if (nrhs > 7) {
if (datatype == NC_CHAR) {
mat = SetStr(prhs[7]);
}
else {
mat = prhs[7];
}
if (mat == NULL) {
mat = prhs[7];
}
}
else {
if (datatype == NC_CHAR) {
mat = SetStr(prhs[6]);
}
else {
mat = prhs[6];
}
if (mat == NULL) {
mat = prhs[6];
}
}
pr = mxGetPr(mat);
start = Mat2Long(prhs[3]);
count = Mat2Long(prhs[4]);
stride = Mat2Long(prhs[5]);
imap = NULL;
for (i = 0; i < ndims; i++) {
if (count[i] == -1) {
status = ncdiminq(cdfid, dim[i], name, & count[i]);
count[i] -= start[i];
}
}
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
len = 0;
if (ndims > 0) {
len = 1;
for (i = 0; i < ndims; i++) {
len *= count[i];
}
}
autoscale = (nrhs > 8 && Scalar2Int(prhs[8]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr);
status = ncvarputg(cdfid, varid, start, count, stride, imap, value);
Free((VOIDPP) & value);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & stride);
Free((VOIDPP) & count);
Free((VOIDPP) & start);
break;
case VARGETG:
start = Mat2Long(prhs[3]);
count = Mat2Long(prhs[4]);
intcount = Mat2Int(prhs[4]);
stride = Mat2Long(prhs[5]);
imap = NULL;
autoscale = (nrhs > 7 && Scalar2Int(prhs[7]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
for (i = 0; i < ndims; i++) {
if (count[i] == -1) {
status = ncdiminq(cdfid, dim[i], name, & count[i]);
count[i] -= start[i];
}
}
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
m = 0;
n = 0;
if (ndims > 0) {
m = count[0];
n = count[0];
for (i = 1; i < ndims; i++) {
n *= count[i];
if (count[i] > 1) {
m = count[i];
}
}
n /= m;
}
len = m * n;
if (ndims < 2) {
m = 1;
n = len;
}
for (i = 0; i < ndims; i++) {
intcount[i] = count[ndims-i-1]; /* Reverse order. */
}
if (MEXCDF_4 || ndims < 2) {
mat = mxCreateFull(m, n, mxREAL); /* mxCreateDoubleMatrix */
}
# if MEXCDF_5
else {
mat = mxCreateNumericArray(ndims, intcount, mxDOUBLE_CLASS, mxREAL);
}
# endif
pr = mxGetPr(mat);
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = ncvargetg(cdfid, varid, start, count, stride, imap, value);
status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr);
Free((VOIDPP) & value);
if (datatype == NC_CHAR) {
plhs[0] = SetStr(mat);
}
else {
plhs[0] = mat;
}
if (plhs[0] == NULL) {
/* prhs[0] = mat; */
plhs[0] = mat; /* ZYDECO 24Jan2000 */
}
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & stride);
Free((VOIDPP) & intcount);
Free((VOIDPP) & count);
Free((VOIDPP) & start);
break;
case VARRENAME:
name = Mat2Str(prhs[3]);
status = ncvarrename(cdfid, varid, name);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & name);
break;
case VARCOPY:
incdf = cdfid;
invar = varid;
outcdf = Scalar2Int(prhs[3]);
outvar = -1;
/* outvar = ncvarcopy(incdf, invar, outcdf); */
plhs[0] = Int2Scalar(outvar);
plhs[1] = Int2Scalar((outvar >= 0) ? 0 : outvar);
break;
case ATTPUT:
datatype = (nc_type) Parameter(prhs[4]);
datatype = RepairBadDataType(datatype);
if (datatype == NC_CHAR) {
mat = SetNum(prhs[6]);
}
else {
mat = prhs[6];
}
if (mat == NULL) {
mat = prhs[6];
}
len = Scalar2Int(prhs[5]);
if (len == -1) {
len = Count(mat);
}
pr = mxGetPr(mat);
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = Convert(opcode, datatype, len, value, (DOUBLE) 1.0, (DOUBLE) 0.0, pr);
status = ncattput(cdfid, varid, attname, datatype, len, value);
if (value != NULL) {
Free((VOIDPP) & value);
}
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTINQ:
status = ncattinq(cdfid, varid, attname, & datatype, & len);
datatype = RepairBadDataType(datatype);
plhs[0] = Int2Scalar((int) datatype);
plhs[1] = Int2Scalar(len);
plhs[2] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTGET:
status = ncattinq(cdfid, varid, attname, & datatype, & len);
datatype = RepairBadDataType(datatype);
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = ncattget(cdfid, varid, attname, value);
mat = mxCreateDoubleMatrix(1, len, mxREAL);
pr = mxGetPr(mat);
status = Convert(opcode, datatype, len, value, (DOUBLE) 1.0, (DOUBLE) 0.0, pr);
if (value != NULL) {
Free((VOIDPP) & value);
}
if (datatype == NC_CHAR) {
plhs[0] = SetStr(mat);
}
else {
plhs[0] = mat;
}
if (plhs[0] == NULL) {
/* prhs[4] = mat; */
plhs[0] = mat; /* ZYDECO 24Jan2000 */
}
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTCOPY:
incdf = cdfid;
invar = varid;
outcdf = Scalar2Int(prhs[4]);
if (mxIsNumeric(prhs[5])) {
outvar = Scalar2Int(prhs[2]);
}
else {
name = Mat2Str(prhs[5]);
outvar = ncvarid(cdfid, name);
Free((VOIDPP) & name);
}
status = ncattcopy(incdf, invar, attname, outcdf, outvar);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTNAME:
attnum = Scalar2Int(prhs[3]);
attname = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
status = ncattname(cdfid, varid, attnum, attname);
plhs[0] = Str2Mat(attname);
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTRENAME:
newname = Mat2Str(prhs[4]);
status = ncattrename(cdfid, varid, attname, newname);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & attname);
Free((VOIDPP) & newname);
break;
case ATTDEL:
status = ncattdel(cdfid, varid, attname);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case RECPUT:
recnum = Scalar2Long(prhs[2]);
pr = mxGetPr(prhs[3]);
autoscale = (nrhs > 4 && Scalar2Int(prhs[4]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
recvarids = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int));
recsizes = (long *) mxCalloc(MAX_VAR_DIMS, sizeof(long));
datap = (VOIDPP) mxCalloc(MAX_VAR_DIMS, sizeof(VOIDP));
status = ncrecinq(cdfid, & nrecvars, recvarids, recsizes);
if (status == -1) {
plhs[0] = Int2Scalar(status);
break;
}
length = 0;
n = 0;
for (i = 0; i < nrecvars; i++) {
ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
length += recsizes[i];
n += (recsizes[i] / nctypelen(datatype));
}
if (Count(prhs[3]) < n) {
status = -1;
plhs[0] = Int2Scalar(status);
break;
}
if ((value = (VOIDP) mxCalloc((int) length, sizeof(char))) == NULL) {
status = -1;
plhs[0] = Int2Scalar(status);
break;
}
length = 0;
p = value;
for (i = 0; i < nrecvars; i++) {
datap[i] = p;
p += recsizes[i];
}
p = (char *) value;
pr = mxGetPr(prhs[3]);
for (i = 0; i < nrecvars; i++) {
ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
length = recsizes[i] / nctypelen(datatype);
if (autoscale) {
addoffset = Add_Offset(cdfid, recvarids[i]);
scalefactor = Scale_Factor(cdfid, recvarids[i]);
if (scalefactor == 0.0) {
scalefactor = 1.0;
}
}
Convert(opcode, datatype, length, (VOIDP) p, scalefactor, addoffset, pr);
pr += length;
p += recsizes[i];
}
status = ncrecput(cdfid, recnum, datap);
plhs[0] = Int2Scalar(status);
Free ((VOIDPP) & value);
Free ((VOIDPP) & datap);
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
break;
case RECGET:
recnum = Scalar2Long(prhs[2]);
autoscale = (nrhs > 3 && Scalar2Int(prhs[3]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
recvarids = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int));
recsizes = (long *) mxCalloc(MAX_VAR_DIMS, sizeof(long));
datap = (VOIDPP) mxCalloc(MAX_VAR_DIMS, sizeof(VOIDP));
status = ncrecinq(cdfid, & nrecvars, recvarids, recsizes);
if (status == -1) {
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
plhs[1] = Int2Scalar(status);
break;
}
if (nrecvars == 0) {
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
plhs[0] = mxCreateFull(0, 0, REAL);
break;
}
length = 0;
n = 0;
for (i = 0; i < nrecvars; i++) {
ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
length += recsizes[i];
n += (recsizes[i] / nctypelen(datatype));
}
if ((value = (VOIDP) mxCalloc((int) length, sizeof(char))) == NULL) {
status = -1;
plhs[1] = Int2Scalar(status);
break;
}
if (value == NULL) {
status = -1;
plhs[1] = Int2Scalar(status);
break;
}
length = 0;
p = value;
for (i = 0; i < nrecvars; i++) {
datap[i] = p;
p += recsizes[i];
}
if ((status = ncrecget(cdfid, recnum, datap)) == -1) {
plhs[1] = Int2Scalar(status);
break;
}
m = 1;
plhs[0] = mxCreateFull(m, n, REAL);
if (plhs[0] == NULL) {
status = -1;
plhs[1] = Int2Scalar(status);
break;
}
pr = mxGetPr(plhs[0]);
p = (char *) value;
for (i = 0; i < nrecvars; i++) {
status = ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
if (status == -1) {
plhs[1] = Int2Scalar(status);
break;
}
length = recsizes[i] / nctypelen(datatype);
if (autoscale) {
addoffset = Add_Offset(cdfid, recvarids[i]);
scalefactor = Scale_Factor(cdfid, recvarids[i]);
if (scalefactor == 0.0) {
scalefactor = 1.0;
}
}
Convert(opcode, datatype, length, (VOIDP) p, scalefactor, addoffset, pr);
pr += length;
p += recsizes[i];
}
plhs[1] = Int2Scalar(status);
Free ((VOIDPP) & value);
Free ((VOIDPP) & datap);
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
break;
case RECINQ:
recvarids = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int));
recsizes = (long *) mxCalloc(MAX_VAR_DIMS, sizeof(long));
status = ncrecinq(cdfid, & nrecvars, recvarids, recsizes);
if (status != -1) {
for (i = 0; i < nrecvars; i++) {
ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
recsizes[i] /= nctypelen(datatype);
}
m = 1;
n = nrecvars;
plhs[0] = Int2Mat(recvarids, m, n);
plhs[1] = Long2Mat(recsizes, m, n);
}
plhs[2] = Int2Scalar(status);
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
break;
case TYPELEN:
datatype = (nc_type) Parameter(prhs[1]);
len = nctypelen(datatype);
plhs[0] = Int2Scalar(len);
plhs[1] = Int2Scalar((len >= 0) ? 0 : 1);
break;
case SETFILL:
fillmode = Scalar2Int(prhs[1]);
status = ncsetfill(cdfid, fillmode);
plhs[0] = Int2Scalar(status);
plhs[1] = Int2Scalar(0);
break;
case SETOPTS:
plhs[0] = Int2Scalar(ncopts);
plhs[1] = Int2Scalar(0);
ncopts = Scalar2Int(prhs[1]);
break;
case ERR:
plhs[0] = Int2Scalar(ncerr);
ncerr = 0;
plhs[1] = Int2Scalar(0);
break;
case PARAMETER:
if (nrhs > 1) {
plhs[0] = Int2Scalar(Parameter(prhs[1]));
plhs[1] = Int2Scalar(0);
}
else {
i = 0;
while (strcmp(parms[i].name, "NONE") != 0) {
mexPrintf("%12d %s\n", parms[i].code, parms[i].name);
i++;
}
plhs[0] = Int2Scalar(0);
plhs[1] = Int2Scalar(-1);
}
break;
default:
break;
}
return;
}
int ex_put_prop_array (int exoid,
int obj_type,
const char *prop_name,
const int *values)
{
int num_props, i, propid, dimid, dims[1], iresult;
int found = FALSE;
long start[1], count[1], num_obj;
nclong *lptr;
char name[MAX_VAR_NAME_LENGTH+1];
char tmpstr[MAX_STR_LENGTH+1];
char obj_stype[MAX_VAR_NAME_LENGTH+1];
char dim_name[MAX_VAR_NAME_LENGTH+1];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* check if property has already been created */
num_props = ex_get_num_props(exoid, obj_type);
switch (obj_type)
{
case EX_ELEM_BLOCK:
strcpy (obj_stype, VAR_ID_EL_BLK);
strcpy (dim_name, DIM_NUM_EL_BLK);
break;
case EX_NODE_SET:
strcpy (obj_stype, VAR_NS_IDS);
strcpy (dim_name, DIM_NUM_NS);
break;
case EX_SIDE_SET:
strcpy (obj_stype, VAR_SS_IDS);
strcpy (dim_name, DIM_NUM_SS);
break;
case EX_ELEM_MAP:
strcpy (obj_stype, VAR_EM_PROP(1));
strcpy (dim_name, DIM_NUM_EM);
break;
case EX_NODE_MAP:
strcpy (obj_stype, VAR_NM_PROP(1));
strcpy (dim_name, DIM_NUM_NM);
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_put_prop_array",errmsg,exerrval);
return (EX_FATAL);
}
/* inquire id of previously defined dimension (number of objects) */
if ((dimid = ncdimid (exoid, dim_name)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of %s objects in file id %d",
obj_stype, exoid);
ex_err("ex_put_prop_array",errmsg, exerrval);
return (EX_FATAL);
}
/* get number of objects */
if (ncdiminq (exoid, dimid, dim_name, &num_obj) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of %s objects in file id %d",
obj_stype, exoid);
ex_err("ex_put_prop_array",errmsg, exerrval);
return (EX_FATAL);
}
for (i=1; i<=num_props; i++)
{
switch (obj_type){
case EX_ELEM_BLOCK:
strcpy (name, VAR_EB_PROP(i));
break;
case EX_NODE_SET:
strcpy (name, VAR_NS_PROP(i));
break;
case EX_SIDE_SET:
strcpy (name, VAR_SS_PROP(i));
break;
case EX_ELEM_MAP:
strcpy (name, VAR_EM_PROP(i));
break;
case EX_NODE_MAP:
strcpy (name, VAR_NM_PROP(i));
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_put_prop_array",errmsg,exerrval);
return(EX_FATAL);
}
if ((propid = ncvarid (exoid, name)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get property array id in file id %d",
exoid);
ex_err("ex_put_prop_array",errmsg,exerrval);
return (EX_FATAL);
}
/* compare stored attribute name with passed property name */
memset(tmpstr, 0, MAX_STR_LENGTH+1);
if ((ncattget (exoid, propid, ATT_PROP_NAME, tmpstr)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get property name in file id %d", exoid);
ex_err("ex_put_prop_array",errmsg,exerrval);
return (EX_FATAL);
}
if (strcmp(tmpstr, prop_name) == 0)
{
found = TRUE;
break;
}
}
/* if property array has not been created, create it */
if (!found)
{
/* put netcdf file into define mode */
if (ncredef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,"Error: failed to place file id %d into define mode",exoid);
ex_err("ex_put_prop_array",errmsg,exerrval);
return (EX_FATAL);
}
/* create a variable with a name xx_prop#, where # is the new number */
/* of properties */
switch (obj_type){
case EX_ELEM_BLOCK:
strcpy (name, VAR_EB_PROP(num_props+1));
break;
case EX_NODE_SET:
strcpy (name, VAR_NS_PROP(num_props+1));
break;
case EX_SIDE_SET:
strcpy (name, VAR_SS_PROP(num_props+1));
break;
case EX_ELEM_MAP:
strcpy (name, VAR_EM_PROP(num_props+1));
break;
case EX_NODE_MAP:
strcpy (name, VAR_NM_PROP(num_props+1));
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_put_prop_array",errmsg,exerrval);
goto error_ret; /* Exit define mode and return */
}
dims[0] = dimid;
ncsetfill(exoid, NC_FILL); /* fill with zeros per routine spec */
if ((propid = ncvardef (exoid, name, NC_LONG, 1, dims)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to create property array variable in file id %d",
exoid);
ex_err("ex_put_prop_array",errmsg,exerrval);
goto error_ret; /* Exit define mode and return */
}
ncsetfill(exoid, NC_NOFILL); /* default: nofill */
/* store property name as attribute of property array variable */
if ((ncattput (exoid, propid, ATT_PROP_NAME, NC_CHAR,
strlen(prop_name)+1, prop_name)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store property name %s in file id %d",
prop_name,exoid);
ex_err("ex_put_prop_array",errmsg,exerrval);
goto error_ret; /* Exit define mode and return */
}
/* leave define mode */
if (ncendef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to leave define mode in file id %d",
exoid);
ex_err("ex_put_prop_array",errmsg,exerrval);
return (EX_FATAL);
}
}
/* put num_obj values in property array */
/* this contortion is necessary because netCDF is expecting nclongs; fortunately
it's necessary only when ints and nclongs aren't the same size */
start[0] = 0;
count[0] = num_obj;
if (sizeof(int) == sizeof(nclong)) {
iresult = ncvarput (exoid, propid, start, count, values);
} else {
lptr = itol (values, (int)num_obj);
iresult = ncvarput (exoid, propid, start, count, lptr);
free(lptr);
}
if (iresult == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store property values in file id %d",
exoid);
ex_err("ex_put_prop_array",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
ncsetfill(exoid, NC_NOFILL); /* default: nofill */
if (ncendef (exoid) == -1) /* exit define mode */
{
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_prop_array",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_get_init_ext (int exoid,
ex_init_params *info)
{
int dimid;
long lnum_dim, lnum_nodes, lnum_elem, lnum_elem_blk, lnum_node_sets;
long lnum_side_sets, lnum_edge_sets, lnum_face_sets, lnum_elem_sets;
long lnum_node_maps, lnum_edge_maps, lnum_face_maps, lnum_elem_maps;
long lnum_edge, lnum_face, lnum_edge_blk, lnum_face_blk;
char errmsg[MAX_ERR_LENGTH];
int title_len;
nc_type title_type;
exerrval = 0; /* clear error code */
if (ncattinq (exoid, NC_GLOBAL, ATT_TITLE, &title_type, &title_len) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to inquire title in file id %d", exoid);
ex_err("ex_get_init",errmsg,exerrval);
return (EX_FATAL);
}
/* Check title length to avoid overrunning clients memory space;
include trailing null */
if (title_len > MAX_LINE_LENGTH+1) {
sprintf(errmsg,
"Error: Title is too long (%d characters) in file id %d",
title_len-1, exoid);
exerrval = -1;
ex_err("ex_get_init",errmsg,exerrval);
return (EX_FATAL);
}
/* printf("[ex_get_init] title length: %d\n",title_len); */
if (ncattget (exoid, NC_GLOBAL, ATT_TITLE, info->title) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get title in file id %d", exoid);
ex_err("ex_get_init",errmsg,exerrval);
return (EX_FATAL);
}
/* printf("[ex_get_init] title: %s\n",info->title); */
if ((dimid = ncdimid (exoid, DIM_NUM_DIM)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of dimensions in file id %d",
exoid);
ex_err("ex_get_init",errmsg,exerrval);
return (EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &lnum_dim) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of dimensions in file id %d",
exoid);
ex_err("ex_get_init",errmsg,exerrval);
return (EX_FATAL);
}
info->num_dim = lnum_dim;
/* Handle case with zero-nodes */
#define EX_GET_DIM_VALUE(TNAME,DNAME,DIMVAR,LDIMVAL,SDIMVAL) \
if ((DIMVAR = ncdimid (exoid, DNAME)) == -1) { \
/* TNAME are optional and default to zero. */ \
SDIMVAL = 0; \
} else { \
\
if (ncdiminq (exoid, DIMVAR, (char *) 0, &LDIMVAL) == -1) \
{ \
exerrval = ncerr; \
sprintf(errmsg, \
"Error: failed to get number of " TNAME " in file id %d", \
exoid); \
ex_err("ex_get_init",errmsg,exerrval); \
return (EX_FATAL); \
} \
SDIMVAL = LDIMVAL; \
}
EX_GET_DIM_VALUE( "nodes",DIM_NUM_NODES,dimid,lnum_nodes,info->num_nodes);
EX_GET_DIM_VALUE( "edges", DIM_NUM_EDGE,dimid, lnum_edge, info->num_edge);
EX_GET_DIM_VALUE( "faces", DIM_NUM_FACE,dimid, lnum_face, info->num_face);
EX_GET_DIM_VALUE("elements", DIM_NUM_ELEM,dimid, lnum_elem, info->num_elem);
if (info->num_elem > 0) {
if ((dimid = ncdimid (exoid, DIM_NUM_EL_BLK)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of element blocks in file id %d",
exoid);
ex_err("ex_get_init",errmsg,exerrval);
return (EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &lnum_elem_blk) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of element blocks in file id %d",
exoid);
ex_err("ex_get_init",errmsg,exerrval);
return (EX_FATAL);
}
info->num_elem_blk = lnum_elem_blk;
} else {
info->num_elem_blk = 0;
}
EX_GET_DIM_VALUE("node sets", DIM_NUM_NS,dimid,lnum_node_sets,info->num_node_sets);
EX_GET_DIM_VALUE("edge sets", DIM_NUM_ES,dimid,lnum_edge_sets,info->num_edge_sets);
EX_GET_DIM_VALUE("face sets", DIM_NUM_FS,dimid,lnum_face_sets,info->num_face_sets);
EX_GET_DIM_VALUE("side sets", DIM_NUM_SS,dimid,lnum_side_sets,info->num_side_sets);
EX_GET_DIM_VALUE("elem sets",DIM_NUM_ELS,dimid,lnum_elem_sets,info->num_elem_sets);
EX_GET_DIM_VALUE("node maps", DIM_NUM_NM,dimid,lnum_node_maps,info->num_node_maps);
EX_GET_DIM_VALUE("edge maps",DIM_NUM_EDM,dimid,lnum_edge_maps,info->num_edge_maps);
EX_GET_DIM_VALUE("face maps",DIM_NUM_FAM,dimid,lnum_face_maps,info->num_face_maps);
EX_GET_DIM_VALUE("elem maps", DIM_NUM_EM,dimid,lnum_elem_maps,info->num_elem_maps);
/* Edge and face blocks are also optional (for backwards compatability) */
EX_GET_DIM_VALUE("edge blocks",DIM_NUM_ED_BLK,dimid,lnum_edge_blk,info->num_edge_blk);
EX_GET_DIM_VALUE("face blocks",DIM_NUM_FA_BLK,dimid,lnum_face_blk,info->num_face_blk);
return (EX_NOERR);
}
int ex_open (const char *path,
int mode,
int *comp_ws,
int *io_ws,
float *version)
{
int exoid;
nclong file_wordsize;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* set error handling mode to no messages, non-fatal errors */
ex_opts(exoptval); /* call required to set ncopts first time through */
if (mode == EX_READ) /* READ ONLY */
{
#if defined(__LIBCATAMOUNT__)
if ((exoid = ncopen (path, NC_NOWRITE)) < 0)
#else
if ((exoid = ncopen (path, NC_NOWRITE|NC_SHARE)) < 0)
#endif
{
/* NOTE: netCDF returns an id of -1 on an error - but no error code! */
if (ncerr == 0)
exerrval = EX_FATAL;
else
exerrval = ncerr;
sprintf(errmsg,"Error: failed to open %s read only",path);
ex_err("ex_open",errmsg,exerrval);
return(EX_FATAL);
}
}
else if (mode == EX_WRITE) /* READ/WRITE */
{
#if defined(__LIBCATAMOUNT__)
if ((exoid = ncopen (path, NC_WRITE)) < 0)
#else
if ((exoid = ncopen (path, NC_WRITE|NC_SHARE)) < 0)
#endif
{
/* NOTE: netCDF returns an id of -1 on an error - but no error code! */
if (ncerr == 0)
exerrval = EX_FATAL;
else
exerrval = ncerr;
sprintf(errmsg,"Error: failed to open %s write only",path);
ex_err("ex_open",errmsg,exerrval);
return(EX_FATAL);
}
/* turn off automatic filling of netCDF variables */
if (ncsetfill (exoid, NC_NOFILL) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to set nofill mode in file id %d",
exoid);
ex_err("ex_open", errmsg, exerrval);
return (EX_FATAL);
}
}
else
{
exerrval = EX_BADFILEMODE;
sprintf(errmsg,"Error: invalid file open mode: %d",mode);
ex_err("ex_open",errmsg,exerrval);
return (EX_FATAL);
}
/* determine version of EXODUS II file, and the word size of
* floating point values stored in the file
*/
if (ncattget (exoid, NC_GLOBAL, ATT_VERSION, version) == -1)
{
exerrval = ncerr;
sprintf(errmsg,"Error: failed to get database version for file id: %d",
exoid);
ex_err("ex_open",errmsg,exerrval);
return(EX_FATAL);
}
/* check ExodusII file version - old version 1.x files are not supported */
if (*version < 2.0)
{
exerrval = EX_FATAL;
sprintf(errmsg,"Error: Unsupported file version %.2f in file id: %d",
*version, exoid);
ex_err("ex_open",errmsg,exerrval);
return(EX_FATAL);
}
if (ncattget (exoid, NC_GLOBAL, ATT_FLT_WORDSIZE, &file_wordsize) == -1)
{ /* try old (prior to db version 2.02) attribute name */
if (ncattget (exoid,NC_GLOBAL,ATT_FLT_WORDSIZE_BLANK,&file_wordsize) == -1)
{
exerrval = EX_FATAL;
sprintf(errmsg,"Error: failed to get file wordsize from file id: %d",
exoid);
ex_err("ex_open",errmsg,exerrval);
return(exerrval);
}
}
/* initialize floating point size conversion.
*/
if (ex_conv_ini( exoid, comp_ws, io_ws, file_wordsize ) != EX_NOERR ) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: failed to init conversion routines in file id %d",
exoid);
ex_err("ex_open", errmsg, exerrval);
return (EX_FATAL);
}
return (exoid);
}
/* ----------------------------- MNI Header -----------------------------------
@NAME : PutMaxMin
@INPUT : ImInfo - pointer to struct describing the image variable
ImVals - pointer to array of doubles containing the image data
SliceNum, FrameNum - needed to correctly place the max and min
values into the MIimagemax and MIimagemin variables
DoFrames - whether or not there is a time dimension in this file
@OUTPUT : (none)
@RETURNS : (void)
@DESCRIPTION: Finds the max and min values of an image, and puts them
into the MIimagemax and MIimagemin variables associated
with the specified image variable. Note: the caller must
make sure that MIimagemax and MIimagemin exist in the
file, and ensure that ImInfo->MaxID and ImInfo->MinID contain
their variable ID's.
@METHOD :
@GLOBALS :
@CALLS :
@CREATED : 93-6-3, Greg Ward
@MODIFIED :
---------------------------------------------------------------------------- */
void PutMaxMin (ImageInfoRec *ImInfo, double *ImVals,
long SliceNum, long FrameNum,
Boolean DoSlices, Boolean DoFrames)
{
int i;
double Max, Min;
long Coord [2]; /* might use 0, 1 or 2 elements */
int old_ncopts;
int ret;
nc_type range_type;
int range_len;
int update_vr;
double valid_range[2];
double vr_max;
#ifdef DEBUG
int NumDims; /* number of dimensions in imagemax/imagemin */
int Dims [4]; /* dimension ID's of imagemax/imagemin */
printf ("Slice dimension is %d\n", ImInfo->SliceDim);
printf ("Frame dimension is %d\n", ImInfo->FrameDim);
ncvarinq (ImInfo->CDF, ImInfo->MaxID, NULL, NULL, &NumDims, Dims, NULL);
printf ("MIimagemax has %d dimensions: ", NumDims);
for (i = 0; i < NumDims; i++)
{
printf ("%5d", Dims [i]);
}
putchar ('\n');
ncvarinq (ImInfo->CDF, ImInfo->MinID, NULL, NULL, &NumDims, Dims, NULL);
printf ("MIimagemin has %d dimensions: ", NumDims);
for (i = 0; i < NumDims; i++)
{
printf ("%5d", Dims [i]);
}
putchar ('\n');
#endif
Max = - DBL_MAX;
Min = DBL_MAX;
/*
* Find the actual max and min values in the buffer
*/
for (i = 0; i < ImInfo->ImageSize; i++)
{
if (ImVals [i] > Max)
{
Max = ImVals [i];
}
if (ImVals [i] < Min)
{
Min = ImVals [i];
}
} /* for i */
/*
* Now figure out the Coord vector (where to put the max and min
* within the MIimagemax and MIimagemin variables), and put 'em there
*/
if (DoFrames) /* i.e. some frame was specified */
{
Coord [ImInfo->FrameDim] = FrameNum;
}
if (DoSlices)
{
Coord [ImInfo->SliceDim] = SliceNum;
}
#ifdef DEBUG
printf ("Slice %ld, frame %ld: max is %lg, min is %lg\n",
(DoSlices) ? (SliceNum) : -1,
(DoFrames) ? (FrameNum) : -1,
Max, Min);
if (DoSlices && DoFrames)
printf ("Coord vector is: %ld %ld\n", Coord [0], Coord [1]);
#endif
mivarput1 (ImInfo->CDF, ImInfo->MaxID, Coord, NC_DOUBLE, MI_SIGNED, &Max);
mivarput1 (ImInfo->CDF, ImInfo->MinID, Coord, NC_DOUBLE, MI_SIGNED, &Min);
/*
* Update the image valid_range attribute for floating-point volumes
*/
if ((ImInfo->DataType == NC_FLOAT) || (ImInfo->DataType == NC_DOUBLE)) {
/* Get type and length of valid_range attribute */
old_ncopts = ncopts; ncopts = 0;
ret = ncattinq(ImInfo->CDF, ImInfo->ID, MIvalid_range,
&range_type, &range_len);
ncopts = old_ncopts;
/* If type and length are okay, then read in old value and update */
if ((ret != MI_ERROR) &&
(range_type == NC_DOUBLE) && (range_len == 2)) {
(void) ncattget(ImInfo->CDF, ImInfo->ID, MIvalid_range, valid_range);
/* Test for first write of valid range */
vr_max = (ImInfo->DataType == NC_DOUBLE ?
1.79769313e+308 : 3.402e+38);
update_vr = ((valid_range[0] < -vr_max) && (valid_range[1] > vr_max));
/* Check the range */
if ((Min < valid_range[0]) || update_vr)
valid_range[0] = Min;
if ((Max > valid_range[1]) || update_vr)
valid_range[1] = Max;
/* Check for whether float rounding is needed */
if (ImInfo->DataType == NC_FLOAT) {
valid_range[0] = (float) valid_range[0];
valid_range[1] = (float) valid_range[1];
}
/* Write it out */
(void) ncattput(ImInfo->CDF, ImInfo->ID, MIvalid_range,
NC_DOUBLE, 2, valid_range);
}
} /* if DataType is floating-point */
} /* PutMaxMin */
MNCAPI int
minc_load_data(char *path, void *dataptr, int datatype,
long *ct, long *cz, long *cy, long *cx,
double *dt, double *dz, double *dy, double *dx,
void **infoptr)
{
int fd; /* MINC file descriptor */
nc_type nctype; /* netCDF type */
char *signstr; /* MI_SIGNED or MI_UNSIGNED */
int length;
int dim_id[MI_S_NDIMS];
long dim_len[MI_S_NDIMS];
int i, j; /* Generic loop counters */
int var_id;
int var_ndims;
int var_dims[MAX_NC_DIMS];
int icv; /* MINC image conversion variable */
long start[MI_S_NDIMS];
long count[MI_S_NDIMS];
size_t ucount[MI_S_NDIMS];
int dir[MI_S_NDIMS]; /* Dimension "directions" */
int map[MI_S_NDIMS]; /* Dimension mapping */
int old_ncopts; /* For storing the old state of ncopts */
double *p_dtmp;
long *p_ltmp;
struct file_info *p_file;
struct att_info *p_att;
int r; /* Generic return code */
*infoptr = NULL;
fd = miopen(path, NC_NOWRITE);
if (fd < 0) {
return (MINC_STATUS_ERROR);
}
old_ncopts =get_ncopts();
set_ncopts(0);
for (i = 0; i < MI_S_NDIMS; i++) {
dim_id[i] = ncdimid(fd, minc_dimnames[i]);
if (dim_id[i] >= 0) {
ncdiminq(fd, dim_id[i], NULL, &dim_len[i]);
var_id = ncvarid(fd, minc_dimnames[i]);
ncattinq(fd, var_id, MIstep, &nctype, &length);
switch (i) {
case MI_S_T:
p_ltmp = ct;
p_dtmp = dt;
break;
case MI_S_X:
p_ltmp = cx;
p_dtmp = dx;
break;
case MI_S_Y:
p_ltmp = cy;
p_dtmp = dy;
break;
case MI_S_Z:
p_ltmp = cz;
p_dtmp = dz;
break;
default:
return (MINC_STATUS_ERROR);
}
if (nctype == NC_DOUBLE && length == 1) {
ncattget(fd, var_id, MIstep, p_dtmp);
}
else {
*p_dtmp = 0; /* Unknown/not set */
}
*p_ltmp = dim_len[i];
}
else {
dim_len[i] = 0;
}
}
set_ncopts(old_ncopts);
var_id = ncvarid(fd, MIimage);
ncvarinq(fd, var_id, NULL, &nctype, &var_ndims, var_dims, NULL);
if (var_ndims != 3 && var_ndims != 4) {
return (MINC_STATUS_ERROR);
}
/* We want the data to wind up in t, x, y, z order. */
for (i = 0; i < MI_S_NDIMS; i++) {
map[i] = -1;
}
for (i = 0; i < var_ndims; i++) {
if (var_dims[i] == dim_id[MI_S_T]) {
map[MI_S_T] = i;
}
else if (var_dims[i] == dim_id[MI_S_X]) {
map[MI_S_X] = i;
}
else if (var_dims[i] == dim_id[MI_S_Y]) {
map[MI_S_Y] = i;
}
else if (var_dims[i] == dim_id[MI_S_Z]) {
map[MI_S_Z] = i;
}
}
icv = miicv_create();
minc_simple_to_nc_type(datatype, &nctype, &signstr);
miicv_setint(icv, MI_ICV_TYPE, nctype);
miicv_setstr(icv, MI_ICV_SIGN, signstr);
miicv_attach(icv, fd, var_id);
for (i = 0; i < var_ndims; i++) {
start[i] = 0;
}
for (i = 0; i < MI_S_NDIMS; i++) {
if (map[i] >= 0) {
count[map[i]] = dim_len[i];
}
}
r = miicv_get(icv, start, count, dataptr);
if (r < 0) {
return (MINC_STATUS_ERROR);
}
if (map[MI_S_T] >= 0) {
if (*dt < 0) {
dir[MI_S_T] = -1;
*dt = -*dt;
}
else {
dir[MI_S_T] = 1;
}
}
if (map[MI_S_X] >= 0) {
if (*dx < 0) {
dir[MI_S_X] = -1;
*dx = -*dx;
}
else {
dir[MI_S_X] = 1;
}
}
if (map[MI_S_Y] >= 0) {
if (*dy < 0) {
dir[MI_S_Y] = -1;
*dy = -*dy;
}
else {
dir[MI_S_Y] = 1;
}
}
if (map[MI_S_Z] >= 0) {
if (*dz < 0) {
dir[MI_S_Z] = -1;
*dz = -*dz;
}
else {
dir[MI_S_Z] = 1;
}
}
if (var_ndims == 3) {
for (i = 1; i < MI_S_NDIMS; i++) {
map[i-1] = map[i];
dir[i-1] = dir[i];
}
}
j = 0;
for (i = 0; i < MI_S_NDIMS; i++) {
if (dim_len[i] > 0) {
ucount[j++] = dim_len[i];
}
}
restructure_array(var_ndims, dataptr, ucount, nctypelen(nctype),
map, dir);
miicv_detach(icv);
miicv_free(icv);
old_ncopts =get_ncopts();
set_ncopts(0);
/* Generate the complete infoptr array.
* This is essentially an in-memory copy of the variables and attributes
* in the file.
*/
p_file = (struct file_info *) malloc(sizeof (struct file_info));
ncinquire(fd, &p_file->file_ndims, &p_file->file_nvars,
&p_file->file_natts, NULL);
p_file->file_atts = (struct att_info *) malloc(sizeof (struct att_info) *
p_file->file_natts);
p_file->file_vars = (struct var_info *) malloc(sizeof (struct var_info) *
p_file->file_nvars);
for (i = 0; i < p_file->file_natts; i++) {
p_att = &p_file->file_atts[i];
ncattname(fd, NC_GLOBAL, i, p_att->att_name);
ncattinq(fd, NC_GLOBAL,
p_att->att_name,
&p_att->att_type,
&p_att->att_len);
p_att->att_val = malloc(p_att->att_len * nctypelen(p_att->att_type));
ncattget(fd, NC_GLOBAL, p_att->att_name, p_att->att_val);
}
for (i = 0; i < p_file->file_nvars; i++) {
struct var_info *p_var = &p_file->file_vars[i];
ncvarinq(fd, i,
p_var->var_name,
&p_var->var_type,
&p_var->var_ndims,
p_var->var_dims,
&p_var->var_natts);
p_var->var_atts = malloc(p_var->var_natts *
sizeof (struct att_info));
if (ncdimid(fd, p_var->var_name) >= 0) {
/* It's a dimension variable, have to treat it specially... */
}
for (j = 0; j < p_var->var_natts; j++) {
p_att = &p_var->var_atts[j];
ncattname(fd, i, j, p_att->att_name);
ncattinq(fd, i,
p_att->att_name,
&p_att->att_type,
&p_att->att_len);
p_att->att_val = malloc(p_att->att_len * nctypelen(p_att->att_type));
ncattget(fd, i, p_att->att_name, p_att->att_val);
}
}
*infoptr = p_file;
set_ncopts(old_ncopts);
miclose(fd);
return (MINC_STATUS_OK);
}
/* Open an input netCDF file and get some information about it */
int process_ncinfile(char *ncname, unsigned char appendnc, int outncfid,
char *outncname, int *nfiles, unsigned char verbose)
{
struct fileinfo ncinfile; /* Information about an input netCDF file */
int nfiles2; /* Number of files in the decomposed domain */
int d, v, n; /* Loop variables */
int dimid; /* ID of a dimension */
int decomp[4]; /* "domain_decomposition" information */
char attname[MAX_NC_NAME]; /* Name of a global or variable attribute */
unsigned char ncinfileerror=0; /* Were there any file errors? */
/* Open an input netCDF file; return if not openable - possibly IEEE */
if ((ncinfile.ncfid=ncopen(ncname,NC_NOWRITE))==(-1)) return(2);
/* Determine the number of files in the decomposed domain */
if (ncattget(ncinfile.ncfid,NC_GLOBAL,"NumFilesInSet",
(void *)&nfiles2)==(-1))
{
if (*nfiles==1)
{
fprintf(stderr,"Error: missing the \"NumFilesInSet\" global attribute!\n");
return(1);
}
else if (*nfiles==(-1))
{
fprintf(stderr,"Warning: missing the \"NumFilesInSet\" global attribute.\n");
}
}
*nfiles=nfiles2;
/* Get some general information about the input netCDF file */
if (ncinquire(ncinfile.ncfid,&(ncinfile.ndims),&(ncinfile.nvars),
&(ncinfile.ngatts),&(ncinfile.recdim))==(-1))
{
fprintf(stderr,"Error: cannot read the file's metadata!\n");
ncclose(ncinfile.ncfid);
return(1);
}
/* Get some information about the dimensions */
for (d=0; d < ncinfile.ndims; d++)
{
if ((ncdiminq(ncinfile.ncfid,d,ncinfile.dimname[d],
&(ncinfile.dimsize[d])))==(-1))
{
fprintf(stderr,"Error: cannot read dimension #%d's metadata!\n",d);
ncclose(ncinfile.ncfid);
return(1);
}
ncinfile.dimfullsize[d]=ncinfile.dimsize[d];
ncinfile.dimstart[d]=1;
ncinfile.dimend[d]=(-1);
}
/* Get some information about the variables */
for (v=0; v < ncinfile.nvars; v++)
{
if ((ncvarinq(ncinfile.ncfid,v,ncinfile.varname[v],
&(ncinfile.datatype[v]),&(ncinfile.varndims[v]),
ncinfile.vardim[v],&(ncinfile.natts[v])))==(-1))
{
fprintf(stderr,"Error: cannot read variable #%d's metadata!\n",v);
ncclose(ncinfile.ncfid);
return(1);
}
/* If the variable is also a dimension then get decomposition info */
if ((dimid=ncdimid(ncinfile.ncfid,ncinfile.varname[v]))!=(-1))
{
if (ncattget(ncinfile.ncfid,v,"domain_decomposition",
(void *)decomp)!=(-1))
{
ncinfile.dimfullsize[dimid]=decomp[1]-decomp[0]+1;
ncinfile.dimstart[dimid]=decomp[2]-(decomp[0]-1);
ncinfile.dimend[dimid]=decomp[3]-(decomp[0]-1);
}
else
{
ncinfile.dimfullsize[dimid]=ncinfile.dimsize[dimid];
ncinfile.dimstart[dimid]=1;
ncinfile.dimend[dimid]=(-1);
}
}
}
#if DEBUG==1
print_debug(&ncinfile,verbose);
#endif
/* If the output netCDF file was just created then define its structure */
if (!appendnc)
{
#if DEBUG==1
printf("Creating output netCDF file... \"%s\"\n",outncname);
#endif
/* Define the dimensions */
for (d=0; d < ncinfile.ndims; d++)
{
if (d==ncinfile.recdim)
ncdimdef(outncfid,ncinfile.dimname[d],NC_UNLIMITED);
else ncdimdef(outncfid,ncinfile.dimname[d],ncinfile.dimfullsize[d]);
}
/* Define the variables and copy their attributes */
for (v=0; v < ncinfile.nvars; v++)
{
ncvardef(outncfid,ncinfile.varname[v],ncinfile.datatype[v],
ncinfile.varndims[v],ncinfile.vardim[v]);
for (n=0; n < ncinfile.natts[v]; n++)
{
ncattname(ncinfile.ncfid,v,n,attname);
if (!strcmp(attname,"domain_decomposition")) continue;
else
{
if (ncattcopy(ncinfile.ncfid,v,attname,outncfid,v)==(-1))
{
fprintf(stderr,"Error: cannot copy variable \"%s\"'s attributes!\n",
ncinfile.varname[v]);
return(1);
}
}
}
}
/* Copy the global attributes */
for (n=0; n < ncinfile.ngatts; n++)
{
ncattname(ncinfile.ncfid,NC_GLOBAL,n,attname);
if (!strcmp(attname,"NumFilesInSet")) continue;
else if (!strcmp(attname,"filename"))
ncattput(outncfid,NC_GLOBAL,attname,NC_CHAR,strlen(outncname),
(void *)outncname);
else
{
if (ncattcopy(ncinfile.ncfid,NC_GLOBAL,attname,outncfid,
NC_GLOBAL)==(-1))
{
fprintf(stderr,"Error: cannot copy the file's global attributes!\n");
return(1);
}
}
}
/* Definitions done */
ncendef(outncfid);
}
/* Copy all the data values of the dimensions and variables */
ncinfileerror=copy_nc_data(&ncinfile,outncfid,appendnc,verbose);
/* Done */
ncclose(ncinfile.ncfid);
return(ncinfileerror);
}
int ex_get_block( int exoid,
int blk_type,
int blk_id,
char* elem_type,
int* num_entries_this_blk,
int* num_nodes_per_entry,
int* num_edges_per_entry,
int* num_faces_per_entry,
int* num_attr_per_entry )
{
int dimid, connid, len, blk_id_ndx;
long lnum_entries_this_blk, lnum_nodes_per_entry, lnum_attr_per_entry;
long lnum_edges_per_entry, lnum_faces_per_entry;
char *ptr;
char errmsg[MAX_ERR_LENGTH];
nc_type dummy;
const char* tname;
const char* dnument;
const char* dnumnod;
const char* dnumedg;
const char* dnumfac;
const char* dnumatt;
const char* ablknam;
const char* vblkcon;
const char* vblkids;
exerrval = 0;
/* First, locate index of element block id in VAR_ID_EL_BLK array */
switch (blk_type) {
case EX_EDGE_BLOCK:
tname = "edge";
vblkids = VAR_ID_ED_BLK;
blk_id_ndx = ex_id_lkup(exoid,vblkids,blk_id);
dnument = DIM_NUM_ED_IN_EBLK(blk_id_ndx);
dnumnod = DIM_NUM_NOD_PER_ED(blk_id_ndx);
dnumedg = 0;
dnumfac = 0;
dnumatt = DIM_NUM_ATT_IN_EBLK(blk_id_ndx);
vblkcon = VAR_EBCONN(blk_id_ndx);
ablknam = ATT_NAME_ELB;
break;
case EX_FACE_BLOCK:
tname = "face";
vblkids = VAR_ID_FA_BLK;
blk_id_ndx = ex_id_lkup(exoid,vblkids,blk_id);
dnument = DIM_NUM_FA_IN_FBLK(blk_id_ndx);
dnumnod = DIM_NUM_NOD_PER_FA(blk_id_ndx);
dnumedg = 0; /* it is possible this might be non-NULL some day */
dnumfac = 0;
dnumatt = DIM_NUM_ATT_IN_FBLK(blk_id_ndx);
vblkcon = VAR_FBCONN(blk_id_ndx);
ablknam = ATT_NAME_ELB;
break;
case EX_ELEM_BLOCK:
tname = "element";
vblkids = VAR_ID_EL_BLK;
blk_id_ndx = ex_id_lkup(exoid,vblkids,blk_id);
dnument = DIM_NUM_EL_IN_BLK(blk_id_ndx);
dnumnod = DIM_NUM_NOD_PER_EL(blk_id_ndx);
dnumedg = DIM_NUM_EDG_PER_EL(blk_id_ndx);
dnumfac = DIM_NUM_FAC_PER_EL(blk_id_ndx);
dnumatt = DIM_NUM_ATT_IN_BLK(blk_id_ndx);
vblkcon = VAR_CONN(blk_id_ndx);
ablknam = ATT_NAME_ELB;
break;
default:
exerrval = EX_BADPARAM;
sprintf( errmsg, "Bad block type parameter (%d) specified for file id %d.",
blk_type, exoid );
return (EX_FATAL);
}
if (exerrval != 0)
{
if (exerrval == EX_NULLENTITY) /* NULL element block? */
{
if ( elem_type )
strcpy(elem_type, "NULL"); /* NULL element type name */
*num_entries_this_blk = 0; /* no elements */
*num_nodes_per_entry = 0; /* no nodes */
*num_attr_per_entry = 0; /* no attributes */
return (EX_NOERR);
}
else
{
sprintf(errmsg,
"Error: failed to locate element block id %d in %s array in file id %d",
blk_id,vblkids,exoid);
ex_err("ex_get_block",errmsg,exerrval);
return (EX_FATAL);
}
}
/* inquire values of some dimensions */
if ( num_entries_this_blk )
{
if ((dimid = ncdimid (exoid, dnument)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of %ss in block %d in file id %d",
tname,blk_id,exoid);
ex_err("ex_get_block",errmsg, exerrval);
return(EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &lnum_entries_this_blk) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of %ss in block %d in file id %d",
tname,blk_id, exoid);
ex_err("ex_get_block",errmsg, exerrval);
return(EX_FATAL);
}
*num_entries_this_blk = lnum_entries_this_blk;
}
if ( num_nodes_per_entry )
{
if ((dimid = ncdimid (exoid, dnumnod)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of nodes/%s in block %d in file id %d",
tname,blk_id,exoid);
ex_err("ex_get_block",errmsg, exerrval);
return(EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &lnum_nodes_per_entry) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of nodes/%s in block %d in file id %d",
tname,blk_id, exoid);
ex_err("ex_get_block",errmsg, exerrval);
return(EX_FATAL);
}
*num_nodes_per_entry = lnum_nodes_per_entry;
}
if ( num_edges_per_entry )
{
if ( blk_type != EX_ELEM_BLOCK )
{
exerrval = (EX_WARN);
sprintf(errmsg,
"Warning: non-NULL pointer passed to num_edges_per_entry for %s block query in file id %d",
tname,exoid);
ex_err("ex_get_block",errmsg,exerrval);
}
else
{
if ((dimid = ncdimid (exoid, dnumedg)) == -1)
{
/* undefined => no edge entries per element */
lnum_edges_per_entry = 0;
}
else
{
if (ncdiminq (exoid, dimid, (char *) 0, &lnum_edges_per_entry) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of edges/%s in block %d in file id %d",
tname,blk_id, exoid);
ex_err("ex_get_block",errmsg, exerrval);
return(EX_FATAL);
}
}
*num_edges_per_entry = lnum_edges_per_entry;
}
}
if ( num_faces_per_entry )
{
if ( blk_type != EX_ELEM_BLOCK )
{
exerrval = (EX_WARN);
sprintf(errmsg,
"Warning: non-NULL pointer passed to num_faces_per_entry for %s block query in file id %d",
tname,exoid);
ex_err("ex_get_block",errmsg,exerrval);
}
else
{
if ((dimid = ncdimid (exoid, dnumfac)) == -1)
{
/* undefined => no face entries per element */
lnum_faces_per_entry = 0;
}
else
{
if (ncdiminq (exoid, dimid, (char *) 0, &lnum_faces_per_entry) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of faces/%s in block %d in file id %d",
tname,blk_id, exoid);
ex_err("ex_get_block",errmsg, exerrval);
return(EX_FATAL);
}
}
*num_faces_per_entry = lnum_faces_per_entry;
}
}
if ( num_attr_per_entry )
{
if ((dimid = ncdimid (exoid, dnumatt)) == -1)
{
/* dimension is undefined */
*num_attr_per_entry = 0;
}
else
{
if (ncdiminq (exoid, dimid, (char *) 0, &lnum_attr_per_entry) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of attributes in %s block %d in file id %d",
tname,blk_id, exoid);
ex_err("ex_get_block",errmsg, exerrval);
return(EX_FATAL);
}
*num_attr_per_entry = lnum_attr_per_entry;
}
}
if ( elem_type )
{
/* look up connectivity array for this element block id */
if ((connid = ncvarid (exoid, vblkcon)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate connectivity array for element block %d in file id %d",
blk_id,exoid);
ex_err("ex_get_block",errmsg, exerrval);
return(EX_FATAL);
}
if (ncattinq (exoid, connid, ablknam, &dummy, &len) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get element block %d type in file id %d",
blk_id,exoid);
ex_err("ex_get_block",errmsg, exerrval);
return(EX_FATAL);
}
if (len > (MAX_STR_LENGTH+1))
{
len = MAX_STR_LENGTH;
sprintf (errmsg,
"Warning: element block %d type will be truncated to %d chars",
blk_id,len);
ex_err("ex_get_block",errmsg,EX_MSG);
}
/* get the element type name */
if (ncattget (exoid, connid, ablknam, elem_type) == -1)
{
exerrval = ncerr;
sprintf(errmsg,"Error: failed to get element block %d type in file id %d",
blk_id, exoid);
ex_err("ex_get_block",errmsg, exerrval);
return(EX_FATAL);
}
/* get rid of trailing blanks */
ptr = elem_type;
/* fprintf(stderr,"[exgblk] %s, len: %d\n",ptr,len); */
while (ptr < elem_type + len && *ptr != ' ')
{
ptr++;
}
*(ptr) = '\0';
}
return (EX_NOERR);
}