* 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();          }     }	   }