MNCAPI int
MI2varputg(int fd, int varid, const long *startp, const long *countp,
const long *stridep, const long *imapp, const void *valp)
{
if (MI2_ISH5OBJ(fd)) {
return (hdf_varputg(fd, varid, startp, countp, stridep, imapp, valp));
}
else {
return (ncvarputg(fd, varid, startp, countp, stridep, imapp, valp));
}
}
/* ----------------------------- MNI Header -----------------------------------
@NAME : copy_the_chunk
@INPUT : reshape_info - information for reshaping volume
chunk_start - start of current block
chunk_count - count for current block
chunk_data - pointer to enough space for chunk
fillvalue - pixel value to zero volume, if necessary.
@OUTPUT : (none)
@RETURNS : (nothing)
@DESCRIPTION: Copies the chunk from the input file to the output file.
@METHOD :
@GLOBALS :
@CALLS :
@CREATED : October 25, 1994 (Peter Neelin)
@MODIFIED :
---------------------------------------------------------------------------- */
static void copy_the_chunk(Reshape_info *reshape_info,
long chunk_start[],
long chunk_count[],
void *chunk_data,
double fillvalue)
{
int idim, odim, in_ndims, out_ndims;
long input_start[MAX_VAR_DIMS], input_count[MAX_VAR_DIMS];
long output_start[MAX_VAR_DIMS], output_count[MAX_VAR_DIMS];
long input_imap[MAX_VAR_DIMS], output_imap[MAX_VAR_DIMS];
void *output_origin;
int datatype_size;
long total_size, ipix, first, last;
int zero_data, really_copy_the_data;
union {
char c; short s; long l; float f; double d;
} value_buffer;
/* Get number of dimensions */
out_ndims = reshape_info->output_ndims;
in_ndims = reshape_info->input_ndims;
/* Get size of output datatype */
datatype_size = nctypelen(reshape_info->output_datatype);
/* Create input start and count */
translate_output_to_input(reshape_info, chunk_start, chunk_count,
input_start, input_count);
/* Find out if we need to zero the volume and if we need to copy any
data */
zero_data = FALSE;
really_copy_the_data = TRUE;
total_size = 1;
for (idim=0; idim < in_ndims; idim++) {
first = input_start[idim];
last = input_start[idim] + input_count[idim] - 1;
if ((first < 0) || (last >= reshape_info->input_size[idim]))
zero_data = TRUE;
if ((last < 0) || (first >= reshape_info->input_size[idim]))
really_copy_the_data = FALSE;
total_size *= input_count[idim];
}
/* Make sure that input vectors are legal and translate them back
to output */
truncate_input_vectors(reshape_info, input_start, input_count);
translate_input_to_output(reshape_info, input_start, input_count,
output_start, output_count);
/* Write out zero data if needed */
if (zero_data) {
convert_value_from_double(fillvalue,
reshape_info->output_datatype,
reshape_info->output_is_signed,
&value_buffer);
for (ipix=0; ipix < total_size; ipix++) {
(void) memcpy((char *)chunk_data + ipix*datatype_size,
&value_buffer, datatype_size);
}
(void) ncvarput(reshape_info->outmincid, reshape_info->outimgid,
chunk_start, chunk_count, chunk_data);
}
/* Set up hypothetical imap variable for input */
for (idim=in_ndims-1; idim >= 0; idim--) {
input_imap[idim] = ((idim == in_ndims-1) ?
datatype_size :
input_imap[idim+1] * input_count[idim+1]);
}
/* Create output imap variable from input one (re-ordering dimensions and
flipping). Also work out the chunk origin (point to byte for output
[0,0,0...]). */
output_origin = chunk_data;
for (odim=0; odim < out_ndims; odim++) {
idim = reshape_info->map_out_to_in[odim];
if (reshape_info->input_count[idim] > 0) {
output_imap[odim] = input_imap[idim];
}
else {
output_imap[odim] = -input_imap[idim];
output_origin =
(void *) ((char *)output_origin -
(output_count[odim] - 1) * output_imap[odim]);
}
}
/* Should we really copy the data? */
if (really_copy_the_data) {
/* Read in the data */
(void) miicv_get(reshape_info->icvid, input_start, input_count,
chunk_data);
/* Write it out */
(void) ncvarputg(reshape_info->outmincid, reshape_info->outimgid,
output_start, output_count, NULL, output_imap,
output_origin);
}
}
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;
}