contour.java

java 作图的程序

package graph;

import java.awt.*;
import java.applet.*;
import java.net.URL;
import java.util.*;
import java.io.InputStream;

/*
**************************************************************************
**
**    Class  Contour
**
**************************************************************************
**    Copyright (C) 1996 Leigh Brookshaw
**
**    This program is free software; you can redistribute it and/or modify
**    it under the terms of the GNU General Public License as published by
**    the Free Software Foundation; either version 2 of the License, or
**    (at your option) any later version.
**
**    This program is distributed in the hope that it will be useful,
**    but WITHOUT ANY WARRANTY; without even the implied warranty of
**    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**    GNU General Public License for more details.
**
**    You should have received a copy of the GNU General Public License
**    along with this program; if not, write to the Free Software
*    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
**************************************************************************
**
** This class extends the interactive graphics class to incorporate
** contours.
**
*************************************************************************/

/**
 * This class extends the interactive graphics class G2Dint to incorporate
 * contouring.
 *
 * @version  $Revision: 1.11 $, $Date: 1996/08/12 23:37:08 $.
 * @author   Leigh Brookshaw
 */

public class Contour extends G2Dint {

/*
**************
**
** Constants
**
*************/
	
/*
**   The minimum length of a curve before it gets a label
*/
	 static final int MINCELLS = 30;
/*
**   Default number of contour levels
*/
	 static final int NLEVELS = 12;
	 

/**********************
**
** Protected Variables
**
***********************/
	 
/**
 *   Dimension of the contour grid in the X direction
 */
     protected int nx;
/**
 *   Dimension of the contour grid in the Y direction
 */
     protected int ny;
/**
 *   Vector array containing the Contour curves.
 *   Each index in the array contains curves at a given
 *   contour level
 */
     protected Vector curves[];

/**
 *   If set the class calculates the contour levels based on
 *   the data minimum and maximum. Default value <i>true</i>.
 */
     protected boolean autoLevels;
/*
 *   If true the contour levels are calculated in
 *   logarithmic intervals
 */
     protected boolean logLevels;
/*
 *   If true the limits of the plot are the limits of the
 *   data grid not the limits of the contours!
 */
     protected boolean gridLimits;
/*
 *   The array of contour levels
 */
     protected double levels[];
/**
 *   The label for each contour level
 */
     protected TextLine labels[];
/**
 *   Font to use in drawing Labels
 */
     protected Font labelfont;
/**
 *   Color to use in drawing Labels
 */
     protected Color labelcolor;
/**
 *   Style to use in drawing Labels. TextLine.SCIENTIFIC or
 *   TextLine.ALGEBRAIC.
 */
     protected int labelStyle;
/**
 *   Precision to use in drawing Labels.
 */
     protected int labelPrecision;

/**
 *   Number of Significant figures to use in drawing Labels.
 */
     protected int labelSignificant;

/**
 *   Which levels will get labels. If it is equal to 1 every level
 *   gets a label, equal to 2 every second level etc. If it is equal to 0
 *   no labels are displayed.   
 */
     protected int labelLevels;
/**
 *   If false labels are not drawn
 */
     protected boolean drawlabels;
/**
 *   If true the labels will be calculated for each
 *   contour level. These might not look all that hot.
 */
     protected boolean autoLabels;
 /**
  *  Color to draw non labelled contour line
  */
     protected Color contourColor;
 /**
  *  Color to draw labelled contour line
  */
     protected Color labelledColor;
 
/**
 *   The data grid, a 2D array stored in linear form.
 *   It is assumed that [0,0] is the bottom left corner
 *   and the data is ordered by row.
 */
     protected double grid[];

/**
 *   The X minimum limit of the data grid
 */
     protected double xmin;
/**
 *   The X maximum limit of the data grid
 */
     protected double xmax;
/**
 *   The Y minimum limit of the data grid
 */
     protected double ymin;
/**
 *   The Y maximum limit of the data grid
 */
     protected double ymax;
/**
 *   The minimum value of the grid values
 */
     protected double zmin;
/**
 *   The maximum value of the grid values
 */
     protected double zmax;

  /**
   * Boolean value if true Contours will not be calculated
   */
     public boolean noContours = false;

/*
*****************
**
** Constructors
**
****************/

  /**
   * Instantaite the class
   */
     public Contour() {

           grid = null;
           xmin = 0.0;
           xmax = 0.0;
           ymin = 0.0;
           ymax = 0.0;
           zmin = 0.0;
           zmax = 0.0;

           nx = 0;
           ny = 0;

           levels = new double[NLEVELS];
           labels = new TextLine[NLEVELS];

           autoLevels  = true;
           logLevels   = false;
           gridLimits  = false;
           autoLabels  = true;
           labelfont   = new Font("Helvetica",Font.PLAIN,12);
           labelcolor  = Color.blue;
           labelLevels = 1;
           labelStyle       = TextLine.ALGEBRAIC;
           labelPrecision   = 2;
           labelSignificant = 3;
           drawlabels = true;

           contourColor  = null;
           labelledColor = null;

           curves = null;

     }

/*
************
**
** Methods
**
***********/
  /**
   *  Load the grid to contour from a URL. There are 2 formats for the data
   *  optionally the limits of the grid can be parsed.<BR>
   *  <PRE>
   *  The expected format of the data 
   *           1st Number:   nx
   *           2nd Number:   ny
   *           nx*ny numbers following
   *
   *  Optionally
   *           1st Number:   nx
   *           2nd Number:   ny
   *           3rd Number:   xmin
   *           4th Number:   xmax
   *           5th Number:   ymin
   *           6th Number:   ymax
   *           nx*ny numbers following
   *  </PRE><BR>
   *  If xmin, xmax, ymin, ymax are not specified they are assumed
   *  to be [1.0,nx,1.0,ny]
   *
   * @param file URL of the file to load
   * @return <i>true</I> of the load was successful.
   *
   */
    public boolean loadGrid( URL file) {
           byte b[] = new byte[50];
           int nbytes = 0;
           int max  = 100;
           int inc  = 100;
           int n    = 0;
           double data[] = new double[max];
           InputStream is = null;
           boolean comment    = false;
           int c;

           try {
                 is = file.openStream();

                 while( (c=is.read()) > -1 ) {
                     
                     switch (c) {
                     
                         case '#':
                                    comment = true;
                                    break;
                         case '\r': case '\n':
                                    comment = false;
                         case ' ': case '\t':
                                if( nbytes > 0 ) {
                                   String s = new String(b,0,0,nbytes);
                                   data[n] = Double.valueOf(s).doubleValue();
                                   n++;
                                   if( n >= max ) {
                                       max += inc;
                                       double d[] = new double[max];
                                       System.arraycopy(data, 0, d, 0, n);
                                       data = d;
                                   }

                                   nbytes = 0;
                                }
                                break;
                         default:
                                   if( !comment ) {
                                        b[nbytes] = (byte)c;
                                        nbytes++;
                                   }
                                   break;
                      }

                  }

                if (is != null) is.close();
        } catch(Exception e) {
          System.out.println("Failed to load Grid from file ");
          e.printStackTrace();
          if (is != null) try { is.close(); } catch (Exception ev) { }
          return false;
        }

        if(n < 1 ) {
           System.out.println("Failed to load Grid from file ");
           return false;
	 }

        nx = (int)(data[0] + 0.5);
        ny = (int)(data[1] + 0.5);

        if( n == nx*ny+6 ) {
            xmin = data[2];
            xmax = data[3];
            ymin = data[4];
            ymax = data[5];

            grid = new double[nx*ny];
            System.arraycopy(data, 6, grid, 0, nx*ny);
	} else 
        if( n == nx*ny+2 ) {
            xmin = 1.0;
            xmax = (double)(nx);
            ymin = 1.0;
            ymax = (double)(ny);
        
            grid = new double[nx*ny];
            System.arraycopy(data, 2, grid, 0, nx*ny);
	} else {
            System.out.println("Error loading grid, Wrong number of points ");
            grid = null;
            return false;
	  }

        zrange();
        calcLevels();

        detachCurves();
        curves = null;

        return true;
        
     }
     
  /**
   *  Set the range of the grid
   * @param xmin Minimum X value
   * @param xmax Maximum X value
   * @param ymin Minimum Y value
   * @param ymax Maximum Y value
   */


     public void setRange(double xmin,double xmax,double ymin,double ymax) {

            if( xmin >= xmax || ymin >= ymax ) return;

            this.xmin = xmin;
            this.xmax = xmax;
            this.ymin = ymin;
            this.ymax = ymax;
     }

  /**
   *  Return the range of the grid
   * @return An array contining xmin,xmax,ymin,ymax.
   */
     public double[] getRange() {
            double d[] = new double[4];
            d[0] = xmin;
            d[1] = xmax;
            d[2] = ymin;
            d[3] = ymax;

            return d;
      }
  /**
   *  return the dimensions of the grid
   * @return An array containing the number of columns, number of rows.
   */
     public int[] getDim() {
            int i[] = new int[2];
         
            i[0] = nx;
            i[1] = ny;

            return i;
      }

  /**
   *  Return the grid
   * @return An array of size nx by ny contining the data grid.
   */
     public double[] getGrid() { return grid; }

  /**
   * Manually set the contour levels.
   * @param levels An array containing the contour levels
   * @param nl The number of contour levels in the arrray
   */
     public void setLevels(double levels[], int nl) {
           int i;
           if( levels == null || nl <= 0 ) return;

           detachCurves();
           curves = null;

           autoLevels = false;

           this.levels = new double[nl];
           
           System.arraycopy(levels,0,this.levels,0,nl);

           labels = new TextLine[nl];
           for(i=0; i<labels.length; i++) {
             labels[i] = new TextLine( String.valueOf( (float)levels[i] ) );
           } 
     }
  /**
   * Manually set the Contour labels.
   * @param labels An array containing the labels.
   * @param nl Number of labels in the Array.
   */
     public void setLabels(TextLine labels[], int nl) {
           if( labels == null || nl <= 0 ) return;

           autoLabels = false;
           this.labels = new TextLine[nl];
           
           System.arraycopy(labels,0,this.labels,0,nl);
     }

  /**
   * Set the font to be used with All the labels
   * @param f Font
   */
     public void setLabelFont(Font f) {
           labelfont = f;
     }

  /**
   * Set the Color to be used with all the labels.
   * @param c Color
   */
     public void setLabelColor(Color c) {
           labelcolor = c;
     }
     
  /**
   *  Set the grid to be contoured.
   * @param grid Array of values
   * @param nx   Number of columns
   * @param ny   Number of rows
   */
     public void setGrid(double grid[],int nx,int ny) {
        this.grid = grid;
        this.nx   = nx;
        this.ny   = ny;

        zrange();
        calcLevels();

     }
  /**
   * Delete all the Contours
   */
     public void deleteContours() {
          if(curves == null) return;
          detachCurves();
          curves = null;
     }
  /**
   * Detach contours so that they will not be plotted.
   */
     public void detachContours() {
          if(curves == null) return;
          detachCurves();
     }
  /**
   * Attach contours so that they will be plotted.
   */
     public void attachContours() {
          if(curves == null) return;
          attachCurves();
     }
     
  /**