Example #1
0
static Error ConvertObject(Object in, char *strin, Object *out)
{

Class cl;
    
    if (!(cl = DXGetObjectClass(in))) 
      return ERROR;
    switch (cl) {
       case CLASS_GROUP:
          DXSetError(ERROR_DATA_INVALID,"colormaps must be a single field");
          return ERROR;
       case CLASS_FIELD:
          if (!strcmp(strin,"hsv"))  {
            if (!(*out = (Object)_dxfMakeRGBColorMap((Field)in))) 
	        return ERROR;
          }
          else {
            if (!(*out = (Object)_dxfMakeHSVfromRGB((Field)in))) 
	        return ERROR;
          }
	  break;
       default:
          break;
    }

    return OK; 
    
  }
Example #2
0
/* unlike Inquire, say yes if you find any */
static int queryNDconnections(Field f, int n)
{
    char *cp;
    Object con;
    
    
    if (!(con = DXGetComponentValue(f, "connections"))) {
	if (n == 0)
	    return 1;
	return 0;
    }
    
    if (DXGetObjectClass(con) != CLASS_ARRAY)
	return 0;
    
    if (!DXGetStringAttribute(con, "element type", &cp))
	return 0;
    
    if (!strcmp(cp, "lines") && (n == 1))
	return 1;
    
    if ((!strcmp(cp, "triangles") || !strcmp(cp, "quads")) && (n == 2))
	return 1;
    
    if ((!strcmp(cp, "tetrahedra") || !strcmp(cp, "cubes")) && (n == 3))
	return 1;

    if (!strncmp(cp, "cubes", 5) && (strlen(cp) > 5) && (n > 3))
	return 1;

    return 0;
}
Example #3
0
static Error 
ExtractMatrix(Object o, Matrix *m)
{
    Pointer p;
    int i, items, shape[2];
    Type type;
    float *fp;

    if (DXGetObjectClass(o) != CLASS_ARRAY)
	return ERROR;
    
    if (!DXTypeCheck((Array)o, TYPE_FLOAT, CATEGORY_REAL, 2, 3, 3) &&
	!DXTypeCheck((Array)o, TYPE_FLOAT, CATEGORY_REAL, 2, 4, 3) &&
        !DXTypeCheck((Array)o, TYPE_INT, CATEGORY_REAL, 2, 3, 3) &&
	!DXTypeCheck((Array)o, TYPE_INT, CATEGORY_REAL, 2, 4, 3))
	return ERROR;

    if (!DXGetArrayInfo((Array)o, &items, &type, NULL, NULL, shape))
	return ERROR;

    if (items != 1)
	return ERROR;

    p = DXGetArrayData((Array)o);
    items = shape[0] * shape[1];

    if (type == TYPE_FLOAT)
	memcpy((char *)m, (char *)p, items * sizeof(float));
    else
	for (i=0, fp=(float *)m; i<items; i++, fp++)
	    *fp = (float)((int *)p)[i];

    return OK;
}
Example #4
0
/* return how many items in this field are valid */
static Error validcount(Field f, char *component, int *icount)
{
    Array a = NULL;
    char *dep = NULL;
    char *invalid = NULL;
    InvalidComponentHandle ih;

    /* assume none and be happily surprised when it finds some */
    *icount = 0;

    /* this must be called at the field level.  if you want to recurse
     * through a hierarchy, do the recursion above this subroutine.
     */
    if (DXGetObjectClass((Object)f) != CLASS_FIELD) {
	Return_Internal_Error;
    }
    
    a = (Array)DXGetComponentValue(f, component);
    if (!a) {
	DXSetError(ERROR_DATA_INVALID, "field has no `%s' component",
		   component);
	return ERROR;
    }

    /* follow a dependency. */
    if (!DXGetStringAttribute((Object)a, "dep", &dep)) {
	DXSetError(ERROR_DATA_INVALID, 
		   "The `%s' component does not have a `dep' attribute",
		   component);
	return ERROR;
    }
    
    if (!DXGetArrayInfo(a, icount, NULL, NULL, NULL, NULL))
	return ERROR;

#define INVLEN 10     /* strlen("invalid "); */    
    
    if (!(invalid = (char *)DXAllocate(strlen(dep) + INVLEN)))
	return ERROR;

    strcpy(invalid, "invalid ");
    strcat(invalid, dep);

    /* if no invalid component, all valid */
    if (!DXGetComponentValue(f, invalid)) {
	DXFree((Pointer)invalid);
	return OK;
    }
    DXFree((Pointer)invalid);

    ih = DXCreateInvalidComponentHandle((Object)f, NULL, dep);
    if (!ih) 
	return ERROR;

    *icount = DXGetValidCount(ih);
    DXFreeInvalidComponentHandle(ih);

    return OK;
}
Example #5
0
static int qimage(Object o)
{
    int n;
    Array a;
    char *s;
    
    /* an image has got to be a field or a composite field */
    if (DXGetObjectClass(o) != CLASS_FIELD) {
	if (DXGetObjectClass(o) != CLASS_GROUP)
	    return 0;
	if (DXGetGroupClass((Group)o) != CLASS_COMPOSITEFIELD)
	    return 0;
	o = DXGetEnumeratedMember((Group)o, 0, NULL);
    }

    /* check to see if it's the right shape, etc */

    /* check positions */
    a = (Array) DXGetComponentValue((Field)o, "positions");
    if (!a || !DXQueryGridPositions(a, &n, NULL, NULL, NULL) || n!=2)
	return 0;
    
    /* check connections */
    a = (Array) DXGetComponentValue((Field)o, "connections");
    if (!a || !DXQueryGridConnections(a, &n, NULL) || n!=2)
	return 0;

    /* is there a colors component */
    a = (Array) DXGetComponentValue((Field)o, "colors");
    if (!a)
	return 0;

    /* check dep */
    s = DXGetString((String)DXGetAttribute((Object)a, "dep"));
    if (s && strcmp(s, "positions"))
	return 0;
    
    return 1;
}
Example #6
0
static uint32 
computeRecipe(Program *p, int ind)
{
    ProgramVariable *pv;
    Object obj;
    uint32 tcrc;
    gvar *gv;

    if (ind == -1) 
        return(computeDefaultRecipe (NULL));

    pv = FETCH_LIST(p->vars, ind);
    gv = pv->gv;
    /* gv will be null for prehidden inputs for outboards, anything else?*/
    if(!gv)
        gv = _dxf_ExCreateGvar(GV_UNRESOLVED);

    /* if input already has a recipe, just use it,
     * Otherwise, it must be some kind of known variable
     */
    if (gv->reccrc == 0)
    {
	obj = gv->obj;
	if (obj == NULL)
	    obj = pv->dflt;

	if (obj == NULL)
	    tcrc = computeDefaultRecipe (obj);
	else
	{
	    switch (DXGetObjectClass (obj))
	    {
		case CLASS_ARRAY:
		    tcrc = computeArrayRecipe ((Array) obj);
		    break;

		case CLASS_STRING:
		    tcrc = computeStringRecipe ((String) obj);
		    break;

		default:
		    tcrc = computeDefaultRecipe (obj);
		    break;
	    }
	}
        pv->reccrc = gv->reccrc = tcrc;
	DXSetObjectTag (obj, tcrc);
    }

    return(gv->reccrc);
}
Example #7
0
Error
m_Options(Object *in, Object *out)
{
    Object a, v;
    char *s;
    int i;

    /* check input object */
    if (!in[0]) {
	DXSetError(ERROR_BAD_PARAMETER, "#10000", "input");
	return ERROR;
    }
   
    /* create output copy */
    out[0] = DXCopy(in[0], COPY_HEADER);
    if (!out[0])
	return ERROR;

    /* arrays don't copy by default - you have to call something special
     *  to get a new copy.
     */
    if (out[0] == in[0] && DXGetObjectClass(in[0]) == CLASS_ARRAY) {
	out[0] = (Object)_dxfReallyCopyArray((Array)in[0]);
	if (!out[0])
	    return ERROR;
    }

    /* set attributes */
    for (i=0; i<PAIRS; i++) {
	a = in[2*i+1];
	v = in[2*i+2];
	if (a) {
	    if (!DXExtractString(a, &s)) {
		DXSetError(ERROR_BAD_PARAMETER, "#10200", "attribute name");
		goto error;
	    }
	    /* NB - ok for v to be NULL - this deletes the attribute */
	    if (!DXSetAttribute(out[0], s, v)) 
		goto error;
	}
    }
    
    return OK;

error:
    if (out[0] != in[0])
	DXDelete(out[0]);
    out[0] = NULL;
    return ERROR;
}
Example #8
0
static void
Slide2DSetRenderable(void *data, Object obj)
{
    Slide2DData sdata = (Slide2DData)data;
    if (sdata->obj)
	DXDelete(sdata->obj);

    /*
     * Scarf up the scene object group
     */
    if (DXGetObjectClass(obj) != CLASS_GROUP)
    {
	DXWarning("Slide2D: Object must be a group of transfomrmed objects");
	sdata->obj = NULL;
    }
    else
	sdata->obj = DXReference(obj);
}
Example #9
0
static void
CaptionSetRenderable(void *data, Object obj)
{
    CaptionData sdata = (CaptionData)data;
    if (sdata->obj)
	DXDelete(sdata->obj);

    /*
     * Receive the current state of the object
     */
    if (DXGetObjectClass(obj) != CLASS_GROUP)
    {
	DXWarning("Caption: Object must be a group");
	sdata->obj = NULL;
    }
    else
	sdata->obj = DXReference(obj);
}
Example #10
0
static Error atleast1image(Object o)
{
    Object subo, old;
    int i;

    switch (DXGetObjectClass(o)) {
      case CLASS_FIELD:
	if (qimage(o))
	    return OK;
	break;

      case CLASS_GROUP:
	/* traverse members */
	for (i=0; subo = DXGetEnumeratedMember((Group)o, i, NULL); i++)
	    if (atleast1image(subo))
		return OK;
	break;
    
      case CLASS_SCREEN:
	if (!DXGetScreenInfo((Screen)o, &subo, NULL, NULL))
	    return ERROR;

	return atleast1image(subo);

      case CLASS_XFORM:
	if (!DXGetXformInfo((Xform)o, &subo, NULL))
	    return ERROR;

	return atleast1image(subo);

      case CLASS_CLIPPED:
	if (!DXGetClippedInfo((Clipped)o, &subo, NULL))
	    return ERROR;

	return atleast1image(subo);

      default:
	break;
    }

    return ERROR;
}
Example #11
0
static Error atleast1contype(Object o, int n)
{
    Object subo, old;
    int i;

    switch (DXGetObjectClass(o)) {
      case CLASS_FIELD:
	if (queryNDconnections((Field)o, n))
	    return OK;
	break;

      case CLASS_GROUP:
	/* traverse members */
	for (i=0; subo = DXGetEnumeratedMember((Group)o, i, NULL); i++)
	    if (atleast1contype(subo, n))
		return OK;
	break;
    
      case CLASS_SCREEN:
	/* these don't act like other objs;  don't count them for this */
	break;

      case CLASS_XFORM:
	if (!DXGetXformInfo((Xform)o, &subo, NULL))
	    return ERROR;

	return atleast1contype(subo, n);

      case CLASS_CLIPPED:
	if (!DXGetClippedInfo((Clipped)o, &subo, NULL))
	    return ERROR;

	return atleast1contype(subo, n);

      default:
	break;
    }

    return ERROR;
}
Example #12
0
static void *
Slide2DInitMode(Object args, int w, int h, int *mask)
{
    Slide2DData sdata = (Slide2DData)DXAllocateZero(sizeof(struct slide2DData));
    if (! sdata)
	return NULL;

    /* 
     * Parse the argument.  It better be a string or an integer.
     */
    if (! args)
    {
        DXWarning("Slide2D: argument required (index 0 used)");
	sdata->label = NULL;
	sdata->index = 0;
    }
    else if (DXGetObjectClass(args) == CLASS_STRING)
    {
	sdata->args = DXReference(args);
	sdata->label = DXGetString((String)args);
    }
    else if (DXGetObjectClass(args) == CLASS_ARRAY)
    {
	Type t;

	DXGetArrayInfo((Array)args, NULL, &t, NULL, NULL, NULL);
	if (t == TYPE_INT)
	{
	    sdata->args = DXReference(args);
	    sdata->index = *(int *)DXGetArrayData((Array)args);
	    sdata->label = NULL;
	}
	else if (t == TYPE_UBYTE ||
		 t == TYPE_BYTE  ||
		 t == TYPE_STRING)
	{
	    sdata->args = DXReference(args);
	    sdata->label = (char *)DXGetArrayData((Array)args);
	    sdata->index = -1;
	}
	else
	{
	    DXWarning("Slide2D: argument must be string or int (index 0 used)");
	    sdata->label = NULL;
	    sdata->index = 0;
	}

    }

    /*
     * Save the window width and height for scaling purposes
     */
    sdata->w = w;
    sdata->h = h;

    /*
     * Initially, the button is up
     */
    sdata->strokeStart = 1;

    /* 
     * Pay attention to only the left and middle buttons
     */
    *mask = DXEVENT_LEFT | DXEVENT_MIDDLE;
	
    return (void *)sdata;
}
Example #13
0
Error
m_Light(Object *in, Object *out)
{
    Vector v;
    RGBColor c;
    int camera = 0;
    char *colorstr;

    /* if first parm isn't a vector, try to see if it's a camera object.
     *  if so, use the same calculation as the renderer uses for the default
     *  light - slightly to the left of the camera position.
     */
    if (!in[0]) {
	v.x = v.y = 0.0;
	v.z = 1.0;
    } 
    else if (!DXExtractParameter(in[0], TYPE_FLOAT, 3, 1, (Pointer)&v)) {

	if (DXGetObjectClass(in[0]) == CLASS_CAMERA) {
	    Point from, to;
	    Vector eye, up, left;

	    DXGetView((Camera)in[0], &from, &to, &up);
	    eye = DXNormalize(DXSub(from,to));
	    left = DXCross(eye, up);
	    v = DXAdd(eye, left);
	} 
	else {
	    DXSetError(ERROR_BAD_PARAMETER, "#10670", "`where'");
	    return ERROR;
	}
    }             


    /* color, default is white */
    if (!in[1]) {
	c.r = c.b = c.g = 1.0;
    } 
    else if (DXExtractString(in[1],&colorstr)) {
        if (!DXColorNameToRGB(colorstr, &c))
	    /* it sets a reasonable error string */
	    return ERROR;
    } 
    else if (!DXExtractParameter(in[1], TYPE_FLOAT, 3, 1, (Pointer)&c)) {
        DXSetError(ERROR_BAD_PARAMETER, "#10510", "color");
        return ERROR;
    }             

    
    /* absolute or camera relative? */
    if (in[2] && !DXExtractInteger(in[2], &camera)) {
        DXSetError(ERROR_BAD_PARAMETER, "#10070", "camera flag");
        return ERROR;
    }


    if (!camera)
	out[0] = (Object)DXNewDistantLight(v, c);
    else
	out[0] = (Object)DXNewCameraDistantLight(v, c);
    
		
    return(out[0] ? OK : ERROR);
}
Example #14
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 );

}
Example #15
0
Error 
_dxfValidate(Field f)
{
    Array current = NULL;
    Array target = NULL;
    char *tname, *cname;
    int ncurrent, ntarget, *ip;
    int index;
    unsigned char *cp;
    int i, j, lim, nitems;
    Type type, ref_type;
    Category cat;
    String s = NULL;
    Object o = NULL;
    int rank, shape[MAXRANK];
    int counts[MAXRANK];

    for (i=0; (current=(Array)DXGetEnumeratedComponentValue(f, i, &cname)); i++) {

	/* dep */
	if ((s = (String)DXGetAttribute((Object)current, "dep")) != NULL) {
	    /* make sure number of items matches number of items in dep */
	    if ((DXGetObjectClass((Object)s) != CLASS_STRING) ||
	        ((tname = DXGetString(s)) == NULL)) {
		DXSetError(ERROR_DATA_INVALID, 
			 Err_MustBeString, "dep", cname);
		return ERROR;
	    }
	    
	    if ((target = (Array)DXGetComponentValue(f, tname)) == NULL) {
		DXSetError(ERROR_DATA_INVALID, 
			 Err_MissingComp, tname, "dep", cname);
		return ERROR;
	    }
	    
	    if (DXGetObjectClass((Object)target) != CLASS_ARRAY) {
		DXSetError(ERROR_DATA_INVALID,
			 Err_NotArray, tname, "dep", cname);
		return ERROR;
	    }
	    
	    if (!DXGetArrayInfo(current, &nitems, &type, &cat, &rank, shape))
		return ERROR;
	    
	    ncurrent = nitems;

	    if (!DXGetArrayInfo(target, &nitems, &type, &cat, &rank, shape))
		return ERROR;
	    
	    ntarget = nitems;
	    
	    if (ncurrent != ntarget) {
		DXSetError(ERROR_DATA_INVALID,
			 Err_DiffCount, "dep",
			 ncurrent, cname, ntarget, tname);
		return ERROR;
	    }

	} /* end of if (has dep) */


	/* ref */
	if ((s = (String)DXGetAttribute((Object)current, "ref")) != NULL) {
	    if ((DXGetObjectClass((Object)s) != CLASS_STRING) ||
	        ((tname = DXGetString(s)) == NULL)) {
		DXSetError(ERROR_DATA_INVALID, 
			   Err_MustBeString, "ref", cname);
		return ERROR;
	    }
	    
	    if ((target = (Array)DXGetComponentValue(f, tname)) == NULL) {
		DXSetError(ERROR_DATA_INVALID,
			   Err_MissingComp, tname, "ref", cname);
		return ERROR;
	    }
	    
	    if (DXGetObjectClass((Object)target) != CLASS_ARRAY) {
		DXSetError(ERROR_DATA_INVALID, 
			   Err_NotArray, tname, "ref", cname);
		return ERROR;
	    }
	    
	    if (!DXGetArrayInfo(current, &nitems, &type, &cat, &rank, shape))
		return ERROR;
	    
	    if ( !( type == TYPE_INT || type == TYPE_UBYTE ) ) {
		DXSetError(ERROR_DATA_INVALID, Err_RefNotInt, cname);
		return ERROR;
	    }
	    ref_type = type;
	    
	    ncurrent = nitems;
	    for (j=0; j<rank; j++)
	        ncurrent *= shape[j];
	    
	    if (ncurrent > 0) {
                
		if (!DXGetArrayInfo(target, &nitems, &type, &cat, &rank, shape))
		    return ERROR;
		
		ntarget = nitems;
                
                /* only do this if they are already irregular */
                if (DXGetArrayClass(current) == CLASS_ARRAY) {
                    if ((ip = (int *)DXGetArrayData(current)) == NULL)
                        return ERROR;
		    cp = (unsigned char *) ip;
                    
		    /* neighbors can have -1's as indicies */
                    lim = strcmp(cname, "neighbors") ? 0 : -1;

		    for (j=0; j < ncurrent; j++) {
			if (ref_type == TYPE_INT) index = *(ip++);
			else                      index = *(cp++);

			if (index < lim || index >= ntarget) {
			    DXSetError(ERROR_DATA_INVALID, Err_OutOfRange,
				j+1, ending(j+1), cname, index, lim, ntarget-1);
			    return ERROR;
			}
		    }

                } else if (DXQueryGridConnections(current, &rank, counts)) {
		    for (j=0, ncurrent=1; j<rank; j++)
			ncurrent *= counts[j];
                    if (ncurrent > ntarget) {
                        DXSetError(ERROR_DATA_INVALID,
                                 Err_DiffCount, "ref",
                                 ncurrent, cname, ntarget, tname);
                        return ERROR;
                    }
                } else {
                    /* mesh array of mixed path and irregular arrays. */
                    /* have to handle the terms separately */
                }
	    }
	} /* end of if (has ref) */


        /* der - can be string lists here */
	if ((o = DXGetAttribute((Object)current, "der")) != NULL) {

	    if (DXExtractString(o, &tname)) {    /* simple string? */
		if ((target = (Array)DXGetComponentValue(f, tname)) == NULL) {
		    DXSetError(ERROR_DATA_INVALID,
			       Err_MissingComp, tname, "der", cname);
		    return ERROR;
		}
		
		if (DXGetObjectClass((Object)target) != CLASS_ARRAY) {
		    DXSetError(ERROR_DATA_INVALID,
			       Err_NotArray, tname, "der", cname);
		    return ERROR;
		}
	    } else if (DXExtractNthString(o, 0, &tname)) {  /* string list? */
		for (j=0; DXExtractNthString(o, j, &tname); j++) {
		    
		    if ((target = (Array)DXGetComponentValue(f, tname)) == NULL) {
			DXSetError(ERROR_DATA_INVALID,
				   Err_MissingComp, tname, "der", cname);
			return ERROR;
		    }
		    
		    if (DXGetObjectClass((Object)target) != CLASS_ARRAY) {
			DXSetError(ERROR_DATA_INVALID,
				   Err_NotArray, tname, "der", cname);
			return ERROR;
		    }
		}
	    } else {  /* neither string or string list */
		DXSetError(ERROR_DATA_INVALID, 
			   Err_MustBeStringList, "der", cname);
		return ERROR;
	    }
	    
	} /* end of if (has der) */

        /* element type */
	if ((s = (String)DXGetAttribute((Object)current, "element type")) != NULL) {
	    if ((DXGetObjectClass((Object)s) != CLASS_STRING) ||
	        ((tname = DXGetString(s)) == NULL)) {
		DXSetError(ERROR_DATA_INVALID, 
			 Err_MustBeString, "element type", cname);
		return ERROR;
	    }
	    
	    if (!strcmp(cname, "connections") && 
		DXQueryGridConnections(current, &rank, counts)) {

		if (!elemtypecheck(rank, tname))
		    return ERROR;
	    }

	} /* end of if (has element type) */

    }  /* for each component in the field */

    /* check for missing positions component if the field has more than
     *  one component.
     */
    if (i > 1 && !DXGetComponentValue(f, "positions"))
	DXWarning("importing a field with no `positions' component");

    return OK;
}
Example #16
0
static Error saydata(Object o, char *opt)
{
    Array a;
    int nitems;
    Type type;
    Category category;
    int rank;
    int shape[MAXRANK];
    int valids;
    Point boxlist[8];
    Point vboxlist[8];
    float min, max, avg;

    if (DXGetObjectClass(o) == CLASS_ARRAY) {
	DXGetArrayInfo((Array)o, &nitems, &type, &category, &rank, shape);
	pinfo(1, nitems, nitems, type, category, rank, shape);
    } else if (DXGetObjectClass(o) == CLASS_FIELD) {
	a = (Array)DXGetComponentValue((Field)o, "positions");
	if (!a) {
	    DescribeMsg("The Field does not contain any positions.  It will not cause an error, but will be\n");
	    DescribeMsg("silently ignored by most modules since positions are required.\n");
	    DescribeMsg("Use the `Mark' or `Replace' module to create a `positions' component.\n");
	}
	a = (Array)DXGetComponentValue((Field)o, "data");
	if (!a) {
	    DescribeMsg("The Field contains nothing marked as data items.\n");
            DescribeMsg("If the Field does contain data under another name, use the `Mark' module\n");
            DescribeMsg("to select what should be used as data.\n");
	} else {
	    DXGetArrayInfo(a, &nitems, &type, &category, &rank, shape);
	    if (!validcount((Field)o, "data", &valids))
		return ERROR;
	    pinfo(1, nitems, valids, type, category, rank, shape);
	}
    } else if (!DXGetType((Object)o, &type, &category, &rank, shape)) {
	/* DescribeMsg("no data type information\n"); */
	DXResetError();
    } else
	pinfo(0, 0, 0, type, category, rank, shape);

    /* get bbox and print it in a non-threatening format */
    if (!DXBoundingBox(o, boxlist)) {
	/* DescribeMsg("Cannot get information about the positions of the data\n"); */
	DXResetError();
    } else {
	DescribeMsg("The positions are enclosed within the box defined by the corner points:\n");
	DescribeMsg("[ %g %g %g ] and [ %g %g %g ]\n", 
		  boxlist[0].x, boxlist[0].y, boxlist[0].z,
		  boxlist[7].x, boxlist[7].y, boxlist[7].z);
    }
    if (!DXValidPositionsBoundingBox(o, vboxlist)) {
	/* DescribeMsg("Cannot get information about the valid positions of the data\n"); */
	DXResetError();
    } else {
	if ((boxlist[0].x != vboxlist[0].x) || (boxlist[7].x != vboxlist[7].x)
	 || (boxlist[0].y != vboxlist[0].y) || (boxlist[7].y != vboxlist[7].y)
	 || (boxlist[0].z != vboxlist[0].z) || (boxlist[7].z != vboxlist[7].z)) {
	    DescribeMsg("The VALID positions are enclosed within the box defined by the corner points:\n");
	    DescribeMsg("[ %g %g %g ] and [ %g %g %g ]\n", 
		      vboxlist[0].x, vboxlist[0].y, vboxlist[0].z,
		      vboxlist[7].x, vboxlist[7].y, vboxlist[7].z);
	}
    }

    /* something about data stats */
    if (!DXStatistics(o, "data", &min, &max, &avg, NULL)) {
	/* DescribeMsg("Cannot get information about the data values\n"); */
	DXResetError();
    } else {
	DescribeMsg("Data range is:\n");
	DescribeMsg("minimum = %g, maximum = %g, average = %g\n", 
		    min, max, avg);
	if (rank > 0) {
	    /* ??? call vectorstats here if rank >= 1 
	     * look at the code in histogram; does rank=1, nothing
	     * about larger.
	     */
	    DescribeMsg("(These are the scalar statistics which will be used by modules\n");
	    DescribeMsg("which need scalar values.  The length is computed for vectors and\n");
	    DescribeMsg("the determinant for matricies.)\n");
	}
    }
    return OK;
	
}
Example #17
0
/* accumulate info about what's what
 */
static Error traverse(Object o, struct info *ip, int nosee)
{
    Object subo;
    Class curclass;
    int i;

    switch (curclass = DXGetObjectClass(o)) {
      case CLASS_FIELD:
	return validfield((Field)o, ip, nosee);
	
      case CLASS_GROUP:
	/* traverse members */
	for (i=0; (subo = DXGetEnumeratedMember((Group)o, i, NULL)); i++) {
	    if (!traverse(subo, ip, nosee))
		return ERROR;
	}
	break;
	
      case CLASS_SCREEN:
	if (!DXGetScreenInfo((Screen)o, &subo, NULL, NULL))
	    return ERROR;

	return traverse(subo, ip, 1);

      case CLASS_XFORM:
	if (!DXGetXformInfo((Xform)o, &subo, NULL))
	    return ERROR;

	return traverse(subo, ip, nosee);

      case CLASS_CLIPPED:
	if (!DXGetClippedInfo((Clipped)o, &subo, NULL))
	    return ERROR;

	return traverse(subo, ip, nosee);  /* is this right? */

      case CLASS_LIGHT:
	ip->ri.nlights++;
	break;
	
      case CLASS_INTERPOLATOR:
      case CLASS_MAX:
      case CLASS_MIN:
      case CLASS_PRIVATE:
      case CLASS_DELETED:
      case CLASS_STRING:
      case CLASS_ARRAY:
      case CLASS_CAMERA:	
      default:
	for (i=0; i<ip->ri.badobjs; i++) {
	    if (ip->ri.badclass[i] == curclass)
		return OK;
	}
	ip->ri.badobjs++;
	ip->ri.badclass = (Class *)DXReAllocate((Pointer)ip->ri.badclass, 
						sizeof(Class) * ip->ri.badobjs);
	ip->ri.badclass[ip->ri.badobjs - 1] = curclass;

	break;
    }

    return OK;
}
Example #18
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; 
    
  }
Example #19
0
/* make sure the field contains colors and that > 1 are valid.
 * i guess we can look to see that the positions are 1D <= p <= 3D
 * as well.  and we could look at connections here as well.
 */
static Error validfield(Field f, struct info *ip, int nosee)
{
    int icount = 0;
    Array colors, pos, conn;
    char *elem = NULL;
    char *dep = NULL;
    char *invalid = NULL;
    InvalidComponentHandle ih;

    
    /* check for fields - recurse above this */
    if (DXGetObjectClass((Object)f) != CLASS_FIELD) {
	Return_Internal_Error;
    }

    /* check pos first */
    pos = (Array)DXGetComponentValue(f, "positions");
    if (!pos) {
	ip->np.nopos++;
	return OK;
    }

    if (!DXGetArrayInfo(pos, &icount, NULL, NULL, NULL, NULL))
	return ERROR;

    if (icount <= 0) {
	ip->np.nopos++;
	return OK;
    }

    /* pos must be vector, rank 1,  1 <= shape <= 3 */
    if ((!DXTypeCheck(pos, TYPE_FLOAT, CATEGORY_REAL, 1, 1)) &&
	(!DXTypeCheck(pos, TYPE_FLOAT, CATEGORY_REAL, 1, 2)) &&
	(!DXTypeCheck(pos, TYPE_FLOAT, CATEGORY_REAL, 1, 3))) {
	ip->ri.badpos++;
	return OK;
    }

    /* check Nd of conn here.  if "nosee" is true, don't count the
     * Nd of the connections because normal modules won't "see" these
     * as normal fields.
     */
    
    if (!nosee) {
	conn = (Array)DXGetComponentValue(f, "connections");
	if (!conn)
	    ip->nd.c0++;
	else if (DXGetObjectClass((Object)conn) != CLASS_ARRAY)
	    ip->nd.cbad++;
	else if (!DXGetStringAttribute((Object)conn, "element type", &elem))
	    ip->nd.cmissing++;
	else if (!strcmp(elem, "lines"))
	    ip->nd.c1++;
	else if (!strcmp(elem, "triangles") || !strcmp(elem, "quads"))
	    ip->nd.c2++;
	else if (!strcmp(elem, "tetrahedra") || !strcmp(elem, "cubes"))
	    ip->nd.c3++;
	else if (!strncmp(elem, "cubes", 5) && (strlen(elem) > 5))
	    ip->nd.cplus++;
	else
	    ip->nd.cbad++;
    }

   
    /* expect colors and follow dependency */
    colors = (Array)DXGetComponentValue(f, "colors");
    if (!colors) {
	ip->ri.nocolors++;
	return OK;
    } else {
	/* check for colormap component */
	if (DXGetComponentValue(f, "color map") != NULL)
	    ip->nc.cbytemap++;
	else if (DXTypeCheck(colors, TYPE_UBYTE, CATEGORY_REAL, 1, 3))
	    ip->nc.cubyte++;	
	else if (DXTypeCheck(colors, TYPE_FLOAT, CATEGORY_REAL, 1, 3))
	    ip->nc.cfloat++;
	else
	    ip->nc.cunknown++; 
    }

    /* follow colors dependency.  it will be unusual to find no dep. */
    if (!DXGetStringAttribute((Object)colors, "dep", &dep)) {
	ip->np.nodep++;
	return OK;
    }
    
    if (!DXGetArrayInfo(colors, &icount, NULL, NULL, NULL, NULL))
	return ERROR;

    if (icount == 0) {
	ip->np.novalid++;
	return OK;
    }
	
#define INVLEN 10     /* strlen("invalid "); */    
    
    if (!(invalid = (char *)DXAllocate(strlen(dep) + INVLEN)))
	return ERROR;

    strcpy(invalid, "invalid ");
    strcat(invalid, dep);

    /* if no invalid component, all valid */
    if (!DXGetComponentValue(f, invalid)) {
	DXFree((Pointer)invalid);
	ip->ri.nfields++;
	return OK;
    }
    DXFree((Pointer)invalid);

    ih = DXCreateInvalidComponentHandle((Object)f, NULL, dep);
    if (!ih) 
	return ERROR;

    icount = DXGetValidCount(ih);
    DXFreeInvalidComponentHandle(ih);

    if (icount == 0) {
	ip->np.novalid++;
	return OK;
    }

    ip->ri.nfields++;
    return OK;
}
Example #20
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;
}
Example #21
0
static Error
traverse(Object *in, Object *out)
{
    switch(DXGetObjectClass(in[0]))
    {
    case CLASS_FIELD:
    case CLASS_ARRAY:
        /*
         * If we have made it to the leaf level, call the leaf handler.
         */
        if (! doLeaf(in, out))
            return ERROR;

        return OK;

    case CLASS_GROUP:
    {
        int   i, j;
        int   memknt;
        Class groupClass  = DXGetGroupClass((Group)in[0]);

        DXGetMemberCount((Group)in[0], &memknt);


        /*
         * Create new in and out lists for each child
         * of the first input.
         */
        for (i = 0; i < memknt; i++)
        {
            Object new_in[2], new_out[1];

            /*
             * For all inputs that are Values, pass them to
             * child object list.  For all that are Field/Group, get
             * the appropriate decendent and place it into the
             * child input object list.
             */

            /* input "input" is Field/Group */
            if (in[0])
                new_in[0] = DXGetEnumeratedMember((Group)in[0], i, NULL);
            else
                new_in[0] = NULL;

            /* input "size" is Value */
            new_in[1] = in[1];

            /*
             * For all outputs that are Values, pass them to
             * child object list.  For all that are Field/Group,  get
             * the appropriate decendent and place it into the
             * child output object list.  Note that none should
             * be NULL (unlike inputs, which can default).
             */

            /* output "output" is Field/Group */
            new_out[0] = DXGetEnumeratedMember((Group)out[0], i, NULL);

            if (! traverse(new_in, new_out))
                return ERROR;

            /*
             * Now for each output that is not a Value, replace
             * the updated child into the object in the parent.
             */

            /* output "output" is Field/Group */
            DXSetEnumeratedMember((Group)out[0], i, new_out[0]);

        }
        return OK;
    }

    case CLASS_XFORM:
    {
        int    i, j;
        Object new_in[2], new_out[1];


        /*
         * Create new in and out lists for the decendent of the
         * first input.  For inputs and outputs that are Values
         * copy them into the new in and out lists.  Otherwise
         * get the corresponding decendents.
         */

        /* input "input" is Field/Group */
        if (in[0])
            DXGetXformInfo((Xform)in[0], &new_in[0], NULL);
        else
            new_in[0] = NULL;

        /* input "size" is Value */
        new_in[1] = in[1];

        /*
         * For all outputs that are Values, copy them to
         * child object list.  For all that are Field/Group,  get
         * the appropriate decendent and place it into the
         * child output object list.  Note that none should
         * be NULL (unlike inputs, which can default).
         */

        /* output "output" is Field/Group */
        DXGetXformInfo((Xform)out[0], &new_out[0], NULL);

        if (! traverse(new_in, new_out))
            return ERROR;

        /*
         * Now for each output that is not a Value replace
         * the updated child into the object in the parent.
         */

        /* output "output" is Field/Group */
        DXSetXformObject((Xform)out[0], new_out[0]);

        return OK;
    }

    case CLASS_SCREEN:
    {
        int    i, j;
        Object new_in[2], new_out[1];


        /*
         * Create new in and out lists for the decendent of the
         * first input.  For inputs and outputs that are Values
         * copy them into the new in and out lists.  Otherwise
         * get the corresponding decendents.
         */

        /* input "input" is Field/Group */
        if (in[0])
            DXGetScreenInfo((Screen)in[0], &new_in[0], NULL, NULL);
        else
            new_in[0] = NULL;

        /* input "size" is Value */
        new_in[1] = in[1];


        /*
         * For all outputs that are Values, copy them to
         * child object list.  For all that are Field/Group,  get
         * the appropriate decendent and place it into the
         * child output object list.  Note that none should
         * be NULL (unlike inputs, which can default).
         */

        /* output "output" is Field/Group */
        DXGetScreenInfo((Screen)out[0], &new_out[0], NULL, NULL);

        if (! traverse(new_in, new_out))
            return ERROR;

        /*
         * Now for each output that is not a Value, replace
         * the updated child into the object in the parent.
         */

        /* output "output" is Field/Group */
        DXSetScreenObject((Screen)out[0], new_out[0]);

        return OK;
    }

    case CLASS_CLIPPED:
    {
        int    i, j;
        Object new_in[2], new_out[1];


        /* input "input" is Field/Group */
        if (in[0])
            DXGetClippedInfo((Clipped)in[0], &new_in[0], NULL);
        else
            new_in[0] = NULL;

        /* input "size" is Value */
        new_in[1] = in[1];


        /*
         * For all outputs that are Values, copy them to
         * child object list.  For all that are Field/Group,  get
         * the appropriate decendent and place it into the
         * child output object list.  Note that none should
         * be NULL (unlike inputs, which can default).
         */

        /* output "output" is Field/Group */
        DXGetClippedInfo((Clipped)out[0], &new_out[0], NULL);

        if (! traverse(new_in, new_out))
            return ERROR;

        /*
         * Now for each output that is not a Value, replace
         * the updated child into the object in the parent.
         */

        /* output "output" is Field/Group */
        DXSetClippedObjects((Clipped)out[0], new_out[0], NULL);

        return OK;
    }

    default:
    {
        DXSetError(ERROR_BAD_CLASS, "encountered in object traversal");
        return ERROR;
    }
    }
}
Example #22
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;


}
Example #23
0
static Error sayclass(Object o, char *intro, int descend)
{
    int count;

    switch (DXGetObjectClass(o)) {
	
      case CLASS_GROUP:
	if (!DXGetMemberCount((Group)o, &count))
	    return ERROR;
	
	switch(DXGetGroupClass((Group)o)) {
	    
	  case CLASS_GROUP:
	    DescribeMsg("%s %s Group which contains %d member%s.\n", 
		      intro, IS, count, (count==1 ? "" : "s"));
	    break;
	    
	  case CLASS_COMPOSITEFIELD:
	    DescribeMsg("%s %s Partitioned Field which contains %d partition%s.\n", 
		      intro, IS, count, (count==1 ? "" : "s"));
	    break;
	    
	  case CLASS_MULTIGRID:
	    DescribeMsg("%s %s Multigrid Group which contains %d member%s.\n", 
		      intro, IS, count, (count==1 ? "" : "s"));
	    break;
	    
	  case CLASS_SERIES:
	    DescribeMsg("%s %s Series Group which contains %d series member%s.\n", 
		      intro, IS, count, (count==1 ? "" : "s"));
	    DescribeMsg("To work with one member at a time use the `Select' module\n");

	    break;
	
	  default:
	    DescribeMsg("%s %s Group Object but of unrecognized Group Type.\n",
		      intro, IS);
	    break;
	}
	
	if (descend)
	    saymembers((Group)o);
	break;
	
      case CLASS_FIELD:
        DescribeMsg("%s %s Field, the basic data carrying structure in DX.\n", 
		  intro, IS);
        break;

      case CLASS_ARRAY:
	DescribeMsg("%s %s Array Object, containing a list of data values.\n",
		  intro, IS_V);

	switch (DXGetArrayClass((Array)o)) {
	    
	  case CLASS_ARRAY:
	    break;

	  case CLASS_PRODUCTARRAY:
	  case CLASS_MESHARRAY:
	  case CLASS_PATHARRAY:
	  case CLASS_CONSTANTARRAY:
	  case CLASS_REGULARARRAY:
	    DescribeMsg("These values are stored in a compact format to save space.\n");
	    break;
	
	  default:
	    DescribeMsg("The Array is of an unrecognized type.\n");
	    break;
	}

	/* ??? add code here ??? - print the first N values? */
	break;
	
      case CLASS_STRING:
	DescribeMsg("%s %s String, a list of character values\n",
		  intro, IS);
	DescribeMsg("It contains the value `%s'\n", DXGetString((String)o));
	break;
	
      case CLASS_CAMERA:
	DescribeMsg("%s %s Camera, used to set the viewpoint for Rendering.\n",
		  intro, IS);
	break;

      case CLASS_XFORM:
	DescribeMsg("%s %s Transformed object, meaning that a transformation will be applied to the final object before rendering.\n",
		  intro, IS);
	/* sayclass of xformed obj? */
	break;

      case CLASS_OBJECT:
	DescribeMsg("%s %s Generic Object, of unrecognized type.\n", intro, IS);
	break;

      case CLASS_LIGHT:
	DescribeMsg("%s %s Light, used to set the Lighting parameters for Rendering.\n",
		  intro, IS);
	break;
	
      case CLASS_CLIPPED:
	DescribeMsg("%s %s Clipped Object, which means that at Rendering time part of the object will be invisible.\n",
		    intro, IS);
	/* sayclass of clipped obj? */
	break;
	
      case CLASS_INTERPOLATOR:
	DescribeMsg("%s %s Interpolator. Internal use only.\n", intro, IS);
	break;
	
      case CLASS_SCREEN:
	DescribeMsg("%s %s Screen Object, meaning this object stays aligned with the screen.\n", 
		  intro, IS);
	/* say something about the screen obj? */
	break;
	
      case CLASS_MAX:
	DescribeMsg("Unrecognized Object.  Object type above Class Max.\n");
	break;
	
      case CLASS_MIN:
	DescribeMsg("Unrecognized Object.  Object type below Class Min.\n");
	break;

      case CLASS_PRIVATE:
	DescribeMsg("%s %s Private object, defined by a user.\n", intro, IS);
	break;

      case CLASS_DELETED:
	DescribeMsg("%s %s Deleted Object. Should not happen.\n", intro, IS);
	break;

      default:
	DescribeMsg("%s %s Unrecognized object.  Bad return from GetObjectType().\n",
		  intro, IS);
	break;
    }

    return OK;
}
Example #24
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 );

}
Example #25
0
int
m_Convert(Object *in, Object *out)
{
  Array    incolorvec, outcolorvec;
  int      ismap, isfield, count, i, ii, numitems, addpoints;
  char     *colorstrin, *colorstrout; 
  char     newstrin[30], newstrout[30];
  Object   gout;
  float    *dpin=NULL, *dpout=NULL;

  gout=NULL;
  incolorvec = NULL;
  outcolorvec = NULL;
   
  if (!in[0]) {
    DXSetError(ERROR_MISSING_DATA,"#10000","data");
    return ERROR;
  }
  out[0] = in[0];
  ismap = 0; 
  isfield = 0; 
  

  /*
   *  if it's an array (vector or list of vectors)
   */

  if (DXGetObjectClass(in[0]) == CLASS_ARRAY) {
    if (!(DXQueryParameter((Object)in[0], TYPE_FLOAT, 3, &numitems))) {
      /* must be a list of 3-vectors or a field */
      DXSetError(ERROR_BAD_PARAMETER,"#10550","data");
      out[0] = NULL;
      return ERROR;
    }
    if (!(incolorvec = DXNewArray(TYPE_FLOAT,CATEGORY_REAL, 1, 3))){
      out[0] = NULL;
      return ERROR;
    }
    if (!(DXAddArrayData(incolorvec,0,numitems,NULL)))
      goto error;
    if (!(dpin = (float *)DXGetArrayData(incolorvec)))
      goto error;
    if (!(DXExtractParameter((Object)in[0], TYPE_FLOAT, 3, numitems,
			   (Pointer)dpin))) {
      /* must be a list of 3-vectors or a field */
      DXSetError(ERROR_BAD_PARAMETER,"#10550","data");
      goto error;
    }

    /*    
     *  also make the output array
     */
    if (!(outcolorvec = DXNewArray(TYPE_FLOAT,CATEGORY_REAL, 1, 3)))
      goto error;
    if (!(DXAddArrayData(outcolorvec,0,numitems,NULL)))
      goto error;
    if (!(dpout = (float *)DXGetArrayData(outcolorvec)))
      goto error;

  }
  else { 
    if (_dxfIsColorMap(in[0])) 
      ismap = 1;
    else {
      DXResetError();
      isfield = 1;
    }
  }




  
  /* now extract the to and from space names */
  /*  get color name  */
  if (!(in[1]))
    colorstrin = "hsv";
  else 
    if (!DXExtractString((Object)in[1], &colorstrin)) {
      /* invalid input string */
      DXSetError(ERROR_BAD_PARAMETER,"#10200","incolorspace");
      goto error;
    }
  /*  convert color name to all lower case and remove spaces */
  count = 0;
  i = 0;
  while ( i<29 && colorstrin[i] != '\0') {
    if (isalpha(colorstrin[i])){
      if (isupper(colorstrin[i]))
	newstrin[count]= tolower(colorstrin[i]);
      else
	newstrin[count]= colorstrin[i];
      count++;
    }
    i++;
  }

  newstrin[count]='\0';
  if (strcmp(newstrin,"rgb")&&strcmp(newstrin,"hsv")) {
    DXSetError(ERROR_BAD_PARAMETER,"#10210", newstrin, "incolorspace");
    goto error;
  }
  
  
  if (!in[2]) 
    colorstrout = "rgb";
  else if (!DXExtractString((Object)in[2], &colorstrout)) {
      /* invalid outcolorspace string */
    DXSetError(ERROR_BAD_PARAMETER,"#10200","outcolorspace");
    goto error;
  }
  
  /*  convert color name to all lower case and remove spaces */
  count = 0;
  i = 0;
  while ( i<29 && colorstrout[i] != '\0') {
    if (isalpha(colorstrout[i])){
      if (isupper(colorstrout[i]))
	newstrout[count]= tolower(colorstrout[i]);
      else
	newstrout[count]= colorstrout[i];
      count++;
    }
    i++;
  }
  newstrout[count]='\0';
  if (strcmp(newstrout,"rgb")&&strcmp(newstrout,"hsv")){
    /* invalid outcolorspace string */
    DXSetError(ERROR_BAD_PARAMETER,"#10210", newstrout, "outcolorspace");
    goto error;
  }
  
  if (!strcmp(newstrin,newstrout)) {
    DXWarning("incolorspace and outcolorspace are the same");
    return OK;
  }

  if (!in[3]) {
     /* default behavior is to treat maps like maps (adding points)
        and to treat fields like fields (not adding points) */
  }
  else {
     if (!DXExtractInteger(in[3], &addpoints)) {
        DXSetError(ERROR_BAD_PARAMETER, "#10070",
                   "addpoints");
        goto error;
     }
     if ((addpoints < 0) || (addpoints > 1)) {
        DXSetError(ERROR_BAD_PARAMETER, "#10070",
                   "addpoints");
        goto error;
     }
     if (isfield && addpoints) {
        DXSetError(ERROR_BAD_PARAMETER, "#10370",
         "for a field with greater than 1D positions, addpoints", "0");
        goto error;
     }
     if (ismap && (!addpoints)) {
        /* treat the map like a field */
        ismap = 0;
        isfield = 1;
     }
  }

  /* we have been given a vector value or list of values, not a map */
  if ((!ismap)&&(!isfield)) {
    if (!strcmp(newstrin,"hsv")) {
      for (ii = 0; ii < numitems*3; ii = ii+3) {
	if (!(_dxfHSVtoRGB(dpin[ii], dpin[ii+1], dpin[ii+2],
		       &dpout[ii], &dpout[ii+1], &dpout[ii+2]))) 
	  goto error;
      }
    }
    else {
      for (ii = 0; ii < numitems*3; ii = ii+3) {
	if (!(_dxfRGBtoHSV(dpin[ii], dpin[ii+1], dpin[ii+2],
		       &dpout[ii], &dpout[ii+1], &dpout[ii+2]))) 
	  goto error;
      }
    }
    out[0] = (Object)outcolorvec;
    DXDelete((Object)incolorvec);
    return OK;
  }

  /* we have a map or field */
  else {
    if (ismap) {
      if (!(ConvertObject(in[0], newstrin, &gout)))
        goto error;
    }
    else {
      gout = DXCopy(in[0], COPY_STRUCTURE);
      if (!gout) goto error;
      if (!(ConvertFieldObject(gout, newstrin)))
         goto error;
    }
    out[0] = gout;
    return OK;
  }

  error:
    out[0] = NULL;
    DXDelete((Object)gout);
    DXDelete((Object)incolorvec);
    DXDelete((Object)outcolorvec);
    return ERROR;
}
Example #26
0
Error
_dxfAsyncRender (dxObject r, Camera c, char *obsolete, char *displayString)
{
    Private 	    cacheObject = NULL;
    tdmChildGlobalP   globals = NULL;
    char*		    cacheId = NULL;
    tdmParsedFormatT *pFormat = NULL;
    dxObject	   attr;


    ENABLE_DEBUG();
    DEBUG_MARKER("_dxfAsyncRender ENTRY");
    ENTRY(("_dxfAsyncRender (0x%x, 0x%x, \"%s\", \"%s\")",
           r, c, obsolete, displayString));

# if defined(DEBUG)

    if(DXGetAttribute(r, "force env var")) {
        char *Buff;

        if(DXExtractString(DXGetAttribute(r, "force env var"), &Buff)) {
            PRINT(("Putting Variable %s\n", Buff));
            putenv(Buff);
        }
    }
#  endif


    if (!c && !DXGetImageBounds(r,NULL,NULL,NULL,NULL))
        goto error;


    /* get host and window name from display string, fill in the cache id */
    if (!(pFormat = _tdmParseDisplayString (displayString, &cacheId)))
        goto error;

    /* validate the display string */
    if (!(_validateDisplayString(pFormat, 1)))
        goto error ;

    /* Get a pointer to the global data, out of the cache or create a new one. */
    if((cacheObject = (Private) DXGetCacheEntry(cacheId, 0, 0)) != NULL) {
        globals = (tdmChildGlobalP) DXGetPrivateData(cacheObject) ;
#if defined(DX_NATIVE_WINDOWS)
        /*
         * Now lock globals so that rendering doesn't occur in another
         * thread until the setup is done.  If we create a globals structure 
         * here, the lock is created in CreateRenderModule, and its created 
         * owned.
         */
        {
            DEFGLOBALDATA(globals);
            if (DXWaitForSignal(1, &LOCK) == WAIT_TIMEOUT)
                goto error;
        }
#endif

    } else {
        if(!(globals = (tdmChildGlobalP)_dxfCreateRenderModule(pFormat)))
            return ERROR;

        /* save globals in cache; call _dxfEndRenderModule when cache deleted */
        if(!(cacheObject = (Private)
                           DXNewPrivate((Pointer) globals,
                                        (Error (*)(Pointer))_dxfEndRenderModule))) {
            /* Can't cache tdm globals */
            DXErrorGoto (ERROR_INTERNAL, "#13290");
        }

        /* Create a reference so this doesn't get deleted while I'm using it */
        DXReference ((Pointer)cacheObject);

        /* associate cacheId with cacheObject, set to permanent status */
        if(! DXSetCacheEntry((Pointer)cacheObject, CACHE_PERMANENT,
                             cacheId, 0, 0)) {
            /* Can't set cache entry for tdm globals */
            DXErrorGoto (ERROR_INTERNAL, "#13300") ;
        }

        /* save the cacheId to allow cache deletion upon DestroyNotify event */
        if(! (globals->cacheId = tdmAllocate(strlen(cacheId)+1))) {
            DXErrorGoto (ERROR_NO_MEMORY, "") ;
        }

        /* save cacheId */
        strcpy(globals->cacheId,cacheId) ;
    }

    /* Now that we have a global store, use it */
    {
        int needInit = 0;
        DEFGLOBALDATA(globals);

        if (!OBJECT || (OBJECT && OBJECT_TAG != DXGetObjectTag(r)))
        {
            if (OBJECT)
                DXDelete(OBJECT);

            OBJECT = DXReference(r);
            OBJECT_TAG = DXGetObjectTag(r);
            needInit = 1;
        }

        if (!CAMERA || (CAMERA && CAMERA_TAG != DXGetObjectTag((dxObject)c)))
        {
            if (CAMERA)
                DXDelete(CAMERA);

            CAMERA = DXReference((dxObject)c);
            CAMERA_TAG = DXGetObjectTag((dxObject)c);
            needInit = 1;
        }

        _dxfInitializeStereoSystemMode(globals, DXGetAttribute(r, "stereo system mode"));
        _dxfInitializeStereoCameraMode(globals, DXGetAttribute(r, "stereo camera mode"));

        if(CAMERA && needInit)
        {
            if(!_dxfInitRenderObject(LWIN)) {
                /* unable to set up for rendering */
                DXErrorGoto(ERROR_NO_HARDWARE_RENDERING, "#13350");
            }
        }

        /* Handle X events and redraw the image */
#if !defined(DX_NATIVE_WINDOWS)
        if(! _dxfProcessEvents (-1, globals, 1))
            goto error;
#endif

    }

    if ((attr = DXGetAttribute((dxObject)c, "camera interaction mode")) == NULL)
        if ((attr = DXGetAttribute(r, "object interaction mode")) == NULL)
            attr = DXGetAttribute(r, "interaction mode");

    if (attr) {
        Array amode;
        int mode;

        if (DXGetObjectClass(attr) == CLASS_GROUP) {
            if (NULL == (amode = (Array)DXGetMember((Group)attr, "mode")))
                DXErrorGoto(ERROR_DATA_INVALID,
                            "interaction mode args group must contain a member named \"mode\"");
        } else if (DXGetObjectClass(attr) != CLASS_ARRAY) {
            DXErrorGoto(ERROR_DATA_INVALID,
                        "interaction mode args must be a group or array");
        } else
            amode = (Array)attr;

        if (DXExtractInteger((dxObject)amode, &mode))
            _dxfSetInteractionMode(globals, mode, attr);
        else
            DXErrorGoto(ERROR_DATA_INVALID,
                        "interaction mode attribute must be an integer");
    } else
        _dxfSetInteractionMode(globals, 11, NULL);

    if(cacheObject) {
        /* delete the working reference  */
        DXDelete((Pointer)cacheObject) ;
        cacheObject = NULL;
    }

    if (cacheId)
        tdmFree(cacheId);
    if (pFormat)
        _dxfDeleteParsedDisplayString(pFormat);

    EXIT(("OK"));
    DEBUG_MARKER("_dxfAsyncRender EXIT");
    return OK ;

error:

    if(cacheObject) {
        /* delete the working reference  */
        DXDelete((Pointer)cacheObject) ;
        cacheObject = NULL;
    }

    if (cacheId)
        tdmFree(cacheId);
    if (pFormat)
        _dxfDeleteParsedDisplayString(pFormat);

    EXIT(("ERROR"));
    DEBUG_MARKER("_dxfAsyncRender EXIT");
    return ERROR ;
}
Example #27
0
/* print something about each member, up to MEMBERCOUNT items */
static Error saymembers(Group g)
{
    int i, count;
    char *name;
    Object subo, firstsubo;
    int same;
    Class grouptype;
    float position;
    
    
    if (!DXGetMemberCount(g, &count))
	return ERROR;
    
    /* no members, nothing to do here */
    if (count <= 0)
	return OK;

    /* save group type; we'll use it later on */
    grouptype = DXGetGroupClass(g);
    switch (grouptype) {
	
      case CLASS_GROUP:
	if (count <= MEMBERCOUNT) {
	    for (i=0; i<count; i++) {
		if (!(subo = DXGetEnumeratedMember(g, i, &name)))
		    return ERROR;
		if (name)
		    DescribeMsg(" member %d is named %s\n", i, name);
	    }
	} else {
	    for (i=0; i<MEMBERCOUNT/2; i++) {
		if (!(subo = DXGetEnumeratedMember(g, i, &name)))
		    return ERROR;
		if (name)
		    DescribeMsg(" member %d is named %s\n", i, name);
	    }
	    DescribeMsg(" ...\n");
	    for (i=count-MEMBERCOUNT/2; i<count; i++) {
		if (!(subo = DXGetEnumeratedMember(g, i, &name)))
		    return ERROR;
		if (name)
		    DescribeMsg(" member %d is named %s\n", i, name);
	    }
	}
	break;
	
      case CLASS_COMPOSITEFIELD:
	break;
	
      case CLASS_MULTIGRID:
	/* bbox? */
	break;
	
      case CLASS_SERIES:
	if (count <= MEMBERCOUNT) {
	    for (i=0; i<count; i++) {
		if (!(subo = DXGetSeriesMember((Series)g, i, &position)))
		    return ERROR;
		DescribeMsg(" member %d is at position %g\n", i, position);
	    }
	} else {
	    for (i=0; i<MEMBERCOUNT/2; i++) {
		if (!(subo = DXGetSeriesMember((Series)g, i, &position)))
		    return ERROR;
		DescribeMsg(" member %d is at position %g\n", i, position);
	    }
	    DescribeMsg(" ...\n");
	    for (i=count-MEMBERCOUNT/2; i<count; i++) {
		if (!(subo = DXGetSeriesMember((Series)g, i, &position)))
		    return ERROR;
		DescribeMsg(" member %d is at position %g\n", i, position);
	    }
	    
	}
	break;
	
      default:
	break;
    }

    /* if only one member, say what it is and return */
    if (count <= 1) {
	subo = DXGetEnumeratedMember(g, 0, NULL);
	return sayclass(subo, "The member", 0);
    }
	
    /* if there is more than one member of this group, check out
     * whether the group members are all the same type of object.
     * this has to be true for a composite field and should be true
     * for a multigrid, and usually for a series.
     */
    same = 1;
    firstsubo = DXGetEnumeratedMember(g, 0, NULL);
    for (i=1; i<count; i++) {
	if (!(subo = DXGetEnumeratedMember(g, i, NULL)))
	    return ERROR;
	if (DXGetObjectClass(firstsubo) != DXGetObjectClass(subo)) {
	    same = 0;
	    break;
	}
    }
    
    switch (grouptype) {
      case CLASS_GROUP:
	if (same)
	    sayclass(firstsubo, "Each group member", 0);
	else 
	    DescribeMsg("The group contains members of different object types\n");
	break;
	
      case CLASS_COMPOSITEFIELD:
	if (!same || (DXGetObjectClass(firstsubo) != CLASS_FIELD)) {
	    DescribeMsg("This is not a well-formed Partitioned Field.\n");
	    DescribeMsg("Members should all be Field objects and they are not.\n");
	    if (!same) 
		DescribeMsg("It contains members of more than one object type.\n");
	    if ((DXGetObjectClass(firstsubo) != CLASS_FIELD))
		DescribeMsg("It contains members which are not Field objects.\n");
	}
	break;
	
      case CLASS_MULTIGRID:
	/* what about partitioned members? i think they are ok */
	break;
#if 0
	if (!same || (DXGetObjectClass(firstsubo) != CLASS_FIELD)) {
	    DescribeMsg("This is not a well-formed MultiGrid Group.\n");
	    DescribeMsg("Members should all be Field objects and they are not.\n");
	    if (!same) 
		DescribeMsg("It contains members of more than one object type.\n");
	    if ((DXGetObjectClass(firstsubo) != CLASS_FIELD))
		DescribeMsg("It contains members which are not Field objects.\n");
	}
	break;
#endif
	
      case CLASS_SERIES:
	if (same)
	    sayclass(firstsubo, "Each series member", 0);
	else 
	    DescribeMsg("The series contains members of different object types\n");
	break;
	
      default:
	break;
    }
    
    return OK;
}
Example #28
0
static Error
traverse(Object *in, Object *out)
{
  switch(DXGetObjectClass(in[0]))
  {
    case CLASS_FIELD:
/*     case CLASS_ARRAY: */
      if (! doLeaf(in, out))
  	     return ERROR;

      return OK;

#if 0
    case CLASS_GROUP:
    {
      int   i, j;
      int   memknt;
      Class groupClass  = DXGetGroupClass((Group)in[0]);

      DXGetMemberCount((Group)in[0], &memknt);

        for (i = 0; i < memknt; i++)
        {
          Object new_in[4], new_out[1];

          if (in[0])
            new_in[0] = DXGetEnumeratedMember((Group)in[0], i, NULL);
          else
            new_in[0] = NULL;

          new_in[1] = in[1];
          new_in[2] = in[2];
          new_in[3] = in[3];

          new_out[0] = DXGetEnumeratedMember((Group)out[0], i, NULL);

          if (! traverse(new_in, new_out))
            return ERROR;

          DXSetEnumeratedMember((Group)out[0], i, new_out[0]);

        }
      return OK;
    }

    case CLASS_XFORM:
    {
      int    i, j;
      Object new_in[4], new_out[1];

      if (in[0])
        DXGetXformInfo((Xform)in[0], &new_in[0], NULL);
      else
        new_in[0] = NULL;

      new_in[1] = in[1];
      new_in[2] = in[2];
      new_in[3] = in[3];

      DXGetXformInfo((Xform)out[0], &new_out[0], NULL);

      if (! traverse(new_in, new_out))
        return ERROR;

      DXSetXformObject((Xform)out[0], new_out[0]);

      return OK;
    }

    case CLASS_SCREEN:
    {
       int    i, j;
       Object new_in[4], new_out[1];

       if (in[0])
         DXGetScreenInfo((Screen)in[0], &new_in[0], NULL, NULL);
       else
         new_in[0] = NULL;

       new_in[1] = in[1];
       new_in[2] = in[2];
       new_in[3] = in[3];

       DXGetScreenInfo((Screen)out[0], &new_out[0], NULL, NULL);

       if (! traverse(new_in, new_out))
         return ERROR;

       DXSetScreenObject((Screen)out[0], new_out[0]);

       return OK;
     }

     case CLASS_CLIPPED:
     {
       int    i, j;
       Object new_in[4], new_out[1];


       if (in[0])
         DXGetClippedInfo((Clipped)in[0], &new_in[0], NULL);
       else
         new_in[0] = NULL;

       new_in[1] = in[1];
       new_in[2] = in[2];
       new_in[3] = in[3];

       DXGetClippedInfo((Clipped)out[0], &new_out[0], NULL);

       if (! traverse(new_in, new_out))
         return ERROR;

       DXSetClippedObjects((Clipped)out[0], new_out[0], NULL);

       return OK;
     }
#endif

     default:
     {
       DXSetError(ERROR_BAD_CLASS, "input must be Field");
       return ERROR;
     }
  }
}
Example #29
0
Error DXCallOutboard (PFE m, int dxfd)
{
    static int  firsttime = 1;
    Array	oarr;
    int		nin	= 0;
    int		nout	= 0;
    Object	*ilist = NULL;
    Object	*olist = NULL;
    Error	ret    = ERROR;
    Error	modret;
    ErrorCode	ecode;
    char        *emessptr = NULL;
    Group	iobj	= NULL;
    Group	oobj	= NULL;
    Array	code	= NULL;
    String	mess	= NULL;
    int		i;
    int		*iptr;
    int		count	= 0;
    int		one = 1;
    int         zero = 0;


    if (firsttime && ! callsetup (dxfd)) {
	host_status = HOST_CLOSED;
	return ERROR;
    }

	
    /*
     * Import the remote object, extract the number of inputs and outputs,
     * and rip them apart appropriately.  group members are: 
     * input parm count, 
     * input object list (the pointers values don't mean anything in this
     * address space; the interesting part is whether they are NULL or not),
     * the output parm count,
     * and then each input object which isn't null.
     */

    iobj = (Group) _dxfImportBin_FP(dxfd);
    if(iobj == NULL)
        goto finish_up;

    if (!DXExtractInteger (DXGetEnumeratedMember (iobj, 0, NULL), &nin))
	goto finish_up;

    ilist = (Object *) DXAllocateZero(sizeof (Object) * nin);
    if (!ilist)
	goto finish_up;
    
    iptr = (int *)DXGetArrayData((Array)DXGetEnumeratedMember (iobj, 1, NULL));

    if (!DXExtractInteger (DXGetEnumeratedMember (iobj, 2, NULL), &nout))
	goto finish_up;

    count = 3;
    for (i=0; i<nin; i++) 
    {
	if (iptr[i] == (int)NULL)
	    continue;

	ilist[i] = DXGetEnumeratedMember(iobj, count++, NULL);
    }

    olist = (Object *) DXAllocateZero(sizeof (Object) * nout);
    if (!olist)
	goto finish_up;

    /*
     * Call the module, and save the error code if set.
     */

    DXResetError();
    
    _dxd_exOutboard = TRUE;
    modret = m (ilist, olist);
    _dxd_exOutboard = FALSE;

    /*
     * get these now, before we do something else which overwrites them.
     */
    ecode = DXGetError ();
    emessptr = DXGetErrorMessage();

    /* 
     * now BEFORE we do anything which allocates memory or new objects
     * check the return objects for validity.  we saw a case where the
     * object being returned was deleted, and then the DXNewGroup() 
     * below got the exact same address allocated, so when we put the
     * group together we put a reference to the parent group into the
     * same group as a child.  bad things followed...
     *
     * (the two calls above to geterror & geterrormsg don't allocate anything;
     * they return a value & ptr to a static respectively)
     */
    for (i = 0; i < nout; i++) {
	if (olist[i] == NULL)
	    continue;

	switch (DXGetObjectClass(olist[i])) {
	  case CLASS_DELETED:
	  case CLASS_MIN:
	  case CLASS_MAX:
	    if (ecode == ERROR_NONE) {
		DXSetError(ERROR_BAD_CLASS, "bad object returned as output %d from outboard module", i);
		ecode = DXGetError ();
		emessptr = DXGetErrorMessage();
	    } else
		DXAddMessage("bad object returned as output %d from outboard module", i);

	    olist[i] = NULL;
	  default: /* Lots of other classes */
	    break;
	}
    }

    /*
     * Set up for return, at least the return code and message.
     */
    
    oobj = DXNewGroup ();
    if (oobj == NULL)
	goto finish_up;

    if (!(code = DXNewArray (TYPE_INT, CATEGORY_REAL, 0)))
	goto finish_up;

    if (! DXAddArrayData (code, 0, 1, (Pointer) &ecode))
	goto finish_up;

    mess = DXNewString (emessptr);
    if (mess == NULL)
	goto finish_up;

    if (! DXSetEnumeratedMember (oobj, 0, (Object) code) ||
	! DXSetEnumeratedMember (oobj, 1, (Object) mess))
	goto finish_up;

    /*
     * If everything is OK then go ahead and return any objects too.
     */

    if (modret == OK)
    {
	/* send output list so the caller can tell which outputs
	 * were set.  only send the non-NULL ones.
	 */
	oarr = DXNewArray(TYPE_INT, CATEGORY_REAL, 0);
	if (!oarr)
	    goto finish_up;
	for (i = 0; i < nout; i++) {
	    if (! DXAddArrayData(oarr, i, 1, (olist+i) ? 
                                 (Pointer)&one : (Pointer)&zero))
		goto finish_up;
	}
	
	if (! DXSetEnumeratedMember(oobj, 2, (Object)oarr))
	    goto finish_up;
	

	count = 3;
        for (i = 0; i < nout; i++)
        {
	    if (olist[i] == NULL)
		continue;

	    if (! DXSetEnumeratedMember (oobj, count++, olist[i]))
		goto finish_up;

	}
    }

    if (!_dxfExportBin_FP ((Object)oobj, dxfd))
	goto finish_up;

    /* 
     * if you get to this point, there were no other errors.
     */
    ret = OK;


finish_up:

    /*
     * get rid of space not needed anymore.  this doesn't matter for
     * one-shots, but for persistent modules we will run out of memory
     * eventually if these aren't deleted.
     */

    DXDelete ((Object) iobj);
    DXDelete ((Object) oobj);

    DXFree ((Pointer) ilist);
    DXFree ((Pointer) olist);

    return ret;
}