root/InOutExpositor/oExpl.pde

///////////////////////////////////////////////////////////////////////////////////////////////////////
class Pt {
  float x,y ;
  Pt(float _x, float _y) {
    x = _x ;
    y = _y ;
  }  
}
Pt getEllipsePosition( float depth, float ang ) {
  Pt res = new Pt( width/2 + ellipseA*depth*cos( ang ), centerY + ellipseB*depth*sin( ang ) ) ;
  return res ;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
//// Arborescence with provenance et destination (avec exhibition minimale distance)
class Branche { // Link A -------> B
  Client A,B ;
  boolean realA, realB ;
  float aAng, bAng ; // avec l'angle et le depth, on connait la position
  int depth ;
  int type ;

  ///////////////// For live tracing
  float tgv = 0.5 ;
  float t ;
  boolean end,killed ;
  Branche(Client _A, Client _B, int d, int intyp) {
    A = _A ;
    B = _B ;
    depth = d ;
    type = intyp ;
    //////
    realA = true ;
    realB = true ;
    aAng = 0 ;
    bAng = 0 ;
    ////// for live tracing
    t = 0 ;
    end = false ;
    killed = false ;
  }
  void updateIfRealClientPositions() {
    // only t‚àö‚Ñ¢te
    if(realB) {
      print("...moving "+B.name+"\n") ;
      B.moveTo( getEllipsePosition(depth,bAng).x, getEllipsePosition(depth,bAng).y ) ;
    }
  }
  void traceLink() {
    float opp = 50-depth*3.5 ;
    stroke(getColorType(type),opp) ;
    float a,b,na,nb ;
    if(realA) {
      a = A.x() ;
      b = A.y() ;
    }
    else {
      a = getEllipsePosition(depth-1,aAng).x ;
      b = getEllipsePosition(depth-1,aAng).y ;
    }
    if(realB) { 
      na = B.x() ;
      nb = B.y() ;
    }
    else {
      na = getEllipsePosition(depth,bAng).x ;
      nb = getEllipsePosition(depth,bAng).y ;     
    }
    if(!realA || !realB) drawSimpleDottedLineOp(a,b,na,nb, opp) ;
    if(!realA) A.traceClientCloneAt(a,b, opp) ;
    if(!realB) B.traceClientCloneAt(na,nb, opp) ;
    //text("P:"+depth,a,b) ;
    //text("P:"+(depth),na,nb) ;
  }
  void traceLinkWithColor( int op ) {
    noFill() ;
    stroke(getColorType(type),op);
    line(A.x(),A.y(),B.x(),B.y()) ;
    strokeWeight(2) ;
    ellipse(A.x(), A.y(), 11, 11) ;
    ellipse(B.x(), B.y(), 11, 11) ;
    strokeWeight(1) ;
  }
  void traceLive() {
    float dd = sqrt(pow(A.x()-B.x(),2) + pow(A.y()-B.y(),2)) ;
    t+=20.0*tgv/dd ;
    stroke(getColorType(type),100) ;
    traceTrajetLinkFlux(A.x(), A.y(), B.x(), B.y(),t) ;
    if(t>=1) end = true ;
  }
}

////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
class Explorator { // for a Client A, got the in & out trajects (branches en profondeur)
  Client A ;
  Vector oL ;

  int depIn = explDepthMAX ;
  int depOut = explDepthMAX ;
  Vector inBranches, outBranches ; // Vecteur des branches par profondeur
  Vector inCells, outCells ;        // contient les CLient touchees par le CLient

  Explorator( Client _A, int iD, int oD ) {
    A = _A ;
    depIn = iD ;
    depOut = oD ;

    ///////////////////// INIT exploration
    for(int i=0;i<nClients;i++) ((Client)getClient(i)).toBeCloned = false ;

    if(showEllipses) {
      Pt rPt ;
      for(int i=0;i<nClients;i++) {
        float cLune = shiftANG-PI/2 ;
        rPt = getEllipsePosition(random(4.1,4.9), random(cLune-PI/4,cLune+PI/4) ) ;
        ((Client)getClient(i)).moveTo(rPt.x,rPt.y);
        A.moveTo( width/2, centerY ) ;
      }
    }
    A.toBeCloned = true ;

    inBranches = new Vector() ;
    outBranches = new Vector() ;
    Vector firstCol = new Vector() ;
    Branche sourceBranche = new Branche(A,A,0,0) ;
    firstCol.addElement( sourceBranche ) ;
    inBranches.addElement( firstCol ) ;
    outBranches.addElement( firstCol ) ;

    //////////////// STart !
    explore( false ) ; // explore IN
    explore( true ) ; // explore OUT

    //////// For live sun beam traject links [sic]
    oL = new Vector() ;
    oL.addElement( new Branche(A,A,0,0) ) ;
  }
  ///////////////////////////
  ///////////////////////////
  void trace( boolean isOut ) {
    int maxOd ;
    Vector col ;
    if(isOut) {
      maxOd = min(outDepth,depOut) ;
    }
    else {
      maxOd = min(inDepth,depIn) ;
    }

    for(int u=0;u<=maxOd;u++) {
      if(isOut) col = (Vector)outBranches.elementAt(u) ;
      else col = (Vector)inBranches.elementAt(u) ;

      for(int v=0;v<col.size();v++) {
        Branche br = (Branche)col.elementAt(v) ;
        //int op = int(200-200*u/(maxOd+3.0)) ;
        //br.traceLinkWithColor( op ) ;
        br.traceLink() ;
      }
    }
  }
  ///////////////////////////
  void explore( boolean isOut ) {
    //print("---------------------- Explore  :"+A.name+"\n") ;

    ////////// parcours
    int prof = 0 ;
    Vector oldCol ;
    boolean encore = true ;

    int dept = depIn ;
    if(isOut) dept = depOut ;

    while( prof<dept && encore ) {
      //print("New profondeur-------------------: "+prof+"\n") ;
      encore = false ;
      Vector newCol = new Vector() ;
      oldCol = new Vector() ;

      if(isOut) oldCol = (Vector)outBranches.elementAt(prof) ;
      else oldCol = (Vector)inBranches.elementAt(prof) ;

      int NinDepth = oldCol.size() ;
      for(int u=0;u<NinDepth;u++) { // For all Clients of a Depth

        Branche fromBranche = (Branche)oldCol.elementAt(u) ;
        Client from = fromBranche.B ;

        Vector lCopins ;

        // get out linked clients of each
        if(isOut) lCopins = getOutLinkedClients( from ) ;
        else lCopins = getInLinkedClients( from ) ;

        // for all linked clients, add a Branche
        int nbSuivants = lCopins.size() ;
        for(int v=0;v<nbSuivants;v++) {
          Client to = (Client)lCopins.elementAt(v) ;

          int t = 0 ;
          Branche newBr = new Branche(from,to,prof+1,t) ;

          newBr.realB = !to.toBeCloned ;
          to.toBeCloned = true ;

          newBr.realA = fromBranche.realB ;
          newBr.aAng = fromBranche.bAng ;

          if(prof==0) {
            if(!isOut) fromBranche.bAng = shiftANG+PI ;
            else fromBranche.bAng = shiftANG ; 
          }
          if(nbSuivants==1) newBr.bAng = fromBranche.bAng ;
          else newBr.bAng = fromBranche.bAng + (openANG)*(float)v/(nbSuivants-1) - openANG/2 ;
          
          float divz = 100.3 ; // 15
          newBr.bAng += random(-PI/divz,PI/divz) ;
          
          if(showEllipses) {
            //////// moving POSITION of real Clients
            newBr.updateIfRealClientPositions() ;
          }
          //print("Adding branche "+v+" from "+nbSuivants+" :("+prof+" :::: "+newBr.A.name+" to "+newBr.B.name+"\n") ;
          //print("Reality: "+newBr.realA+" to "+newBr.realB+"\n") ;

          newCol.addElement( newBr ) ;
          encore = true ;
        }
      }

      if(isOut) outBranches.addElement( newCol ) ;
      else inBranches.addElement( newCol ) ;

      prof++ ;
    }
    if(isOut) depOut = prof-1 ;
    else depIn = prof-1 ;
  }
  ///////////////////////////
  void runLive() {
    stroke(210,20,20,20) ;
    for(int i=oL.size()-1;i>=0;i--) {
      Branche l = (Branche)oL.elementAt(i) ;
      if( !l.killed )
        l.traceLive() ;
      else oL.removeElement(l) ;
    }
  }
  ///////////////////////////
  void exploreOutLive() {
    int tS = oL.size() ;
    for(int i=0;i<tS;i++) { // pour tous les link
      Branche l = (Branche)oL.elementAt(i) ;
      if( !l.killed && l.end ) { // live link finished (on est arrive a une cellule)
        l.killed = true ;
        for(int t=0;t<3;t++) {
          Client endc = l.B ;
          for(int j=0;j<nClients;j++) { // dans toutes les cellules
            if( drawnState.isLink(t,endc.id,j) ) { // si lien endId -----> autre (j)
              oL.addElement( new Branche(endc,getClient(j),0,t) );
            }
          }
        }
      }
    }
  }
  ///////////////////////////
}
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////