contour.java

java 作图的程序

   * Set the contour's color.
   * @param c Color
   */
     public void setContourColor(Color c) { contourColor = c; }  
  /**
   * Set the labelled contour's color.
   * @param c Color
   */
     public void setLabelledContourColor(Color c) { labelledColor = c; }  
    
  /**
   * Return the contour levels.
   * @return An array containing the contour levels
   */
     public double[] getLevels() { return levels; }
  /**
   * If true the limits of the plot will be the grid limits.
   * If false the limits of the plot will be the contours.
   * @param b boolean
   */
     
     public void setLimitsToGrid(boolean b) { gridLimits = b; }
  /**
   *  Set the contour levels that are to have labels.
   * <pre>
   *    if 0 no labels are drawn
   *    if 1 every level gets a label
   *    If 2 every 2nd level gets a label
   *    etc.
   * </pre>
   */
     public void setLabelLevels(int i) { 
          if(i<=0) labelLevels = 0;
          else     labelLevels = i;
	}

  /**
   * If true contour levels are calculated on a log scale.
   * @param b boolean
   */
     public void setLogLevels(boolean b) {
               logLevels = b;

               if( zmin <= 0.0 || zmax <= 0.0 ) logLevels = false;
	     }

  /**
   * Set the number of contour levels.
   * @@param l Number of contour levels
   */
     public void setNLevels(int l) {
         if(l <= 0) return;
         
         levels = new double[l];
         
         calcLevels();

         detachCurves();
         curves = null;
     }

  /**
   * If true contour levels are calculated automatically.
   * @param b boolean
   */
     public void setAutoLevels(boolean b) {
               autoLevels = b;
	     }
  /**
   * If true contour levels are not labeled.
   * @param b boolean
   */
     public void setDrawLabels(boolean b) {
               drawlabels = b;
	     }

  /**
   * Set the label style, either TextLine.SCIENTIFIC or
   * TextLine.ALGEBRAIC.
   * @param s Style
   */
     public void setLabelStyle(int s) { 
                   labelStyle = s;
                   calcLabels();
 }

  /**
   * Get the label style, either TextLine.SCIENTIFIC or
   * TextLine.ALGEBRAIC.
   * @return style
   */
     public int getLabelStyle() { return labelStyle; }

  /**
   * Set the label precision.
   * @param s Precision
   */
     public void setLabelPrecision(int p) { 
                   labelPrecision = p; 
                   calcLabels();
     }

  /**
   * Get the label precision.
   * @return precision
   */
     public int getLabelPrecision() { return labelPrecision; }

  /**
   * Set the label significant figures.
   * @param s number of significant figures
   */
     public void setLabelSignificance(int s) { 
                   labelSignificant = s;
                   calcLabels();
     }

  /**
   * Get the number of significant figures for labels.
   * @return number of significant figures
   */
     public int getLabelSignificance() { return labelSignificant; }


  /**
   *   Add extra events to the G2Dint event handler.
   * 
   *   If 'l' is pressed repaint without the labels
   *   If 'L' is pressed repaint with the labels.
   */
     public boolean keyDown(Event e, int key) {
           if(xaxis==null || yaxis==null) return false;

           if( super.keyDown(e,key) ) return true;

           switch ( key ) {

           case 'l':
                     drawlabels = false;
                     repaint();
                     return true;
           case 'L':
                     drawlabels = true;
                     repaint();
                     return true;
           }

           return false;
     }

/*
********************
**
** Private Methods
**
*******************/

/*
**  calcLevels()
**              Calculate the contour levels
*/
     private void calcLevels() {
       int i;
       int l;
       
       if(!autoLevels) return;

       if(levels == null) levels = new double[NLEVELS];
       labels = new TextLine[levels.length];
       // Nice label steps not implemented yet
       //levelStep();

       
       if( logLevels ) {
          double inc = Math.log(zmax-zmin)/
                      (double)(levels.length+1);
          try {
             for(i=0; i<levels.length; i++) levels[i] = zmin + 
                          Math.pow(Math.E,(double)(i+1)*inc);
	   } catch (Exception e) {
             System.out.println("Error calculateing Log levels!");
             System.out.println("... calculating linear levels instead");
             logLevels = false;
             calcLevels();
           }
	} else {
          double inc = (zmax-zmin)/(double)(levels.length+1);   
          for(i=0; i<levels.length; i++) levels[i] = zmin + (double)(i+1)*inc;
        }
     }
/*
**  calcLabels()
**              Calculate the labels
*/
     private void calcLabels() {
        int i;
        if( !autoLabels ) return;

        if(levels==null || levels.length <= 0) return;

        labels = new TextLine[levels.length];


        for(i=0; i<labels.length; i++) {
             labels[i] = new TextLine();
             labels[i].parseDouble(levels[i],
                      labelSignificant,labelPrecision,labelStyle);
        } 
     }

/*
**   zrange()
**           Calculate the range of the grid
*/

     private void zrange() {
        int i;
     
        zmin = grid[0];
        zmax = grid[1];
        for( i=0; i<grid.length; i++) {

             zmin = Math.min(zmin,grid[i]);
             zmax = Math.max(zmax,grid[i]);

        }

        System.out.println("Data range: zmin="+zmin+", zmax="+zmax);

        if(zmin == zmax) {
           System.out.println("Cannot produce contours of a constant surface!");
	 }

        if(zmin <= 0 || zmax <= 0) logLevels = false;


      }
/*
**   paintFirst(Graphics g, Rectangle r)
**        before anything is painted calculate the contours.
*/

      public void paintFirst(Graphics g, Rectangle r) {

         //System.out.println("paintFirst called");



         if( curves == null && !noContours ) { 
                                  calculateCurves();
                                  calcLabels();
				}

         setContourColors();

         if(gridLimits && !userlimits ) {
           if( xaxis != null ) {
                if(xaxis.minimum > xmin ) xaxis.minimum = xmin;
                if(xaxis.maximum < xmax ) xaxis.maximum = xmax;
	      }

           if( yaxis != null ) {
                if(yaxis.minimum > ymin ) yaxis.minimum = ymin;
                if(yaxis.maximum < ymax ) yaxis.maximum = ymax;
	      }
         } else 
         if( dataset.isEmpty() ) {
           if( xaxis != null ) {
                xaxis.minimum = xmin;
                xaxis.maximum = xmax;
	      }

           if( yaxis != null ) {
                yaxis.minimum = ymin;
                yaxis.maximum = ymax;
	      }
         }


      }

  /**
  *  Set the colors for the contour lines
  */
      private void setContourColors() {
        int i;
        int j;
        Vector v;

        if(curves == null || 
           (contourColor==null && labelledColor==null) ) return;

	for(i=0; i<curves.length; i++) {
            setContourColors(curves[i],null);
        }

        if(contourColor != null) {
	   for(i=0; i<curves.length; i++) {
               setContourColors(curves[i],contourColor);
           }
        }

        if(labelledColor != null) {
	   for(i=0; i<curves.length; i++) {
               if(i%labelLevels == 0) {
                  setContourColors(curves[i],labelledColor);
               }
           }
        }



      }

  /**
  *  Set the colors for the contour lines
  */
      private void setContourColors(Vector v, Color c) {
        int i;
        DataSet d;

        if(v == null) return;

	for(i=0; i<v.size(); i++) {
            d = (DataSet)(v.elementAt(i));
            if(d != null) d.linecolor = c;
        }

      }
/*
**    attachCurves()
**        Attach all the curves to the graph and to the axes
*/
      private void attachCurves() {
         int i;
         if(curves == null) return;

         for(i=0; i<curves.length; i++) attachCurves(curves[i]);

      }
/*
**    attachCurves(Vector v)
**        Attach all the curves from a given level to the graph and to the axes
*/

      private void attachCurves(Vector v) {
         int j;
         if(v == null) return;
         for(j=0; j<v.size(); j++) {
               attachDataSet((DataSet)(v.elementAt(j)));
               if(xaxis != null) 
                        xaxis.attachDataSet((DataSet)(v.elementAt(j)));
               if(yaxis != null) 
                        yaxis.attachDataSet((DataSet)(v.elementAt(j)));
	     }
      }
/*
**    detachCurves()
**                 Detach All the curves from the graph and the axes.
*/
      private void detachCurves() {
         int i;
         if(curves == null) return;

         for(i=0; i<curves.length; i++) detachCurves(curves[i]);
      }
/*
**    detachCurves()
**                 Detach all the curves from a given level from 
**                 the graph and the axes.
*/
      private void detachCurves(Vector v) {
         int j;
         if(v == null) return;
         for(j=0; j<v.size(); j++) {
               detachDataSet((DataSet)(v.elementAt(j)));
               if(xaxis != null) 
                        xaxis.detachDataSet((DataSet)(v.elementAt(j)));
               if(yaxis != null) 
                        yaxis.detachDataSet((DataSet)(v.elementAt(j)));
	     }
      }

/*
**    paintLast(Graphics g, Rectangle rect)
**          Last thing to be done is to draw the contour labels if required.
*/
      public void paintLast(Graphics g, Rectangle rect) {
              int i, j;
              int points;
              int index;
              Vector v;
              DataSet ds;
              double point[] = new double[2];
              int x;
              int y;
              Color current = g.getColor();
              Rectangle r = new Rectangle();


              if( xaxis == null || yaxis == null || labels == null || 
                  labelLevels == 0 || !drawlabels || curves == null ) {
                         super.paintLast(g,rect);
                         return;
	      }
              

              for(i=0; i<levels.length; i++) {
                 if( labels[i] != null && !labels[i].isNull() &&
                     i%labelLevels == 0 ) {
                    labels[i].setFont(labelfont);
                    labels[i].setColor(labelcolor); 
                    v = curves[i];
                    for(j=0; j<v.size(); j++) {
                        ds =  (DataSet)(v.elementAt(j));
                        points = ds.dataPoints();
                        index = (int)(Math.random()*(double)MINCELLS);
                        while ( points > MINCELLS ) {
                             point = ds.getPoint(index);
                             x = xaxis.getInteger(point[0]);
                             y = yaxis.getInteger(point[1]);

                             r.width  = labels[i].getWidth(g);
                             r.height = labels[i].getAscent(g);
                             r.x = x - r.width/2;
                             r.y = y - r.height/2;

                             g.setColor(DataBackground);
                             g.fillRect(r.x, r.y, r.width, r.height);

                             g.setColor(current);
                             
                             labels[i].draw(g, r.x, r.y+r.height, 
                                            TextLine.LEFT);

                             points -= MINCELLS;
                             index += MINCELLS;
                        }                        
		      }
		  }
	      }

              super.paintLast(g,rect);


	    }
/*
**   calculateCurves()
**        Calculate the contours and attach them to the graph and axes.
*/

     protected void calculateCurves() {
          int i;
          int j;
          double data[];
          double xscale = (xmax-xmin)/(double)(nx-1);
          double yscale = (ymax-ymin)/(double)(ny-1);
          
          IsoCurve isocurve;


          isocurve = new IsoCurve(grid,nx,ny);


          if( curves != null) {
                               detachCurves();
                               curves = null;
			     }
          if( zmin == zmax ) return;

          curves = new Vector[levels.length];
          

          for(i=0; i<levels.length; i++) {
              System.out.println("Calculating Contours: level="+levels[i]);
              isocurve.setValue(levels[i]);

              curves[i] = new Vector();

              while( (data = isocurve.getCurve()) != null ) {
                for(j=0; j<data.length; ) {
                   data[j] = xmin + data[j]*xscale;
                   j++;
                   data[j] = ymin + data[j]*yscale;
                   j++;
		 }

                try {
                  curves[i].addElement(new DataSet(data, data.length/2));
                } catch (Exception e) {
                  System.out.println("Error loading contour into DataSet!");
                  System.out.println("...Contour Level "+levels[i]);
                }
              }

              attachCurves(curves[i]);

              //repaint();
          }


     }
	


   }