int_expr.c

LastWave

          for(j=1;j<size3;j++) *resFlt += array3[j];
          break;

        /* any */
        case 4:
          *resFlt = 0;
          for(j=0;j<size3;j++) if (array3[j] != 0) {*resFlt = 1; break;}
          break;

        /* all */
        case 5:
          *resFlt = 1;
          for(j=0;j<size3;j++) if (array3[j] == 0) {*resFlt = 0; break;}
          break;

        /* mean */
        case 6:
          *resFlt = array3[0];
          for(j=1;j<size3;j++) *resFlt += array3[j];
          *resFlt/=size3;
          break;

        }

        Clean(*resVC);
        return(FloatType); 
      }
      
      if (r == RangeType) {
        rg3 = (RANGE) *resVC;
        if (rg3->size == 0) {
          SetErrorf("Not expecting emty range");
          *left = begin2+1;
          Clean(*resVC);
          return(0);
        }
        switch(opIndex) {
        
        /* sum */
        case 3 :
          *resFlt = rg3->size*rg3->first+rg3->step*rg3->size*(rg3->size-1)/2;
          break;

        /* any */
        case 4 :
          if (rg3->first != 0 || rg3->size != 1) *resFlt = 1;
          else *resFlt = 0;
          break;

        /* all */
        case 5 : 
          f1 = -rg3->first/rg3->step;
          if (f1 >= 0 && f1 <rg3->size && f1 == ((int) f1)) *resFlt = 0;
          else *resFlt = 1;
          break;

        /*min and max */
        case 1: case 2:          
          if (rg3->step >= 0) {
            if (opIndex == 1) *resFlt = rg3->first;
            else if (opIndex == 1) *resFlt = rg3->first;
            else *resFlt = RangeLast(rg3);
          }
          else {
            if (opIndex == 2) *resFlt = rg3->first;
            else *resFlt = RangeLast(rg3);
          }
          break;
        }  
        
        Clean(*resVC);
        return(FloatType); 
      }
    }      


     /* Case op(expression,expression) */
     if (opIndex >= 3) {
       SetErrorf("Bad syntax");
       *left = begin;
       Clean(*resVC);
       return(0);
     }

     if (**left != ',') {
       SetErrorf("Expecting a comma");
       *left = begin;
       Clean(*resVC);
       return(0);
     }
     
     vc3 = *resVC;
     temp = *resFlt;
     begin = *left+1;
     oldFlagSpace = defParam->flagSpace;
     defParam->flagSpace = YES;
     if (r == SignalType || r == RangeType) r = RangeType | SignalType;
     if (!(r=TTExpr1(begin,left,resFlt,resVC,r,defParam))) return(0);
     defParam->flagSpace = oldFlagSpace;
     if (**left != ')') {
       SetErrorf("Expecting a ')'");
       *left = begin;
       Clean(*resVC);
       return(0);
     }

     if (r & flagType == 0) {
       if (r==FloatType) SetErrorf("Not expecting a LWFLOAT");
       else if (r==SignalType) SetErrorf("Not expecting a signal");
       else if (r==ImageType) SetErrorf("Not expecting an image");
       *left = begin2;
       Clean(*resVC);
       return(0);
     }
     
     (*left)++;
     
     /* Case of floats */
     if (r == FloatType) {
       if (opIndex == 1) *resFlt = MIN(*resFlt,temp);
       else *resFlt = MAX(*resFlt,temp);
       Clean(*resVC);
       return(r);
     }  

     /* Case of images */
     if (r == ImageType) {
       i1 = (IMAGE) *resVC;
       i2 = (IMAGE) vc3;
       if (i1->nrow != i2->nrow || i1->ncol != i2->ncol) {
         SetErrorf("Images should have the same size");
         *left = begin2;
         Clean(*resVC);
         return(0);
       }
       if (i1->nRef == 1) i3 = i1;
       else if (i2->nRef == 1) i3 = i2;
       else {
         i3 = TNewImage();
         SizeImage(i3,i1->ncol,i1->nrow);
       }
       *resVC = (VALUE) i3;
       if (opIndex == 1) {
         for (j=0;j<i3->nrow*i3->ncol;j++) i3->pixels[j] = MIN(i1->pixels[j],i2->pixels[j]);
       }
       else {
         for (j=0;j<i3->nrow*i3->ncol;j++) i3->pixels[j] = MAX(i1->pixels[j],i2->pixels[j]);
       }
       return(r);
     }  


     /* Case of signals/ranges */
     if (GetTypeValue(vc3) == rangeType) {
       s1 = NULL;
       rg1 = (RANGE) vc3;
       size1 = rg1->size;
     }
     else {
       s1 = (SIGNAL) vc3;
       rg1 = NULL;
       size1 = s1->size;
     }
     if (r == RangeType) {
       s2 = NULL;
       rg2 = (RANGE) *resVC;
       size2 = rg2->size;
     }
     else {
       s2 = (SIGNAL) *resVC;
       rg2 = NULL;
       size2 = s2->size;       
     }

     if (size1 != size2) {
       SetErrorf("Signals/ranges should have the same size");
       *left = begin2;
       Clean(*resVC);
       return(0);
     }
     if (s1 && s1->nRef == 1) s3 = s1;
     else if (s2 && s2->nRef == 1) s3 = s2;
     else {
       s3 = TNewSignal();
       if (s1) {
         SizeSignal(s3,size1,s1->type);
         CopyFieldsSig(s1,s3);
         if (s1->type == XYSIG) memcpy(s3->X,s1->X,s1->size*sizeof(LWFLOAT));
       }
       else SizeSignal(s3,size1,YSIG);
     }
     *resVC = (VALUE) s3;
     if (opIndex == 1) {
       if (rg1) {
         if (rg2) for (j=0;j<s3->size;j++) s3->Y[j] = MIN(RangeVal(rg1,j),RangeVal(rg2,j));
         else for (j=0;j<s3->size;j++) s3->Y[j] = MIN(RangeVal(rg1,j),s2->Y[j]);
       }
       else {
         if (rg2) for (j=0;j<s3->size;j++) s3->Y[j] = MIN(s1->Y[j],RangeVal(rg2,j));
         else for (j=0;j<s3->size;j++) s3->Y[j] = MIN(s1->Y[j],s2->Y[j]);
       }
     }
     else {
       if (rg1) {
         if (rg2) for (j=0;j<s3->size;j++) s3->Y[j] = MAX(RangeVal(rg1,j),RangeVal(rg2,j));
         else for (j=0;j<s3->size;j++) s3->Y[j] = MAX(RangeVal(rg1,j),s2->Y[j]);
       }
       else {
         if (rg2) for (j=0;j<s3->size;j++) s3->Y[j] = MAX(s1->Y[j],RangeVal(rg2,j));
         else for (j=0;j<s3->size;j++) s3->Y[j] = MAX(s1->Y[j],s2->Y[j]);
       }
     }
     return(r);
  }

  /***********************************************************
   * 
   * Operators "find"
   * 
   * 'op(expression)' returns a signal/image
   *
   ***********************************************************/

  /* Eighth array */
  arrayIndex = 8;
  for (op = opArray8, opSize = opSizeArray8 ;;op++,opSize++) {                                                         
    if (*op == NULL) break; 
    if (!strncmp(begin,*op,*opSize) && !IsValidSymbolChar(begin[*opSize])) break; 
  }
  opIndex = op-opArray8+1;
    
  if (*op != NULL) {    

    *left = begin;
    
    /* Check some types */
    if (!(flagType & (ImageType | SignalType))) {
      SetErrorf("Not expecting a signal or an image");
      Clean(*resVC);
      return(0);
    }

    /* Skip operator */
    begin2= begin; 
    begin  += *opSize; 
    ParamSkipSpace(begin); 
    *left = begin;


    /* test (... */
    if (*begin != '(') {
      SetErrorf("Expecting a '('");
      *left = begin;
      Clean(*resVC);
      return(0);
    }
    begin2 = begin;
    
    /* Read expression */
    begin1 = begin;
    begin++;
    *left = begin;
    oldFlagSpace = defParam->flagSpace;
    defParam->flagSpace = YES;
    if (!(r=TTExpr1(begin,left,resFlt,resVC,ImageType | SignalType,defParam))) return(0);
    defParam->flagSpace = oldFlagSpace;
    
    if (**left != ')') {
      SetErrorf("Expecting a ')'");
      Clean(*resVC);
      return(0);    
    }

    (*left)++;
    if (r == SignalType) {
      s1 = (SIGNAL) *resVC;
      s3 = TNewSignal();
      for(j1=0,j=0;j<s1->size;j++) {
        if (s1->Y[j] != 0) j1++;
      }
      SizeSignal(s3,j1,YSIG);
      for(j1=0,j=0;j<s1->size;j++) {
        if (s1->Y[j] != 0) s3->Y[j1++] = j;
      }
      *resVC = (VALUE) s3;
      return(SignalType);
    }


    if (r == ImageType) {
      i1 = (IMAGE) *resVC;
      i3 = TNewImage();
      for(n=0,j=0;j<i1->nrow;j++) {
        for(j1=0;j1<i1->ncol;j1++) {
          if (i1->pixels[j*i1->ncol+j1] != 0) n++;
        }
      }
      SizeImage(i3,n,2);
      for(n=0,j=0;j<i1->nrow;j++) {
        for(j1=0;j1<i1->ncol;j1++) {
          if (i1->pixels[j*i1->ncol+j1] != 0) {
            i3->pixels[n] = j;
            i3->pixels[(n++)+i3->ncol] = j1;
          }
        }
      }      
      *resVC = (VALUE) i3;
      return(ImageType);
    }

  }
    
    
  /***********************************************************
   * 
   *  A terminal expression
   * 
   * 
   *
   ***********************************************************/
   
   r = TermExpr(begin,left,resFlt,resVC,flagType,defParam);
   if (r==NO) return(0);
   
   return(r);
}




/*
 * Generic function that Sets the output of a binary operator on floats, images, ranges and signals
 *
 * This function is called below by the TTExpr<n> functions which deal with binary
 * operators, i.e., the functions TTExpr<n> functions with 2<=n<=7
 *
 * If both arguments of the operator are floats then this function is not called.
 * If one of the argument is neither a range, a signal, an image or a LWFLOAT it is not called either.
 *
 * The arguments are : 
 *
 *    - r1, vc1 : correspond to the first argument of the binary operator (r1 is the type
 *                and vc1 the corresponding variable content). If it is a LWFLOAT then
 *                vc1 = NULL
 *    - r2, vc2 : correspond to the second argument of the binary operator (r2 is the type
 *                and vc2 the corresponding variable content). If it is a LWFLOAT then
 *                vc2 = NULL
 *    - flag    : one of '+', '*' or '/' to manage more efficiently vectors 
 *                (a range + a range with the same step is a range .....)
 *
 * The function returns 1 if succeded and 0 otherwise.
 * (allocation wil be performed only if necessary).
 *      
 * 
 */
static unsigned char TTSetOutput2(unsigned char r1, VALUE vc1,  unsigned char r2, VALUE vc2, VALUE *vc3, char flag)
 {
   char flagRange;
   char flagTemp1;
   char flagTemp2;
   SIGNAL s1,s2,s3;
   IMAGE i1,i2,i3;
   RANGE rg1,rg2,rg3;
   unsigned char r3;

   /* Some checkings */
   if (r1!=SignalType && r1 != RangeType && r1 != ImageType && r1 != FloatType ||
       r2!=SignalType && r2 != RangeType && r2 != ImageType && r2 != FloatType) 
       Errorf("TTSetOutput2() : Weird 1");
   if (r1 == FloatType && r2 == FloatType) {
     Errorf("TTSetOutput2() : Weird 2");
   }   
   
   /* Bad combination error */
   if (((r1==SignalType || r1 == RangeType) && r2==ImageType) || ((r2==SignalType|| r2 == RangeType) && r1==ImageType)) {
     SetErrorf("Bad combination image - signal or range");
     return(0);
   }

   /* 
    * Just set the variables 
    */
   *vc3 = NULL;
   s1 = s2 = s3 = NULL;
   i1 = i2 = i3 = NULL;
   rg1 = rg2 = rg3 = NULL;
   if (r1 == SignalType) s1 = (SIGNAL) vc1;
   else if (r1 == RangeType) rg1 = (RANGE) vc1;
   else if (r1 == ImageType) i1 = (IMAGE) vc1;
   if (r2 == SignalType) s2 = (SIGNAL) vc2;
   else if (r2 == RangeType) rg2 = (RANGE) vc2;
   else if (r2 == ImageType) i2 = (IMAGE) vc2;
   if (vc1 && vc1->nRef == 1) flagTemp1 = YES;
   else flagTemp1 = NO;
   if (vc2 && vc2->nRef == 1) flagTemp2 = YES;
   else flagTemp2 = NO;
   
   
   /*
    * Case one argument is a signal or a range
    */
   if (r1==SignalType || r2 == SignalType || r1 == RangeType || r2 == RangeType) {
   
     /* If both are signals or ranges we must check their sizes */
     if (r1==SignalType && r2 == SignalType && s1->size != s2->size) {
       SetErrorf("Signals have different size");
       return(0);
     }
     if (r1==SignalType && r2 == RangeType && s1->size != rg2->size) {
       SetErrorf("Signal and range have different size");
       return(0);
     }
     if (r2==SignalType && r1 == RangeType && s2->size != rg1->size) {
       SetErrorf("Range and signal have different size");
       return(0);
     }
     if (r2==RangeType && r1 == RangeType && rg2->size != rg1->size) {
       SetErrorf("Ranges have different size");
       return(0);
     }
 
     /* Is the result a range ? */
     if (flag=='+' && ((r1 == RangeType && r2 == FloatType) || (r2 == RangeType && r1 == FloatType) || 
         (r1 == RangeType && r2 == RangeType))) flagRange = YES; 
     else if (flag=='*' && ((r1 == RangeType && r2 == FloatType) || (r2 == RangeType && r1 == FloatType))) flagRange = YES;
     else if (flag=='/' && (r1 == RangeType && r2 == FloatType)) flagRange = YES;
     else flagRange = NO;
       
     /* Set rg3 if necessary */
     if (flagRange) {
       if (flagTemp1 && r1 == RangeType) rg3 = rg1;
       else if (flagTemp2 && r2 == RangeType) rg3 = rg2;
       else rg3 = TNewRange();
       *vc3 = (VALUE) rg3;
       r3 = RangeType;
       if (rg1) rg3->size = rg1->size;
       else if (rg2) rg3->size = rg2->size;
     }
     
     /* Set s3 if necessary */
     else {
       if (r1 == SignalType && flagTemp1) s3 = s1;
       else if (r2 == SignalType && flagTemp2) s3 = s2;
       else {
         s3 = TNewSignal();
         if (r1==SignalType) {
           SizeSignal(s3,s1->size,s1->type);
           CopyFieldsSig(s1,s3);