head	1.1;
access;
symbols;
locks; strict;
comment	@# @;


1.1
date	97.11.09.01.23.12;	author kowallik;	state Exp;
branches;
next	;


desc
@@


1.1
log
@Initial revision
@
text
@// angle vs time plot

// last changed 05/08/97 
// status: needs lots of cleaning up

import java.awt.*;
import java.util.*;
import java.lang.*;


class T_Graph extends Panel
{
// angle vs time data - static because also used by fourier    
   static Vector t= new Vector();		
   
   boolean reshaped = false;
   FontMetrics fm;
   main parent;
   
   Image offscreen;			// image for plot
   Image down_off;			// image for x-ticklabels
   Image labelx_off;
   Image labely_off;
   Image left_off;
   
   double maxt,mint;				// min-max for plots
   		
   Panel down, small, tiny, left, labelx, labely, title;
  
   
   T_Graph()
   {
     setBackground(Color.lightGray);
     
     setLayout(new BorderLayout());
     small=new Panel();
     tiny=new Panel();
     down = new Panel();
     left=new Panel();
     labelx=new Panel();
     labely=new Panel();
     
     add("West", labely);
     add("South", labelx);
     add("Center", small);
      
     small.setLayout(new BorderLayout(0,5));
     small.add("South", down);
     small.add("West", left); 
     small.add("Center", tiny);
    
     this.show();
   }
   
   public void exit()
   {
      t.removeAllElements();
      
      try
      {
         offscreen.flush();
         down_off.flush();
         left_off.flush();
         labelx_off.flush();
         labely_off.flush();
      }catch(NullPointerException npe)
      {}
   }



// as soon as we are done

   void cleanup(boolean rerun)
   {
      Graphics g;
      Dimension d;
      t.removeAllElements();
      if(rerun==false)
      {
         maxt=0;
         mint=0;
         try
         {
            d = left.size();
            g = left_off.getGraphics();
            g.setColor(Color.lightGray);
            g.fillRect(0, 0, d.width, d.height);
            d = down.size();
            g = down_off.getGraphics();
            g.setColor(Color.lightGray);
            g.fillRect(0, 0, d.width, d.height);
         }catch(NullPointerException npe)
         {}   
      }
      try
      {
         d = tiny.size();
         g = offscreen.getGraphics();
         g.setColor(Color.white);
         g.fillRect(0, 0, d.width, d.height);
         g.setColor(Color.black);
         paint(g);
      }catch(NullPointerException npe)
      {}   
   }
   
   
   void draw(double y)
   {
      Graphics g;
      Dimension d;
      
      int j;
      double off=0,sc=10;
      
      if (offscreen==null)
      {
         // make sure there is enough space to label axis
         if(!reshaped)
         {
            d = this.size();
            labely.reshape( 0,           0,         15, d.height-15);
            labelx.reshape(55, d.height-15, d.width-50, 15);
            small.reshape( 15,           0, d.width-15, d.height-15); 
            left.reshape(   0,           0,         40, d.height-30);
            down.reshape(  40, d.height-30, d.width-55, 15);
            tiny.reshape(  40,           0, d.width-55, d.height-30);
            d = down.size();
            down_off = this.createImage(d.width, d.height);
            d = left.size();
            left_off = this.createImage(d.width, d.height);
            d = labelx.size();
            labelx_off = this.createImage(d.width, d.height);
            
            d = labely.size();
            labely_off = this.createImage(d.width, d.height);
            reshaped=true; 
         }
         d=tiny.size();
         offscreen=this.createImage(d.width, d.height);
         g = offscreen.getGraphics();
         fm = g.getFontMetrics();
         g.setColor(Color.white);
         g.fillRect(0,0,d.width, d.height);   
      }
      g = offscreen.getGraphics();
      g.setColor(Color.black);
      d = tiny.size();
      
      
// label x-axis - do this at the beginnig and whenever we filled the whole plot  

      if((t.size()%d.width)==0)
      {
         label();
         xlabel(1);
      }

// wait to get an idea what the range for x and y is
// collect data but don't plot anything
      
      if(t.size()<10)
      {
          t.addElement(new Double(y));
          if(y>maxt) maxt=y;
          if(y<mint) mint=y;
      }
      else				// collect and plot data
      {
         if(t.size()==10) drawall();
         
         if((y>maxt) || (y<mint))
         {
            if(y>maxt) maxt=y+(y-mint)*0.05;
            if(y<mint) mint=y-(maxt-y)*0.05;
            
// scaling changed clear and redraw            
            drawall();
         }
         
// scaling didn't change
         t.addElement(new Double(y));
      
         off= (maxt+mint)/2;
         sc = d.height/(maxt-mint);
         Double tmp=(Double) t.elementAt(t.size()-2);
         double yo=tmp.doubleValue();
         
         j=t.size();
         while(j>d.width) j-=d.width;
         if (j>2)
         {
            g.drawLine (j-1, (int)((-yo+off)*sc+d.height/2),
                        j,   (int)((-y+off)*sc+d.height/2));
            g.setColor(Color.white);
            g.fillRect(j+1, 0, 5, d.height);
         }
         if(j<=2)
         {
           g.clearRect(0, 0, 5, d.height);
         } 
      }
      paint(g);  
   }
   
   public void drawcom()
   {
      Graphics g = offscreen.getGraphics();
      Dimension d = tiny.size();
      g.setColor(Color.white);
      g.fillRect(0,0,d.width, d.height);  
      g.setColor(Color.black);
      
      int step = 1;
      while( (t.size()/step) > d.width)
      {
         step++;
      }
      
      double off= (maxt+mint)/2;
      double sc = d.height/(maxt-mint);
      for(int i=step; i<t.size(); i+=step)
      {
         Double tmp=(Double) t.elementAt(i);
         double yy=tmp.doubleValue();
         tmp=(Double) t.elementAt(i-step);
         double yo=tmp.doubleValue();
         g.drawLine ((int) (i/step),(int)((-yo+off)*sc+d.height/2),
                     (int) (i/step)+1,(int)((-yy+off)*sc+d.height/2));
      }
      xlabel(step);
      label();
      paint(g);
   }      


// redraw the angle-time plot
   
   public void drawall()
   {
      int i,j,k=0;
      Graphics g=offscreen.getGraphics();
      Dimension d=tiny.size();
      
      double off= (maxt+mint)/2;
      double sc = d.height/(maxt-mint);
      g.setColor(Color.white);
      g.fillRect(0, 0, d.width, d.height);   
      g.setColor(Color.black);
      
      j=t.size();
      while (j>d.width) j-=d.width;
            
      for(i=(t.size()-j+1); i<t.size(); i++)
      {
         k++;
         Double tmp=(Double) t.elementAt(i);
         double yy=tmp.doubleValue();
         tmp=(Double) t.elementAt(i-1);
         double yo=tmp.doubleValue();
      
         g.drawLine (k,(int)((-yo+off)*sc+d.height/2),
                     k+1,(int)((-yy+off)*sc+d.height/2));
      }
      label();
      xlabel(1);
      paint(g);
   }
   

// draw labels and ticklabels at angle-time except the ticks at x-axis
   
   public void label()
   {
      int n;
      
// label y-axis      
      Graphics g = left_off.getGraphics();
      Dimension d = left.size();
      g.setColor(Color.lightGray);
      g.fillRect(0, 0, d.width, d.height);
      g.setColor(Color.black);
      
      Double dd = new Double((Math.floor(maxt*100))/100);
      g.drawString(dd.toString(), 2,10);
      dd= new Double((Math.floor(mint*100))/100);
      g.drawString(dd.toString(), 2, d.height);
      
// write "time" at x-axis
      d = labelx.size();
      g = labelx_off.getGraphics();
      g.setColor(Color.lightGray);
      g.fillRect(0, 0, d.width, d.height);
      g.setColor(Color.black);
      g.drawString("time", (int) ((d.width-fm.stringWidth("time"))/2), 
                           d.height-2);

// write angle  on the left side      
      d = labely.size();
      g = labely_off.getGraphics();
      g.setColor(Color.lightGray);
      g.fillRect(0, 0, d.width, d.height);
      g.setColor(Color.black);
      
      int h= fm.getHeight()-2;
      g.drawString("a", (int) (10-0.5*fm.stringWidth("a")) , 20+h);
      g.drawString("n", (int) (10-0.5*fm.stringWidth("n")) , 20+2*h);
      g.drawString("g", (int) (10-0.5*fm.stringWidth("g")) , 20+3*h);
      g.drawString("l", (int) (10-0.5*fm.stringWidth("l")) , 20+4*h);
      g.drawString("e", (int) (10-0.5*fm.stringWidth("e")) , 20+5*h);
   }

   public void xlabel(int step)
   {
      int n;
         
// label x-axis
      Dimension d = down.size();
      Graphics g = down_off.getGraphics();
      g.setColor(Color.lightGray);
      g.fillRect(0,0,d.width,d.height);
      g.setColor(Color.black);
      
      if (step==1)		// regular scaling 
      {
         n=(int) Math.floor(t.size()/d.width);
      }
      else			// compressed drawing
      {
         n=0;   
      }
      
      for(int m=0; m<(d.width); m+=100)
      {
         Integer kk=new Integer((int)((m*step+n*(d.width))/20));
         g.drawString(kk.toString(), m, d.height-2);
      }
      paint(g);      
   }
   
   
// draw the power spectrum in the big window   
// this uses the whole dataset for the fourier spectrum
// we draw only the first 32 frequencies 
   
   public void fdrawall()
   {
      Dimension d, s;
      Graphics g, f;
      int el,i,j,k=0;
      int jmax;
      double Mmax=0;
      int m;
      
// x-axis shows frequency
      d = labelx.size();
      g = labelx_off.getGraphics();
      g.setColor(Color.lightGray);
      g.fillRect(0, 0, d.width, d.height);
      g.setColor(Color.black);
      g.drawString("frequency", (int) ((d.width-fm.stringWidth("frequency"))/2), 
                           d.height-2);
                           
// clear ticklabels on y-axis
      d = left.size();
      g = left_off.getGraphics();
      g.setColor(Color.lightGray);
      g.fillRect(0, 0, d.width, d.height);
      g.setColor(Color.black);
      
// write Power on the left side      
      d = labely.size();
      g = labely_off.getGraphics();
      g.setColor(Color.lightGray);
      g.fillRect(0, 0, d.width, d.height);
      g.setColor(Color.black);
      int h= fm.getHeight()-2;
      
      g.drawString("p", (int) (10-0.5*fm.stringWidth("p")) , 20+h);
      g.drawString("o", (int) (10-0.5*fm.stringWidth("o")) , 20+2*h);
      g.drawString("w", (int) (10-0.5*fm.stringWidth("w")) , 20+3*h);
      g.drawString("e", (int) (10-0.5*fm.stringWidth("e")) , 20+4*h);
      g.drawString("r", (int) (10-0.5*fm.stringWidth("r")) , 20+5*h);



// the fourier analysis part
     
      double F[]=new double[(int) (t.size()/4)+1];
      double G[]=new double[(int) (t.size()/4)+1];
      double R[]=new double[(int) (t.size()/4)+1];
      double M[]=new double[(int) (t.size()/4)+1];
      
      el=2*((int) (t.size()/8));
      
      for(i=0; i<el; i++)
      {
         R[i]=((Double)t.elementAt(i)).doubleValue();
      }
      
      for(j=1; j<(el/2); j++)
      {  
         F[j]=0;
         G[j]=0;
         
         for (k=0; k<el; k++)		/*loop for sums*/
         {
            F[j]+=R[k]*Math.cos((2*Math.PI*k*j/el));
            G[j]+=R[k]*Math.sin((2*Math.PI*k*j/el));
         }
         M[j]= ((Math.sqrt(F[j]*F[j]+G[j]*G[j])));
         if (M[j]>Mmax) Mmax=M[j];
      }


      d = down.size();
      s = tiny.size();
      f = down_off.getGraphics();
      g = offscreen.getGraphics();
      f.setColor(Color.lightGray);
      f.fillRect(0,0,d.width,d.height);
      f.setColor(Color.black);
      g.clearRect(0,0,s.width, s.height); 
             
// where to draw the labels and bars      
      double dist = (s.width/33);
      double sch = 0.9*s.height/Mmax;

// check if we really have 32 frequencies in case someone clicks on stop     
      if ((el/2)>33) jmax = 33;
      else jmax=(el/2);     
      
      for (j=0; j<jmax; j++)
      {
         g.fillRect((int) ((j-0.1)*dist),(int) (s.height-sch*M[j]), 
                    (int) (0.2*dist),(int) (sch*M[j]));
                   
         if (Math.round(j/2.0)!=(j/2.0))
         {
            Integer kk=new Integer(j);
            f.drawString(kk.toString(),
             		(int) (j*dist-fm.stringWidth(kk.toString())/2), 
             		d.height-2);
         }
      }
      paint(g);
   }
   
   
   public void paint(Graphics g)
   {
      if(offscreen!=null)
      {
         g = tiny.getGraphics();
         g.drawImage(offscreen, 0, 0, Color.lightGray, this);
      }
      if(down_off != null)
      {
         g = down.getGraphics();
         g.drawImage(down_off, 0, 0, Color.lightGray, this);
      }
      if(left_off != null)
      {
         g = left.getGraphics();
         g.drawImage(left_off, 0, 0, Color.lightGray, this);
      }
      if(labelx_off != null)
      {
         g = labelx.getGraphics();
         g.drawImage(labelx_off, 0, 0, Color.lightGray, this);
      }
      if(labely_off != null)
      {
         g = labely.getGraphics();
         g.drawImage(labely_off, 0, 0, Color.lightGray, this);
      }
   }
   public void update()
   {
      Graphics g = this.getGraphics();
      paint(g);
   }
}
@