Exemplo n.º 1
0
static Error DoSXEnum( Object o, char *name, char *dep ){

      Array a;
      int n, i, *to;
      Object oo;


/*  If the supplied object is a field... */

      switch( DXGetObjectClass( o ) ){
      case CLASS_FIELD:


/*  See how many items there are in the requested component. */

         a = (Array) DXGetComponentValue( (Field) o, dep );
         if( !a ) {
            DXSetError( ERROR_DATA_INVALID, "field has no \"%s\" component", dep );
            return( ERROR );
         }

         DXGetArrayInfo( a, &n, NULL, NULL, NULL, NULL );


/*  Create a new array to hold the enumeration, and get a pointer to it. */

         a = (Array) DXNewArray( TYPE_INT, CATEGORY_REAL, 0 );
         if( !DXAddArrayData( a, 0, n, NULL ) ) return( ERROR );
         to = (int *) DXGetArrayData( a );


/*  Add this new array to the field. */

         DXSetComponentValue( (Field) o, name, (Object) a );


/*  Store a value for the "dep" attribute of the new array. */

         DXSetComponentAttribute( (Field) o, name, "dep", (Object) DXNewString( dep ) );


/*  Store the enumeration values. */

         for( i=0; i<n; i++ ) *(to++) = i;


/*  Indicate that the component values have changed, and complete the
 *  output field. */

         DXChangedComponentValues( (Field) o, name );
         if( !DXEndField( (Field) o ) ) return( ERROR );

         break;


/*  If the supplied object is a group, call this function recursively for
 *  each member of the group. */

      case CLASS_GROUP:

         for( i=0; oo=(Object)DXGetEnumeratedMember((Group)o,i,NULL); i++ ){
            if( !DoSXEnum( oo, name, dep ) ) return( ERROR );
         }

         break;

      }

      return( OK );

}
Exemplo n.º 2
0
static int
doLeaf(Object *in, Object *out)
{
  int result=0;
  Field field;
  Category category;
  Category lookup_category;
  int rank, shape[30];
  char *cat_comp;
  char *data_comp;
  char *lookup_comp;
  char name_str[256];
  char *opstr;
  int operation;
  int lookup_knt;
  int lookup_knt_provided = 0;
  Array cat_array = NULL;
  Array data_array = NULL;
  Array out_array = NULL;
  Array array = NULL;
  Array lookup_array = NULL;
  float *out_data;
  int data_knt, cat_knt;
  int out_knt=0;
  Type cat_type, data_type, lookup_type;
  float floatmax;
  ICH invalid;

  if (DXGetObjectClass(in[0]) == CLASS_FIELD)
  {
    field = (Field)in[0];

    if (DXEmptyField(field))
      return OK;
  }

  if (!DXExtractString((Object)in[1], &opstr))
	opstr = STR_COUNT;

  if (!strcmp(opstr, STR_COUNT))
    operation = STAT_COUNT;
  else if (!strcmp(opstr, STR_MEAN))
    operation = STAT_MEAN;
  else if (!strcmp(opstr, STR_SD))
    operation = STAT_SD;
  else if (!strcmp(opstr, STR_VAR))
    operation = STAT_VAR;
  else if (!strcmp(opstr, STR_MIN))
    operation = STAT_MIN;
  else if (!strcmp(opstr, STR_MAX))
    operation = STAT_MAX;
  else if (!strcmp(opstr, STR_ACCUM))
    operation = STAT_ACCUM;
  else
    operation = STAT_UNDEF;

  if (operation == STAT_UNDEF) {
    DXSetError(ERROR_BAD_PARAMETER, "statistics operation must be one of: count, mean, sd, var, min, max");
    goto error;
  }

  if (!DXExtractString((Object)in[2], &cat_comp))
	cat_comp = STR_DATA;
  if (!DXExtractString((Object)in[3], &data_comp))
	data_comp = STR_DATA;

  if (in[0])
  {
      if (DXGetObjectClass(in[0]) != CLASS_FIELD)
      {
        DXSetError(ERROR_BAD_CLASS, "\"input\" should be a field");
        goto error;
      }

      cat_array = (Array)DXGetComponentValue((Field)in[0], cat_comp);
      if (! cat_array)
      {
        DXSetError(ERROR_MISSING_DATA, "\"input\" has no \"%s\" categorical component", cat_comp);
        goto error;
      }

      if (DXGetObjectClass((Object)cat_array) != CLASS_ARRAY)
      {
        DXSetError(ERROR_BAD_CLASS, "categorical component \"%s\" of \"input\" should be an array", cat_comp);
        goto error;
      }

      if (!HasInvalid((Field)in[0], cat_comp, &invalid))
      {
        DXSetError(ERROR_INTERNAL, "Bad invalid component");
        goto error;
      }

      if (invalid)
      {
        DXSetError(ERROR_DATA_INVALID, "categorical component must not contain invalid data");
        goto error;
      }

      DXGetArrayInfo(cat_array, &cat_knt, &cat_type, &category, &rank, shape);
      if ( (cat_type != TYPE_BYTE && cat_type != TYPE_UBYTE && cat_type != TYPE_INT && cat_type != TYPE_UINT)
             || category != CATEGORY_REAL || !((rank == 0) || ((rank == 1)&&(shape[0] == 1))))
      {
        DXSetError(ERROR_DATA_INVALID, "categorical component %s must be scalar non-float", cat_comp);
        goto error;
      }

      if (operation != STAT_COUNT) {
        data_array = (Array)DXGetComponentValue((Field)in[0], data_comp);
        if (! data_array)
        {
          DXSetError(ERROR_MISSING_DATA, "\"input\" has no \"%s\" data component", data_comp);
          goto error;
        }

        if (DXGetObjectClass((Object)data_array) != CLASS_ARRAY)
        {
          DXSetError(ERROR_BAD_CLASS, "data component \"%s\" of \"input\" should be an array", data_comp);
          goto error;
        }

        DXGetArrayInfo(data_array, &data_knt, &data_type, &category, &rank, shape);
        if ( (data_type != TYPE_BYTE && data_type != TYPE_UBYTE && data_type != TYPE_INT && data_type != TYPE_UINT
             && data_type != TYPE_FLOAT && data_type != TYPE_DOUBLE)	
               || category != CATEGORY_REAL || !((rank == 0) || ((rank == 1)&&(shape[0] == 1))))
        {
          DXSetError(ERROR_DATA_INVALID, "data component \"%s\" must be scalar", data_comp);
          goto error;
        }

        if (data_knt != cat_knt)
        {
	  DXSetError(ERROR_DATA_INVALID, "category and data counts must be the same");
	  goto error;
        }
      }
  }

  if (in[4]) {
      if (DXExtractString((Object)in[4], &lookup_comp)) {
	    lookup_array = (Array)DXGetComponentValue((Field)in[0], lookup_comp);
	    if (!lookup_array)
	    {
	      DXSetError(ERROR_MISSING_DATA, "\"input\" has no \"%s\" lookup component", lookup_comp);
	      goto error;
	    }
      } else if (DXExtractInteger((Object)in[4], &lookup_knt)) {
	    lookup_knt_provided = 1;
	    out_knt = lookup_knt;
      } else if (DXGetObjectClass((Object)in[4]) == CLASS_ARRAY) {
	    lookup_array = (Array)in[4];
	    sprintf(name_str, "%s lookup", cat_comp);
	    lookup_comp = name_str;
      } else { 
            DXSetError(ERROR_DATA_INVALID, "lookup component must be string, integer, or array");
	    goto error;
      }
  } else {
      sprintf(name_str, "%s lookup", cat_comp);
      lookup_comp = name_str;
      lookup_array = (Array)DXGetComponentValue((Field)in[0], lookup_comp);
  } 

  if (lookup_array) {
    DXGetArrayInfo(lookup_array, &lookup_knt, &lookup_type, &lookup_category, &rank, shape);
    out_knt = lookup_knt;
  } else if (!lookup_knt_provided){
    if (!DXStatistics((Object)in[0], cat_comp, NULL, &floatmax, NULL, NULL)) {
      DXSetError(ERROR_INTERNAL, "Bad statistics on categorical component");
      goto error;
    }
    out_knt = (int)(floatmax+1.5);
  }

  out_array = DXNewArray(TYPE_FLOAT, CATEGORY_REAL, 0);
  if (! out_array)
    goto error;

  if (! DXSetAttribute((Object)out_array, "dep", (Object)DXNewString("positions")))
    goto error;

  if (! DXAddArrayData(out_array, 0, out_knt, NULL))
    goto error;

  if (out[0])
  {
    if (DXGetObjectClass(out[0]) != CLASS_FIELD)
    {
      DXSetError(ERROR_INTERNAL, "non-field object found in output");
      goto error;
    }

    if (DXGetComponentValue((Field)out[0], "data"))
      DXDeleteComponent((Field)out[0], "data");

    if (! DXSetComponentValue((Field)out[0], "data", (Object)out_array))
      goto error;

    if (lookup_array) {
      if (! DXSetComponentValue((Field)out[0], lookup_comp, (Object)lookup_array))
        goto error;
    }
  }
  else
  {
    out[0] = (Object)DXNewField();
    array = DXMakeGridPositions(1, out_knt, 0.0, 1.0);
    if (!array)
	goto error;
    DXSetComponentValue((Field)out[0], "positions", (Object)array);
    array = DXMakeGridConnections(1, out_knt);
    if (!array)
	goto error;
    DXSetComponentValue((Field)out[0], "connections", (Object)array);
    DXSetComponentValue((Field)out[0], "data", (Object)out_array);
    if (lookup_array) {
      if (! DXSetComponentValue((Field)out[0], lookup_comp, (Object)lookup_array))
        goto error;
    }
  }

  out_data = DXGetArrayData(out_array);
  if (! out_data)
    goto error;

  result = CategoryStatistics_worker(
  		out_data, cat_knt, out_knt, cat_array, data_array,
		cat_type, data_type, operation);

  if (! result) {
     if (DXGetError()==ERROR_NONE)
        DXSetError(ERROR_INTERNAL, "error return from user routine");
     goto error;
  }

  result = (DXEndField((Field)out[0]) != NULL);

error:
  return result;
}
Exemplo n.º 3
0
Error m_SXConstruct( Object *in, Object*out){
/*
*+
*  Name:
*     SXConstruct

*  Purpose:
*     constructs a regular field with regular connections

*  Language:
*     ANSI C

*  Syntax:
*     output = SXConstruct( object, lower, upper, deltas, counts );

*  Classification:
*     Realization

*  Description:
*     The SXConstruct module constructs a field with regular positions
*     and connections covering a volume with specified bounds. It is
*     similar to the standard Construct module, but is somewhat easier to
*     use if a simple grid is required.

*     If "object" is given, its bounds define the extent of the output
*     field. Otherwise, the vectors given for "upper" and "lower" define
*     the extent of the output field.

*     If "deltas" is supplied, it defines the distances between adjacent
*     positions on each axis. It should be a vector with the same number
*     of dimensions as "upper" and "lower", or a single value (in which
*     case the supplied value is used for all axes). The upper and lower
*     bounds are expanded if necessary until they span an integer number
*     of deltas.
*
*     If "deltas" is not supplied, then "counts" must be supplied and
*     should be an integer vector giving the number of positions on each
*     axis, or a single integer (in which case the same value is used for
*     all axes).

*  Parameters:
*     object = field (given)
*        object to define extent of new field [none]
*     lower = vector (Given)
*        explicit lower bounds of new field [none]
*     upper = vector (Given)
*        explicit upper bounds of new field [none]
*     deltas = scalar or vector (Given)
*        increment for each axis
*     counts = integer or vector (Given)
*        number of positions along each axis
*     output = field (Returned)
*        output field

*  Components:
*     The output has "positions", "connections" and "box" components, but
*     no "data" component.

*  Examples:
*     This example imports a scattered data set from "C02.general",
*     extracts a single frame, uses SXConstruct to make a grid covering the
*     bounds of the frame, with increments of 10.0 along each axis, and
*     then uses SXBIN to find the mean data value in each of the square
*     connections of this new grid. the resulting field is displayed.
*
*     data = Import("/usr/lpp/dx/samples/data/CO2.general");
*     frame17 = Select(data,17);
*     newgrid = SXConstruct(frame17,deltas=10);
*     binned = SXBin(frame17,newgrid);
*     coloured = AutoColor(binned);
*     camera = AutoCamera(coloured);
*     Display(coloured,camera);

*  See Also:
*     Construct, Grid

*  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:
*     18-OCT-1995 (DSB):
*        Original version
*     {enter_further_changes_here}

*  Bugs:
*     {note_any_bugs_here}

*-
*/


/*  Local Variables. */


      int      cnt[3];       /* Counts */
      int     *counts;       /* Pointers to counts */
      float    del[3];       /* Deltas */
      float    del3d[9];     /* 3-D Deltas */
      float   *deltas;       /* Pointers to deltas */
      float   *lower;        /* Pointer to lower bounds */
      float   *upper;        /* Pointer to upper bounds */
      float    lbnd[3];      /* lower bounds */
      float    ubnd[3];      /* upper bounds */
      int      ndim;         /* No. of components for each vector */
      int      ndim2;        /* No. of dimensions in second object */
      Object   o=NULL;       /* Output object */
      float    bnd;          /* Current bound value */
      Point    box[8];       /* Bounding box */
      Category cat;          /* Array category */
      Array    array;        /* An array */
      float   *box_ptr;      /* Pointer to box array */
      int      i;            /* Loop count */
      int      j;            /* Loop count */
      int      ncorn;        /* No. of corners in the bounding box */
      int      rank;         /* Array rank */
      float    tmp;          /* Swapping space */
      Type     type;         /* Array numeric type */


/*  If OBJECT was supplied, check it is a field. */

      if( in[0] ){

         if( DXGetObjectClass(in[0]) != CLASS_FIELD ){
            DXSetError( ERROR_BAD_TYPE, "input object is not a field" );
            goto error;
         }


/*  Take a copy of it. */

         o = DXCopy( in[0], COPY_STRUCTURE );


/*  Get the bounding box component from the object */

         array = (Array) DXGetComponentValue( (Field) o, "box" );


/*  If no bounding box was found, create one. */

         if( !array ){
            if( !DXBoundingBox( o, box ) ){
               DXSetError( ERROR_UNEXPECTED, "cannot obtain a bounding box." );
               goto error;
            }
            array = (Array) DXGetComponentValue( (Field) o, "box" );
         }


/*  Get a pointer to the bounding box array and the number of items in
 *  the array, etc. */

         box_ptr = (float *) DXGetArrayData( array );
         DXGetArrayInfo( array, &ncorn, &type, &cat, &rank, &ndim );

         if( type != TYPE_FLOAT ){
            DXSetError( ERROR_BAD_TYPE, "input object positions are not TYPE_FLOAT");
            goto error;
         }

         if( cat != CATEGORY_REAL ){
            DXSetError( ERROR_BAD_TYPE, "input object positions are not REAL");
            goto error;
         }

         if( rank > 1 ){
            DXSetError( ERROR_BAD_TYPE, "input object positions have rank larger than 1");
            goto error;
         }

         if( rank == 0 ) ndim = 1;

         if( ndim > 3 ){
            DXSetError( ERROR_BAD_TYPE, "input object positions have more than 3 dimensions");
            goto error;
         }


/*  Store the bounds for each dimension. */

         for( j=0; j<ndim; j++){
            lbnd[j] = FLT_MAX;
            ubnd[j] = FLT_MIN;
         }

         for( i=0; i<ncorn; i++ ){
            for( j=0; j<ndim; j++ ){
               bnd = *(box_ptr++);
               if( bnd < lbnd[j] ) lbnd[j]=bnd;
               if( bnd > ubnd[j] ) ubnd[j]=bnd;
            }
         }


/*  Delete the copy of the input object */

         DXDelete( o );
         o = NULL;
         array = NULL;


/*  If OBJECT was not supplied, get the bounds from LOWER and UPPER. */

      } else {

         if( !in[1] ) {
            DXSetError( ERROR_MISSING_DATA, "No lower bounds supplied");
            goto error;

         } else {
            lower = SXGet1r( "lower", in[1], &ndim );
            if( !lower ) goto error;

            if( ndim > 3 ){
               DXSetError( ERROR_BAD_TYPE, "lower bounds have more than 3 dimensions");
               goto error;
            }

         }

         if( !in[2] ) {
            DXSetError( ERROR_MISSING_DATA, "No upper bounds supplied");
            goto error;

         } else {
            upper = SXGet1r( "upper", in[2], &ndim2 );
            if( !upper ) goto error;

            if( ndim2 != ndim ){
               DXSetError( ERROR_BAD_TYPE, "number of upper and lower bounds does not match");
               goto error;
            }

         }

         for( j=0; j<ndim; j++){
            lbnd[j] = lower[j];
            ubnd[j] = upper[j];
         }

      }


/*  Ensure bounds are OK. */

      for( j=0; j<ndim; j++ ){
         if( ubnd[j] < lbnd[j] ) {
            tmp = ubnd[j];
            ubnd[j] = lbnd[j];
            lbnd[j] = tmp;
         }
      }


/*  If DELTAS was supplied, get its values and check dimensionality. */

      if( in[3] ){
         deltas = SXGet1r( "deltas", in[3], &ndim2 );

         if( ndim2 == 1 ){
            for( j=0; j<ndim; j++){
               del[j] = *deltas;
            }

         } else {
            if( ndim2 != ndim ){
               DXSetError( ERROR_BAD_TYPE, "incorrect number of deltas given");
               goto error;
            } else {
               for( j=0; j<ndim; j++){
                  del[j] = deltas[j];
               }
            }
         }


/*  Find the corresponding counts and adjust lower bounds */

         for( j=0; j<ndim; j++ ){
            if( del[j] > 0.0 ){
               cnt[j] = 1 + (int) ( 0.9999 + (ubnd[j]-lbnd[j])/del[j] );
               lbnd[j] = 0.5*( ubnd[j] + lbnd[j] - ( cnt[j] - 1 )*del[j] );
            } else {
               DXSetError( ERROR_BAD_TYPE, "negative or zero delta given");
               goto error;
            }
         }


/*  If COUNTS was supplied, get its values and check dimensionality. */

      } else if( in[4] ){
         counts = SXGet1i( "counts", in[4], &ndim2 );

         if( ndim2 == 1 ){
            for( j=0; j<ndim; j++){
               cnt[j] = *counts;
            }

         } else {
            if( ndim2 != ndim ){
               DXSetError( ERROR_BAD_TYPE, "incorrect number of counts given");
               goto error;
            } else {
               for( j=0; j<ndim; j++){
                  cnt[j] = counts[j];
               }
            }
         }


/*  Find corresponding DELTAS */

         for( j=0; j<ndim; j++ ){
            if( cnt[j] > 1 ) {
               del[j] = ( ubnd[j] - lbnd[j] )/( (float) cnt[j] - 1 );

            } else {
               cnt[j] = 1;
               del[j] = 1.0;
               tmp = 0.5*( ubnd[j]+ lbnd[j] );
               ubnd[j] = tmp;
               lbnd[j] = tmp;
            }

         }


/*  report an error if neither COUNTS nor DELTAS was supplied. */

      } else {
         DXSetError( ERROR_MISSING_DATA, "no deltas or counts given");
         goto error;
      }


/*  Construct the n-d delta vectors, form the increments on each axis. */

      for( j=0; j<9; j++ ) del3d[j] = 0.0;
      for( j=0; j<ndim; j++ ) del3d[ j*(ndim+1) ] = del[j];


/*  Create the output field. */

      o = (Object) DXNewField();
      if( !o ) goto error;


/* Create the positions array and put it in the field. */

      array = DXMakeGridPositionsV( ndim, cnt, lbnd, del3d );
      if( !array ) goto error;
      if( !DXSetComponentValue( (Field) o, "positions", (Object) array ) ) goto error;
      array = NULL;


/* Create the connections array and put it in the field. */

      array = DXMakeGridConnectionsV( ndim, cnt );
      if( !array ) goto error;
      if( !DXSetComponentValue( (Field) o, "connections", (Object) array ) ) goto error;
      array = NULL;


/*  Finish the field */

      if( !DXEndField( (Field) o ) ) goto error;


/*  Return the output field. */

      out[0] = o;
      return( OK );

error:
      DXDelete( o );
      return( ERROR );

}
Exemplo n.º 4
0
static Error ConvertFieldObject(Object out, char *strin)
{

Class cl;
int i, rank, shape[30], numitems;
Type type;
Category category;
Array data, new_data;
RGBColor *dp_old, *dp_new;
Object subo;
float red, green, blue, hue, sat, val;
    
    if (!(cl = DXGetObjectClass(out))) 
      return ERROR;
    switch (cl) {
       case CLASS_GROUP:
	  for (i=0; (subo = DXGetEnumeratedMember((Group)out, i, NULL)); i++) {
            if (!ConvertFieldObject((Object)subo, strin))
	        return ERROR;
            }
	  break;
       case CLASS_FIELD:
          if (DXEmptyField((Field)out))
             return OK;
          data = (Array)DXGetComponentValue((Field)out,"data");
          if (!data) { 
             DXSetError(ERROR_MISSING_DATA,"#10240", "data");
             return ERROR;
          }
          DXGetArrayInfo(data,&numitems,&type,&category,&rank,shape);
          if ((type != TYPE_FLOAT)||(category != CATEGORY_REAL)) {
             DXSetError(ERROR_DATA_INVALID,"#10331", "data");
             return ERROR;
          }
          if ((rank != 1)||(shape[0] != 3)) {
             DXSetError(ERROR_DATA_INVALID,"#10331", "data");
             return ERROR;
          }
          new_data = DXNewArray(TYPE_FLOAT,CATEGORY_REAL,1,3);
          new_data = DXAddArrayData(new_data, 0, numitems, NULL);
          dp_old = (RGBColor *)DXGetArrayData(data);
          dp_new = (RGBColor *)DXGetArrayData(new_data);
          if (!strcmp(strin,"hsv"))  {
              for (i=0; i<numitems; i++) {
                 if (!_dxfHSVtoRGB(dp_old[i].r, dp_old[i].g, dp_old[i].b,
                               &red, &green, &blue))
                     return ERROR;
                 dp_new[i] = DXRGB(red,green,blue);
              }
          }
          else {
              for (i=0; i<numitems; i++) {
                 if (!_dxfRGBtoHSV(dp_old[i].r, dp_old[i].g, dp_old[i].b,
                               &hue, &sat, &val))
                     return ERROR;
                 dp_new[i] = DXRGB(hue, sat, val);
              }
          }
          DXSetComponentValue((Field)out, "data", (Object)new_data);
          DXChangedComponentValues((Field)out,"data");
          DXEndField((Field)out);
	  break;
       default:
          break;
    }

    return OK; 
    
  }
Exemplo n.º 5
0
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 );
      }

}
Exemplo n.º 6
0
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 );
      }

}
Exemplo n.º 7
0
static int
doLeaf(Object *in, Object *out)
{
    int i, result=0;
    Array array;
    Field field;
    Pointer *in_data[2], *out_data[1];
    int in_knt[2], out_knt[1];
    Type type;
    Category category;
    int rank, shape;
    Object attr, src_dependency_attr = NULL;
    char *src_dependency = NULL;
    /*
     * Irregular positions info
     */
    int p_knt, p_dim;
    float *p_positions;
    int c_knt = -1;

    /* User-added declarations */
    float *scratch, *in_ptr, size;
    Point inpoint, *out_pos_ptr;
    ArrayHandle handle;
    Array connections;
    Line *conn_ptr;

    /*
     * positions and/or connections are required, so the first must
     * be a field.
     */
    if (DXGetObjectClass(in[0]) != CLASS_FIELD)
    {
        DXSetError(ERROR_DATA_INVALID,
                   "positions and/or connections unavailable in array object");
        goto error;
    }
    else
    {

        field = (Field)in[0];

        if (DXEmptyField(field))
            return OK;

        /*
         * Determine the dependency of the source object's data
         * component.
         */
        src_dependency_attr = DXGetComponentAttribute(field, "data", "dep");
        if (! src_dependency_attr)
        {
            DXSetError(ERROR_MISSING_DATA, "\"input\" data component is missing a dependency attribute");
            goto error;
        }

        if (DXGetObjectClass(src_dependency_attr) != CLASS_STRING)
        {
            DXSetError(ERROR_BAD_CLASS, "\"input\" dependency attribute");
            goto error;
        }

        src_dependency = DXGetString((String)src_dependency_attr);

        array = (Array)DXGetComponentValue(field, "positions");
        if (! array)
        {
            DXSetError(ERROR_BAD_CLASS, "\"input\" contains no positions component");
            goto error;
        }

        /* change to doLeaf so that regular positions are not expanded */

        if (!(handle = DXCreateArrayHandle(array)))
            goto error;

        scratch = DXAllocate(3*sizeof(float));
        if (!scratch)
            goto error;

        DXGetArrayInfo(array, &p_knt, NULL, NULL, NULL, &p_dim);


    }

    /* New User code starts here */

    /* Make the new positions array for the output */
    array = DXNewArray(TYPE_FLOAT, CATEGORY_REAL, 1, 3);
    if (! array)
        goto error;


    /* Check that the positions are three dimensional: */
    if (p_dim != 3) {
        DXSetError(ERROR_DATA_INVALID,"input positions must be 3-dimensional");
        goto error;
    }
    /* Allocate space in the new positions array */
    if (! DXAddArrayData(array, 0, 4*p_knt, NULL))
        goto error;

    /* Get a pointer to the output positions */
    out_pos_ptr  = (Point *)DXGetArrayData(array);


    /* Make a connections component for the output */
    connections = DXNewArray(TYPE_INT, CATEGORY_REAL, 1, 2);

    /* Allocate space in the new connections array */
    if (! DXAddArrayData(connections, 0, 2*p_knt, NULL))
        goto error;
    DXSetAttribute((Object)connections, "element type",
                   (Object)DXNewString("lines"));
    /* Get a pointer to the new connections */
    conn_ptr = (Line *)DXGetArrayData(connections);

    /* Now "draw" the x's */
    for (i=0; i< p_knt; i++) {
        /* the following line accesses the position via the
         * array handling routines
         */
        in_ptr = (float *)DXIterateArray(handle, i, in_ptr, scratch);
        inpoint = DXPt(in_ptr[0], in_ptr[1], in_ptr[2]);
        DXExtractFloat(in[1], &size);
        out_pos_ptr[4*i]   = DXPt(inpoint.x - size, inpoint.y, inpoint.z);
        out_pos_ptr[4*i+1] = DXPt(inpoint.x + size, inpoint.y, inpoint.z);
        out_pos_ptr[4*i+2] = DXPt(inpoint.x, inpoint.y - size, inpoint.z);
        out_pos_ptr[4*i+3] = DXPt(inpoint.x, inpoint.y + size, inpoint.z);

        conn_ptr[2*i] = DXLn(4*i, 4*i+1);
        conn_ptr[2*i+1] = DXLn(4*i+2, 4*i+3);
    }

    /* Clean up; we're about to significantly modify the positions and connections
     */
    DXChangedComponentStructure((Field)out[0],"positions");
    DXChangedComponentStructure((Field)out[0],"connections");

    /* Now place the new positions and connections in the output field */
    DXSetComponentValue((Field)out[0], "positions", (Object)array);
    DXSetComponentValue((Field)out[0], "connections", (Object)connections);

    /* Finalize the field */
    DXEndField((Field)out[0]);

    /* Delete scratch and handle */
    DXFree((Pointer)scratch);
    DXFreeArrayHandle(handle);

    /* return */
    return OK;
error:

    /* Delete scratch and handle */
    DXFree((Pointer)scratch);
    DXFreeArrayHandle(handle);
    return ERROR;


}