arcpath.java

Petri网分析工具PIPE is open-source

	public void setPointLocation(int index, double x, double y) {
    if(index<pathPoints.size() && index>=0)
		((ArcPathPoint)pathPoints.get(index)).setPointLocation((float)x,(float)y);
	}
	
	public void setPointLocation(int index, Point2D.Double point) {
		((ArcPathPoint)pathPoints.get(index)).setPointLocation((float)point.x,(float)point.y);
	}
	public void setPointType(int index, boolean type) {
		((ArcPathPoint)pathPoints.get(index)).setPointType(type);
	}
	
	public void setFinalPointType(boolean type) {
		((ArcPathPoint)pathPoints.get(getEndIndex())).setPointType(type);
	}
	
	public void togglePointType(int index) {
		((ArcPathPoint)pathPoints.get(index)).togglePointType();
	}
	
	public boolean isPointSelected(int index) {
		return ((ArcPathPoint)pathPoints.get(index)).isSelected();
	}
	
	public void selectPoint(int index) {
		((ArcPathPoint)pathPoints.get(index)).select();
	}
	
	public void deselectPoint(int index) {
		((ArcPathPoint)pathPoints.get(index)).deselect();
	}
	
	public int getNumPoints() {
		return pathPoints.size();
	}
	
	
	public Point2D.Float getPoint(int index) {
		return ((ArcPathPoint)pathPoints.get(index)).getPoint();
	}
	
	public ArcPathPoint getPathPoint(int index) {
		return ((ArcPathPoint)pathPoints.get(index));
	}
	
	public Arc getArc() {
		return myArc;
	}
	
	public void showPoints() {
		if (!pointLock)
		{
			for (int i=0; i<pathPoints.size(); i++)
				((ArcPathPoint)pathPoints.get(i)).setVisible(true);
		}
	}
	
	public void hidePoints() {
		if (!pointLock)
		{
			for (int i=0; i<pathPoints.size(); i++)
			{
				currentPoint = ((ArcPathPoint)pathPoints.get(i));
				if (!currentPoint.isSelected())
					currentPoint.setVisible(false);
			}
		}
	}
	
	/* (non-Javadoc)
	 * @see java.awt.Shape#intersects(java.awt.geom.Rectangle2D)
	 */
	public void setPointVisibilityLock(boolean lock) {
		pointLock = lock;
	}	

	
//	public double getEndAngle() {
//		if (getEndIndex()>0)
//			return ((ArcPathPoint)pathPoints.get(getEndIndex())).getAngle((ArcPathPoint)(pathPoints.get(getEndIndex()-1)));
//		return 0;
//	}
//	
//	public double getStartAngle() {
//		if (getEndIndex()>0)
//			return ((ArcPathPoint)pathPoints.get(0)).getAngle((ArcPathPoint)(pathPoints.get(1)));
//		return 0;
//	}
	
	/* modified to use control points, ensures a curve hits a place tangetially */
	public double getEndAngle() {
		if (getEndIndex()>0){
			if (getArc().getTarget() instanceof Transition)
				return ((ArcPathPoint)pathPoints.get(getEndIndex())).getAngle(((ArcPathPoint)(pathPoints.get(getEndIndex()))).getControl2());
			else
				return ((ArcPathPoint)pathPoints.get(getEndIndex())).getAngle(((ArcPathPoint)(pathPoints.get(getEndIndex()))).getControl1());
		}
		return 0;
	}
	
	public double getStartAngle() {
		if (getEndIndex()>0)
			return ((ArcPathPoint)pathPoints.get(0)).getAngle(((ArcPathPoint)(pathPoints.get(1))).getControl2());
		return 0;
	}
	/* (non-Javadoc)
	 * @see java.awt.Shape#contains(double, double, double, double)
	 */
	public boolean contains(
		double arg0,
		double arg1,
		double arg2,
		double arg3) {
		// TODO Auto-generated method stub
		return false;
	}

	/* (non-Javadoc)
	 * @see java.awt.Shape#intersects(double, double, double, double)
	 */
	public boolean intersects(
		double arg0,
		double arg1,
		double arg2,
		double arg3) {
		// TODO Auto-generated method stub
		return false;
	}

	/* (non-Javadoc)
	 * @see java.awt.Shape#getBounds()
	 */
	public Rectangle getBounds() {
		// TODO Auto-generated method stub
		return path.getBounds();
	}

	/* (non-Javadoc)
	 * @see java.awt.Shape#contains(java.awt.geom.Point2D)
	 */
	public boolean contains(Point2D p) {
		return shape.contains(p);
	} 
	/* (non-Javadoc)
	 * @see java.awt.Shape#contains(java.awt.geom.Point2D)
	 */
	public boolean proximityContains(Point2D p) {
		return proximityShape.contains(p);
	} 	
	/* (non-Javadoc)
	 * @see java.awt.Shape#getBounds2D()
	 */
	public Rectangle2D getBounds2D() {
		// TODO Auto-generated method stub
		return null;
	}

	/* (non-Javadoc)
	 * @see java.awt.Shape#contains(java.awt.geom.Rectangle2D)
	 */
	public boolean contains(Rectangle2D arg0) {
		// TODO Auto-generated method stub
		return false;
	}

	/* (non-Javadoc)
	 * @see java.awt.Shape#intersects(java.awt.geom.Rectangle2D)
	 */
	public boolean intersects(Rectangle2D r) {
		return shape.intersects(r);
	}
	/* (non-Javadoc)
	 * @see java.awt.Shape#intersects(java.awt.geom.Rectangle2D)
	 */
	public boolean proximityIntersects(Rectangle2D r) {
		return proximityShape.intersects(r);
	}	
	
	/* (non-Javadoc)
	 * @see java.awt.Shape#getPathIterator(java.awt.geom.AffineTransform)
	 */
	public PathIterator getPathIterator(AffineTransform arg0) {
		return path.getPathIterator(arg0);
	}

	/* (non-Javadoc)
	 * @see java.awt.Shape#getPathIterator(java.awt.geom.AffineTransform, double)
	 */
	public PathIterator getPathIterator(AffineTransform arg0, double arg1) {
		return path.getPathIterator(arg0, arg1);
	}

	public Cubic[] calcNaturalCubic(int n, int[] x) {
		float[] gamma = new float[n+1];
		float[] delta = new float[n+1];
		float[] D = new float[n+1];
		int i;
		/* We solve the equation
		 [2 1       ] [D[0]]   [3(x[1] - x[0])  ]
		 |1 4 1     | |D[1]|   |3(x[2] - x[0])  |
		 |  1 4 1   | | .  | = |      .         |
		 |    ..... | | .  |   |      .         |
		 |     1 4 1| | .  |   |3(x[n] - x[n-2])|
		 [       1 2] [D[n]]   [3(x[n] - x[n-1])]
		 
		 by using row operations to convert the matrix to upper triangular
		 and then back sustitution.  The D[i] are the derivatives at the knots.
		 */
		
		gamma[0] = 1.0f/2.0f;
		for ( i = 1; i < n; i++) {
			gamma[i] = 1/(4-gamma[i-1]);
		}
		gamma[n] = 1/(2-gamma[n-1]);
		
		delta[0] = 3*(x[1]-x[0])*gamma[0];
		for ( i = 1; i < n; i++) {
			delta[i] = (3*(x[i+1]-x[i-1])-delta[i-1])*gamma[i];
		}
		delta[n] = (3*(x[n]-x[n-1])-delta[n-1])*gamma[n];
		
		D[n] = delta[n];
		for ( i = n-1; i >= 0; i--) {
			D[i] = delta[i] - gamma[i]*D[i+1];
		}
		
		/* now compute the coefficients of the cubics */
		Cubic[] C = new Cubic[n];
		for ( i = 0; i < n; i++) {
			C[i] = new Cubic(x[i], D[i], 3*(x[i+1] - x[i]) - 2*D[i] - D[i+1],
					2*(x[i] - x[i+1]) + D[i] + D[i+1]);
		}
		return C;
	}
	
	
	
	public void addPointsToGui(GuiView editWindow) {
		ArcPathPoint pathPoint;
		((ArcPathPoint)pathPoints.get(0)).setDraggable(false);
		((ArcPathPoint)pathPoints.get(pathPoints.size()-1)).setDraggable(false);

		ArcPathPointHandler pointHandler;
		for (int i=0; i<pathPoints.size(); i++)
		{
			pathPoint = (ArcPathPoint)pathPoints.get(i);
			pathPoint.setVisible(false);
			editWindow.add(pathPoint);
			pointHandler = new ArcPathPointHandler(editWindow, pathPoint);
			pathPoint.addMouseListener(pointHandler);
			pathPoint.addMouseMotionListener(pointHandler);
			pathPoint.updatePointLocation();
		}
	}
	
	public void delete() {						// Michael: Tells the arc points to remove themselves
		while (!pathPoints.isEmpty()){
			((ArcPathPoint)pathPoints.get(0)).kill();	// force delete of ALL points
		}
	  }
	
	public String[][] getArcPathDetails(){
		
		int length = getEndIndex() + 1;
		
		String[][] details = new String[length][3];
		
		for (int c = 0; c < length; c++){
			
			details[c][0] = String.valueOf(((ArcPathPoint)pathPoints.get(c)).getX());
			details[c][1] = String.valueOf(((ArcPathPoint)pathPoints.get(c)).getY());
			details[c][2] = String.valueOf(((ArcPathPoint)pathPoints.get(c)).getPointType());
		}
		return details;
	}
	
	public void purgePathPoints()	// Dangerous! Only called from DataLayer when loading ArcPaths
	{
		pathPoints.clear();
	}
	
	public void setTransitionAngle(int angle){
		transitionAngle = angle;
		transitionAngle %= 360;
	}
}



class Cubic {
	
	float a,b,c,d;         /* a + b*u + c*u^2 +d*u^3 */
	
	public Cubic(float a, float b, float c, float d){
		this.a = a;
		this.b = b;
		this.c = c;
		this.d = d;
	}
	
	// Return first control point coordinate (calculated from coefficients)
	public float getX1() {
		return ((b+3*a)/3);
	}
	
	// Return second control point coordinate (calculated from coefficients)
	public float getX2() {
		return ((c+2*b+3*a)/3);
	}
	
	/** evaluate cubic */
	public float eval(float u) {
		return (((d*u) + c)*u + b)*u + a;
	}
	
}