TAO/examples/Simulator/DOVEBrowser/DoubleVisComp.java

   1 //
   2 // = FILENAME
   3 //    DoubleVisComp.java
   4 //
   5 // = AUTHOR
   6 //    Seth Widoff (core graph functionality)
   7 //    Michael Kircher (mk1@cs.wustl.edu)
   8 //
   9 // = DESCRIPTION
  10 //   This is a Visualization Component for displaying doubles.
  11 //
  12 // ============================================================================
  13
  14
  15
  16
  17 import java.awt.*;
  18 import java.util.*;
  19
  20 public class DoubleVisComp extends Canvas implements VisComp
  21 {
  22   private static final int MIN_SPACING = 2;
  23   private static final int POINT_HISTORY = 200;
  24   private static final Font FONT = new Font ("Dialog", Font.PLAIN, 10);
  25
  26   private Queue plot_;
  27   private String title_;
  28   private Graphics offgraphics_;
  29   private Image offscreen_;
  30   private Dimension offscreensize_;
  31   private int max_value_;
  32   private int old_max_value_;
  33   private int spacing_;
  34   private boolean max_increased_ = false;
  35   private static boolean monotonic_scale_ = false;
  36
  37   private float local_max_ = 0;
  38   private static float local_max_values_ [] = null;
  39   private static int local_max_value_count_ = 0;
  40   private int local_max_value_index_ = 0;
  41
  42   public DoubleVisComp()
  43   {
  44     super();
  45
  46     // Re-initialize the global array of local maxima.
  47     local_max_init ();
  48
  49     plot_ = new Queue();
  50     spacing_ = MIN_SPACING;
  51     title_ = "";
  52     max_value_ = 1;
  53     old_max_value_ = max_value_;
  54
  55     java.util.Random rand = new java.util.Random (System.currentTimeMillis());
  56     float hue_ = rand.nextFloat();
  57     float brightness = rand.nextFloat();
  58
  59     hue_ += .075;
  60
  61     if (hue_ > 1.0)
  62       hue_ -= 1.0;
  63
  64     if (brightness > 0.75)
  65       brightness -= 0.25;
  66
  67     Color new_color = Color.getHSBColor(hue_, 1, brightness);
  68
  69     this.setBackground(new_color);
  70     this.setForeground(Color.white);
  71   }
  72
  73   public static synchronized void monotonic_scale (boolean b) {
  74     monotonic_scale_ = b;
  75   }
  76
  77   public static synchronized boolean monotonic_scale () {
  78     return monotonic_scale_;
  79   }
  80
  81   public void setName (String title) {
  82       title_ = title;
  83   }
  84
  85   public int getProperty () {
  86       return Properties.DOUBLE;
  87     }
  88
  89   public Dimension getMinimumSize () {
  90       return new Dimension (75, 75);
  91     }
  92
  93   public Dimension getPreferredSize () {
  94       return new Dimension (175, 175);
  95     }
  96
  97   public String getName() {
  98     return title_;
  99   }
 100
 101   public int getMax() {
 102       return old_max_value_;
 103     }
 104
 105   public void update(java.util.Observable observable, java.lang.Object obj)
 106   {
 107     Double double_temp_;
 108     try {
 109       double_temp_ = (Double) obj;
 110     }
 111     catch (Exception excp) {
 112       double_temp_ = new Double (0.0);
 113       System.out.println (excp);
 114       System.out.println ("Visualization Component received wrong data type!");
 115     }
 116
 117     float new_point = double_temp_.floatValue();
 118     Float temp = (Float)plot_.dequeue_tail();
 119     plot_.enqueue_head(new Float(new_point));
 120
 121     if (new_point > local_max_)
 122       {
 123         local_max_ = new_point;
 124         local_max_values_ [local_max_value_index_] = local_max_;
 125       }
 126
 127     if (monotonic_scale_)
 128       {
 129         float global_max = 0;
 130         global_max = global_max_value ();
 131
 132         while (global_max > max_value_)
 133           max_value_ *= 2;
 134
 135         while ((global_max < max_value_/2) && (max_value_ > old_max_value_))
 136           max_value_ /= 2;
 137       }
 138     else
 139       {
 140         while (local_max_ > max_value_)
 141           max_value_ *= 2;
 142
 143         while ((local_max_ < max_value_/2) && (max_value_ > old_max_value_))
 144           max_value_ /= 2;
 145       }
 146
 147     repaint();
 148   }
 149
 150   public void update(Graphics g)
 151   {
 152     Dimension d = getSize ();
 153     float tmp, value_1, value_2;
 154     FontMetrics fm = g.getFontMetrics ();
 155     Enumeration queue_iter = plot_.forward_iterator();
 156     int x1 = d.width - 8, y1, x2, y2, fheight = fm.getHeight (), i;
 157     String value =  "Value (of " + max_value_ + "): " + String.valueOf(plot_.head());
 158
 159     if ((offscreen_ == null) ||
 160         (offscreensize_.width != d.width - 8) ||
 161         (offscreensize_.height != d.height - 8))
 162       {
 163         offscreen_ = createImage(d.width - 8, d.height - 8);
 164         offscreensize_ = new Dimension(d.width - 8, d.height - 8);
 165         offgraphics_ = offscreen_.getGraphics();
 166         offgraphics_.setFont(FONT);
 167       }
 168
 169     g.setColor (Color.lightGray);
 170     g.draw3DRect (0, 0, d.width - 1, d.height - 1, true);
 171     g.draw3DRect (1, 1, d.width - 3, d.height - 3, true);
 172     g.draw3DRect (2, 2, d.width - 5, d.height - 5, true);
 173
 174     local_max_ = 0;
 175
 176     offgraphics_.setColor (getBackground());
 177     offgraphics_.fillRect (0, 0, offscreensize_.width, offscreensize_.height);
 178     offgraphics_.setColor (getForeground());
 179     offgraphics_.drawString(title_, 5, fheight);
 180     offgraphics_.drawString(value, 5, offscreensize_.height - 5);
 181
 182     value_1 = ((Float)queue_iter.nextElement()).floatValue();
 183     while (queue_iter.hasMoreElements())
 184       {
 185         value_2 = ((Float)queue_iter.nextElement()).floatValue();
 186
 187         if (value_1 > local_max_)
 188           local_max_ = value_1;
 189
 190         y1 = normalize(offscreensize_.height - fheight, value_1);
 191         y2 = normalize(offscreensize_.height - fheight, value_2);
 192
 193         tmp = value_2;
 194         value_2 = value_1;
 195         value_1 = tmp;
 196
 197         x2 = x1 - spacing_;
 198         offgraphics_.drawLine(x1, y1, x2, y2);
 199         x1 = x2;
 200         if (x1 <= 5)
 201           break;
 202       }
 203
 204     local_max_values_ [local_max_value_index_] = local_max_;
 205
 206     g.drawImage(offscreen_, 3, 3, null);
 207   }
 208
 209   public void paint(Graphics g)
 210   {
 211     Dimension d = getSize ();
 212     int plot_length = plot_.length();
 213     int num_points = d.width / spacing_;
 214
 215     if (plot_.length() < num_points)
 216       {
 217         for (int i = 0; i < num_points - plot_length; i++)
 218           plot_.enqueue_tail(new Float(0));
 219       }
 220     else if (plot_.length() > num_points)
 221       {
 222         for (int i = 0; i < plot_length - num_points; i++)
 223           plot_.dequeue_tail();
 224       }
 225
 226     update(g);
 227   }
 228
 229   private static synchronized float global_max_value () {
 230     float result = 0;
 231
 232     for (int i = 0; i < local_max_value_count_; ++i)
 233       {
 234         if (result < local_max_values_ [i])
 235           {
 236             result = local_max_values_ [i];
 237           }
 238       }
 239
 240     return result;
 241   }
 242
 243   private synchronized void local_max_init () {
 244
 245     // Create a new, larger, array to hold the local maxima
 246     float new_max_values [] =
 247       new float [local_max_value_count_ + 1];
 248
 249     // Copy the previously stored maxima (if any) into the new array.
 250     for (int i = 0; i < local_max_value_count_; ++i)
 251       {
 252         new_max_values [i] = local_max_values_ [i];
 253       }
 254
 255     // Replace the old array with the new one.
 256     local_max_values_ = new_max_values;
 257
 258     // Store the local index for this object, bump up the count.
 259     local_max_value_index_ = local_max_value_count_;
 260     local_max_value_count_++;
 261   }
 262
 263
 264   private int normalize(int height, float coord)
 265   {
 266     float ratio = (float)coord/max_value_;
 267     float pixels = (float)height*ratio;
 268     float location = (float)height - pixels;
 269
 270     return Math.round(location);
 271   }
 272 }
 273
 274