plot2d.java

wekaUT是 university texas austin 开发的基于weka的半指导学习(semi supervised learning)的分类器

		  } else {
		    drawDataPoint(x,y,temp_plot.m_shapeSize[i],
				  MISSING_SHAPE,gx);
		  }
		} else {
		  if (temp_plot.m_shapeType[i] == CONST_AUTOMATIC_SHAPE) {
		    if (temp_plot.m_connectPoints[i] == true) {
		      drawDataPoint(x,y,prevx,prevy,
				    temp_plot.m_shapeSize[i],j,gx);
		    } else {
		      drawDataPoint(x,y,temp_plot.m_shapeSize[i],j,gx);
		    }
		  } else {
		    if (temp_plot.m_connectPoints[i] == true) {
		      drawDataPoint(x,y,prevx,prevy,temp_plot.m_shapeSize[i],
				    temp_plot.m_shapeType[i],gx);
		    } else {
		      drawDataPoint(x,y,temp_plot.m_shapeSize[i],
				    temp_plot.m_shapeType[i],gx);
		    }
		  }
		}
	      }
	    }
	  }
	}
      }
    }
  }

  /*
  public void determineAxisPositions(Graphics gx) {
    setFonts(gx);
    int mxs = m_XaxisStart;
    int mxe = m_XaxisEnd;
    int mys = m_YaxisStart;
    int mye = m_YaxisEnd;
    m_axisChanged = false;

    int h = this.getHeight();
    int w = this.getWidth();
    int hf = m_labelMetrics.getAscent();
    int mswx=0;
    int mswy=0;

    //      determineBounds();
    int fieldWidthX = (int)((Math.log(m_maxX)/Math.log(10)))+1;
    int precisionX = 1;
    if ((Math.abs(m_maxX-m_minX) < 1) && ((m_maxY-m_minX) != 0)) {
      precisionX = (int)Math.abs(((Math.log(Math.abs(m_maxX-m_minX)) / 
				   Math.log(10))))+1;
    }
    String maxStringX = Utils.doubleToString(m_maxX,
					     fieldWidthX+1+precisionX
					     ,precisionX);
    mswx = m_labelMetrics.stringWidth(maxStringX);
    int fieldWidthY = (int)((Math.log(m_maxY)/Math.log(10)))+1;
    int precisionY = 1;
    if (Math.abs((m_maxY-m_minY)) < 1 && ((m_maxY-m_minY) != 0)) {
      precisionY = (int)Math.abs(((Math.log(Math.abs(m_maxY-m_minY)) / 
				   Math.log(10))))+1;
    }
    String maxStringY = Utils.doubleToString(m_maxY,
					     fieldWidthY+1+precisionY
					     ,precisionY);
    String minStringY = Utils.doubleToString(m_minY,
					     fieldWidthY+1+precisionY
					     ,precisionY);

    if (m_plotInstances.attribute(m_yIndex).isNumeric()) {
      mswy = (m_labelMetrics.stringWidth(maxStringY) > 
	      m_labelMetrics.stringWidth(minStringY))
	? m_labelMetrics.stringWidth(maxStringY)
	: m_labelMetrics.stringWidth(minStringY);
    } else {
      mswy = m_labelMetrics.stringWidth("MM");
    }

    m_YaxisStart = m_axisPad;
    m_XaxisStart = 0+m_axisPad+m_tickSize+mswy;

    m_XaxisEnd = w-m_axisPad-(mswx/2);
      
    m_YaxisEnd = h-m_axisPad-(2 * hf)-m_tickSize;
    } */

  /**
   * Draws the axis and a spectrum if the colouring attribute is numeric
   * @param gx the graphics context
   */
  private void paintAxis(Graphics gx) {
    setFonts(gx);
    int mxs = m_XaxisStart;
    int mxe = m_XaxisEnd;
    int mys = m_YaxisStart;
    int mye = m_YaxisEnd;
    m_plotResize = false;

    int h = this.getHeight();
    int w = this.getWidth();
    int hf = m_labelMetrics.getAscent();
    int mswx=0;
    int mswy=0;

    //      determineBounds();
    int precisionXmax = 1;
    int precisionXmin = 1;
    int precisionXmid = 1;
    /*if ((Math.abs(m_maxX-m_minX) < 1) && ((m_maxY-m_minX) != 0)) {
      precisionX = (int)Math.abs(((Math.log(Math.abs(m_maxX-m_minX)) / 
				   Math.log(10))))+1;
				   } */
    int whole = (int)Math.abs(m_maxX);
    double decimal = Math.abs(m_maxX) - whole;
    int nondecimal;
    nondecimal = (whole > 0) 
      ? (int)(Math.log(whole) / Math.log(10))
      : 1;
    
    precisionXmax = (decimal > 0) 
      ? (int)Math.abs(((Math.log(Math.abs(m_maxX)) / 
				      Math.log(10))))+2
      : 1;
    if (precisionXmax > VisualizeUtils.MAX_PRECISION) {
      precisionXmax = 1;
    }

    String maxStringX = Utils.doubleToString(m_maxX,
					     nondecimal+1+precisionXmax
					     ,precisionXmax);

    whole = (int)Math.abs(m_minX);
    decimal = Math.abs(m_minX) - whole;
    nondecimal = (whole > 0) 
      ? (int)(Math.log(whole) / Math.log(10))
      : 1;
    precisionXmin = (decimal > 0) 
      ? (int)Math.abs(((Math.log(Math.abs(m_minX)) / 
				      Math.log(10))))+2
      : 1;
    if (precisionXmin > VisualizeUtils.MAX_PRECISION) {
      precisionXmin = 1;
    }
   
    String minStringX = Utils.doubleToString(m_minX,
					     nondecimal+1+precisionXmin,
					     precisionXmin);

    mswx = m_labelMetrics.stringWidth(maxStringX);

    int precisionYmax = 1;
    int precisionYmin = 1;
    int precisionYmid = 1;
    whole = (int)Math.abs(m_maxY);
    decimal = Math.abs(m_maxY) - whole;
    nondecimal = (whole > 0) 
      ? (int)(Math.log(whole) / Math.log(10))
      : 1;
    precisionYmax = (decimal > 0) 
      ? (int)Math.abs(((Math.log(Math.abs(m_maxY)) / 
				      Math.log(10))))+2
      : 1;
    if (precisionYmax > VisualizeUtils.MAX_PRECISION) {
      precisionYmax = 1;
    }
    
    String maxStringY = Utils.doubleToString(m_maxY,
					     nondecimal+1+precisionYmax
					     ,precisionYmax);


    whole = (int)Math.abs(m_minY);
    decimal = Math.abs(m_minY) - whole;
    nondecimal = (whole > 0) 
      ? (int)(Math.log(whole) / Math.log(10))
      : 1;
    precisionYmin = (decimal > 0) 
      ? (int)Math.abs(((Math.log(Math.abs(m_minY)) / 
				      Math.log(10))))+2
      : 1;
    if (precisionYmin > VisualizeUtils.MAX_PRECISION) {
      precisionYmin = 1;
    }
   
    String minStringY = Utils.doubleToString(m_minY,
					     nondecimal+1+precisionYmin
					     ,precisionYmin);

    if (m_plotInstances.attribute(m_yIndex).isNumeric()) {
      mswy = (m_labelMetrics.stringWidth(maxStringY) > 
	      m_labelMetrics.stringWidth(minStringY))
	? m_labelMetrics.stringWidth(maxStringY)
	: m_labelMetrics.stringWidth(minStringY);
      mswy += m_labelMetrics.stringWidth("M");
    } else {
      mswy = m_labelMetrics.stringWidth("MM");
    }

    m_YaxisStart = m_axisPad;
    m_XaxisStart = 0+m_axisPad+m_tickSize+mswy;

    m_XaxisEnd = w-m_axisPad-(mswx/2);
      
    m_YaxisEnd = h-m_axisPad-(2 * hf)-m_tickSize;

    // draw axis
    gx.setColor(m_axisColour);
    if (m_plotInstances.attribute(m_xIndex).isNumeric()) {
      if (w > (2 * mswx)) {
	
	gx.drawString(maxStringX, 
		      m_XaxisEnd-(mswx/2),
		      m_YaxisEnd+hf+m_tickSize);
	
	mswx = m_labelMetrics.stringWidth(minStringX);
	gx.drawString(minStringX,
		      (m_XaxisStart-(mswx/2)),
		      m_YaxisEnd+hf+m_tickSize);

	// draw the middle value
	if (w > (3 * mswx) && 
	    (m_plotInstances.attribute(m_xIndex).isNumeric())) {
	  double mid = m_minX+((m_maxX-m_minX)/2.0);
	   whole = (int)Math.abs(mid);
	   decimal = Math.abs(mid) - whole;
	   nondecimal = (whole > 0) 
	     ? (int)(Math.log(whole) / Math.log(10))
	     : 1;
	   precisionXmid = (decimal > 0) 
	     ? (int)Math.abs(((Math.log(Math.abs(mid)) / 
			       Math.log(10))))+2
	     : 1;
	   if (precisionXmid > VisualizeUtils.MAX_PRECISION) {
	     precisionXmid = 1;
	   }
	  
	  String maxString = Utils.doubleToString(mid,
						  nondecimal+1+precisionXmid,
						  precisionXmid);
	  int sw = m_labelMetrics.stringWidth(maxString);
	  double mx = m_XaxisStart+((double)(m_XaxisEnd-m_XaxisStart)/2.0);
	  gx.drawString(maxString,
			(int)(mx-(((double)sw)/2.0)),
			m_YaxisEnd+hf+m_tickSize);
	  gx.drawLine((int)mx,m_YaxisEnd,(int)mx,m_YaxisEnd+m_tickSize);
	}
      }
    } else {
      int numValues = m_plotInstances.attribute(m_xIndex).numValues();
      int div = (numValues % 2 > 0) ? (numValues/2)+1 : (numValues/2);
      int maxXStringWidth = (m_XaxisEnd - m_XaxisStart) / numValues;

      for (int i=0;i<numValues;i++) {
	String val = m_plotInstances.attribute(m_xIndex).value(i);
	int sw = m_labelMetrics.stringWidth(val);
	int rm;
	// truncate string if necessary
	if (sw > maxXStringWidth) {
	  int incr = (sw / val.length());
	  rm = (sw - maxXStringWidth) / incr;
	  if (rm == 0) {
	    rm = 1;
	  }
	  val = val.substring(0,val.length()-rm);
	  sw = m_labelMetrics.stringWidth(val);
	}
	if (i == 0) {
	  gx.drawString(val,(int)convertToPanelX(i),
			m_YaxisEnd+hf+m_tickSize);
	} else if (i == numValues -1) {
	  if ((i % 2) == 0) {
	    gx.drawString(val,
			  m_XaxisEnd-sw,
			  m_YaxisEnd+hf+m_tickSize);
	  } else {
	    gx.drawString(val,
			  m_XaxisEnd-sw,
			  m_YaxisEnd+(2*hf)+m_tickSize);
	  }
	} else {
	  if ((i % 2) == 0) {
	    gx.drawString(val,
			  (int)convertToPanelX(i)-(sw/2),
			  m_YaxisEnd+hf+m_tickSize);
	  } else {
	    gx.drawString(val,
			  (int)convertToPanelX(i)-(sw/2),
			  m_YaxisEnd+(2*hf)+m_tickSize);
	  }
	}
	gx.drawLine((int)convertToPanelX(i),
		    m_YaxisEnd,
		    (int)convertToPanelX(i),
		    m_YaxisEnd+m_tickSize);
      }
	
    }

    // draw the y axis
    if (m_plotInstances.attribute(m_yIndex).isNumeric()) {
      if (h > (2 * hf)) {
	gx.drawString(maxStringY, 
		      m_XaxisStart-mswy-m_tickSize,
		      m_YaxisStart+(hf));

	gx.drawString(minStringY,
		      (m_XaxisStart-mswy-m_tickSize),
		      m_YaxisEnd);

	// draw the middle value
	if (w > (3 * hf) && 
	    (m_plotInstances.attribute(m_yIndex).isNumeric())) {
	  double mid = m_minY+((m_maxY-m_minY)/2.0);
	  whole = (int)Math.abs(mid);
	  decimal = Math.abs(mid) - whole;
	  nondecimal = (whole > 0) 
	    ? (int)(Math.log(whole) / Math.log(10))
	    : 1;
	  precisionYmid = (decimal > 0) 
	    ? (int)Math.abs(((Math.log(Math.abs(mid)) / 
			      Math.log(10))))+2
	    : 1;
	  if (precisionYmid > VisualizeUtils.MAX_PRECISION) {
	    precisionYmid = 1;
	  }
	 
	  String maxString = Utils.doubleToString(mid,
						  nondecimal+1+precisionYmid,
						  precisionYmid);
	  int sw = m_labelMetrics.stringWidth(maxString);
	  double mx = m_YaxisStart+((double)(m_YaxisEnd-m_YaxisStart)/2.0);
	  gx.drawString(maxString,
			m_XaxisStart-sw-m_tickSize-1,
			(int)(mx+(((double)hf)/2.0)));
	  gx.drawLine(m_XaxisStart-m_tickSize,(int)mx,m_XaxisStart,(int)mx);
	}
      }
    } else {
      int numValues = m_plotInstances.attribute(m_yIndex).numValues();
      int div = ((numValues % 2) == 0) ? (numValues/2) : (numValues/2+1);
      int maxYStringHeight = (m_YaxisEnd - m_XaxisStart) / div;
      int sw = m_labelMetrics.stringWidth("M");
      for (int i=0;i<numValues;i++) {
	// can we at least print 2 characters
	if (maxYStringHeight >= (2*hf)) {
	  String val = m_plotInstances.attribute(m_yIndex).value(i);
	  int numPrint = ((maxYStringHeight/hf) > val.length()) ?
	    val.length() :
	    (maxYStringHeight/hf);
	    
	  for (int j=0;j<numPrint;j++) {
	    String ll = val.substring(j,j+1);
	    if (val.charAt(j) == '_' || val.charAt(j) == '-') {
	      ll = "|";
	    }
	    if (i == 0) {
	      gx.drawString(ll,m_XaxisStart-sw-m_tickSize-1,
			    (int)convertToPanelY(i)
			    -((numPrint-1)*hf)
			    +(j*hf)
			    +(hf/2));
	    } else if (i == (numValues-1)) {
	      if ((i % 2) == 0) {
		gx.drawString(ll,m_XaxisStart-sw-m_tickSize-1,
			      (int)convertToPanelY(i)
			      +(j*hf)
			      +(hf/2));
	      } else {
		gx.drawString(ll,m_XaxisStart-(2*sw)-m_tickSize-1,
			      (int)convertToPanelY(i)
			      +(j*hf)
			      +(hf/2));
	      }
	    } else {
	      if ((i % 2) == 0) {
		gx.drawString(ll,m_XaxisStart-sw-m_tickSize-1,
			      (int)convertToPanelY(i)
			      -(((numPrint-1)*hf)/2)
			      +(j*hf)
			      +(hf/2));
	      } else {
		gx.drawString(ll,m_XaxisStart-(2*sw)-m_tickSize-1,
			      (int)convertToPanelY(i)
			      -(((numPrint-1)*hf)/2)
			      +(j*hf)
			      +(hf/2));
	      }
	    }
	  }
	}
	gx.drawLine(m_XaxisStart-m_tickSize,
		    (int)convertToPanelY(i),
		    m_XaxisStart,
		    (int)convertToPanelY(i));
      }
    }

    gx.drawLine(m_XaxisStart,
		m_YaxisStart,
		m_XaxisStart,
		m_YaxisEnd);
    gx.drawLine(m_XaxisStart,
		m_YaxisEnd,
		m_XaxisEnd,
		m_YaxisEnd);

    if (m_XaxisStart != mxs || m_XaxisEnd != mxe ||
	m_YaxisStart != mys || m_YaxisEnd != mye) {
      m_plotResize = true;
    }
  }

  /**
   * Add more colours to the colour map
   */
  private void extendColourMap(int highest) {
    System.err.println("Extending colour map");
      for (int i = m_colorList.size(); i < highest; i++) {
	Color pc = m_DefaultColors[i % 10];
	int ija =  i / 10;
	ija *= 2; 
	for (int j=0;j<ija;j++) {
	  pc = pc.brighter();
	}
	
	m_colorList.addElement(pc);
      }
  }

  /**
   * Renders this component
   * @param gx the graphics context
   */
  public void paintComponent(Graphics gx) {
    super.paintComponent(gx);
    if (m_plotInstances != null 
	&& m_plotInstances.numInstances() > 0
	&& m_plotInstances.numAttributes() > 0) {
      if (m_plotCompanion != null) {
	m_plotCompanion.prePlot(gx);
      }

      m_JRand = new Random(m_JitterVal);
      paintAxis(gx);
      if (m_axisChanged || m_plotResize) {
	int x_range = m_XaxisEnd - m_XaxisStart;
	int y_range = m_YaxisEnd - m_YaxisStart;
	if (x_range < 10) {
	  x_range = 10;
	}
	if (y_range < 10) {
	  y_range = 10;
	}

	m_drawnPoints = new int[x_range + 1][y_range + 1];
	fillLookup();
	m_plotResize = false;
	m_axisChanged = false;
      }
      paintData(gx);
    }
  }

  /**
   * Main method for testing this class
   * @param args arguments
   */
  public static void main(String [] args) {
    try {
      if (args.length < 1) {
	System.err.println("Usage : weka.gui.visualize.Plot2D "
			   +"<dataset> [<dataset> <dataset>...]");
	System.exit(1);
      }

      final javax.swing.JFrame jf = 
	new javax.swing.JFrame("Weka Knowledge Explorer: Visualize");
      jf.setSize(500,400);
      jf.getContentPane().setLayout(new BorderLayout());
      final Plot2D p2 = new Plot2D();
      jf.getContentPane().add(p2, BorderLayout.CENTER);
      jf.addWindowListener(new java.awt.event.WindowAdapter() {
	  public void windowClosing(java.awt.event.WindowEvent e) {
	    jf.dispose();
	    System.exit(0);
	  }
	});
      
      p2.addMouseListener(new MouseAdapter() {
	  public void mouseClicked(MouseEvent e) {
	    if ((e.getModifiers() & InputEvent.BUTTON1_MASK) ==
		InputEvent.BUTTON1_MASK) {
	      p2.searchPoints(e.getX(), e.getY(), false);
	    } else {
	      p2.searchPoints(e.getX(), e.getY(), true);
	    }
	  }
	});

      jf.setVisible(true);
      if (args.length >= 1) {
	for (int j = 0; j < args.length; j++) {
	  System.err.println("Loading instances from " + args[j]);
	  java.io.Reader r = new java.io.BufferedReader(
			     new java.io.FileReader(args[j]));
	  Instances i = new Instances(r);
	  i.setClassIndex(i.numAttributes()-1);
	  PlotData2D pd1 = new PlotData2D(i);

	  if (j == 0) {
	    pd1.setPlotName("Master plot");
	    p2.setMasterPlot(pd1);
	    p2.setXindex(2);
	    p2.setYindex(3);
	    p2.setCindex(i.classIndex());
	  } else {
	    pd1.setPlotName("Plot "+(j+1));
	    pd1.m_useCustomColour = true;
	    pd1.m_customColour = (j % 2 == 0) ? Color.red : Color.blue; 
	    p2.addPlot(pd1);
	  }
	}
      }
    } catch (Exception ex) {
      ex.printStackTrace();
      System.err.println(ex.getMessage());
    }
  }
}