ext_alloc.c

LastWave

  if (val == NULL) return(xDoc);
  
  return(GetFloatField(((EXT) val)->abscissa,arg));
}

static void * SetXExtV(VALUE val, void **arg)
{
  /* Documentation */
  if (val == NULL) return(xDoc);
  
  return(SetFloatField(&(((EXT) val)->abscissa),arg,0));
}


/*
 * Answers to the different print messages
 */
 
void PrintExt(EXT ext)
{
  Printf("<&ext;%p>\n",ext);
}

char *ToStrExt(EXT ext, char flagShort)
{
  static char str[30];
  
  sprintf(str,"<&ext;%p>",ext);
  
  return(str);
}


void PrintInfoExt(EXT ext)
{
  Printf("  x  :  %g [%d]\n",ext->abscissa,ext->index);
  Printf("  y  :  %d\n",ext->scale);
  Printf("  z  :  %g\n",ext->ordinate);
}



/*
 * The field list
 */
 
struct field fieldsExt[] = {

  "x", GetXExtV, SetXExtV, NULL, NULL,
  "index", GetIndexExtV, SetIndexExtV, NULL, NULL,
  "y", GetYExtV, NULL, NULL, NULL,
  "z", GetZExtV, SetZExtV, NULL, NULL,
  "nbExt", GetNbExtExtV, NULL, NULL, NULL,
  "next", GetNextExtV, NULL, NULL, NULL,
  "last", GetLastExtV, NULL, NULL, NULL,
  "first", GetFirstExtV, NULL, NULL, NULL,
  "previous", GetPreviousExtV, NULL, NULL, NULL,
  "coarser", GetCoarserExtV, NULL, NULL, NULL,
  "coarsest", GetCoarsestExtV, NULL, NULL, NULL,
  "finer", GetFinerExtV, NULL, NULL, NULL,
  "finest", GetFinestExtV, NULL, NULL, NULL,
  "extrep", GetExtrepExtV, NULL, NULL, NULL,

  NULL, NULL, NULL, NULL, NULL
};



/*
 * The type structure for EXT
 */
 
char *extType = "&ext"; 

TypeStruct tsExt = {

  "{{{&ext} {This type is used to store a local extremum of a wavelet transform. It is itself in a structure of type &extrep (i.e., \
an extrema representation)}}}",  /* Documentation */

  &extType,       /* The basic (unique) type name */
  NULL,     /* The GetType function */                       
  
  DeleteExt,     /* The Delete function */
  NewExt,     /* The Delete function */
  
  CopyExt,       /* The copy function */
  NULL,       /* The clear function */
  
  ToStrExt,       /* String conversion */
  PrintExt,   /* The Print function : print the object when 'print' is called */
  PrintInfoExt,   /* The PrintInfo function : called by 'info' */

  NULL,              /* The NumExtract function : used to deal with syntax like 10a */
   
  fieldsExt,      /* The list of fields */
};
 



/********************************************************
 * 
 *     Dealing with Extlis
 *
 ********************************************************/

/* delete an extrema and all the extrema it points to */
static void DeleteExtAndPoint (EXT ext)
{
  if (ext != NULL)
    {
      DeleteExtAndPoint(ext->next);
      ext->next = ext->previous = ext->finer = ext->coarser = NULL;
      ext->extlis = NULL;
      DeleteExt(ext);
    }
}


/* Delete an extrema list */
void DeleteExtlis(EXTLIS extlis)
{
  DeleteExtAndPoint(extlis->first);
#ifdef DEBUGALLOC
DebugType = "Extlis1d";
#endif
  Free(extlis);
}

/* Initialization of an  extrema list */
void ClearExtlis(EXTLIS extlis)
{
  extlis->size = 0;
  DeleteExtAndPoint(extlis->first);
  extlis->first = NULL;
  extlis->end = NULL;
}

/* Allocate an extrema list and return it */
EXTLIS NewExtlis(void)
{
  EXTLIS extlis;

#ifdef DEBUGALLOC
DebugType = "Extlis1d";
#endif
  extlis = (EXTLIS) (Malloc(sizeof(struct extlis)));

  extlis->size = 0;
  extlis->first = NULL;
  extlis->end = NULL;
  extlis->extrep = NULL;

  return(extlis);
}


/********************************************************
 * 
 *     Dealing with Extrep
 *
 ********************************************************/

/***********************************************************************************
 *
 *  Misc functions on extreps
 *
 ***********************************************************************************/

/* Check an extrep is not empty */
void CheckExtrep(EXTREP extrep)
{
  if (extrep == NULL || extrep->nOct == 0) 
    Errorf("Run 'extrema' first");
}


/*
 * Command to get/set the fields of a extrep
 */ 

void C_SetExtrep(char **argv)
{
  EXTREP extrep;
  EXT ext;
  int ival,o,v;
  char *field;
  LWFLOAT fval,x,y;
  char *name1,*name;

  argv = ParseArgv(argv,tSTR,&field,tEXTREP,&extrep,-1);
  
  if (!strcmp(field,"noct")) {
    if (*argv == NULL) SetResultInt(extrep->nOct);
    else {
      argv = ParseArgv(argv,tINT,&ival,0);
      if (ival < 0 || ival > NOCT-1) Errorf("Bad 'noct' value '%d'",ival);
      extrep->nOct = ival;
    }
  }

  else if (!strcmp(field,"nvoice")) {
    if (*argv == NULL) SetResultInt(extrep->nVoice);
    else {
      argv = ParseArgv(argv,tINT,&ival,0);
      if (ival < 0 || ival > NVOICE-1) Errorf("Bad 'nvoice' value '%d'",ival);
      extrep->nVoice = ival;
    }
  }

  else if (!strcmp(field,"size")) {
    if (*argv == NULL) SetResultInt(extrep->size);
    else {
      argv = ParseArgv(argv,tINT,&ival,0);
      if (ival < 0) Errorf("Bad 'size' value '%d'",ival);
      extrep->size = ival;
    }
  }

  else if (!strcmp(field,"dx")) {
    if (*argv == NULL) SetResultFloat(extrep->dx);
    else {
      argv = ParseArgv(argv,tFLOAT,&fval,0);
      if (fval <= 0) Errorf("Bad 'dx' value '%.8g'",fval);
      extrep->dx = fval;
    }
  }

  else if (!strcmp(field,"x0")) {
    if (*argv == NULL) SetResultFloat(extrep->x0);
    else {
      argv = ParseArgv(argv,tFLOAT,&fval,0);
      extrep->x0 = fval;
    }
  }
  
  else if (!strcmp(field,"name")) {
    NoMoreArgs(argv);
    SetResultStr(extrep->name);
  }

  else if (!strcmp(field,"wname")) {
    if (*argv == NULL) SetResultStr(extrep->wName);
    else {
      argv = ParseArgv(argv,tSTR,&name,0);
      if (extrep->wName != NULL) Free(extrep->wName);
      extrep->wName = CopyStr(name);
    }
  }

  else if (!strcmp(field,"*wtrans")) {
    ParseArgv(argv,tVNAME_,NULL,&name1,0);
    if (name1 == NULL) SetResultInt((int) (extrep->wtrans != NULL));
    else if (extrep->wtrans == NULL) {
      DeleteVariableIfExist(name1);
      SetResultInt(0);
    }
    else {
      SetVariable(name1,(VALUE) extrep->wtrans);
      SetResultInt(1);
    }
  }
  
  else if (!strcmp(field,"*extFirst")) {
    ParseArgv(argv,tINT,&o,tINT,&v,tVNAME,&name1,0);
    if (o >extrep->nOct || o <=0 ) Errorf("Bad octave number '%d'",o);
    if (v >=extrep->nVoice || v <0 ) Errorf("Bad voice number '%d'",v);
    if (extrep->D[o][v]->first==NULL) {
      DeleteVariableIfExist(name1);
      SetResultInt(0);
    }
    else {
      SetVariable(name1,(VALUE) extrep->D[o][v]->first);
      SetResultInt(1);
    }
  }

  else if (!strcmp(field,"*extClosest")) {
    ParseArgv(argv,tFLOAT,&x,tFLOAT,&y,tVNAME,&name1,0);
    /* Get the oct and voice */
    v = ((int) (y+.5))%extrep->nVoice;
    o = ((int) (y+.5))/extrep->nVoice+1;
    if (o >extrep->nOct || o <=0 ) {
      DeleteVariableIfExist(name1);
      SetResultInt(0);
    }
    if (v >=extrep->nVoice || v <0 ) {
      DeleteVariableIfExist(name1);
      SetResultInt(0);
    }   
    if (extrep->D[o][v]->first==NULL) {
      DeleteVariableIfExist(name1);
      SetResultInt(0);
    }
    else {
      for (ext = extrep->D[o][v]->first; ext->next !=NULL;ext = ext->next) {
        if (ext->abscissa > x) break;
      }
      if (ext->abscissa > x && ext->previous) {
        if (fabs(ext->previous->abscissa-x) < fabs(ext->abscissa-x)) ext = ext->previous;
      }
      SetVariable(name1,(VALUE) ext);
      SetResultInt(1);
    }
  }

    
  else Errorf("Unknow extrep field '%s'",field);  
}


/*
 * Various actions on extreps
 */ 

void C_Extrep(char **argv)
{
  EXTREP extrep;
  char *action;
  LWFLOAT x,y;
  int o,v;
  EXT ext;

  argv = ParseArgv(argv,tWORD,&action,tEXTREP_,NULL,&extrep,-1);
  if (extrep == NULL) extrep = (GetWtransCur())->extrep;
  
  if (!strcmp(action,"closest")) {
    ParseArgv(argv,tFLOAT,&x,tFLOAT,&y,0);
    /* Get the oct and voice */
    v = ((int) (y+.5))%extrep->nVoice;
    o = ((int) (y+.5))/extrep->nVoice+1;
    if (o >extrep->nOct || o <=0 || v >=extrep->nVoice || v <0 || extrep->D[o][v]->first==NULL) ext = NULL;
    else {
      for (ext = extrep->D[o][v]->first; ext->next !=NULL;ext = ext->next) {
        if (ext->abscissa > x) break;
      }
      if (ext->abscissa > x && ext->previous) {
        if (fabs(ext->previous->abscissa-x) < fabs(ext->abscissa-x)) ext = ext->previous;
      }
    }
    
    if (ext == NULL) SetResultValue(nullValue);
    else SetResultValue(ext);
    return;
  }

  
  else Errorf("Unknow action '%s'",action);  
}


/*
 * Get the current extrep 
 * (generate an error if there is none)
 */
 
EXTREP GetExtrepCur(void)
{
  EXTREP extrep;
  WTRANS wtrans;
 
 if (!ParseTypedValLevel_(levelCur, "objCur", NULL, (VALUE *) &wtrans, wtransType)) Errorf1("");

  if (wtrans->extrep == NULL) Errorf("Current wavelet transform does not have any extrema representation");
  extrep = wtrans->extrep;
  AddRefValue(extrep);
  TempValue(extrep);
   
  return(extrep);
}


   
/*************************
 * Copy an extrep 
 ************************/

void CopyExtrep(EXTREP extrep1,EXTREP extrep2,int flagCut,LWFLOAT xMin,LWFLOAT xMax)
{
  EXTLIS extlis1,extlis2;
  EXT ext1,ext2,ext2Old;
  int o,v;
    
  if (extrep1 == extrep2) return;
    
  ClearExtrep(extrep2);
	
  extrep2->x0 = extrep1->x0;
  extrep2->dx = extrep1->dx;
  extrep2->size = extrep1->size ;
  extrep2->nVoice = extrep1->nVoice;
  extrep2->nOct = extrep1->nOct;
  extrep2->aMin = extrep1->aMin;
  if (extrep1->wName != NULL) extrep2->wName = CopyStr(extrep1->wName);
 
  for(o=1;o<=extrep1->nOct;o++)
    for(v=0;v<extrep1->nVoice;v++) {
      extlis1 = extrep1->D[o][v];
      extlis2 = extrep2->D[o][v];
      for(ext1 = extlis1->first;ext1 != NULL; ext1 = ext1->next)  {
           if (flagCut == YES && (ext1->abscissa < xMin || ext1->abscissa > xMax)) 
                continue;
           ext2Old = ext2;
           ext2 = NewExt();
           CopyExt(ext1,ext2);
           ext2->coarser = ext2->finer = NULL;
           ext2->extlis = extlis2;
           if (extlis2->size == 0) {
              extlis2->first = ext2;
              ext2->previous = NULL;
           }
           else {
              ext2->previous = ext2Old;
              ext2->previous->next = ext2;
           }
           ext2->next = NULL; 
           extlis2->size++;
      }
      if (extlis2->size != 0) extlis2->end = ext2;
   }
}

EXTREP CopyExtrep1(EXTREP extrep1,EXTREP extrep2)
{
  if (extrep2 == NULL) extrep2 = NewExtrep();
  CopyExtrep(extrep1,extrep2,NO,0,0);
  return(extrep2);
}

void C_ECopy(char **argv)
{
  EXTREP extrep1,extrep2;
  	
  argv = ParseArgv(argv,tEXTREP,&extrep1,tEXTREP,&extrep2,0);
	
  CheckExtrep(extrep1);
	
  CopyExtrep(extrep1,extrep2,NO,0.,0.);
}

/* Default name for an extrep */
static char defaultName[] = "";