root/InOutExpositor/dLink.pde

////////////////////////////////////////////////////////////
// Links drawing utilities
////////////////////////////////////////////////////////////
void initTrajet()
{
  background(0) ;
  liveExplorator = new Explorator( getSelected(), 0, 0 ) ;
}
void traceTrajet()
{
  liveExplorator.exploreOutLive() ;
  liveExplorator.runLive() ;

  //print("Showing Flux ( "+ tL.size() +" )\n") ; 
  if( liveExplorator.oL.size()>1000 ) {
    displayTrajet = false ;
    clearBackground = true ; 
  }
}
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////
void drawOutLinkTriangle( Client A ) 
{
  Vector outCopins = getOutLinkedClients(A) ;
  Client copin ;
  int nb = 0 ;
  if(A.connected) {
    stroke(50,130) ;
    fill(50,130) ;
  }
  else {
    stroke(50,90) ;
    fill(50,90) ; 
  }

  int n = int(A.out[0].on) + int(A.out[1].on) + int(A.out[2].on) ;
  ellipse(A.x(),A.y(),2*15*n,2*15*n) ;

  for(int i=0;i<outCopins.size();i++) {
    nb = 0 ;
    copin = (Client)outCopins.elementAt(i) ;
    if(showType[0] && drawnState.isLink(0,A.id,copin.id)) nb++ ;
    if(showType[1] && drawnState.isLink(1,A.id,copin.id)) nb++ ;
    if(showType[2] && drawnState.isLink(2,A.id,copin.id)) nb++ ;
    drawClientsTriangle(A,copin,nb) ;
  }
}
void drawClientsTriangle( Client A, Client B, int nb )
{
  float larg = 2+nb*15;
  float ang = (float)getLinkAngle(A,B)+PI/2 ;
  arc(A.x(),A.y(),2*larg,2*larg,ang,ang+PI) ;
  drawTriangle(A.x(),A.y(),B.x(),B.y(),larg) ;
}
void drawTriangle(float a, float b, float c, float d, float larg) {
  float ang = (float)getPointsAngle(a,b,c,d)+PI/2;
  beginShape(TRIANGLES);
  vertex(c,d) ;
  vertex(a+larg*cos(ang), b+larg*sin(ang)) ;
  vertex(a-larg*cos(ang), b-larg*sin(ang)) ;
  vertex(c,d) ;
  endShape() ; 
}
////////////////////////////////////////////////////////////////////////////
void drawArrowLine(float x1, float y1, float x2, float y2)
{
  float x = (0.7*x1+0.3*x2) ;
  float y = (0.7*y1+0.3*y2) ;
  line(x1,y1,x,y) ;
}
////////////////////////////////////////////////////////////////////////////
void drawSimpleLine( Client A, Client B, int type) {
  stroke(getColorType(type)) ;
  float decal = 0 ;
  float beg = 1.7 ;
  float pas = 1.2 ;
  if(type==0) decal = beg  ;
  if(type==1) decal = beg + pas ;
  if(type==2) decal = beg + 2*pas ;
  float a = (float)getLinkAngle(A,B)+PI/2 ;
  line(A.x()+ decal*cos(a),A.y()+ decal*sin(a),B.x()+ decal*cos(a),B.y()+ decal*sin(a)) ;
}
////////////////////////////////////////////////////////////////////////////
void drawOrientedSimpleLine( Client A, Client B, int type) {
  int nSegm = 2+int(2*distance(A,B)/10.0) ;
  float maxWidth = 11.2 ;
  float sw,xa,ya,xb,yb ;
  float opac ;
  for(int k=0;k<nSegm;k++) {
    sw = 0.5 + maxWidth - k*maxWidth/(nSegm-1) ;
    strokeWeight(sw) ;
    opac = 255 - 255*k/(nSegm-1) ;
    stroke(getColorType(type),opac) ;
    xa = lerp(A.x(), B.x(), k/(float)nSegm);
    ya = lerp(A.y(), B.y(), k/(float)nSegm);
    xb = lerp(A.x(), B.x(), (k+1)/(float)nSegm);
    yb = lerp(A.y(), B.y(), (k+1)/(float)nSegm);
    line(xa,ya,xb,yb) ;
  }
  strokeWeight(1) ;
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
void drawSimpleDottedLine(float x1, float y1, float x2, float y2) {
  float dd = sqrt(pow(x1-x2,2)+pow(y1-y2,2)) ;
  int n = int(dd/3.0) ;
  stroke(190,130) ;
  for(int k=0; k<=n; k=k+2) {
    //alph = 150-(float)k*255/(float)n ;
    //sw = 3.5-(float)k*2/(float)n ;
    //strokeWeight(sw) ;
    //stroke(hu, sat , lum, alph) ;
    float xa = lerp(x1, x2, k/(float)n);
    float ya = lerp(y1, y2, k/(float)n);
    float xb = lerp(x1, x2, (k+1)/(float)n);
    float yb = lerp(y1, y2, (k+1)/(float)n);
    line(xa, ya, xb, yb);
  }
}
void drawSimpleDottedLineOp(float x1, float y1, float x2, float y2, float op) {
  float dd = sqrt(pow(x1-x2,2)+pow(y1-y2,2)) ;
  int n = int(dd/3.0) ;
  stroke(190,op) ;
  for(int k=0; k<=n; k=k+2) {
    //alph = 150-(float)k*255/(float)n ;
    //sw = 3.5-(float)k*2/(float)n ;
    //strokeWeight(sw) ;
    //stroke(hu, sat , lum, alph) ;
    float xa = lerp(x1, x2, k/(float)n);
    float ya = lerp(y1, y2, k/(float)n);
    float xb = lerp(x1, x2, (k+1)/(float)n);
    float yb = lerp(y1, y2, (k+1)/(float)n);
    line(xa, ya, xb, yb);
  }
}
////////////////////////////////////////
void drawOrientedDottedLine(Client A, Client B, int type) // A -----------> B
{
  float decal = 4 ;
  float a = (float)getLinkAngle(A,B)+PI/2.0 ;
  float x1 = A.x() + decal*cos((float)a) ;
  float y1 = A.y() + decal*sin((float)a) ;
  float x2 = B.x() + decal*cos((float)a) ;
  float y2 = B.y() + decal*sin((float)a) ;
  drawDottedLine(x1, y1, x2, y2, type) ;
}
////////////////////////////////////////////////////////////////////////////
float dPointFROM = 15 ;
float dPointTO = 25 ;
float dPoint = dPointFROM ;
void drawDottedLine(float x1, float y1, float x2, float y2, int type)
{
  dPoint += 0.1 ;
  if(dPoint>dPointTO) dPoint=dPointFROM ;

  float dd = sqrt(pow(x1-x2,2)+pow(y1-y2,2)) ;
  int n = floor(dd*7/((float)dPoint));
  int from = 0 ;

  float hu = 0 ;
  float sat = 200 ;
  float lum = 200;
  float alph ;
  float sw = 1 ;

  if(type==2) { // VIDEO
    hu = hue(getColorType(2)) ;
  }
  if(type==1) { // AUDIO
    hu = hue(getColorType(1));
    from=from+1;
  }
  if(type==0) { // DATA
    lum = 255 ;
    sat = 0 ;
    from=from+2;
    hu = hue(getColorType(0)) ;
  }
  colorMode(HSB);
  for(int k=from; k<=n; k=k+3) {
    alph = 200-(float)k*200/(float)n ;
    sw = 5.5-(float)k*2/(float)n ;
    strokeWeight(sw) ;
    stroke(hu, sat , lum, alph) ;
    float xa = (float)lerp(x1, x2, (float)k/(float)n);
    float ya = (float)lerp(y1, y2, (float)k/(float)n);
    float xb = (float)lerp(x1, x2, (float)(k+1)/(float)n);
    float yb = (float)lerp(y1, y2, (float)(k+1)/(float)n);
    line((float)xa, (float)ya, (float)xb, (float)yb);
  }
  strokeWeight(1) ;
  colorMode(RGB);
}
////////////////////////////////////////////////////////////////////////////
// For live sun beam links traject
void traceTrajetLinkFlux( float x1, float y1, float x2, float y2, float t)
{
  //float x = x2*t + x1*(1-t) ;
  //float y = y2*t + y1*(1-t) ;
  //ellipse(x,y,3,3) ;

  for(int k=-3;k<3;k=k+2) {
    float t1 = t+k*0.02-0.02 ;
    float t2 = t+k*0.02 ;
    float ax = x2*t1 + x1*(1-t1) ;
    float ay = y2*t1 + y1*(1-t1) ;
    float bx = x2*t2 + x1*(1-t2) ;
    float by = y2*t2 + y1*(1-t2) ;
    if(t1>=0 && t2<=1) line(ax,ay,bx,by) ;
  }
}
////////////////////////////////////////////////////////////////////////////
void drawArcLink(Client A, Client B, boolean curv, int type)
{
  Client temp ;
  if(curv) {
    temp=A ;
    A=B ;
    B=temp ; 
  }
  float ax = A.x() ;
  float ay = A.y() ;
  float bx = B.x() ;
  float by = B.y() ;

  float sina = sin(A.angle) ;
  float cosa = cos(A.angle) ;
  float sinb = sin(B.angle+PI) ;
  float cosb = cos(B.angle+PI) ;

  float ddst = sqrt(pow(ax-bx,2) + pow(ay-by,2)) ;
  float d = ddst*2 ;

  float u = clientBoxL/3 ;
  float v = d ;
  if(!curv) { v= 4.4*d/(sqrt(1+d));}

  noFill() ;
  stroke(getColorType(type),190) ;
  strokeWeight(2.1) ;
  if(curv) { 
    //curve(ax+v*cosa, ay+v*sina, ax-u*cosa, ay-u*sina, bx-u*cosb, by-u*sinb, bx+v*cosb, by+v*sinb) ;
    float ix1,iy1,ix2,iy2,t1,t2,sw,alph ;
    int steps = 5+int(distance(A,B)/3) ;
    float macSW = 14.5 ;
    for(int i=0;i<steps;i=i+1) { //+3
      t1 = i/float(steps);
      t2 = (i+1)/float(steps);
      alph = 255-(float)(i+1)*255/(float)steps ;
      sw = 0.5+ macSW-(float)(i+1)*macSW/(float)(steps) ;
      strokeWeight(sw+1) ;
      stroke(getColorType(type), alph) ;
      ix1 = curvePoint(ax+v*cosa, ax-u*cosa, bx-u*cosb, bx+v*cosb, t1);
      iy1 = curvePoint(ay+v*sina, ay-u*sina, by-u*sinb, by+v*sinb, t1);
      ix2 = curvePoint(ax+v*cosa, ax-u*cosa, bx-u*cosb, bx+v*cosb, t2);
      iy2 = curvePoint(ay+v*sina, ay-u*sina, by-u*sinb, by+v*sinb, t2);
      line(ix1,iy1,ix2,iy2) ;
    }
  }
  else bezier(ax+u*cosa, ay+u*sina, ax+v*cosa, ay+v*sina, bx+v*cosb, by+v*sinb, bx+u*cosb, by+u*sinb) ;
  strokeWeight(1) ;
}
////////////////////////////////////////////
void drawHalfCircle(Client A, Client B, float y, int type )  // A ------> B
{
  stroke(getColorType(type),120) ;

  float x1 = A.x() ;
  float x2 = B.x() ;
  float an=0 ;
  float r = abs(x1-x2)/2 ;
  if(x1<x2) an=PI;
  float nMorc = 2 + int(abs(x1-x2)/5.0);
  float a,b,c,d ;
  float o = (x1+x2)/2 ;
  c=0 ;
  d=0 ;
  //// strokeweight
  float sw ;
  float maxWeight = 7 ;

  for(int i=0;i<nMorc-1;i++) {
    a = o + r*cos(an+(i*PI/nMorc)) ;
    b = y + r*sin(an+(i*PI/nMorc)) ;
    c = o + r*cos(an+((i+1)*PI/nMorc)) ;
    d = y + r*sin(an+((i+1)*PI/nMorc)) ;
    sw = 0.3 + maxWeight - i*maxWeight/(nMorc-2) ;
    strokeWeight(sw) ;
    line(a,b,c,d) ;
  }
  line(c,d,x2,y) ;
  strokeWeight(1) ;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////