circles.c

LastWave

/*..........................................................................*/
/*                                                                          */
/*      L a s t W a v e    P a c k a g e 'circles'                          */
/*                                                                          */
/*      Copyright (C) 2002 Emmanuel Bacry                                   */
/*      email : [e-mail]                              */
/*                                                                          */
/*..........................................................................*/

#include "lastwave.h"
#include "int_fsilist.h"


/************************************************************************
 * 
 * 
 * Defining the CIRCLES VALUE
 * 
 * 
 ************************************************************************/


/* A single circle */
typedef struct circle { 
  FLOAT x;
  FLOAT y;
  FLOAT r;
} Circle;

/* The CIRCLES VALUE */
typedef struct circles {

  /* The fields of the VALUE structure */
  ValueFields;

  Circle *array;
  
  int n;
  
  char *name;
} Circles, *CIRCLES;

/* The corresponding &type */
static char *circlesType = "&circles";



/*
 * The type structure for CIRCLES
 */

extern CIRCLES NewCircles(void);
extern void DeleteCircles(CIRCLES c);
extern void ClearCircles(CIRCLES c);
extern CIRCLES  CopyCircles(CIRCLES in, CIRCLES out);
extern char *ToStrCircles(CIRCLES c, char flagShort);
extern void PrintCircles(CIRCLES c);
extern void PrintInfoCircles(CIRCLES c);

extern struct field fieldsCircles[];

TypeStruct tsCircles = {

  "{{{&circles} {A description of the type '&circles'.}}}",  /* Documentation */

  &circlesType,       /* The basic (unique) type name */
  NULL,               /* The GetType function */                       
  
  DeleteCircles,     /* The Delete function */
  NewCircles,     /* The Delete function */
  
  CopyCircles,       /* The copy function */
  ClearCircles,       /* The clear function */
  
  ToStrCircles,       /* String conversion */
  PrintCircles,   /* The Print function : print the object when 'print' is called */
  PrintInfoCircles,   /* The PrintInfo function : called by 'info' */

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


/*
 * The field list
 */
static void * GetExtractCirclesV(CIRCLES c,void **arg);
static void * SetExtractCirclesV(CIRCLES c,void **arg);
static void * GetExtractOptionsCirclesV(CIRCLES c,void **arg);
static void * GetExtractInfoCirclesV(CIRCLES c,void **arg);
static void * GetNameCirclesV(CIRCLES c, void **arg);
static void * SetNameCirclesV(CIRCLES c, void **arg);
static void * GetNCirclesV(CIRCLES c, void **arg);
static void * SetNCirclesV(CIRCLES c, void **arg);
static void * GetExtractOptionsRXYCirclesV(CIRCLES c,void **arg);
static void * GetExtractInfoRXYCirclesV(CIRCLES c,void **arg);
static void * GetRCirclesV(CIRCLES c, void **arg);
static void * SetRCirclesV(CIRCLES c, void **arg);
static void * GetXCirclesV(CIRCLES c, void **arg);
static void * SetXCirclesV(CIRCLES c, void **arg);
static void * GetYCirclesV(CIRCLES c, void **arg);
static void * SetYCirclesV(CIRCLES c, void **arg);

struct field fieldsCircles[] = {

  "", GetExtractCirclesV, SetExtractCirclesV, GetExtractOptionsCirclesV, GetExtractInfoCirclesV,
  "r", GetRCirclesV, SetRCirclesV, GetExtractOptionsRXYCirclesV, GetExtractInfoRXYCirclesV,
  "x", GetXCirclesV, SetXCirclesV, GetExtractOptionsRXYCirclesV, GetExtractInfoRXYCirclesV,
  "y", GetYCirclesV, SetYCirclesV, GetExtractOptionsRXYCirclesV, GetExtractInfoRXYCirclesV,
  "name", GetNameCirclesV, SetNameCirclesV, NULL, NULL,
  "n", GetNCirclesV, SetNCirclesV, NULL, NULL,

  NULL, NULL, NULL, NULL, NULL
};
  




CIRCLES NewCircles(void)
{
  CIRCLES c;
  extern TypeStruct tsCircles;

  c = Malloc(sizeof(Circles));
  
  InitValue(c,&tsCircles);
  
  c->array = NULL;
  c->n = 0;
  c->name = CopyStr("");
  
  return(c);
}

void DeleteCircles(CIRCLES c)
{
  RemoveRefValue(c);
  if (c->nRef > 0) return;
  
  if (c->n != 0) Free(c->array);
  if (c->name) Free(c->name);
  Free(c);
}



void ClearCircles(CIRCLES c)
{
  if (c->n != 0) {
    Free(c->array);
    c->array = NULL;
    c->n = 0;
  }
}

CIRCLES  CopyCircles(CIRCLES in, CIRCLES out)
{
  if (out == NULL) out = NewCircles();
  
  ClearCircles(out);
  
  out->array = Malloc(sizeof(Circles)*in->n);
  out->n = in->n;  

  memcpy(out->array,in->array,sizeof(Circles)*in->n);
  
  return(out);
}

char *ToStrCircles(CIRCLES c, char flagShort)
{
  static char str[30];

  if (!strcmp(c->name,"")) {
    sprintf(str,"<&circles[%d];%p>",c->n,c);
  }
  else if (strlen(c->name) < 15) {
    sprintf(str,"<&circles[%d];%s>",c->n,c->name);
  }
  else {
    sprintf(str,"<&circles[%d];...>",c->n);
  }
  
  return(str);

}

void PrintCircles(CIRCLES c)
{
  int i;

  if (c->n == 0) Printf("<empty>\n");
  else {  
    for (i=0;i<c->n;i++) 
      Printf("%d : x=%g, y=%g, r= %g\n",i,c->array[i].x,c->array[i].y,c->array[i].r);
  }
}


void PrintInfoCircles(CIRCLES c)
{
  Printf("  name  :  %s\n",c->name);
  Printf("  number of circles  :  %d\n",c->n);
}


/*
 * 'name' field
 */
static char *nameDoc = "{[= <name>]} {Sets/Gets the name of a circles}";


static void * GetNameCirclesV(CIRCLES c, void **arg)
{
  /* Documentation */
  if (c == NULL) return(nameDoc);
  
  return(GetStrField(c->name,arg));
}

static void * SetNameCirclesV(CIRCLES c, void **arg)
{
  
  
  /* doc */
  if (c == NULL) return(nameDoc);

  return(SetStrField(&(c->name),arg));
}

/*
 * 'n' field
 */
static char *nDoc = "{[= <n>]} {Sets/Gets the number of circles of a circles object}";


static void * GetNCirclesV(CIRCLES c, void **arg)
{
  /* Documentation */
  if (c == NULL) return(nDoc);
  
  return(GetIntField(c->n,arg));
}

static void * SetNCirclesV(CIRCLES c, void **arg)
{
  
  int n,i;
    
  /* doc */
  if (c == NULL) return(nDoc);

  n = c->n;

  if (SetIntField(&n,arg,FieldSPositive)==NULL) return(NULL);

  if (n<c->n) c->n = n;
  else {
    ClearCircles(c);
    c->array = Malloc(sizeof(Circles)*n);
    c->n = n;
    for (i= 0;i<n;i++) {
      c->array[i].x = 0;
      c->array[i].y = 0;
      c->array[i].r = 0;
    }
  }
    
  return(numType);
}


/* 
 *
 * Dealing with extractions of the type circles[...]
 *
 */
 
static char *doc = "{[*nolimit,...] [:]= list of <x,y,r>} {Get/Set the circle values}"; 

static char *optionDoc = "{{*nolimit} {*nolimit : indexes can be out of range}}";
static char *extractOptionsCircles[] = {"*nolimit",NULL};
enum {
  FSIOptCirclesNoLimit = FSIOption1
};


static void *GetExtractOptionsCirclesV(CIRCLES c, void **arg)
{ 
  
  
   /* doc */
  if (c == NULL) return(optionDoc);
  
  return(extractOptionsCircles);
}

static void *GetExtractInfoCirclesV(CIRCLES c, void **arg)
{
  static ExtractInfo extractInfo;
  static char flagInit = YES;
  
  
  unsigned long *options = ARG_EI_GetPOptions(arg);

  if (flagInit == YES) {
    extractInfo.nSignals = 1;
    extractInfo.xmin = 0;
    extractInfo.dx = 1;
  }
  
  if (c->n == 0) {
    SetErrorf("No extraction possible on empty list of circles");
    return(NULL);
  }

  extractInfo.xmax = c->n-1;
  
  extractInfo.flags = EIIntIndex;
  if (!(*options & FSIOptCirclesNoLimit)) extractInfo.flags |= EIErrorBound;
  
  return(&extractInfo);
}


static void *GetExtractCirclesV(CIRCLES c, void **arg)
{
  FSIList *fsiList;
  CIRCLES c1;
  FSI_DECL;

  
  /* doc */
  if (c == NULL) return(doc);
  
  fsiList = (FSIList *) ARG_G_GetFsiList(arg);

  c1 = NewCircles();
  TempValue(c1);
  ARG_G_SetResValue(arg,c1);
  
  if (fsiList->nx1 == 0) return(circlesType);
  
  c1->array = Malloc(sizeof(Circle)*fsiList->nx1);
  c1->n = fsiList->nx1;
  
  FSI_FOR_START(fsiList); 
  if (fsiList->options & FSIOptCirclesNoLimit && (_i<0 || _i >= c->n)) continue;
  memcpy(&(c1->array[_k]),&(c->array[_i]),sizeof(Circle));
  FSI_FOR_END;

  return(circlesType);
}


static void *SetExtractCirclesV(CIRCLES c,void **arg)
{
  
  FSIList *fsiList = (FSIList *)  ARG_S_GetFsiList(arg);
  char *type = ARG_S_GetRightType(arg);    
  VALUE val = ARG_S_GetRightValue(arg);
  char *equal = ARG_S_GetEqual(arg);
  VALUE *pValueRes = ARG_S_GetResPValue(arg);

  LISTV lv;
  FSI_DECL;
  FLOAT f;
  SIGNAL sig;
  int _iold, i;

  /* doc */
  if (c == NULL) return(doc);
  
  if (type != listvType) {
    SetErrorf("Right hand side of assignation should be a &listv");
    return(NULL);
  }
  lv = CastValue(val,LISTV);
  
  /* Case := {} */
  if (*equal == ':') {
    if (lv->length != 0) {
      SetErrorf("With := syntax, right handside should be an empty listv");
      return(NULL);
    }
    
    /* Testing the indices are strictly increasing */
    _iold = -1;
    FSI_FOR_START(fsiList);
    if (_i <= _iold) {
      SetErrorf("Indices should be strictly increasing");
      return(NULL);
    }
    _iold = _i;
    FSI_FOR_END;
    
    /* Let's remove the circles ! */
    _iold = -1;
    i = 0;
    FSI_FOR_START(fsiList);
    if (_i == 0) {
      _iold = 0;
      continue;
    }
    else if (_iold == -1) {
      i = _i;
      _iold = _i;
      continue;
    }
    if (_i == _iold+1) {
      _iold = _i;
      continue;
    }
    memmove(&(c->array[i]),&(c->array[_iold+1]),(_i-_iold-1)*sizeof(Circle));
    i+=_i-_iold-1;
    _iold = _i;
    FSI_FOR_END;
    if (_i != c->n-1) {
      memmove(&(c->array[i]),&(c->array[_iold+1]),(c->n-1-_iold)*sizeof(Circle));
    }
    
    c->n -= fsiList->nx;
    
    *pValueRes = (VALUE) c;
    return(circlesType);    
  }
  
  
  /* case +=, -= ... */
  if (*equal != '=') {
    SetErrorf("%s syntaxnot valid",equal);
    return(NULL);
  }
  
  
  /* case = {sig1 ...} */
  if (lv->length != fsiList->nx) {
    SetErrorf("Right and left handside should have the same size");
    return(NULL);
  }
  
  FSI_FOR_START(fsiList);
  GetListvNth(lv,_k,&val,&f);
  if (val == NULL || GetTypeValue(val) != signaliType) {
    SetErrorf("Expect a listv of non empty signals on right handside");
    return(NULL);
  }
  sig = CastValue(val,SIGNAL);
  if (sig->size != 3) {
    SetErrorf("Expect a listv of signals of length 3 on right handside");
    return(NULL);
  }
  if (sig->Y[2] < 0) {
    SetErrorf("Radius must be positive");
    return(NULL);
  }
  c->array[_i].x = sig->Y[0]; 
  c->array[_i].y = sig->Y[1];