Error m_SXRegrid( Object *in, Object *out ){ /* *+ * Name: * SXRegrid * Purpose: * samples a field at positions defined by a another field * Language: * ANSI C * Syntax: * output = SXRegrid( input, grid, nearest, radius, scale, exponent, * coexp, type ); * Classification: * Realisation * Description: * The SXRegrid module samples the "data" component of the "input" * field at the positions held in the "positions" component of the * "grid" field. It is similar to the standard "Regrid" module, but * provides more versatility in assigning weights to each input position, * the option of returning the sums of the weights or the weighted sum * instead of the weighted mean, and seems to be much faster. Both * supplied fields can hold scattered or regularly gridded points, and * need not contain "connections" components. The "data" component in the * "input" field must depend on "positions". * * For each grid position, a set of near-by positions in the input * field are found (using "nearest" and "radius"). Each of these input * positions is given a weight dependant on its distance from the current * grid position. The output data value (defined at the grid position) can * be the weighted mean or weighted sum of these input data values, or * the sum of the weights (selected by "type"). * * The weight for each input position is of the form: * * (d/d0)**exponent * * where "d" is the distance from the current grid position to the * current input position. If a single value is given for "scale" then * that value is used for the d0 constant for all the near-by input * positions. If more than 1 value is given for "scale" then the first * value is used for the closest input position, the second value for the * next closest, etc. The last supplied value is used for any remaining * input positions. A value of zero for "scale" causes the * corresponding input position to be given zero weight. * * If "coexp" is not zero, then the above weights are modified to * become: * * exp( coexp*( (d/d0)**exponent ) ) * * If "nearest" is given an integer value, it specifies N, the maximum * number of near-by input positions to use for each output position. * The N input positions which are closest to the output position are * used. If the string "infinity" is given, then all input positions * closer than the distance given by "radius" are used. Using "radius", * you may specify a maximum radius (from the output position) within * which to find the near-by input positions. If the string "infinity" * is given for "radius" then no limit is placed on the radius. * Parameters: * input = field (Given) * field or group with positions to regrid [none] * grid = field (Given) * grid to use as template [none] * nearest = integer or string (Given) * number of nearest neighbours to use, or "infinity" [1] * radius = scalar or string (Given) * radius from grid point to consider, or "infinity" ["infinity"] * scale = scalar or vector or scalar list (Given) * scale lengths for weights [1.0] * exponent = scalar (Given) * weighting exponent [1.0] * coexp = scalar (Given) * exponential co-efficient for weights [0.0] * type = integer (Given) * type of output values required: 0 - weighted mean, 1 - weighted sum, * 2 - sum of weights [0] * output = field (Returned) * regridded field * Components: * All components except the "data" component are copied from the "grid" * field. The output "data" component added by this module depends on * "positions". An "invalid positions" component is added if any output * data values could not be calculated (e.g. if there are no near-by input * data values to define the weighted mean, or if the weights are too * large to be represented, or if the input grid position was invalid). * Examples: * This example maps the scattered data described in "CO2.general" onto a * regular grid, and displays it. SXRegrid is used to find the data value * at the nearest input position to each grid position. * * input = Import("/usr/lpp/dx/samples/data/CO2.general")$ * frame17 = Select(input,17); * camera = AutoCamera(frame17); * grid = Construct([-100,-170],deltas=[10,10],counts=[19,34]); * regrid = SXRegrid(frame17,grid); * coloured = AutoColor(regrid); * Display(coloured,camera); * * The next example produces a grid containing an estimate of the density * of the scattered points (i.e. the number of points per unit area). The * positions of the original scattered points are shown as dim grey * circles. SXRegrid finds the 5 closest input positions at each grid * position. Zero weight is given to the closest 3 positions. The fourth * position has a weight which is half the density of the points within the * circle passing through the fourth point (i.e. if the fourth point * is at a distance D from the current grid position, there are 3 points * within a circle of radius D, so the density within that circle is * 3/(PI*(D**2)) ). The fifth position has a weight which is half the * density of the points within the circle passing through the fifth * point. The output data value is the sum of the weights (because * "type" is set to 2), which is the mean of the densities within the * circles touching the fourth and fifth points. * * input = Import("/usr/lpp/dx/samples/data/CO2.general")$ * frame17 = Select(input,17); * camera = AutoCamera(frame17); * glyphs=AutoGlyph(frame17,scale=0.1,ratio=1); * glyphs=Color(glyphs,"dim grey"); * grid = Construct([-100,-170],deltas=[10,10],counts=[19,34]); * density=SXRegrid(frame17,grid,nearest=5,scale=[0,0,0,0.691,0.798], * exponent=-2,type=2); * coloured = AutoColor(density); * collected=Collect(coloured,glyphs); * Display(collected,camera); * See Also: * SXBin, ReGrid, Map, Construct * Returned Value: * OK, unless an error occurs in which case ERROR is returned and the * DX error code is set. * Copyright: * Copyright (C) 1995 Central Laboratory of the Research Councils. * All Rights Reserved. * Licence: * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of * the License, or (at your option) any later version. * * This program is distributed in the hope that it will be * useful,but WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR * PURPOSE. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street,Fifth Floor, Boston, MA * 02110-1301, USA * Authors: * DSB: David Berry (STARLINK) * {enter_new_authors_here} * History: * 3-OCT-1995 (DSB): * Original version * {enter_further_changes_here} * Bugs: * {note_any_bugs_here} *- */ /* Local Variables: */ Category cat; /* Array category type */ float coexp; /* Exponential co-efficient for weights */ Type dtype; /* Type of current input data array */ float ext; /* Amount by which to extend grid bounds */ int fld; /* Field counter */ Object grid; /* The grid object */ float *gridpos; /* Pointer to grid positions array */ int i; /* Loop count */ void *indata[MAXFLD];/* Pointer to input data array */ float *inpos; /* Pointer to input positions array */ Array inpos_array; /* Input positions array */ Object input; /* A copy of the input object */ int iopt; /* Index of selected option */ int j; /* Loop count */ float lbnd[3]; /* Lower bounds of grid */ char *opt; /* Textual option for a parameter value */ float radius; /* Max. radius for contributing input positions */ char more; /* Are there more input fields to do? */ int nearest; /* Max. no. of input positions which can contribute to an output position */ Fpair *next; /* The next Fpair structure in the linked list */ int ndim; /* No. of dimensions in grid positions array */ int nfld; /* No. of fields sharing current positions array */ int npos; /* No. of input positions */ int npindim; /* No. of dimensions in input positions array */ int nsamp; /* No. of grid positions */ int nscale; /* No. of scale distances supplied */ int outbad[MAXFLD];/* No. of invalid output positions in each field*/ void *outdata[MAXFLD];/* Pointers to output data arrays */ Array outdata_array;/* Output data array */ Object output; /* The output object */ int outtype; /* Type of output values required */ float exponent; /* Power for weights */ int rank; /* Array rank */ float rsc; /* Reciprocal squared scale distance*/ float *rscale; /* Scale distances for weights */ int tag; /* The tag for the current input positions array */ Type type; /* Array numeric type */ float ubnd[3]; /* Upper bounds of grid */ int veclen[MAXFLD];/* Dimensionality of each input data array */ /* Initialise all created objects so that they can safely be deleted if * an error occurs. */ input = NULL; output = NULL; grid = NULL; outdata_array = NULL; /* Check that the "input" object has been supplied. */ if( !in[0] ) { DXSetError( ERROR_BAD_PARAMETER, "missing parameter \"input\"." ); goto error; } /* Remove (cull) all invalid positions and connections from the input. It is * necessary to take a copy of the input first, because the input object * itself cannot be modified. */ input = DXCopy( in[0], COPY_STRUCTURE ); if( !DXCull( input ) ) goto error; /* Check that the "grid" object has been supplied. */ if( !in[1] ) { DXSetError( ERROR_BAD_PARAMETER, "missing parameter \"grid\"." ); goto error; } /* Get a pointer to an array holding the grid positions, and get the * size and shape of the grid. Any invalid positions are flagged with the * value FLT_MAX (defined in float.h). */ gridpos = SXGetGrid( in[1], &nsamp, &ndim, lbnd, ubnd, &grid ); if( !gridpos ) goto error; /* Get the number of input positions allowed to contribute to each * output position. */ if( !in[2] ){ nearest = 1; } else { opt = "infinity"; if( !SXGet0is( "nearest", in[2], INT_MAX, 1, 1, &opt, &nearest, &iopt ) ) goto error; if( iopt == 0 ) nearest = INT_MAX; } /* Get the maximum radius for input positions which contribute to each * output position. */ if( !in[3] ){ radius = FLT_MAX; } else { opt = "infinity"; if( !SXGet0rs( "radius", in[3], FLT_MAX, 0.0, 1, &opt, &radius, &iopt ) ) goto error; if( iopt == 0 ) radius = FLT_MAX; } /* If a maximum radius has been given, extend the bounds by one radius * at each end to catch some extra input positions. Otherwise, extend * the bounds by 10%. */ if( radius < FLT_MAX ){ for( j=0; j<ndim; j++ ){ lbnd[j] -= radius; ubnd[j] += radius; } } else { for( j=0; j<ndim; j++ ){ ext = 0.1*( ubnd[j] - lbnd[j] ); lbnd[j] -= ext; ubnd[j] += ext; } } /* Get the scale distances used to create weights for each input * position. Convert them to squared reciprocal scale distances. If * no value is supplied for the "scale" parameter, use a single scale * length of 1.0 */ if( !in[4] ){ rsc = 1.0; rscale = &rsc; nscale = 1; } else { rscale = SXGet1r( "scale", in[4], &nscale ); if( !rscale ) goto error; for( i=0; i<nscale; i++ ) { rsc = rscale[i]; if( rsc != 0.0 ){ rscale[i] = 1.0/(rsc*rsc); } else { rscale[i] = 0.0; } } } /* Get the exponent used to create weights for each input position. */ if( !in[5] ){ exponent = 1.0; } else { if( !SXGet0rs( "exponent", in[5], FLT_MAX, -FLT_MAX, 0, &opt, &exponent, &iopt ) ) goto error; } /* Get the co-efficient to used in the exponential when creating weights for * each input position. */ if( !in[6] ){ coexp = 0.0; } else { if( !SXGet0rs( "coexp", in[6], FLT_MAX, -FLT_MAX, 0, &opt, &coexp, &iopt ) ) goto error; } /* Get the type of output value required. */ if( !in[7] ){ outtype = 0; } else { if( !SXGet0is( "type", in[7], 2, 0, 0, &opt, &outtype, &iopt ) ) goto error; } /* Produce a copy of the "input" object to use as the output, replacing all * fields within it with the grid field. Also form a linked list of Fpair * structures describing the fields. */ output = SXMakeOut( input, (Field) grid, 1, 1, 3, "positions" ); if( !output ) goto error; /* Abort if no fields were found. */ if( !head ) { DXSetError( ERROR_DATA_INVALID, "no fields found in \"input\"." ); goto error; } /* Go through the list of fields looking for fields which share the same * positions component. */ more = 1; while( more ){ /* Find the first field with a non-zero positions tag. */ next = head; while( next && !next->postag ) next = next->next; /* If no non-zero positions tags were found, we've finished. */ if( !next ){ more = 0; break; } /* Find the input positions array. Get its shape, size and type. Check it is * usable. */ inpos_array = (Array) next->pos; if( !DXGetArrayInfo( inpos_array, &npos, &type, &cat, &rank, &npindim ) ) goto error; if( type != TYPE_FLOAT ){ DXSetError( ERROR_DATA_INVALID, "positions component in \"input\" is not of type FLOAT." ); goto error; } if( cat != CATEGORY_REAL ){ DXSetError( ERROR_DATA_INVALID, "positions component in \"input\" is not of category REAL." ); goto error; } if( rank > 1 ){ DXSetError( ERROR_DATA_INVALID, "rank %d positions component found in \"input\".", rank ); goto error; } if( rank == 0 ){ /* Scalar data is equivalent to 1-d vector data */ rank = 1; npindim = 1; } if( npindim != ndim ){ DXSetError( ERROR_DATA_INVALID, "dimensionality of \"input\" (%d) does not match \"grid\" (%d).", npindim, ndim ); goto error; } /* Get a pointer to the positions values. */ inpos = (float *) DXGetArrayData( inpos_array ); /* Find all fields which have the same positions tag and the same data * type. */ tag = next->postag; dtype = next->datatype; nfld = 0; while( next ){ if( next->postag == tag && next->datatype == dtype ){ /* Increment the number of fields found so far which share this * positions component. */ nfld++; if( nfld > MAXFLD ){ DXSetError( ERROR_MAX, "\"input\" has too many fields.", MAXFLD ); goto error; } /* Store a pointer to the input data array, and its dimensionality. */ indata[nfld-1] = (void *) DXGetArrayData( (Array) next->data ); veclen[nfld-1] = next->datalen; /* Make a new array to hold the output data values. The output data will * have the same dimensionality as the input data unless the required output * data is "sum of weights" (i.e. if parameter "type" is 2), in which case the * output data will be scalar. */ if( outtype == 2 ) veclen[nfld-1] = 1; outdata_array = DXNewArrayV( dtype, CATEGORY_REAL, 1, &veclen[nfld-1] ); if( !outdata_array ) goto error; if( !DXAddArrayData( outdata_array, 0, nsamp, NULL ) ) goto error; /* Get a pointer to the output data array. */ outdata[nfld-1] = (void *) DXGetArrayData( outdata_array ); if( !outdata[nfld-1] ) goto error; /* Place the new data component in the output field, and indicate that * it now does not need to be deleted explicitly in the event of an error. */ if( !DXSetComponentValue( next->outfld, "data", (Object) outdata_array ) ) goto error; outdata_array = NULL; /* Indicate that the data component of the output field has been * changed. */ DXChangedComponentValues( next->outfld, "data" ); /* Indicate that the data values are dependant on positions. */ if( !DXSetComponentAttribute( next->outfld, "data", "dep", (Object) DXNewString("positions")) ) goto error; } next = next->next; } /* Now sample the input data arrays at the output positions, storing the * resulting sample values in the output data arrays. */ if( dtype == TYPE_FLOAT ){ if( ! SXSampleF( nfld, ndim, veclen, npos, inpos, (float **)indata, nsamp, gridpos, (float **) outdata, lbnd, ubnd, nearest, radius, rscale, nscale, exponent, coexp, outtype, outbad ) ) goto error; } else { if( ! SXSampleD( nfld, ndim, veclen, npos, inpos, (double **)indata, nsamp, gridpos, (double **) outdata, lbnd, ubnd, nearest, radius, rscale, nscale, exponent, coexp, outtype, outbad ) ) goto error; } /* Loop round all the fields that have just been created. */ next = head; fld = 0; while( next ){ if( next->postag == tag ){ /* Create invalid positions components in each output field which have any * undefined data values */ if( outbad[fld] ){ if( dtype == TYPE_FLOAT ){ if( !SXSetInvPosF( (Object) next->outfld, nsamp, veclen[fld], (float *) outdata[fld], "positions" ) ) goto error; } else { if( !SXSetInvPosD( (Object) next->outfld, nsamp, veclen[fld], (double *) outdata[fld], "positions" ) ) goto error; } } /* Complete the construction of this output field. */ DXEndField( next->outfld ); /* Increment the field index, and indicate that this input field has * been done. */ fld++; next->postag = 0; } next = next->next; } } error: /* Free the storage used to hold the link list of Fpair structures * describing the fields in the "input" object. */ while( head ){ next = head->next; DXFree( (Pointer) head ); head = next; } /* Delete the copy of the input objects. Return the "output" object with a good status. */ DXDelete( grid ); DXDelete( input ); /* If all is OK, return the "output" object with a good status. */ if( DXGetError() == ERROR_NONE ){ out[0] = output; return( OK ); /* If an error has occurred, ensure temporary objects are deleted and return * with a bad status. */ } else { DXDelete( (Object) outdata_array ); DXDelete( output ); return( ERROR ); } }
/* item[n] = start + n * delta */ static Array MakeLinearList(Array start, Array end, int *n, Array delta) { int i, j; Array a_start = NULL, a_end = NULL, a_delta = NULL; int delstart = 0, delend = 0, deldelta = 0; Array alist[3]; Array output = NULL; int count = 1; int bytes; Type t; Category c; int rank; int shape[MAXSHAPE]; int nitems; int i_start, i_end, i_delta; float f_start, f_end, f_delta, f_count; Pointer dp; int *ip; Object in[MAXCOMPINPUTS]; /* hardcoded in compute */ Object out; String compstr = NULL; char cbuf[64]; Error rc; /* do this or die in compute */ for (i=0; i<MAXCOMPINPUTS; i++) in[i] = NULL; /* find common format of start, end, delta and check for 4 parms */ i = 0; if (start) alist[i++] = start; if (end) alist[i++] = end; if (delta) alist[i++] = delta; if (n) { count = *n; if (i == 3) { DXWarning("too many inputs specified; ignoring delta"); i--; delta = NULL; } } else if (i == 2) count = 2; if (i < 2) { DXSetError(ERROR_BAD_PARAMETER, "not enough inputs specified to generate a list"); return NULL; } if (!DXQueryArrayCommonV(&t, &c, &rank, shape, i, alist)) { DXAddMessage("start, end and/or delta"); return NULL; } /* shortcut the process here if the data is scalar integer or * scalar float. otherwise, if the data is vector or ubyte * or whatever, fall through and use Compute so we can increment * by irregular values. */ if (t != TYPE_INT && t != TYPE_FLOAT) goto complicated; if (c != CATEGORY_REAL || rank != 0) goto complicated; /* compute missing value(s): * start = end - ((count - 1) * delta) * end = start + ((count - 1) * delta) * count = ((end - start) / delta) + 1 * delta = (end - start) / (count - 1) */ /* convert to the common format */ if (start) a_start = DXArrayConvertV(start, t, c, rank, shape); if (end) a_end = DXArrayConvertV(end, t, c, rank, shape); if (delta) a_delta = DXArrayConvertV(delta, t, c, rank, shape); /* for integer, scalar lists */ if (t == TYPE_INT) { if (!start) { i_end = *(int *)DXGetArrayData(a_end); i_delta = *(int *)DXGetArrayData(a_delta); i_start = i_end - ((count - 1) * i_delta); } if (!end) { i_start = *(int *)DXGetArrayData(a_start); i_delta = *(int *)DXGetArrayData(a_delta); i_end = i_start + ((count - 1) * i_delta); } if (!delta) { /* if count == 1, generate a zero of the right type. otherwise * divide to figure out the right delta to make count-1 steps * between start and end. it's count-1 because if you want * N numbers between start and end, you have N-1 increments. */ i_start = *(int *)DXGetArrayData(a_start); i_end = *(int *)DXGetArrayData(a_end); if (count == 1) i_delta = 0; else i_delta = (i_end - i_start) / (count - 1); /* try to catch the case where delta ends up being 0 (like * because the inputs are int and the count is larger than * the difference between start and end). allow it to be zero * only if start == end; i suppose if you ask for 10 things * where start == end you should be able to get them. */ if (i_delta == 0 && i_start != i_end) { DXSetError(ERROR_BAD_PARAMETER, "count too large to generate list between start and end"); goto error; } } /* if all three arrays are there, count must be missing */ if (i == 3) { i_start = *(int *)DXGetArrayData(a_start); i_end = *(int *)DXGetArrayData(a_end); i_delta = *(int *)DXGetArrayData(a_delta); if (i_delta == 0) count = 1; else { if ((i_end >= i_start && i_delta > 0) || (i_end < i_start && i_delta < 0)) count = (int)(((double)i_end-i_start) / (double)i_delta) +1; else { if (i_delta < 0) DXSetError(ERROR_BAD_PARAMETER, "delta must be positive if start is less than end"); else DXSetError(ERROR_BAD_PARAMETER, "delta must be negative if end is less than start"); goto error; } } } output = (Array)DXNewRegularArray(TYPE_INT, 1, count, (Pointer)&i_start, (Pointer)&i_delta); } /* for float, scalar lists */ if (t == TYPE_FLOAT) { if (!start) { f_end = *(float *)DXGetArrayData(a_end); f_delta = *(float *)DXGetArrayData(a_delta); f_start = f_end - ((count - 1.0) * f_delta); } if (!end) { f_start = *(float *)DXGetArrayData(a_start); f_delta = *(float *)DXGetArrayData(a_delta); f_end = f_start + ((count - 1.0) * f_delta); } if (!delta) { /* if count == 1, generate a zero of the right type. otherwise * divide to figure out the right delta to make count-1 steps * between start and end. it's count-1 because if you want * N numbers between start and end, you have N-1 increments. */ f_start = *(float *)DXGetArrayData(a_start); f_end = *(float *)DXGetArrayData(a_end); if (count == 1) f_delta = 0.0; else f_delta = (f_end - f_start) / (count - 1.0); /* try to catch the case where delta ends up being 0 (like * because the inputs are int and the count is larger than * the difference between start and end). allow it to be zero * only if start == end; i suppose if you ask for 10 things * where start == end you should be able to get them. */ if (f_delta == 0.0 && f_start != f_end) { DXSetError(ERROR_BAD_PARAMETER, "count too large to generate list between start and end"); goto error; } } /* if all three arrays are there, count must be missing */ if (i == 3) { f_start = *(float *)DXGetArrayData(a_start); f_end = *(float *)DXGetArrayData(a_end); f_delta = *(float *)DXGetArrayData(a_delta); if (f_delta == 0.0) count = 1; else { if ((f_end >= f_start && f_delta > 0) || (f_end < f_start && f_delta < 0)) { /* the intermediate float variable below is to minimize * float round-off error. if delta is 0.1 and you * ask for a list between 0 and 1, it does the math in * double, the delta used is actually 0.10000001, and * you get counts = 10.9999999 instead of 11. when * converted directly to int it becomes just 10 and your * list ends at 0.9 instead of 1. * math in base 2 has some problems. */ f_count = ((f_end - f_start) / f_delta) +1; count = (int)f_count; } else { if (f_delta < 0) DXSetError(ERROR_BAD_PARAMETER, "delta must be positive if start is less than end"); else DXSetError(ERROR_BAD_PARAMETER, "delta must be negative if end is less than start"); goto error; } } } output = (Array)DXNewRegularArray(TYPE_FLOAT, 1, count, (Pointer)&f_start, (Pointer)&f_delta); } DXDelete((Object)a_start); DXDelete((Object)a_end); DXDelete((Object)a_delta); /* return Array */ return output; /* input is a vector, or a data type different from int or float. * use compute so this code doesn't have to be replicated for each * different shape and type. */ complicated: nitems = 1; for (j=0; j<rank; j++) nitems *= shape[j]; /* compute missing value(s): * start = end - ((count - 1) * delta) * end = start + ((count - 1) * delta) * count = ((end - start) / delta) + 1 * delta = (end - start) / (count - 1) */ if (!start) { compstr = DXNewString("$0 - (($1 - 1) * $2)"); if (!compstr) goto error; in[0] = (Object)compstr; in[1] = (Object)end; in[3] = (Object)delta; in[2] = (Object)DXNewArray(TYPE_INT, CATEGORY_REAL, 0); if (!in[2]) goto error; if (!DXAddArrayData((Array)in[2], 0, 1, (Pointer)&count)) goto error; /* i need to explain this - it's basically so if compute was * going to try to cache this, it could add a reference and * then later when i call delete the object won't get deleted * out from underneath compute. (i know compute doesn't cache * things, but a different module might.) */ DXReference((Object)compstr); DXReference(in[2]); rc = m_Compute(in, &out); DXDelete((Object)compstr); compstr = NULL; DXDelete(in[2]); in[2] = NULL; if (rc == ERROR) goto error; start = (Array)out; delstart++; } if (!end) { compstr = DXNewString("$0 + (($1 - 1) * $2)"); if (!compstr) goto error; in[0] = (Object)compstr; in[1] = (Object)start; in[3] = (Object)delta; in[2] = (Object)DXNewArray(TYPE_INT, CATEGORY_REAL, 0); if (!in[2]) goto error; if (!DXAddArrayData((Array)in[2], 0, 1, (Pointer)&count)) goto error; DXReference((Object)compstr); DXReference(in[2]); rc = m_Compute(in, &out); DXDelete((Object)compstr); compstr = NULL; DXDelete(in[2]); in[2] = NULL; if (rc == ERROR) goto error; end = (Array)out; delend++; } if (!delta) { /* if count == 1, generate a zero of the right type. otherwise * divide to figure out the right delta to make count-1 steps * between start and end. it's count-1 because if you want * N numbers between start and end, you have N-1 increments. */ if (count == 1) compstr = DXNewString("$1 - $1"); else compstr = DXNewString("($2 - $0) / ($1 - 1)"); if (!compstr) goto error; in[0] = (Object)compstr; in[1] = (Object)start; in[3] = (Object)end; in[2] = (Object)DXNewArray(TYPE_INT, CATEGORY_REAL, 0); if (!in[2]) goto error; if (!DXAddArrayData((Array)in[2], 0, 1, (Pointer)&count)) goto error; DXReference((Object)compstr); DXReference(in[2]); rc = m_Compute(in, &out); DXDelete((Object)compstr); compstr = NULL; DXDelete(in[2]); in[2] = NULL; if (rc == ERROR) goto error; delta = (Array)out; deldelta++; /* try to catch the case where delta ends up being 0 (like * because the inputs are int and the count is larger than * the difference between start and end). allow it to be zero * only if start == end; i suppose if you ask for 10 things * where start == end you should be able to get them. */ if (IsZero(delta) && !IsEqual(start, end)) { DXSetError(ERROR_BAD_PARAMETER, "count too large to generate list between start and end"); goto error; } } /* if all three arrays are there, count must be missing */ if (i == 3) { char tbuf[512]; int firsttime = 1; int lastcount = 0; /* this loop allows us to to handle vectors or matricies as * well as scalars. it requires that the deltas compute to * a consistent count. like start=[0 2 4], end=[4 8 16], * would work if delta=[1 2 4] but not if delta was [1 2 2]. */ for (j=0; j < nitems; j++) { /* i think this code only works for vectors - i'm not sure * what it will do with rank=2 data. */ /* this point of this next compute expression: * if the delta is 0, don't divide by zero - the count is 1. * if the end is smaller than the start, the delta has to be * negative. if it's not, return -1. you can't generate a * negative count from the equations, so this is a safe signal. */ sprintf(tbuf, "float($2.%d) == 0.0 ? " " 1 : " " ( (($1.%d >= $0.%d) && ($2.%d > 0) || " " ($1.%d < $0.%d) && ($2.%d < 0)) ? " " int(float($1.%d - $0.%d) / float($2.%d)) + 1 : " " -1 ) ", j, j, j, j, j, j, j, j, j, j); compstr = DXNewString(tbuf); if (!compstr) goto error; in[0] = (Object)compstr; in[1] = (Object)start; in[2] = (Object)end; in[3] = (Object)delta; DXReference((Object)compstr); rc = m_Compute(in, &out); DXDelete((Object)compstr); compstr = NULL; if (rc == ERROR) goto error; if (!DXExtractInteger(out, &count)) { DXSetError(ERROR_BAD_PARAMETER, "can't compute number of items"); goto error; } DXDelete((Object)out); if (count == 0) continue; if (count < 0) { if (IsNegative(delta)) DXSetError(ERROR_BAD_PARAMETER, "delta must be positive if start is less than end"); else DXSetError(ERROR_BAD_PARAMETER, "delta must be negative if end is less than start"); goto error; } if (firsttime) { lastcount = count; firsttime = 0; } else { if (count != lastcount) { DXSetError(ERROR_BAD_PARAMETER, "inconsistent number of items required by inputs"); goto error; } } } } /* now have 4 consistant values - once again make sure they are * converted into an identical format. */ a_start = DXArrayConvertV(start, t, c, rank, shape); a_end = DXArrayConvertV(end, t, c, rank, shape); a_delta = DXArrayConvertV(delta, t, c, rank, shape); /* make empty array with n items */ output = DXNewArrayV(t, c, rank, shape); if (!output) goto error; if (!DXAddArrayData(output, 0, count, NULL)) goto error; dp = DXGetArrayData(output); if (!dp) goto error; /* foreach n */ /* call compute to add delta */ /* memcpy to right offset in array */ /* end */ bytes = DXGetItemSize(output); sprintf(cbuf, "%s($0 + ($1 * $2))", TypeName(t)); compstr = DXNewString(cbuf); if (!compstr) goto error; in[0] = (Object)compstr; in[1] = (Object)a_start; in[3] = (Object)a_delta; in[2] = (Object)DXNewArray(TYPE_INT, CATEGORY_REAL, 0); if (!in[2]) goto error; if (!DXAddArrayData((Array)in[2], 0, 1, NULL)) goto error; ip = (int *)DXGetArrayData((Array)in[2]); DXReference((Object)compstr); DXReference(in[2]); for (i=0; i<count; i++) { *ip = i; rc = m_Compute(in, &out); if (rc == ERROR) goto error; memcpy(INCVOID(dp, bytes*i), DXGetArrayData((Array)out), bytes); DXDelete((Object)out); } DXDelete((Object)compstr); DXDelete(in[2]); DXDelete((Object)a_start); DXDelete((Object)a_end); DXDelete((Object)a_delta); if (delstart) DXDelete((Object)start); if (delend) DXDelete((Object)end); if (deldelta) DXDelete((Object)delta); /* return Array */ return output; error: DXDelete((Object)output); DXDelete((Object)compstr); DXDelete((Object)a_start); DXDelete((Object)a_end); DXDelete((Object)a_delta); if (delstart) DXDelete((Object)start); if (delend) DXDelete((Object)end); if (deldelta) DXDelete((Object)delta); return NULL; }
Error m_SXBin( Object *in, Object *out ){ /* *+ * Name: * SXBin * Purpose: * bins a field into a grid defined by a another field * Language: * ANSI C * Syntax: * output = SXBin( input, grid, type ); * Classification: * Realization * Description: * The SXBin module bins the "data" component of the "input" field into * the bins defined by the "connections" component of the "grid" field. * The input field can hold scattered or regularly gridded points, but * the "data" component must depend on "positions". The "grid" field must * contain "connections" and "positions" components but need not contain * a "data" component. The input"data" component must be either TYPE_FLOAT * or TYPE_DOUBLE. * * The "data" component in the "output" field contains either the mean * or sum of the "input" data values falling within each connection, or * the number of data values falling within each connection, as specified * by "type". * * When binning a regular grid into another regular grid, beware of the * tendancy to produce artificial large scale structure representing the * "beat frequency" of the two grids. * Parameters: * input = field (Given) * field or group with positions to bin [none] * grid = field (Given) * grid to define the bins [none] * type = integer (Given) * type of output values required: 0 - mean, 1 - sum, * 2 - count [0] * output = field (Returned) * bined field * Components: * All components except the "data" component are copied from the "grid" * field. The output "data" component added by this module depends on * "connections". An "invalid connections" component is added if any output * data values could not be calculated (e.g. if the mean is required of an * empty bin). * Examples: * This example bins the scattered data described in "CO2.general" onto a * regular grid, and displays it. SXBin is used to find the mean data * value in each grid connection. * * input = Import("/usr/lpp/dx/samples/data/CO2.general")$ * frame17 = Select(input,17); * camera = AutoCamera(frame17); * grid = Construct([-100,-170],deltas=[10,10],counts=[19,34]); * bin = SXBin(frame17,grid); * coloured = AutoColor(bin); * Display(coloured,camera); * * This example produces a grid containing an estimate of the density of * the scattered points (i.e. the number of points per unit area). The * positions of the original scattered points are shown as dim grey * circles. SXBin finds the number of input positions in each bin, * Measure finds the area of each bin, and Compute divides the counts * by the areas to get the densities: * * input = Import("/usr/lpp/dx/samples/data/CO2.general")$ * frame17 = Select(input,17); * camera = AutoCamera(frame17); * glyphs = AutoGlyph(frame17,scale=0.1,ratio=1); * glyphs = Color(glyphs,"dim grey"); * grid = Construct([-100,-170],deltas=[40,40],counts=[6,10]); * counts = SXBin(frame17,grid,type=2); * areas = Measure(counts,"element"); * density = Compute("$0/$1",counts,areas); * coloured = AutoColor(density); * collected=Collect(coloured,glyphs); * Display(collected,camera); * See Also: * SXRegrid, Map, Construct, Measure * Returned Value: * OK, unless an error occurs in which case ERROR is returned and the * DX error code is set. * Copyright: * Copyright (C) 1995 Central Laboratory of the Research Councils. * All Rights Reserved. * Licence: * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of * the License, or (at your option) any later version. * * This program is distributed in the hope that it will be * useful,but WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR * PURPOSE. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street,Fifth Floor, Boston, MA * 02110-1301, USA * Authors: * DSB: David Berry (STARLINK) * {enter_new_authors_here} * History: * 9-OCT-1995 (DSB): * Original version * {enter_further_changes_here} * Bugs: * {note_any_bugs_here} *- */ /* Local Variables: */ Array a; /* Array to hold reduced dimension positions */ float *a_ptr; /* Pointer to reduced dimension positions */ Category cat; /* Array category type */ Type dtype; /* Type of current input data array */ int fld; /* Field counter */ Object grid; /* The grid object */ int i; /* Loop count */ void *indata[MAXFLD];/* Pointer to input data array */ float *inpos; /* Pointer to input positions array */ Array inpos_array; /* Input positions array */ Object input; /* A copy of the input object */ Interpolator interp; /* Interpolator for grid */ int j; /* Loop count */ Array map; /* Map from input position to output bin number */ int *map_ptr; /* Pointer to map */ char more; /* Are there more input fields to do? */ Fpair *next; /* The next Fpair structure in the linked list */ int ndim; /* No. of dimensions in grid positions array */ int nfld; /* No. of fields sharing current positions array */ int npos; /* No. of input positions */ int npindim; /* No. of dimensions in input positions array */ int nbin; /* No. of grid positions */ int outbad[MAXFLD];/* No. of invalid output positions in each field*/ void *outdata[MAXFLD];/* Pointers to output data arrays */ Array outdata_array;/* Output data array */ Object output; /* The output object */ int outtype; /* Type of output values required */ float *pa; /* Pointer to next reduced dimension position */ float *pin; /* Pointer to next full dimension position */ int rank; /* Array rank */ int tag; /* The tag for the current input positions array */ Type type; /* Array numeric type */ int veclen[MAXFLD];/* Dimensionality of each input data array */ int *work; /* Pointer to work array */ /* Initialise all created objects so that they can safely be deleted if * an error occurs. */ input = NULL; output = NULL; grid = NULL; outdata_array = NULL; work = NULL; a = NULL; /* Check that the "input" object has been supplied. */ if( !in[0] ) { DXSetError( ERROR_BAD_PARAMETER, "missing parameter \"input\"." ); goto error; } /* Remove (cull) all invalid positions and connections from the input. It is * necessary to take a copy of the input first, because the input object * itself cannot be modified. */ input = DXCopy( in[0], COPY_STRUCTURE ); if( !DXCull( input ) ) goto error; /* Check that the "grid" object has been supplied. */ if( !in[1] ) { DXSetError( ERROR_BAD_PARAMETER, "missing parameter \"grid\"." ); goto error; } /* Create an interpolator which identifies the grid connection containing any * given position. */ interp = SXGetIntp( in[1], &nbin, &ndim, &grid ); if( !interp ) goto error; /* Allocate a work array for use by SXBinD or SXBinF. */ work = (int *) DXAllocate( sizeof( int )*nbin ); if( !work ) goto error; /* Get the type of output value required. */ if( !in[2] ){ outtype = 0; } else { if( !SXGet0is( "type", in[2], 2, 0, 0, NULL, &outtype, NULL ) ) goto error; } /* Produce a copy of the "input" object to use as the output, replacing all * fields within it with the grid field. Also form a linked list of Fpair * structures describing the fields. */ output = SXMakeOut( input, (Field) grid, 1, 1, 3, "positions" ); if( !output ) goto error; /* Abort if no fields were found. */ if( !head ) { DXSetError( ERROR_DATA_INVALID, "no fields found in \"input\"." ); goto error; } /* Go through the list of fields looking for fields which share the same * positions component. */ more = 1; while( more ){ /* Find the first field with a non-zero positions tag. */ next = head; while( next && !next->postag ) next = next->next; /* If no non-zero positions tags were found, we've finished. */ if( !next ){ more = 0; break; } /* Find the input positions array. Get its shape, size and type. Check it is * usable. */ inpos_array = (Array) next->pos; if( !DXGetArrayInfo( inpos_array, &npos, &type, &cat, &rank, &npindim ) ) goto error; if( type != TYPE_FLOAT ){ DXSetError( ERROR_DATA_INVALID, "positions component in \"input\" is not of type FLOAT." ); goto error; } if( cat != CATEGORY_REAL ){ DXSetError( ERROR_DATA_INVALID, "positions component in \"input\" is not of category REAL." ); goto error; } if( rank > 1 ){ DXSetError( ERROR_DATA_INVALID, "rank %d positions component found in \"input\".", rank ); goto error; } if( rank == 0 ){ /* Scalar data is equivalent to 1-d vector data */ rank = 1; npindim = 1; } if( npindim < ndim ){ DXSetError( ERROR_DATA_INVALID, "dimensionality of \"input\" (%d) is less than \"grid\" (%d).", npindim, ndim ); goto error; } /* Get a pointer to the positions values. */ inpos = (float *) DXGetArrayData( inpos_array ); /* If the number of dimensions in the input positions is greater than the * number of dimensions in the grid, remove trailing dimensions from the * input positions so that they match the dimensionality of the grid. */ if( npindim > ndim ){ a = DXNewArrayV( TYPE_FLOAT, CATEGORY_REAL, 1, &ndim ); if( !DXAddArrayData( a, 0, npos, NULL ) ) goto error; a_ptr = (float *) DXGetArrayData( a ); for( i=0; i<npos; i++ ){ pin = inpos + i*npindim; pa = a_ptr + i*ndim; for(j=0;j<ndim;j++) pa[j] = pin[j]; } inpos_array = a; } else { a = NULL; } /* Create an array of the same shape and size as the input positions * array, which holds integer identifiers for the grid connections * containing each input position. These identifiers start at 1 and * go upto nbin. Positions returned holding an identifier of zero do * not fall within the supplied grid. */ map = (Array) DXMap( (Object) inpos_array, (Object) interp, NULL, NULL ); map_ptr = (int *) DXGetArrayData( map ); /* Find all fields which have the same positions tag and the same data * type. */ tag = next->postag; dtype = next->datatype; nfld = 0; while( next ){ if( next->postag == tag && next->datatype == dtype ){ /* Increment the number of fields found so far which share this * positions component. */ nfld++; if( nfld > MAXFLD ){ DXSetError( ERROR_MAX, "\"input\" has too many fields.", MAXFLD ); goto error; } /* Store a pointer to the input data array, and its dimensionality. */ indata[nfld-1] = (void *) DXGetArrayData( (Array) next->data ); veclen[nfld-1] = next->datalen; /* Make a new array to hold the output data values. The output data will * have the same dimensionality as the input data unless the required output * data is "counts (i.e if parameter "type" is 2), in which case the * output data will be scalar. */ if( outtype == 2 ) veclen[nfld-1] = 1; outdata_array = DXNewArrayV( dtype, CATEGORY_REAL, 1, &veclen[nfld-1] ); if( !outdata_array ) goto error; if( !DXAddArrayData( outdata_array, 0, nbin, NULL ) ) goto error; /* Get a pointer to the output data array. */ outdata[nfld-1] = (void *) DXGetArrayData( outdata_array ); if( !outdata[nfld-1] ) goto error; /* Place the new data component in the output field, and indicate that * it now does not need to be deleted explicitly in the event of an error. */ if( !DXSetComponentValue( next->outfld, "data", (Object) outdata_array ) ) goto error; outdata_array = NULL; } next = next->next; } /* Now bin the input data arrays into the output connections, storing the * resulting bin values in the output data arrays. */ if( dtype == TYPE_FLOAT ){ if( ! SXBinF( nfld, veclen, npos, (float **)indata, nbin, (float **) outdata, map_ptr, work, outtype, outbad ) ) goto error; } else { if( ! SXBinD( nfld, veclen, npos, (double **)indata, nbin, (double **) outdata, map_ptr, work, outtype, outbad ) ) goto error; } /* Loop round all the fields that have just been created. */ next = head; fld = 0; while( next ){ if( next->postag == tag ){ /* Create invalid positions components in each output field which have any * undefined data values */ if( outbad[fld] ){ if( dtype == TYPE_FLOAT ){ if( !SXSetInvPosF( (Object) next->outfld, nbin, veclen[fld], (float *) outdata[fld], "connections" ) ) goto error; } else { if( !SXSetInvPosD( (Object) next->outfld, nbin, veclen[fld], (double *) outdata[fld], "connections" ) ) goto error; } } /* Indicate that the data values are dependant on connections. */ if( !DXSetComponentAttribute( next->outfld, "data", "dep", (Object) DXNewString("connections")) ) goto error; /* Indicate that the data component of the output field has been * changed. */ DXChangedComponentValues( next->outfld, "data" ); /* Complete the construction of this output field. */ DXEndField( next->outfld ); /* Increment the field index, and indicate that this input field has * been done. */ fld++; next->postag = 0; } next = next->next; } /* Delete the array used to store the reduced dimensionality input positions * (if used). */ if( a ) { DXDelete( (Object) a ); a = NULL; } } error: /* Free the storage used to hold the link list of Fpair structures * describing the fields in the "input" object. */ while( head ){ next = head->next; DXFree( (Pointer) head ); head = next; } /* Free the work array. */ if( work ) DXFree( (Pointer) work ); /* Delete the copy of the input and grid objects, and the array used to * store the reduced dimensionality input positions (if used). */ DXDelete( grid ); DXDelete( input ); if( a ) DXDelete( (Object) a ); /* If all is OK, return the "output" object with a good status. */ if( DXGetError() == ERROR_NONE ){ out[0] = output; return( OK ); /* If an error has occurred, ensure temporary objects are deleted and return * with a bad status. */ } else { DXDelete( (Object) outdata_array ); DXDelete( output ); return( ERROR ); } }