diff options
Diffstat (limited to 'TAO/examples/Simulator/DOVEBrowser/DoubleVisComp.java')
-rw-r--r-- | TAO/examples/Simulator/DOVEBrowser/DoubleVisComp.java | 275 |
1 files changed, 275 insertions, 0 deletions
diff --git a/TAO/examples/Simulator/DOVEBrowser/DoubleVisComp.java b/TAO/examples/Simulator/DOVEBrowser/DoubleVisComp.java new file mode 100644 index 00000000000..228d9931fc7 --- /dev/null +++ b/TAO/examples/Simulator/DOVEBrowser/DoubleVisComp.java @@ -0,0 +1,275 @@ +// $Id$ +// +// = FILENAME +// DoubleVisComp.java +// +// = AUTHOR +// Seth Widoff (core graph functionality) +// Michael Kircher (mk1@cs.wustl.edu) +// +// = DESCRIPTION +// This is a Visualization Component for displaying doubles. +// +// ============================================================================ + + + + +import java.awt.*; +import java.util.*; + +public class DoubleVisComp extends Canvas implements VisComp +{ + private static final int MIN_SPACING = 2; + private static final int POINT_HISTORY = 200; + private static final Font FONT = new Font ("Dialog", Font.PLAIN, 10); + + private Queue plot_; + private String title_; + private Graphics offgraphics_; + private Image offscreen_; + private Dimension offscreensize_; + private int max_value_; + private int old_max_value_; + private int spacing_; + private boolean max_increased_ = false; + private static boolean monotonic_scale_ = false; + + private float local_max_ = 0; + private static float local_max_values_ [] = null; + private static int local_max_value_count_ = 0; + private int local_max_value_index_ = 0; + + public DoubleVisComp() + { + super(); + + // Re-initialize the global array of local maxima. + local_max_init (); + + plot_ = new Queue(); + spacing_ = MIN_SPACING; + title_ = ""; + max_value_ = 1; + old_max_value_ = max_value_; + + java.util.Random rand = new java.util.Random (System.currentTimeMillis()); + float hue_ = rand.nextFloat(); + float brightness = rand.nextFloat(); + + hue_ += .075; + + if (hue_ > 1.0) + hue_ -= 1.0; + + if (brightness > 0.75) + brightness -= 0.25; + + Color new_color = Color.getHSBColor(hue_, 1, brightness); + + this.setBackground(new_color); + this.setForeground(Color.white); + } + + public static synchronized void monotonic_scale (boolean b) { + monotonic_scale_ = b; + } + + public static synchronized boolean monotonic_scale () { + return monotonic_scale_; + } + + public void setName (String title) { + title_ = title; + } + + public int getProperty () { + return Properties.DOUBLE; + } + + public Dimension getMinimumSize () { + return new Dimension (75, 75); + } + + public Dimension getPreferredSize () { + return new Dimension (175, 175); + } + + public String getName() { + return title_; + } + + public int getMax() { + return old_max_value_; + } + + public void update(java.util.Observable observable, java.lang.Object obj) + { + Double double_temp_; + try { + double_temp_ = (Double) obj; + } + catch (Exception excp) { + double_temp_ = new Double (0.0); + System.out.println (excp); + System.out.println ("Visualization Component received wrong data type!"); + } + + float new_point = double_temp_.floatValue(); + Float temp = (Float)plot_.dequeue_tail(); + plot_.enqueue_head(new Float(new_point)); + + if (new_point > local_max_) + { + local_max_ = new_point; + local_max_values_ [local_max_value_index_] = local_max_; + } + + if (monotonic_scale_) + { + float global_max = 0; + global_max = global_max_value (); + + while (global_max > max_value_) + max_value_ *= 2; + + while ((global_max < max_value_/2) && (max_value_ > old_max_value_)) + max_value_ /= 2; + } + else + { + while (local_max_ > max_value_) + max_value_ *= 2; + + while ((local_max_ < max_value_/2) && (max_value_ > old_max_value_)) + max_value_ /= 2; + } + + repaint(); + } + + public void update(Graphics g) + { + Dimension d = getSize (); + float tmp, value_1, value_2; + FontMetrics fm = g.getFontMetrics (); + Enumeration queue_iter = plot_.forward_iterator(); + int x1 = d.width - 8, y1, x2, y2, fheight = fm.getHeight (), i; + String value = "Value (of " + max_value_ + "): " + String.valueOf(plot_.head()); + + if ((offscreen_ == null) || + (offscreensize_.width != d.width - 8) || + (offscreensize_.height != d.height - 8)) + { + offscreen_ = createImage(d.width - 8, d.height - 8); + offscreensize_ = new Dimension(d.width - 8, d.height - 8); + offgraphics_ = offscreen_.getGraphics(); + offgraphics_.setFont(FONT); + } + + g.setColor (Color.lightGray); + g.draw3DRect (0, 0, d.width - 1, d.height - 1, true); + g.draw3DRect (1, 1, d.width - 3, d.height - 3, true); + g.draw3DRect (2, 2, d.width - 5, d.height - 5, true); + + local_max_ = 0; + + offgraphics_.setColor (getBackground()); + offgraphics_.fillRect (0, 0, offscreensize_.width, offscreensize_.height); + offgraphics_.setColor (getForeground()); + offgraphics_.drawString(title_, 5, fheight); + offgraphics_.drawString(value, 5, offscreensize_.height - 5); + + value_1 = ((Float)queue_iter.nextElement()).floatValue(); + while (queue_iter.hasMoreElements()) + { + value_2 = ((Float)queue_iter.nextElement()).floatValue(); + + if (value_1 > local_max_) + local_max_ = value_1; + + y1 = normalize(offscreensize_.height - fheight, value_1); + y2 = normalize(offscreensize_.height - fheight, value_2); + + tmp = value_2; + value_2 = value_1; + value_1 = tmp; + + x2 = x1 - spacing_; + offgraphics_.drawLine(x1, y1, x2, y2); + x1 = x2; + if (x1 <= 5) + break; + } + + local_max_values_ [local_max_value_index_] = local_max_; + + g.drawImage(offscreen_, 3, 3, null); + } + + public void paint(Graphics g) + { + Dimension d = getSize (); + int plot_length = plot_.length(); + int num_points = d.width / spacing_; + + if (plot_.length() < num_points) + { + for (int i = 0; i < num_points - plot_length; i++) + plot_.enqueue_tail(new Float(0)); + } + else if (plot_.length() > num_points) + { + for (int i = 0; i < plot_length - num_points; i++) + plot_.dequeue_tail(); + } + + update(g); + } + + private static synchronized float global_max_value () { + float result = 0; + + for (int i = 0; i < local_max_value_count_; ++i) + { + if (result < local_max_values_ [i]) + { + result = local_max_values_ [i]; + } + } + + return result; + } + + private synchronized void local_max_init () { + + // Create a new, larger, array to hold the local maxima + float new_max_values [] = + new float [local_max_value_count_ + 1]; + + // Copy the previously stored maxima (if any) into the new array. + for (int i = 0; i < local_max_value_count_; ++i) + { + new_max_values [i] = local_max_values_ [i]; + } + + // Replace the old array with the new one. + local_max_values_ = new_max_values; + + // Store the local index for this object, bump up the count. + local_max_value_index_ = local_max_value_count_; + local_max_value_count_++; + } + + + private int normalize(int height, float coord) + { + float ratio = (float)coord/max_value_; + float pixels = (float)height*ratio; + float location = (float)height - pixels; + + return Math.round(location); + } +} + + |