axesobject.java

JAVA 数学程序库 提供常规的数值计算程序包

			{
			    // log axis
                if (xmax/xmin > 10)
                {
                    xmin = Math.floor(xmin);
                    xmax = Math.ceil(xmax);
                }
                else 
                {
                    // ????
                    xmin--;
                    xmax++;
                }
			}
			    
			XLimP.update(new double[] {xmin, xmax});
			autoTickX();
		}
	}

	protected void autoScaleY()
	{
		double ymin, ymax;
		if (YLimModeP.is("auto") && ChildrenP.size() > 0)
		{
			ymin = ((GraphicalObject)ChildrenP.elementAt(0)).getYMin();
			ymax = ((GraphicalObject)ChildrenP.elementAt(0)).getYMax();
			for (int i=1; i<ChildrenP.size(); i++)
			{
				double _ymin = ((GraphicalObject)ChildrenP.elementAt(i)).getYMin();
				double _ymax = ((GraphicalObject)ChildrenP.elementAt(i)).getYMax();
				if (_ymin < ymin) ymin = _ymin;
				if (_ymax > ymax) ymax = _ymax;
			}
		
			double dy = ymax-ymin;
			if (dy > 10) 
			{
				// nice numbers on axis
				ymin = Math.floor(ymin);
				ymax = Math.ceil(ymax);
			}
			else if (dy == 0)
			{
				ymin--;
				ymax++;
			}

			YLimP.update(new double[] {ymin, ymax});
			autoTickY();
		}
	}

	protected void autoScaleZ()
	{
		double zmin, zmax;
		if (ZLimModeP.is("auto") && ChildrenP.size() > 0)
		{
			zmin = ((GraphicalObject)ChildrenP.elementAt(0)).getZMin();
			zmax = ((GraphicalObject)ChildrenP.elementAt(0)).getZMax();
			for (int i=1; i<ChildrenP.size(); i++)
			{
				double _zmin = ((GraphicalObject)ChildrenP.elementAt(i)).getZMin();
				double _zmax = ((GraphicalObject)ChildrenP.elementAt(i)).getZMax();
				if (_zmin < zmin) zmin = _zmin;
				if (_zmax > zmax) zmax = _zmax;
			}

			double dz = zmax-zmin;
			if (dz > 10)
			{
				zmin = Math.floor(zmin);
				zmax = Math.ceil(zmax);
			}
			else if (dz == 0)
			{
				zmin--;
				zmax++;
			}

			ZLimP.update(new double[] {zmin, zmax});
			autoTickZ();
		}
	}

	protected void autoTick()
	{
		autoTickX();
		autoTickY();
		autoTickZ();
	}

	protected void autoTickX()
	{
		if (XTickModeP.is("auto"))
		{
			double xmin = XLimP.getArray()[0];
            double xmax = XLimP.getArray()[1];
			double[] ticks = new double[5];
			for (int i=0; i<ticks.length; i++)
				ticks[i] = xmin + i * (xmax - xmin) / (ticks.length - 1);
			XTickP.update(ticks);
		}
		autoTickLabelX();
	}

	protected void autoTickY()
	{
		if (YTickModeP.is("auto"))
		{
			double ymin = YLimP.getArray()[0];
            double ymax = YLimP.getArray()[1];
			double[] ticks = new double[5];
			for (int i=0; i<ticks.length; i++)
				ticks[i] = ymin + i * (ymax - ymin) / (ticks.length - 1);
			YTickP.update(ticks);
		}
		autoTickLabelY();
	}

	protected void autoTickZ()
	{
		if (ZTickModeP.is("auto"))
		{
			double zmin = ZLimP.getArray()[0];
            double zmax = ZLimP.getArray()[1];
			double[] ticks = new double[5];
			for (int i=0; i<ticks.length; i++)
				ticks[i] = zmin + i * (zmax - zmin) / (ticks.length - 1);
			ZTickP.update(ticks);
		}
		autoTickLabelZ();
	}

	protected void autoTickLabel()
	{
		autoTickLabelX();
		autoTickLabelY();
		autoTickLabelZ();
	}

	protected void autoTickLabelX()
	{
		double[] ticks = XTickP.getArray();
		String[] labels = new String[ticks.length];
		for (int i=0; i<ticks.length; i++)
		{
			double val = ((double)Math.round(ticks[i]*100))/100;
			labels[i] = new Double(val).toString();
		}
		XTickLabelP.update(labels);
	}

	protected void autoTickLabelY()
	{
		double[] ticks = YTickP.getArray();
		String[] labels = new String[ticks.length];
		for (int i=0; i<ticks.length; i++)
		{
			double val = ((double)Math.round(ticks[i]*100))/100;
			labels[i] = new Double(val).toString();
		}
		YTickLabelP.update(labels);
	}

	protected void autoTickLabelZ()
	{
		double[] ticks = ZTickP.getArray();
		String[] labels = new String[ticks.length];
		for (int i=0; i<ticks.length; i++)
		{
			double val = ((double)Math.round(ticks[i]*100))/100;
			labels[i] = new Double(val).toString();
		}
		ZTickLabelP.update(labels);
	}

	public void paint(Graphics _g) 
	{
	    ErrorLogger.debugLine("AxesObject: paint");
        
		Graphics g = initBackBuffer(_g);

		Graphics2D g2d = (Graphics2D)g;
		//g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
		//g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
		//g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);

		//System.out.println("width = "+this.getSize().width+" height = "+this.getSize().height);
		dyFrame = this.getSize().height;
		dxFrame = this.getSize().width;

		//ErrorLogger.debugLine("AxesObject dxFrame="+dxFrame+" dyFframe="+dyFrame);
		//ErrorLogger.debugLine("AxesObject getX="+this.getX()+" getY="+this.getY());
		//ErrorLogger.debugLine("AxesObject getLocation.x="+this.getLocation().x);

		// size of curves
		int dyCurves = (int)(dyFrame*3/4);
		int dxCurves = (int)(dxFrame*3/4);

		// Origin of curves
		int dyOrig = (dyFrame-dyCurves)/2;
		int dxOrig = (dxFrame-dxCurves)/2;


		// fonts
		FontMetrics fM  = g.getFontMetrics();
		int    sAscent  = fM.getAscent();
		int    sDescent = fM.getDescent();


		// Find range of x-axis and y-axis
		double xmin, xmax, ymin, ymax, dx, dy;
		// X axis
		xmin = XLimP.getArray()[0];
		xmax = XLimP.getArray()[1];
		dx = xmax-xmin;
		// Y axis
		ymin = YLimP.getArray()[0];
		ymax = YLimP.getArray()[1];
		dy = ymax-ymin;

		// add rectangle as background
		g.setColor( ((ColorProperty)getProperty("Color")).getColor() );
		g.fillRect(dxOrig, dyOrig, dxCurves, dyCurves);
		
		Stroke normS = g2d.getStroke();

		int yLabMinX = dxOrig;
		int xLabMinY = dyOrig+dxCurves;

		// X Grid
		double[] xticks      = XTickP.getArray();
		String[] xticklabels = XTickLabelP.getArray();
		Stroke   xS          = XGridStyleP.getStroke(1);
		g2d.setColor(XColorP.getColor());

        ErrorLogger.debugLine("doXGrid xticks.length " + xticks.length);
		for (int i=0; i<xticks.length; i++)
		{
			int xt = dxOrig + (int)((xticks[i] - xmin) / (xmax - xmin) * dxCurves);

			if (xt < dxOrig || xt > (dxFrame-dxOrig))
				continue;

			// grid line
			if (XGridP.isSet() && !XGridStyleP.is("none"))
			{
				g2d.setStroke(xS);
				g.drawLine(xt, dyOrig, xt, dyOrig+dyCurves);
				g2d.setStroke(normS);
			}

			// tick mark
			g.drawLine(xt, dyOrig, xt, dyOrig+5);
			g.drawLine(xt, dyOrig+dyCurves, xt, dyOrig+dyCurves-5);

			// tick text
			if (i < xticklabels.length)
			{
				int    sXWidth = fM.stringWidth(xticklabels[i]);
				g.drawString( xticklabels[i], 
					          xt-sXWidth/2, 
					          dyFrame-dyOrig+5+sAscent);
			}
		}

		// Y Grid
		double[] yticks      = YTickP.getArray();
		String[] yticklabels = YTickLabelP.getArray();
		Stroke   yS          = YGridStyleP.getStroke(1);
		g2d.setColor(YColorP.getColor());
		for (int i=0; i<yticks.length; i++)
		{
			int yt = dyFrame - dyOrig - (int)((yticks[i] - ymin) / (ymax - ymin) * dyCurves);

			if (yt < dyOrig || yt > (dyFrame-dyOrig))
				continue;

			// grid line
			if (YGridP.isSet() && !YGridStyleP.is("none"))
			{
				g2d.setStroke(yS);
				g.drawLine(dxOrig, yt, dxOrig+dxCurves, yt);
				g2d.setStroke(normS);
			}

			// tick mark
			g.drawLine(dxOrig, yt, dxOrig+5, yt);
			g.drawLine(dxOrig+dxCurves, yt, dxOrig+dxCurves-5, yt);

			// tick text
			if (i < yticklabels.length)
			{
				int    sYWidth = fM.stringWidth(yticklabels[i]);
				g.drawString( yticklabels[i],
						dxOrig - 5 - sYWidth, 
						(int)(yt+(sAscent/2)) );
				if (dxOrig-5-sYWidth < yLabMinX)
					yLabMinX = dxOrig-5-sYWidth;
			}
		}

		// draw borders
        if (BoxP.isSet())
        {
            g.setColor(XColorP.getColor());
    		g.drawLine( dxOrig,          dyOrig+dyCurves, dxOrig+dxCurves, dyOrig+dyCurves);
    		g.drawLine( dxOrig,          dyOrig,          dxOrig+dxCurves, dyOrig);
    		g.setColor(YColorP.getColor());
    		g.drawLine( dxOrig+dxCurves, dyOrig+dyCurves, dxOrig+dxCurves, dyOrig);
    		g.drawLine( dxOrig,          dyOrig,          dxOrig,          dyOrig+dyCurves);
    		g.setColor(Color.black);
        }
        
		// Add title
		if (title != null)
		{
			title.setPlotArea(dxOrig+dxCurves/2, dyOrig-5, 0, 0);
			title.paint(g);
		}

		// Add label of x-axis
		if (xLabel != null)
		{
			xLabel.setPlotArea(dxOrig+dxCurves/2, dyFrame-dyOrig+5+sAscent+sDescent, 0, 0);
			xLabel.paint(g);
		}

		// Add label of y-axis
		if (yLabel != null)
		{
			yLabel.setPlotArea(yLabMinX-5, dyFrame/2, 0, 0);
			yLabel.paint(g);
		}


		// plot line objects
		Shape clip  = g.getClip();
		g.clipRect(dxOrig+1, dyOrig+1, dxCurves-1, dyCurves-1);
		for(int n = 0; n < ChildrenP.size(); n++)
		{
			((LineObject)ChildrenP.elementAt(n)).setAxesBoundaries(xmin, xmax, ymin, ymax);
			((LineObject)ChildrenP.elementAt(n)).setPlotArea(dxOrig,dyFrame-dyOrig,dxCurves,dyCurves);
			((LineObject)ChildrenP.elementAt(n)).paint(g);
		}
		g.setClip(clip);

		flushBackBuffer(_g, g);

	}

	public void propertyChanged(Property p)
	{
        ErrorLogger.debugLine("Axesobject property changed: "+ p.getName());
        
        if (p == XLimP)
		{
			XLimModeP.update("manual");
			autoTickX();
		}
		else if (p == YLimP)
		{
			YLimModeP.update("manual");
			autoTickY();
		}
		else if (p == ZLimP)
		{
			ZLimModeP.update("manual");
			autoTickZ();
		}
		else if (p == XLimModeP)
		{
			if (XLimModeP.is("auto"))
				autoScaleX();
		}
		else if (p == YLimModeP)
		{
			if (YLimModeP.is("auto"))
				autoScaleY();
		}
		else if (p == ZLimModeP)
		{
			if (ZLimModeP.is("auto"))
				autoScaleZ();
		}
		else if (p == XTickP)
			XTickModeP.update("manual");
		else if (p == YTickP)
			YTickModeP.update("manual");
		else if (p == ZTickP)
			ZTickModeP.update("manual");
		else if (p == XTickModeP)
		{
			if (XTickModeP.is("auto"))
				autoTickX();
		}
		else if (p == YTickModeP)
		{
			if (YTickModeP.is("auto"))
				autoTickY();
		}
		else if (p == ZTickModeP)
		{
			if (ZTickModeP.is("auto"))
				autoTickZ();
		}
		else if (p == XTickLabelP)
			XTickLabelModeP.update("manual");
		else if (p == YTickLabelP)
			YTickLabelModeP.update("manual");
		else if (p == ZTickLabelP)
			ZTickLabelModeP.update("manual");
		else if (p == XTickLabelModeP)
		{
			if (XTickLabelModeP.is("auto"))
				autoTickLabelX();
		}
		else if (p == YTickLabelModeP)
		{
			if (YTickLabelModeP.is("auto"))
				autoTickLabelY();
		}
		else if (p == ZTickLabelModeP)
		{
			if (ZTickLabelModeP.is("auto"))
				autoTickLabelZ();
		}
        
        repaint();
        
	}
    
    public void clearAxes()
    {
        ChildrenP.removeAllElements();
    }
}