root/InOutExpositor/InOutExpositor.pde

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
This applet is based on the code from the InOutServer applet.
Only Specific parts (not included in the InOutServer applet) are commented here.
InOutExpositor loads the "inout.xml" file (manually, or checking regularly if there is a newer version).
It creates Client objects representing the IN/OUT projects (see comments in the InOutServer applet).
It gets some preview .png files too, using the 'list.txt' file produced by InOutPreviewer.
Different display modes are available (see mModes).
When inactive during a certain amount of time, the AUTOPILOT mode switch automatically between display modes. (and loads the XML)
Note that that all Flags are reseted when changing modes
As indicated on screen, press 'DEL' to see how to show/hide things.
*/
////////////////////////////////////////////////////////////////////////////// Libraries
import processing.opengl.*; // uncommented if application mode
import java.util.Vector;
import traer.physics.*;
import processing.xml.*; // XML in
import java.io.*; // get list of files in directory
import fullscreen.*; 

FullScreen fs; 
////////////////////////////////////////////////////////////////////////////// Screen
// WARNING ! : to export as web applet, you must set the size() arguments manually too
int windW = 1024 ; // Set to screen resolution to get fullscreen in 'Present' mode (or when exporting as application)
int windH = 768 ;
//int windW = 800 ;
//int windH = 500 ;
////////////////////////////////////////////////////////////////////////////// Auto Pilot Mode
int autoPilotLaunchCompt = 50*25 ; // time before AUTO
int autoPilotBetween = 20*25 ; // time between AUTO modes
int fadingTime = 7*25 ; // fading time between modes
////////////////////////////////////////////////////////////////////////////// LOADING FROM XML(s) :
int MAXXMLFILES = 9999 ;
int currXmlListN = 0 ;
boolean goFullscreen = false;
boolean loadXmlFromSample = false ;
boolean loadFromXMLlist = false ;
boolean loadFromXMLlistAutoRun = true ; // auto play the XML list (anyway, try the bottom time-slider)
String xmlFilesFolder = "/xmlList/" ; // XML LIST FOLDER !! WARNING : only "inout_xxx.xml" files in the folder (not ".DS_store" or others)
//String xmlFileAddressLive = "http://io.citu.fr/data/inout.xml" ; // current XML from server
String xmlFileAddressLive = "http://theartcollider.net/yp/ioxml.php" ; // current XML from server
String xmlFileAddressSample = "http://theartcollider.net/data/inout_sample.xml" ; // with fictive connexions
//String xmlFileAddressSample = "inout.xml"; // local included example XML
//String previewFilesAddress = "http://io.citu.fr/previews" ;
String previewFilesAddress = "http://theartcollider.net/yp/_thumb/" ;
////////////////////////////////////////////////////////////////////////////// XML List replay mode
int minTimeStamp = 2000000000 ;
int maxTimeStamp = 0 ;
int currTimeStamp ;
int nXmlFiles ;
int SaveFrameCnt = 0;
////////////////////////////////////////////////////////////////////////////// Various
PFont font;
ParticleSystem physics;
Particle center ;
////////////////////////////////////////////////////////////////////////////// CLIENTS & STUFF INIT
int nClients = 0 ;     // Nombre de clients
Vector myClients ;     // PROJECTS (Clients)
Client highlighted, selected ;   // selected Client
////////////////////////////////////////////////////////////////////////////// OTHER USEFUL CLASSes
Explorator selectedExplorator ;
Explorator liveExplorator ;      // to display selected LiveTrajectWeb (reseau des connexions)
State drawnState ; // current displayed config
GraphUtils clientGraphUtils ;
LocationUtils clientsLocationUtils ;

String[] modeTitle;
int currMode = 0 ;

////////////////////////////////////////////////////////////
int MAXPNGER = 2 ; // png preview images MALLOC size
int PNGLOADINTERVAL = 90 ; // seconds before allowing to reload images

////////////////////////////////////////////////////////////////////////////// PREVIEW PNG
boolean gotPreviewImage = false ;
PImage previewedImage ;
PImage cImageMask ; // Round mask for preview images
////////////////////////////////////////////////////////////////////////////// GENERALES
String aSepa = "@" ; // sep entre adjectifs (ie param)
String aVirg = "/" ; // sep entre valeurs d1 param
String aTag = "%" ; // sep entre tag et valeur tag (nb d'occur)
////////////////////////////////////////////////////////////////////////////// WINDOW
int contextW = 100 ; // ContextMenu
int contextH = 120 ;
////////////////////////////////////////////////////////////////////////////// XML CLIENT/SERVER
int compt = 0 ;
int moduloXMLLoad = 200 ;
String lastXmlDate = "" ;
////////////////////////////////////////////////////////////////////////////// AUTOPILOT MODE variabes
boolean autoPilot = false ; // to change views and move clients automatically
int autoPilotCompt = 0 ;
int autoPilotLastCompt = 0 ;
int autoPilotBegCompt = 0;
float fadeValue = 0 ;
////////////////////////////////////////////////////////////////////////////// Clients Interpolation Mouvement Factor
float clientsSpeedFactor = 0.95 ;
int clearBckgOpacity = 10 ; // [0,255] (when clearBackground=false, controls remanence)
////////////////////////////////////////////////////////////////////////////// FLAGS
boolean radialClientsMovement = false ; // movement during mode change
boolean pleaseWait = false ;
boolean pleaseWait2= false ;
int     bascNewMode = -1;
boolean resetClients = true ;
boolean running = false ;
boolean clearBackground = true ;
boolean allowDragX = true ;
boolean allowDragY = true ;
boolean contextualMenu = false ;
boolean onlyRolloverText = false ;
boolean showFlagsText = false ;
boolean[] showType ;
boolean data = true ;
boolean audio = true ;
boolean video = true ;
/////////////////////////////////////// XML Loading
boolean autoXmlLoad = false ; 
boolean loadXmlNow = false ;
///////////////////////////////////////
boolean displayHistoryQuads = false ;
boolean displayGenome = false ;
boolean displayClients = true ;
boolean displayTrajet = false ;
//////////////////////////////////////// MODES...
boolean showStatsBackg = false ;
boolean showBigPreview = false ;
boolean showEllipses = false ;
boolean showNormalCircle = false ;
boolean showLocations = false ;
/////////////////////////////////////// Client DRAW FLAGS
boolean showClientBox = false ;
boolean showClientInfo = false ;
boolean showClientName = false ;
boolean showTentacules = false ;
/////////////////////////////////////// Satisfaction
boolean showClientScore = false ;
boolean showClientInFriends = false ;
boolean showClientOutFriends = false ;
/////////////////////////////////////// LINKS
boolean showWordArborescence = false ;
boolean showLinkCurves = false ;
boolean showLinkDirect = true ;
boolean showLinkSimple = false ;
boolean showLinkArcs = false ;
boolean showLinkTriangles = true ;
boolean showLinkHalfCircles = false ;
/////////////////////////////////////// PHYICS Modes
boolean processPhysics = false ;
boolean repulsionToAnother = false ;
boolean springsToAnchor = false ;
boolean springsToTags = false ;
boolean springsToClients = false ;

/////////////////////////////////////// MODES !!!!!
String currentModeTitle = "-" ;

/////////////////////////////////////// MODE - HORIZONTAL half circles
float hwcYPos = windH/3 ;
/////////////////////////////////////// MODE - STATS (activity,sociability)
float stMargin = 220 ;
/////////////////////////////////////// MODE - CIRCLE (OLD, unused)
float cirMX = windW*4/7 ;
float cirMY = windH-windH/4 ;
float cirMR = windW/2 ;
float cirMDateWidth = windW/3; // width of dates
int cirNLevel = 10 ;
int cirNLevelOp = 7 ;
float cirMbeginAng = PI ; // clients on circle
float cirMapertureAng = 2*PI/3 ; // idem
/////////////////////////////////////// MODE - systeme solaire
float ellipseA = 80 ;
float ellipseB = 40 ;
float clientBoxH = 20 ; // Cell box
float clientBoxL = 40 ;
color dColor = color(200,200,200) ;
color aColor = color(10,10,200) ;
color vColor = color(200,10,10) ;
////////////////////////////////////// MODE - explorator
float openANG = PI/5 ;
float shiftANG = -PI/6 ;
int explDepthMAX = 6 ;
int inDepth = explDepthMAX ;
int outDepth = explDepthMAX ;
////////////////////////////////////// STATISTIQUES
int clientsOldestDate = 0 ;
int clientsNewestDate = 0 ;
/////////////////////////////////////// LOCAL Vars
int nClients2 = nClients*nClients ; // N^2
float upControlZone = 0 ; //95 ;
float centerY ;
int N_nClients = nClients ;


//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////

Thread loadThread;
ImageLoader loader;

void setup()
{
//  size(800,600,OPENGL);
  size(windW,windH);
  background(10);
  smooth();
  frameRate(25) ;
  font = loadFont("Verdana-48.vlw");
  //font = loadFont("Verdana-11.vlw");
  textFont(font,10);
  textMode(MODEL); // default mode

  //cImageMask = loadImage("cImageMaskE.png") ;

  centerY = upControlZone + (height-upControlZone)/2.0 ;

  ///////////////////////////////////////////////////////////////////////////////// Physics
  physics = new ParticleSystem( 0, 0.05 );
  center = physics.makeParticle( 1.0, width/2, upControlZone + (height-upControlZone)/2, 0 );
  center.makeFixed() ;
  
  //////////////////////////////
  showType = new boolean[3] ;
  showType[0] = true ;
  showType[1] = true ;
  showType[2] = true ;
  //////////////////////////////

  myClients = new Vector() ;
  nClients = int(N_nClients) ;
  nClients2 = nClients*nClients ;
  drawnState = new State(nClients2) ;

  setTypeColors();
  modeTitle = new String[6] ;
  //////////////////////////////////////////////////////////// MODE TITLES
  /*
        modeTitle[0] = "Connections (<)" ;
  modeTitle[1] = "Physical and Metaphysical Locations (w)" ;
  modeTitle[2] = "Sociability and Nervousness (x)" ;
  modeTitle[3] = "Treeview and Influences (c)";
  modeTitle[4] = "Affinity Groups (v)" ;
  modeTitle[5] = "Flux and Reflux (b)" ;
  */
  modeTitle[0] = "Connections" ;
  modeTitle[1] = "Physical and Metaphysical Locations";
  modeTitle[2] = "Sociability and Nervousness";
  modeTitle[3] = "Treeview and Influences";
  modeTitle[4] = "Affinity Groups";
  modeTitle[5] = "Flux and Reflux";

  loader=new ImageLoader();
  loadThread=new Thread(loader);
        loadThread.start();

  if(loadFromXMLlist) getXMLlist() ; // loads XML list for player
  if (goFullscreen) {
    fs = new FullScreen(this);
    fs.enter();
  }
}

//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
void draw()
{   
/*
  if(frameCount%10==0) {
    Client cli ;
    for(int i=0;i<nClients;i++) {
      cli = getClient(i);
      if(cli.showPreview || cli.showSmallPreview) cli.thePNGs.nextImage() ;
    }
  }
*/

  compt++ ;
  if(compt==30) loadXmlNow=true ;

  if(processPhysics) physics.advanceTime( 1.0 );
  if(clearBackground) fill(0) ;
  else fill(0,clearBckgOpacity) ;
  noStroke() ;
  rect(0,0,width,height) ;

  if(running && nClients>0) {
    ////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////// MODE EXPOSITION : AUTOPILOT
    if(!autoPilot && (compt-autoPilotLastCompt)>=autoPilotLaunchCompt) {
      autoPilotBegCompt = compt ;
      autoPilot = true ;
      print("LAUNCHING AUTOPILOT !! after "+(compt-autoPilotLastCompt)+"\n") ;
    }
    if(autoPilot) {
      autoPilotCompt = compt-autoPilotBegCompt;
      /////////// Reloading XML at beginning
      if(autoPilotCompt%autoPilotBetween==0) { // every 'autoPilotBetween' FRAMES
        int modUlo = autoPilotCompt/autoPilotBetween ;
        /*
        int theMode = modUlo%6 ; // modes 0 1 2 3 4 5 only
        */
        // only modes 0 1 2 3 5 
        if ((modUlo%4)==4) {
          modUlo++;
        }
        int theMode = modUlo%6 ;
        if(theMode==0) loadXMLData() ; 
        basculeToMode(theMode) ; // Changing Mode
      }

      /////////// Fading screen :
      float opacTime = autoPilotCompt%autoPilotBetween ;
      if( opacTime>(autoPilotBetween-fadingTime) ) opacTime = autoPilotBetween - opacTime ;
      if( opacTime<fadingTime )
        fadeValue = 255 - 255*opacTime/(float)fadingTime ;
      else fadeValue = 0 ;
      if(fadeValue > 170 && (currMode==4||currMode==2)) pleaseWait = true ;
      else pleaseWait = false ;
    }

    if (bascNewMode >=0) {
      if (pleaseWait2==true) {basculeToMode(bascNewMode); bascNewMode=-1; pleaseWait2=false;}
      else {pleaseWait2=true;}
    }
    ////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////// DRAWING ENVIRONMENT (backg)
    if(showEllipses) traceEllipses() ;
    if(showClientBox) refreshLinkedAngles() ;
    if(showLinkHalfCircles) traceLinkHalfCircleBackg() ;
    if(showNormalCircle) traceNormalCircleBackg() ; // old (concentric circles - sort by dates)
    if(showStatsBackg) traceStatsBackg() ; // 2 axis : activity, sociability

    ////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////// DRAWING CLIENTS
    if(displayClients) {

      //////// CLIENTS LINKS !!!
      for(int i=0;i<nClients;i++)
        if(showLinkTriangles) drawOutLinkTriangle( getClient(i) ) ;

      for(int i=0;i<nClients;i++)
        if(!displayTrajet) getClient(i).traceOutLinks() ;

      //////// LOCATIONS (par dessus les liens!)
      if(showLocations) clientsLocationUtils.trace() ;

      //////// CLIENTS !!!
      for(int i=0;i<nClients;i++)
        getClient(i).traceClient() ;

      //////// Depth Explorator (gray clones)
      if(showEllipses) getSelected().traceExplorator() ;

      //////// Live Sun beam traject
      if(displayTrajet) traceTrajet() ;

      //////// SHOW BIG PREVIEW (il peut y en avoir pluisieurs en mm tmps)
      for(int i=0;i<nClients;i++) {
        Client ccli = getClient(i);
        if(ccli.showPreview) ccli.tracePreviewPNG(1) ;
        if(ccli.showSmallPreview) ccli.tracePreviewPNG(0.2) ;
      }

    } // END if(display)
    ////////////////////////////////////////////////////////
    if(fadeValue>0) { // FADING ALL CLIENTS
      noStroke(); 
      fill(0,fadeValue) ;
      rect(0,0,width,height) ;
      for(int i=0;i<nClients;i++) getClient(i).traceClientPoint() ;
    }

  } //END if(running)
  ////////////////////////////////////////////////////////
  if(loadFromXMLlist && loadFromXMLlistAutoRun && compt>100) loadXmlNow=true ;

  if(loadXmlNow || (autoXmlLoad && compt%moduloXMLLoad==0) ) {
    if(!autoPilot) {
      loadXMLData() ; 
      loadXmlNow = false ;
    }
  }

  ////// INFO TEXT
  traceInfoTexts() ; // CURRENT MODE TITLE
  traceColorLegend(); // data/audio/video colors
  if(showFlagsText) traceFlagsText() ;
  if(pleaseWait || pleaseWait2) tracePleaseWait() ;

  if(loadFromXMLlist) traceTimeLine() ; // mode : replaying list of XML files

  if(loadFromXMLlist && currMode==2) repartClientsByStats( myClients ) ; // if displaying in StatsMode, we replace clients every frame

  if (false) {
    String FrameCounterOUT;
    FrameCounterOUT = nf(SaveFrameCnt++, 6);
    saveFrame("/tmp/iox/frame_"+FrameCounterOUT+".jpg");
  }
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
float timeLineMargin = 10 ;
void traceTimeLine() {
  noFill() ;
  stroke(255) ;
  rect(timeLineMargin, height-2*timeLineMargin,width-2*timeLineMargin,timeLineMargin);
  fill(200) ;
  float INT = (maxTimeStamp-minTimeStamp) ;
  float CURR = (currTimeStamp-minTimeStamp) ;
  float xxx=(CURR*(width-2*timeLineMargin)/INT);
  //print("EE "+xxx+"\n") ;
  rect(timeLineMargin, height-2*timeLineMargin, timeLineMargin+xxx, timeLineMargin) ;
  textAlign(LEFT);
  textFont(font,10);
  noStroke() ;
  fill(255) ;
  int tmpstmp = getTimeStampFromFileName( xmlFiles[currXmlListN%nXmlFiles] ) ;
  String dateStr = formatTimeStamp(tmpstmp) ;
  text(dateStr,timeLineMargin+xxx,height-2*timeLineMargin-4);
}
void traceLastOscMessage(String lmess) {
  textAlign(CENTER);
  textFont(font,10);
  noStroke() ;
  fill(255) ;
  text(lmess,width/2,height-20);
}
void tracePleaseWait() {
  fill(0,180);
  rect(0,0,width,height);
  fill(255) ;
  textAlign(CENTER);
  textFont(font,15);
  noStroke() ;
  fill(255) ;
  text("Loading images ... please wait",width/2,height/2) ;
}
void traceInfoTexts() {
  noStroke() ;
  fill(255) ;
  float bx=10;
  float by=27;
  textAlign(LEFT);
  textFont(font,20);
  text("TheArtCollider.org Traffic-Monitor",bx,by) ;
        /*
  textFont(font,10);
  text("Press DEL to show/hide keyboard controls",bx,by+20) ;
  textAlign(RIGHT);
  float dy=16;
  for(int m=0;m<6;m++) {
    textFont(font,14);
    if(currMode==m) fill(255) ;
    else fill(120) ;
    text(modeTitle[m],width-10,20+m*dy) ;
  }
  */
  textAlign(RIGHT);
        text(modeTitle[currMode],width-30,by) ;

  fill(127,127,127) ;
        ellipse(width-12, height-12, 18, 18);
        ellipse(width-12, 20, 18, 18);
  fill(255,255,127) ;
  textFont(font,13);
        text("?",width-8,height-7) ;
        triangle(width-15, 13, width-5, 20, width-15, 27);

  textAlign(LEFT) ;
}
///////////////////////////////////////////////////////
void traceFlagsText() {
  float widX = width/3 ; // largeur d'une bande
  float pd = 10 ; // petit decalage debut en x
  String info="" ;
  String info2="" ;
  String info3="" ;
  noStroke() ;
  fill(0,180);
  rect(0,0,width,height);
  fill(255) ;
  textAlign(LEFT) ;

  info += "=== GENERAL INFOS ===\n\n" ;
  info += "nClients = "+nClients+"\n" ;
  info += "h - displayClients = " +displayClients +"\n\n" ;

  info += "=== PHYSICS OPTIONS ===\n\n" ;
  info += "? - processPhysics = " +processPhysics +"\n\n" ;

  info += "a - springsToAnchor = " +springsToAnchor +"\n" ;
  info += "e - springsToClients = " +springsToClients +"\n" ;
  info += "z - repulsionToAnother = " +repulsionToAnother +"\n\n\n" ;

  info += "=== DISPLAY MODES ===\n\n" ;

  info += "< - MODE Random\n" ;
  info += "w - MODE Locations\n" ;
  info += "x - MODE Stats\n" ;
  info += "c - MODE Parcours\n" ;
  info += "v - MODE Groups\n" ;
  info += "b - MODE Arcs\n\n" ;
  info += "t - launch live Trajects on selected\n\n" ;

  info2 += "=== DISPLAY OPTIONS ===\n\n" ;
  info2 += "= - showData = "+showType[0]+"\n" ;
  info2 += "/ - showAudio = "+showType[1]+"\n" ;
  info2 += "* - showVideo = "+showType[2]+"\n\n" ;

  info2 += "q - clearBackground = " +clearBackground +"\n\n" ;

  info2 += "n - onlyRolloverText = "+onlyRolloverText +"\n\n" ;

  info2 += "1 - showClientBox = " +showClientBox +"\n" ;
  info2 += "3 - showClientName = " +showClientName +"\n" ;
  info2 += "9 - showClientInfo = " +showClientInfo +"\n" ;
  info2 += "2 - showClientScore = " +showClientScore+"\n\n" ;

  info2 += "i - showClientInFriends = " +showClientInFriends +"\n" ;
  info2 += "o - showClientOutFriends = " +showClientOutFriends +"\n\n" ;

  info2 += "8 - showLinkSimple = " +showLinkSimple +"\n" ;
  info2 += "5 - showLinkDirect = " +showLinkDirect +"\n" ;
  info2 += "4 - showLinkCurves = " +showLinkCurves +"\n" ;
  info2 += "6 - showLinkArcs = " +showLinkArcs +"\n" ;
  info2 += "0 - showLinkTriangles = " +showLinkTriangles +"\n\n" ;

  info3 += "=== LOAD XML OPTIONS ===\n\n" ;
  info3 += "XML LIST REPLAY MODE = "+loadFromXMLlist+"\n" ;
  info3 += "r - loadFromXMLlistAutoRun = "+loadFromXMLlistAutoRun+"\n\n" ;
  info3 += "l - loadXmlData\n" ;
  info3 += "s - autoXmlLoad = "+autoXmlLoad+"\n" ;
  info3 += "u - loadXmlFromSample = "+loadXmlFromSample+"\n" ;
  

  float plx = 70 ;
  textFont(font,10);
  text(info,pd,upControlZone+plx) ;
  text(info2,widX+pd,upControlZone+plx) ;
  text(info3,2*widX+pd,upControlZone+plx) ;
}
void traceColorLegend() {
  noStroke() ;
  textAlign(LEFT) ;
  textFont(font,10);
  float dec=40;
  float dey=5;
  float ll=10;
  float gx=17;
  float gy=height-50;
  fill(dColor);
  rect(gx,gy,ll,ll);
  fill(255);
  text("Data",gx,gy-dey);
  fill(aColor);
  rect(gx+dec,gy,ll,ll);
  fill(255);
  text("Audio",gx+dec,gy-dey);
  fill(vColor);
  rect(gx+2*dec,gy,ll,ll);
  fill(255);
  text("Video",gx+2*dec,gy-dey);
}
void traceLinkHalfCircleBackg() {
  noStroke() ;
  fill(150,60) ;
  rect(0,0,width,hwcYPos) ;
  stroke(100,130) ;  
  line(0,hwcYPos,width,hwcYPos) ;
}
void traceStatsBackg() {
  /////// TRACING STATS LEGEND : to do
  //background(20) ;
  //  float ox = stMargin ;
  //  float oy = height-stMargin ;
  //  float ax = width-stMargin ;
  //  float ay = stMargin ;
  //  noStroke() ;
  //  fill(0) ;
  //  rect(ox,ay,ax-stMargin,oy-stMargin) ;
  //  stroke(70);
  //  line(ox,oy,ax,oy) ;
  //  line(ox,ay,ox,oy) ;

}
void traceNormalCircleBackg() {
  background(70) ;
  fill(0,cirNLevelOp) ;
  //stroke(150,110) ;
  noStroke() ;
  ellipse(cirMX,cirMY,cirMR*2,cirMR*2) ;
  float smallR = cirMR - cirMDateWidth ;
  noStroke() ;
  for(int u=0;u<cirNLevel;u++) {
    float currR = smallR + (float)u*(cirMR-smallR)/cirNLevel ;
    ellipse(cirMX,cirMY,currR*2,currR*2) ;
  }
  //        stroke(150,110) ;
  //        fill(120) ;
  //        ellipse(cirMX,cirMY,smallR*2,smallR*2) ;
  //////// Scale LEGEND :
  traceNormalCircleLegend() ;
}
void traceNormalCircleLegend() {
  stroke(255) ;
  strokeWeight(2) ;
  line(cirMX,height-10,cirMX-cirMR,height-10) ;
  int tn = 20 ;
  for(int t=0;t<tn;t++) {
    float tx = cirMX-t*cirMR/tn ;
    line(tx,height-10, tx,height-15) ;
  }
  //clientsNewestDate
  //clientsOldestDate
  noStroke() ;
  fill(255) ;
  Date dd = new Date(clientsNewestDate) ;
  textFont(font,10);
  text("High "+dd.toString(),cirMX,height-20);
  text("Low "+clientsOldestDate,cirMX-cirMR,height-20); 
}
void traceEllipses() {
  float x,y,nx,ny,a,b,na,nb ;
  float A,B,AA,BB ;
  int N = 50 ;
  float op ;
  for (int c=0; c<8 ;c=c+1) {
    op = 60.0*(1.0-(float)c/10.0) ;
    if(c%2==1) fill(100,op);
    else noFill() ;
    for (int k=0; k<N ;k++) {
      A = ellipseA*c;
      B = ellipseB*c;
      AA = ellipseA*(c+1);
      BB = ellipseB*(c+1);

      x = width/2 + A*cos(k*2*PI/N) ;
      y = centerY + B*sin(k*2*PI/N) ;
      nx = width/2 + A*cos((k+1)*2*PI/N) ;
      ny = centerY + B*sin((k+1)*2*PI/N) ;

      a = width/2 + AA*cos(k*2*PI/N) ;
      b = centerY + BB*sin(k*2*PI/N) ;
      na = width/2 + AA*cos((k+1)*2*PI/N) ;
      nb = centerY + BB*sin((k+1)*2*PI/N) ;
      noStroke() ;
      quad(x,y,a,b,na,nb,nx,ny) ;
      stroke(200,op);
      line(x,y,nx,ny) ;
      line(a,b,na,nb) ;
    }
  }
}
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////