image_alloc.c

LastWave

    case BorderPer : 
      col = (int) fmod(col,im->ncol);
      if (col < 0) col+=im->ncol;
      break;
    case BorderMir1 : 
      col = (int) fmod(col,2*im->ncol);
      if (col < 0) col+=2*im->ncol;
      if (col >= im->ncol) col=2*im->ncol-1-col;
      break;
    case BorderMir : 
      col = (int) fmod(col,2*im->ncol-2);
      if (col < 0) col+=2*im->ncol-2;
      if (col >= im->ncol) col=2*im->ncol-2-col;
      break;
    case Border0 :
      if (col < 0 || col>=im->ncol) return(0);
      break;
  }
  switch (btr) {
    case BorderNone :
    break;
    case BorderCon : /* ?? a faire ?? */
      break;
    case BorderPer : 
      row = (int) fmod(row,im->nrow);
      if (row < 0) row+=im->nrow;
      break;
    case BorderMir1 : 
      row = (int) fmod(row,2*im->nrow);
      if (row < 0) row+=2*im->nrow;
      if (row >= im->nrow) row=2*im->nrow-1-row;
      break;
    case BorderMir : 
      row =(int)  fmod(row,2*im->nrow-2);
      if (row < 0) row+=2*im->nrow-2;
      if (row >= im->nrow) row=2*im->nrow-2-row;
      break;
    case Border0 :
      if (row < 0 || row>=im->nrow) return(0);
      break;
  }
  
  return(im->pixels[im->ncol*row+col]);
}
      

/*
 * The different extract options 
 */
static char *extractOptionsIm[] = {"*nolimit","*bperiodic","*bmirror","*bmirror1","*b0",NULL};
enum {
  FSIOptImNoLimit = FSIOption1,
  FSIOptImBPer = FSIOption2,
  FSIOptImBMir = FSIOption3,
  FSIOptImBMir1 = FSIOption4,
  FSIOptImB0 = FSIOption5
};

/*
 * Doc for extraction []
 */
static char *doc = "{[*opt,rowIndexes;colIndexes] [:]= (<LWFLOAT> | <range> | <signal> | <image>)} {Get/Set the images values}"; 



/* 
 * Set an image [] using explicit parameters
 */
char *SetImageField_(IMAGE imLeft,char *field, FSIList *fsiList, LWFLOAT fltRight, VALUE value,char *equal, char *fieldName)
{
  FSI_DECL_ROW;
  FSI_DECL_COL;
  int i,n;
  char *type;
  SIGNAL sig;
  IMAGE imRight,im;
  LWFLOAT *arrayLeft;
  RANGE rg;
  
  /* Get the type of the right value  */
  if (value == NULL) type = numType;
  else {
    value = ValueOf(value);
    type = GetTypeValue(value);
  }
  
  /* Conversion of range to an image */
  if (type == rangeType) {
    rg = CastValue(value,RANGE);
    im = TNewImage();
    SizeImage(im,rg->size,1);
    im->pixels[0] = rg->first;
    for (i=1;i<rg->size;i++) im->pixels[i] = im->pixels[i-1]+rg->step;
    value = (VALUE) im;
    type = imageiType;
  }
  /* Conversion of signal to an image */
  else if (type == signaliType) {
    sig = CastValue(value,SIGNAL);
    im = TNewImage();
    SizeImage(im,sig->size,1);
    for (i=0;i<sig->size;i++) im->pixels[i] = sig->Y[i];
    value = (VALUE) im;
    type = imageiType;
  }
  /* Conversion of an empty signal to an image */
  else if (type == signalType) {
    im = TNewImage();
    value = (VALUE) im;
    type = imageType;
  }
    
  if (type != numType && type != imageiType && type != imageType) {
    SetErrorf("Expect a LWFLOAT/range/signal/image (and not a '%s') on right handside",type);
    return(NULL);
  }

  if (type == numType) {
    if (value != NULL) fltRight = CastValue(value,NUMVALUE)->f;
    imRight = NULL;
  }
  else if (type == imageiType || type == imageType) {
    imRight = CastValue(value,IMAGE);
  }

  
  /*************************
   *
   * Case value operator is *= += -= /= ^= %=
   *
   *************************/
   
  if (*equal != '=' && *equal != ':') {

    if (type == listvType) {
      SetErrorf("Expect a LWFLOAT/signal/image (and not a '%s') on right handside",type);
      return(NULL);
    }

    if (imLeft->nrow  == 0 || imLeft->ncol  == 0) {
      SetErrorf("Expect a non empty image on the left handside");
      return(NULL);
    }
    
    if (imRight && (fsiList && (imRight->nrow != fsiList->nx || imRight->ncol != fsiList->ny) 
                    || !fsiList && (imRight->nrow != imLeft->nrow || imRight->ncol != imLeft->ncol))) {
      SetErrorf("Images should have the same size");
      return(NULL);
    }
    
    arrayLeft = imLeft->pixels;
    
    switch (*equal) {
    case '+' :  
      if (fsiList == NULL || fsiList->nx == 0 || fsiList->ny == 0) {
        if (imRight == NULL) for (i=0;i<imLeft->nrow*imLeft->ncol;i++) arrayLeft[i]+=fltRight;
        else for (i=0;i<imLeft->nrow*imLeft->ncol;i++) arrayLeft[i]+=imRight->pixels[i];
      }
      else {
        FSI_FOR_INIT(fsiList);
        if (!fsiList->flagImage) {
          if (imRight == NULL) {FSI_FOR_START_ROW(fsiList);FSI_FOR_START_COL(fsiList); arrayLeft[_ir*imLeft->ncol+_ic]+=fltRight;FSI_FOR_END_COL;FSI_FOR_END_ROW;}
          else {n = 0;FSI_FOR_START_ROW(fsiList);FSI_FOR_START_COL(fsiList); arrayLeft[_ir*imLeft->ncol+_ic]+=imRight->pixels[n++];FSI_FOR_END_COL;FSI_FOR_END_ROW;}
        }
        else {
          if (imRight == NULL) {FSI_FOR_START_IMAGE(fsiList);arrayLeft[_ir*imLeft->ncol+_ic]+=fltRight;FSI_FOR_END_IMAGE;}
          else {n = 0;FSI_FOR_START_IMAGE(fsiList); arrayLeft[_ir*imLeft->ncol+_ic]+=imRight->pixels[n++];FSI_FOR_END_IMAGE;}
        }
      }      
      break; 
    case '-' :  
      if (fsiList == NULL || fsiList->nx == 0 || fsiList->ny == 0) {
        if (imRight == NULL) for (i=0;i<imLeft->nrow*imLeft->ncol;i++) arrayLeft[i]-=fltRight;
        else for (i=0;i<imLeft->nrow*imLeft->ncol;i++) arrayLeft[i]-=imRight->pixels[i];
      }
      else {
        FSI_FOR_INIT(fsiList);
        if (!fsiList->flagImage) {
          if (imRight == NULL) {FSI_FOR_START_ROW(fsiList);FSI_FOR_START_COL(fsiList); arrayLeft[_ir*imLeft->ncol+_ic]-=fltRight;FSI_FOR_END_COL;FSI_FOR_END_ROW;}
          else {n = 0;FSI_FOR_START_ROW(fsiList);FSI_FOR_START_COL(fsiList); arrayLeft[_ir*imLeft->ncol+_ic]-=imRight->pixels[n++];FSI_FOR_END_COL;FSI_FOR_END_ROW;}
        }
        else {
          if (imRight == NULL) {FSI_FOR_START_IMAGE(fsiList);arrayLeft[_ir*imLeft->ncol+_ic]-=fltRight;FSI_FOR_END_IMAGE;}
          else {n = 0;FSI_FOR_START_IMAGE(fsiList); arrayLeft[_ir*imLeft->ncol+_ic]-=imRight->pixels[n++];FSI_FOR_END_IMAGE;}
        }
      }      
      break; 
    case '*' :  
      if (fsiList == NULL || fsiList->nx == 0 || fsiList->ny == 0) {
        if (imRight == NULL) for (i=0;i<imLeft->nrow*imLeft->ncol;i++) arrayLeft[i]*=fltRight;
        else for (i=0;i<imLeft->nrow*imLeft->ncol;i++) arrayLeft[i]*=imRight->pixels[i];
      }
      else {
        FSI_FOR_INIT(fsiList);
        if (!fsiList->flagImage) {
          if (imRight == NULL) {FSI_FOR_START_ROW(fsiList);FSI_FOR_START_COL(fsiList); arrayLeft[_ir*imLeft->ncol+_ic]*=fltRight;FSI_FOR_END_COL;FSI_FOR_END_ROW;}
          else {n = 0;FSI_FOR_START_ROW(fsiList);FSI_FOR_START_COL(fsiList); arrayLeft[_ir*imLeft->ncol+_ic]*=imRight->pixels[n++];FSI_FOR_END_COL;FSI_FOR_END_ROW;}
        }
        else {
          if (imRight == NULL) {FSI_FOR_START_IMAGE(fsiList);arrayLeft[_ir*imLeft->ncol+_ic]*=fltRight;FSI_FOR_END_IMAGE;}
          else {n = 0;FSI_FOR_START_IMAGE(fsiList); arrayLeft[_ir*imLeft->ncol+_ic]*=imRight->pixels[n++];FSI_FOR_END_IMAGE;}
        }
      }      
      break; 
    case '^' :  
      if (fsiList == NULL || fsiList->nx == 0 || fsiList->ny == 0) {
        if (imRight == NULL) for (i=0;i<imLeft->nrow*imLeft->ncol;i++) arrayLeft[i]=pow(arrayLeft[i],fltRight);
        else for (i=0;i<imLeft->nrow*imLeft->ncol;i++) arrayLeft[i]=pow(arrayLeft[i],imRight->pixels[i]);
      }
      else {
        FSI_FOR_INIT(fsiList);
        if (!fsiList->flagImage) {
          if (imRight == NULL) {FSI_FOR_START_ROW(fsiList);FSI_FOR_START_COL(fsiList); arrayLeft[_ir*imLeft->ncol+_ic]=pow(arrayLeft[_ir*imLeft->ncol+_ic],fltRight);FSI_FOR_END_COL;FSI_FOR_END_ROW;}
          else {n = 0;FSI_FOR_START_ROW(fsiList);FSI_FOR_START_COL(fsiList); arrayLeft[_ir*imLeft->ncol+_ic]=pow(arrayLeft[_ir*imLeft->ncol+_ic],imRight->pixels[n++]);FSI_FOR_END_COL;FSI_FOR_END_ROW;}
        }
        else {
          if (imRight == NULL) {FSI_FOR_START_IMAGE(fsiList);arrayLeft[_ir*imLeft->ncol+_ic]=pow(arrayLeft[_ir*imLeft->ncol+_ic],fltRight);FSI_FOR_END_IMAGE;}
          else {n = 0;FSI_FOR_START_IMAGE(fsiList);arrayLeft[_ir*imLeft->ncol+_ic]=pow(arrayLeft[_ir*imLeft->ncol+_ic],imRight->pixels[n++]);FSI_FOR_END_IMAGE;}
        }
      }      
      break; 
    case '%' :  
      if (fsiList == NULL || fsiList->nx == 0 || fsiList->ny == 0) {
        if (imRight == NULL) for (i=0;i<imLeft->nrow*imLeft->ncol;i++) arrayLeft[i]= ((int) arrayLeft[i]) % ((int) fltRight);
        else for (i=0;i<imLeft->nrow*imLeft->ncol;i++) arrayLeft[i]=((int) arrayLeft[i]) % ((int) imRight->pixels[i]);
      }
      else {
        FSI_FOR_INIT(fsiList);
        if (!fsiList->flagImage) {
          if (imRight == NULL) {FSI_FOR_START_ROW(fsiList);FSI_FOR_START_COL(fsiList); arrayLeft[_ir*imLeft->ncol+_ic]=((int) arrayLeft[_ir*imLeft->ncol+_ic]) % ((int) fltRight);FSI_FOR_END_COL;FSI_FOR_END_ROW;}
          else {n = 0;FSI_FOR_START_ROW(fsiList);FSI_FOR_START_COL(fsiList); arrayLeft[_ir*imLeft->ncol+_ic]=((int) arrayLeft[_ir*imLeft->ncol+_ic]) % ((int) imRight->pixels[n++]);FSI_FOR_END_COL;FSI_FOR_END_ROW;}
        }
        else {
          if (imRight == NULL) {FSI_FOR_START_IMAGE(fsiList);arrayLeft[_ir*imLeft->ncol+_ic]=((int) arrayLeft[_ir*imLeft->ncol+_ic]) % ((int) fltRight);FSI_FOR_END_IMAGE;}
          else {n = 0;FSI_FOR_START_IMAGE(fsiList); arrayLeft[_ir*imLeft->ncol+_ic]=((int) arrayLeft[_ir*imLeft->ncol+_ic]) % ((int) imRight->pixels[n++]);FSI_FOR_END_IMAGE;}
        }

      }      
      break; 
    case '/' :  
      if (imRight == NULL && fltRight == 0) {      
        SetErrorf("Division by 0");
        return(NULL);
      }
      if (fsiList == NULL || fsiList->nx == 0 || fsiList->ny == 0) {
        if (imRight == NULL) for (i=0;i<imLeft->nrow*imLeft->ncol;i++)  arrayLeft[i]/=fltRight;
        else for (i=0;i<imLeft->nrow*imLeft->ncol;i++) {
          if (imRight->pixels[i] == 0) {     
            SetErrorf("Division by 0");
            return(NULL);
          }
          arrayLeft[i]/=imRight->pixels[i];
        }
      }
      else {
        FSI_FOR_INIT(fsiList);
        if (!fsiList->flagImage) {
          if (imRight == NULL) {FSI_FOR_START_ROW(fsiList);FSI_FOR_START_COL(fsiList); arrayLeft[_ir*imLeft->ncol+_ic]/=fltRight;FSI_FOR_END_COL;FSI_FOR_END_ROW;}
          else {
            n = 0;
            FSI_FOR_START_ROW(fsiList);
            FSI_FOR_START_COL(fsiList); 
            if (imRight->pixels[n] == 0) {     
              SetErrorf("Division by 0");
              return(NULL);
            }
            arrayLeft[_ir*imLeft->ncol+_ic]/=imRight->pixels[n++];
            FSI_FOR_END_COL;
            FSI_FOR_END_ROW;
          }
        }
        else {
          if (imRight == NULL) {FSI_FOR_START_IMAGE(fsiList); arrayLeft[_ir*imLeft->ncol+_ic]/=fltRight;FSI_FOR_END_IMAGE;}
          else {
            n = 0;
            FSI_FOR_START_IMAGE(fsiList);
            if (imRight->pixels[n] == 0) {     
              SetErrorf("Division by 0");
              return(NULL);
            }
            arrayLeft[_ir*imLeft->ncol+_ic]/=imRight->pixels[n++];
            FSI_FOR_END_IMAGE;
          }
        }
      }      
      break; 
    }
  	return(imageiType);
}

  /*************************
   *
   * Case i[rowIndices;colIndices] = image/LWFLOAT
   *
   *************************/

  if (*equal == '=' && type != listvType) {
    /* Case of i=imRight */
    if (fsiList == NULL) {
      if (imRight) CopyImage(imRight,imLeft);
      else {
        SizeImage(imLeft,1,1);
        imLeft->pixels[0] = fltRight;
      }
      return(imageiType);
    }      
      
    /* Case of im[]=imRight */
    if (fsiList->nx==0 || fsiList->ny==0) {
      if (imRight) CopyImage(imRight,imLeft);
      else {
        SizeImage(imLeft,1,1);
        imLeft->pixels[0] = fltRight;
      }
      return(imageiType);
    }      
    
    if (imLeft->ncol  == 0 || imLeft->nrow  == 0) {
      SetErrorf("Expect a non empty image on the left handside");
      return(NULL);
    }
   
    arrayLeft = imLeft->pixels;
  
    /* Case im[1;1]=2 */
    if (type == numType) {
      if (fsiList->nx != 1 || fsiList->ny != 1) {
        SetErrorf("Size of both handsides should match (left is %dx%d, right is 1x1)",fsiList->nx,fsiList->ny);
        return(NULL);
      }
      FSI_FOR_INIT(fsiList);
      _ir =  (int) FSIArray((&(fsiList->fsi[0])),0);
      _ic =  (int) FSIArray((&(fsiList->fsi[_ns+1])),0);
      arrayLeft[_ir*imLeft->ncol+_ic]=fltRight;
      return(imageiType);
    }
    

    /* Case of im[...]=imRight */
    if (!(fsiList->flagImage) && (imRight->nrow != fsiList->nx || imRight->ncol != fsiList->ny)) {
      SetErrorf("Size of both handsides should match (left is %dx%d, right is %dx%d)",fsiList->nx,fsiList->ny,imRight->nrow,imRight->ncol);
      return(NULL);
    }
    if (fsiList->flagImage && imRight->nrow != 1) {
      SetErrorf("Right handside should not be an image");
      return(NULL);
    }
    if (!(fsiList->flagImage)) {
      FSI_FOR_INIT(fsiList);
      n = 0;
      FSI_FOR_START_ROW(fsiList); 
      FSI_FOR_START_COL(fsiList); 
      arrayLeft[_ir*imLeft->ncol+_ic] = imRight->pixels[n++];
      FSI_FOR_END_COL;
      FSI_FOR_END_ROW;
      return(imageiType);
    }
    else {
      n = 0;
      FSI_FOR_INIT(fsiList);
      FSI_FOR_START_IMAGE(fsiList);
      arrayLeft[_ir*imLeft->ncol+_ic] = imRight->pixels[n++];
      FSI_FOR_END_IMAGE;
      return(imageiType);
   }
  }
  
  /* 
   * Case of im[range1,...,rangeN] := LWFLOAT
   */   

  if (*equal == ':') {
    if (fsiList == NULL || type != numType) {
      SetErrorf("Inadequate ':=' syntax");
      return(NULL);
    }
    arrayLeft = imLeft->pixels;
    if (!(fsiList->flagImage)) {
      FSI_FOR_INIT(fsiList);
      FSI_FOR_START_ROW(fsiList); 
      FSI_FOR_START_COL(fsiList); 
      arrayLeft[_ir*imLeft->ncol+_ic] = fltRight;
      FSI_FOR_END_COL;
      FSI_FOR_END_ROW;
      return(imageiType);
    }
    else {
      FSI_FOR_INIT(fsiList);
      FSI_FOR_START_IMAGE(fsiList);
      arrayLeft[_ir*imLeft->ncol+_ic] = fltRight;
      FSI_FOR_END_IMAGE;
      return(imageiType);
   }
  }


 SetErrorf("Weird error");
  return(NULL);
}


/*
 * Basic routine to deal with setting [] an image
 */
void *SetImageField(IMAGE im,void **arg)
{
  char *field = ARG_S_GetField(arg);
  FSIList *fsiList = ARG_S_GetFsiList(arg);
  char *type = ARG_S_GetRightType(arg);    
  LWFLOAT flt = ARG_S_GetRightFloat(arg);   
  VALUE value = ARG_S_GetRightValue(arg);
  char *equal = ARG_S_GetEqual(arg);

  if (SetImageField_(im,field,fsiList,flt,value,equal,NULL) == NULL) return(NULL);
  ARG_S_SetResValue(arg,(VALUE) im);
  return(imageiType);
}  


/* 
 * Routine to deal with setting [] images
 */

static void *SetExtractImageV(VALUE value,void **arg)
{
   /* doc */
  if (value == NULL) return(doc);

  return(SetImageField((IMAGE) value,arg));
}

/* 
 * Routines to deal with extracting [] images
 */

static void *GetImageField_(IMAGE im, void **arg)
{
  char *field;
  FSIList *fsiList;
  LWFLOAT *pFlt;