Java CubicCurve2D.Float方法代码示例

import java.awt.geom.CubicCurve2D; //导入方法依赖的package包/类
private void paintMatcher(Graphics2D g, Color fillClr, 
        int leftX, int rightX, int upL, int upR, int doR, int doL) {
    int topY = Math.min(upL, upR), bottomY = Math.max(doL, doR);
    // try rendering only curves in viewable area
    if (!g.hitClip(leftX, topY, rightX - leftX, bottomY - topY)) {
        return;
    }
    CubicCurve2D upper = new CubicCurve2D.Float(leftX, upL,
            (rightX -leftX)*.3f, upL,
            (rightX -leftX)*.7f, upR,
            rightX, upR);
    CubicCurve2D bottom = new CubicCurve2D.Float(rightX, doR,
            (rightX - leftX)*.7f, doR,
            (rightX -leftX)*.3f, doL,
            leftX, doL);
    GeneralPath path = new GeneralPath();
    path.append(upper, false);
    path.append(bottom, true);
    path.closePath();
    g.setColor(fillClr);
    g.fill(path);
    g.setColor(master.getColorLines());
    g.draw(upper);
    g.draw(bottom);
}
 

import java.awt.geom.CubicCurve2D; //导入方法依赖的package包/类
/**
 * Draws a cubic curve with the current settings.<br>
 * <code>xPoints</code> and <code>yPoints</code> must contain at least 4 points!
 * @param xPoints    x coordinates of the points of the curve
 * @param yPoints    y coordinates of the points of the curve
 * @param startIndex start index to draw segments from
 * @param endIndex   end index to draw segments up to
 */
public void drawCubicCurve2D( final int[] xPoints, final int[] yPoints, final int startIndex, final int endIndex ) {
	if ( xPoints.length < 2 )
		return;
	final CubicCurve2D.Float cubicCurve = new CubicCurve2D.Float();
	this.xPoints = xPoints;
	this.yPoints = yPoints;
	Point2D.Float p = new Point2D.Float(), p1 = new Point2D.Float(), p2 = new Point2D.Float(), p3 = new Point2D.Float(), pTemp;
	final float s = 0.25f;
	getCP( startIndex, p ); getCP( startIndex+1, p1 ); getCP( startIndex+2, p2 );
	for ( int j = startIndex; j < endIndex; j++ ) {
		getCP( j+3, p3 );
		if ( yPoints[ j ] < 0 || yPoints[ j+1 ] < 0 )
			g2.setStroke( STROKE_DASHED_DOUBLE );
		cubicCurve.setCurve(
				p1.x, p1.y,
				-s*p.x + p1.x + s*p2.x, -s*p.y + p1.y + s*p2.y,
				s*p1.x + p2.x - s*p3.x, s*p1.y + p2.y - s*p3.y,
				p2.x, p2.y );
		g2.draw( cubicCurve );
		if ( yPoints[ j ] < 0 || yPoints[ j+1 ] < 0 )
			g2.setStroke( STROKE_DOUBLE_WIDTH );
		pTemp = p; p = p1; p1 = p2; p2 = p3; p3 = pTemp;
	}
}
 

import java.awt.geom.CubicCurve2D; //导入方法依赖的package包/类
public void drawNoteTie(Note note1, Note note2)
{
	g.setStroke(music_stroke_tie);
	
	float grid = getGridSize();
	
	float y1 =  cy - (note1.note*grid*0.5f);
	float y2 =  cy - (note2.note*grid*0.5f);		
	float x1 =  note1.x + grid*0.5f;
	float x2 =  note2.x + grid*0.5f;
		
	CubicCurve2D.Float curve = new CubicCurve2D.Float(
			x1,y1,
			x1,y1+grid*1f,
			x2,y2+grid*1f,
			x2,y2);		
	g.draw(curve);					
}
 

import java.awt.geom.CubicCurve2D; //导入方法依赖的package包/类
public static Shape shapeFromSvgRelativeBezierPath(String pathString, float scalingFactor) {
	String[] points = pathString.split(" ");
	float x1, y1, x2, y2, cx1, cy1, cx2, cy2;
	x2 = y2 = 0;

	float s = scalingFactor;

	Path2D.Float path = new Path2D.Float();
	for (int i = 0; i < points.length / 3; ++i) {
		String c1String = points[i * 3 + 0];
		String c2String = points[i * 3 + 1];
		String targetString = points[i * 3 + 2];

		String[] c1Split = c1String.split(",");
		String[] c2Split = c2String.split(",");
		String[] targetSplit = targetString.split(",");
		x1 = x2;
		y1 = y2;
		x2 = s * Float.parseFloat(targetSplit[0]) + x1;
		y2 = s * Float.parseFloat(targetSplit[1]) + y1;
		cx1 = s * Float.parseFloat(c1Split[0]) + x1;
		cy1 = s * Float.parseFloat(c1Split[1]) + y1;
		cx2 = s * Float.parseFloat(c2Split[0]) + x1;
		cy2 = s * Float.parseFloat(c2Split[1]) + y1;

		CubicCurve2D.Float curve = new CubicCurve2D.Float(x1, y1, cx1, cy1, cx2, cy2, x2, y2);
		path.append(curve, true);
	}
	return path;
}
 

import java.awt.geom.CubicCurve2D; //导入方法依赖的package包/类
/**
 * Paints the current data set as a cubic approximated graph.
 */
private void paintCubicGraph() {
	// Must have at least 4 data points for cubic approximation
	if ( loops.length < 2 )
		return;
	
	// values array might contain negative values which indicates the point is a missing data,
	// it is an estimate to make the chart better/more informative. Multiply this by -1 to get the proper data.
	// Segments which contain a point having negative value should be drawn with dash line/curve.
	
	final CubicCurve2D.Float cubicCurve = new CubicCurve2D.Float();
	Point2D.Float p = new Point2D.Float(), p1 = new Point2D.Float(), p2 = new Point2D.Float(), p3 = new Point2D.Float(), pTemp;
	final float s = 0.25f;
	getCP( idxMin, p );
	getCP( idxMin + 1, p1 );
	getCP( idxMin + 2, p2 );
	
	for ( int j = idxMin; j < idxMax; j++ ) {
		getCP( j + 3, p3 );
		if ( cubicNegativeEstimation && ( values[ j ] < 0 || values[ j + 1 ] < 0 ) )
			g.setStroke( STROKE_DOUBLE_DASHED );
		cubicCurve.setCurve( p1.x, p1.y, -s * p.x + p1.x + s * p2.x, -s * p.y + p1.y + s * p2.y, s * p1.x + p2.x - s * p3.x, s * p1.y + p2.y - s * p3.y,
		        p2.x, p2.y );
		g.draw( cubicCurve );
		if ( cubicNegativeEstimation && ( values[ j ] < 0 || values[ j + 1 ] < 0 ) )
			g.setStroke( dataSet.getStroke() );
		pTemp = p;
		p = p1;
		p1 = p2;
		p2 = p3;
		p3 = pTemp;
	}
}
 

import java.awt.geom.CubicCurve2D; //导入方法依赖的package包/类
/**
 * Constructor that allows to set the modifiers to activate both
 * 'add unidirectional link' and 'add bidirectional link' modes.
 *
 * @param callback               Topology callback
 * @param modifiers              Modifier to activate the plugin to add unidirectional links
 * @param modifiersBidirectional Modifier to activate the plugin to add bidirectional links
 * @since 0.2.0
 */
public AddLinkGraphPlugin(GUINetworkDesign callback, ITopologyCanvas canvas , int modifiers, int modifiersBidirectional) {
    setModifiers(modifiers);
    setModifiersBidirectional(modifiersBidirectional);

    this.callback = callback;
    down = null;
    startVertex = null;
    rawEdge = new CubicCurve2D.Float();
    rawEdge.setCurve(0.0f, 0.0f, 0.33f, 100, .66f, -50, 1.0f, 0.0f);
    rawArrowShape = ArrowFactory.getNotchedArrow(20, 16, 8);
    edgePaintable = new EdgePaintable();
    arrowPaintable = new ArrowPaintable();
    this.canvas = canvas;
}
 

import java.awt.geom.CubicCurve2D; //导入方法依赖的package包/类
/**
 * Returns the shape of a polyline.
 */
private Shape getPolylineShape(Polyline polyline)
{
	float[][] points = polyline.getPoints();
	boolean closedPath = polyline.isClosedPath();
	if (polyline.getJoinStyle() == Polyline.JoinStyle.CURVED)
	{
		GeneralPath polylineShape = new GeneralPath();
		for (int i = 0, n = closedPath ? points.length : points.length - 1; i < n; i++)
		{
			CubicCurve2D.Float curve2D = new CubicCurve2D.Float();
			float[] previousPoint = points[i == 0 ? points.length - 1 : i - 1];
			float[] point = points[i];
			float[] nextPoint = points[i == points.length - 1 ? 0 : i + 1];
			float[] vectorToBisectorPoint = new float[] { nextPoint[0] - previousPoint[0],
					nextPoint[1] - previousPoint[1] };
			float[] nextNextPoint = points[(i + 2) % points.length];
			float[] vectorToBisectorNextPoint = new float[] { point[0] - nextNextPoint[0],
					point[1] - nextNextPoint[1] };
			curve2D.setCurve(point[0], point[1],
					point[0] + (i != 0 || closedPath ? vectorToBisectorPoint[0] / 3.625f : 0),
					point[1] + (i != 0 || closedPath ? vectorToBisectorPoint[1] / 3.625f : 0),
					nextPoint[0]
							+ (i != points.length - 2 || closedPath ? vectorToBisectorNextPoint[0] / 3.625f : 0),
					nextPoint[1]
							+ (i != points.length - 2 || closedPath ? vectorToBisectorNextPoint[1] / 3.625f : 0),
					nextPoint[0], nextPoint[1]);
			polylineShape.append(curve2D, true);
		}
		return polylineShape;
	}
	else
	{
		return getShape(points, closedPath);
	}
}
 

import java.awt.geom.CubicCurve2D; //导入方法依赖的package包/类
private final void drawLine( final Point sourcePoint, final Point sinkPoint )
	{
		final int fromX = sourcePoint.x;
		final int fromY = sourcePoint.y;
		final int toX = sinkPoint.x;
		final int toY = sinkPoint.y;

		float f1, f2, f3, f4, f5, f6, f7, f8 = 0.0f;
		f1 = fromX;
		f2 = fromY;
		f3 = fromX;
		f4 = fromY + WIRE_DIP_PIXELS;
		f5 = toX;
		f6 = toY + WIRE_DIP_PIXELS;
		f7 = toX;
		f8 = toY;
		final CubicCurve2D cubicCurve = new CubicCurve2D.Float( f1, f2, f3, f4, f5, f6, f7, f8 );

		g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
				RenderingHints.VALUE_ANTIALIAS_ON);

		g2d.setColor( Color.BLACK );
		g2d.setStroke( WIRE_STROKE );
		g2d.draw( cubicCurve );

		g2d.setColor( Color.BLUE );
//		g2d.setColor( Color.YELLOW );
		g2d.setStroke( WIRE_BODY_STROKE );
		g2d.draw( cubicCurve );

//		g2d.drawLine( sourcePoint.x, sourcePoint.y, sinkPoint.x, sinkPoint.y );
	}
 

import java.awt.geom.CubicCurve2D; //导入方法依赖的package包/类
private static void addContourToPath(GeneralPath gp, T2Glyph glyph, int startIndex, int count) {
    int offset = 0;
    boolean connect = false;
    while (offset < count) {
        Shape s;
        Point point = glyph.getPoint(startIndex + offset%count);
        Point point_plus1 = glyph.getPoint(startIndex + (offset+1)%count);
        Point point_plus2 = glyph.getPoint(startIndex + (offset+2)%count);
        Point point_plus3 = glyph.getPoint(startIndex + (offset+3)%count);
        if (point.onCurve && point_plus1.onCurve) {
            s = new Line2D.Float(point.x, point.y, point_plus1.x, point_plus1.y);
            offset++;
        } else if (point.onCurve && !point_plus1.onCurve && !point_plus2.onCurve && point_plus3.onCurve) {
            s = new CubicCurve2D.Float(
                point.x,
                point.y,
                point_plus1.x,
                point_plus1.y,
                point_plus2.x,
                point_plus2.y,
                point_plus3.x,
                point_plus3.y);
            offset+=3;
        } else {
            System.out.println("addContourToPath case not catered for!!");
            break;
        }
        gp.append(s, connect);
        connect = true;
    }
}
 

import java.awt.geom.CubicCurve2D; //导入方法依赖的package包/类
/**
 * Draw the given shape on the given OpenGL object.
 *
 * @param gl
 * @param s
 */
private static void drawShape(GL2 gl, Shape s) {
  PathIterator it = s.getPathIterator(new AffineTransform(), shapeFlatness);
  float[] lastMoveTo = new float[6];
  float[] f = new float[6];
  while (!it.isDone()) {
    int res = it.currentSegment(f);
    switch (res) {
      case PathIterator.SEG_CLOSE:
        GLPanel.V(gl, lastMoveTo[0], lastMoveTo[1]);
        break;
      case PathIterator.SEG_MOVETO:
        GLPanel.V(gl, f[0], f[1]);
        System.arraycopy(f, 0, lastMoveTo, 0, 6);
        break;
      case PathIterator.SEG_LINETO:
        GLPanel.V(gl, f[0], f[1]);
        break;
      case PathIterator.SEG_CUBICTO:
      CubicCurve2D c = new CubicCurve2D.Float(lastMoveTo[0], lastMoveTo[1],
          f[0], f[1], f[2], f[3], f[4], f[5]);
      drawShape(gl, c);
        break;
      default:
        throw new Error("Error while drawing AWT shape. "
            + "Path iterator setment not handled:" + res);
    }
    it.next();
  }
}
 

import java.awt.geom.CubicCurve2D; //导入方法依赖的package包/类
@Test
public void cubicCurvesCanBeCloned() throws InstantiationException, IllegalAccessException {
	for (Class shapeClass : new Class[] {
		CubicCurve2D.Float.class, CubicCurve2D.Double.class
	}) {
		assertShapeClassIsCloneable(shapeClass);
	}
}
 

import java.awt.geom.CubicCurve2D; //导入方法依赖的package包/类
/**
 * Draws a section label on the left side of the pie chart.
 *
 * @param g2  the graphics device.
 * @param state  the state.
 * @param record  the label record.
 */
protected void drawLeftLabel(Graphics2D g2, PiePlotState state,
                             PieLabelRecord record) {

    double anchorX = state.getLinkArea().getMinX();
    double targetX = anchorX - record.getGap();
    double targetY = record.getAllocatedY();

    if (this.labelLinksVisible) {
        double theta = record.getAngle();
        double linkX = state.getPieCenterX() + Math.cos(theta)
                * state.getPieWRadius() * record.getLinkPercent();
        double linkY = state.getPieCenterY() - Math.sin(theta)
                * state.getPieHRadius() * record.getLinkPercent();
        double elbowX = state.getPieCenterX() + Math.cos(theta)
                * state.getLinkArea().getWidth() / 2.0;
        double elbowY = state.getPieCenterY() - Math.sin(theta)
                * state.getLinkArea().getHeight() / 2.0;
        double anchorY = elbowY;
        g2.setPaint(this.labelLinkPaint);
        g2.setStroke(this.labelLinkStroke);
        PieLabelLinkStyle style = getLabelLinkStyle();
        if (style.equals(PieLabelLinkStyle.STANDARD)) {
            g2.draw(new Line2D.Double(linkX, linkY, elbowX, elbowY));
            g2.draw(new Line2D.Double(anchorX, anchorY, elbowX, elbowY));
            g2.draw(new Line2D.Double(anchorX, anchorY, targetX, targetY));
        }
        else if (style.equals(PieLabelLinkStyle.QUAD_CURVE)) {
            QuadCurve2D q = new QuadCurve2D.Float();
            q.setCurve(targetX, targetY, anchorX, anchorY, elbowX, elbowY);
            g2.draw(q);
            g2.draw(new Line2D.Double(elbowX, elbowY, linkX, linkY));
        }
        else if (style.equals(PieLabelLinkStyle.CUBIC_CURVE)) {
            CubicCurve2D c = new CubicCurve2D .Float();
            c.setCurve(targetX, targetY, anchorX, anchorY, elbowX, elbowY,
                    linkX, linkY);
            g2.draw(c);
        }
    }
    TextBox tb = record.getLabel();
    tb.draw(g2, (float) targetX, (float) targetY, RectangleAnchor.RIGHT);

}
 

import java.awt.geom.CubicCurve2D; //导入方法依赖的package包/类
/**
 * Draws a section label on the right side of the pie chart.
 *
 * @param g2  the graphics device.
 * @param state  the state.
 * @param record  the label record.
 */
protected void drawRightLabel(Graphics2D g2, PiePlotState state,
                              PieLabelRecord record) {

    double anchorX = state.getLinkArea().getMaxX();
    double targetX = anchorX + record.getGap();
    double targetY = record.getAllocatedY();

    if (this.labelLinksVisible) {
        double theta = record.getAngle();
        double linkX = state.getPieCenterX() + Math.cos(theta)
                * state.getPieWRadius() * record.getLinkPercent();
        double linkY = state.getPieCenterY() - Math.sin(theta)
                * state.getPieHRadius() * record.getLinkPercent();
        double elbowX = state.getPieCenterX() + Math.cos(theta)
                * state.getLinkArea().getWidth() / 2.0;
        double elbowY = state.getPieCenterY() - Math.sin(theta)
                * state.getLinkArea().getHeight() / 2.0;
        double anchorY = elbowY;
        g2.setPaint(this.labelLinkPaint);
        g2.setStroke(this.labelLinkStroke);
        PieLabelLinkStyle style = getLabelLinkStyle();
        if (style.equals(PieLabelLinkStyle.STANDARD)) {
            g2.draw(new Line2D.Double(linkX, linkY, elbowX, elbowY));
            g2.draw(new Line2D.Double(anchorX, anchorY, elbowX, elbowY));
            g2.draw(new Line2D.Double(anchorX, anchorY, targetX, targetY));
        }
        else if (style.equals(PieLabelLinkStyle.QUAD_CURVE)) {
            QuadCurve2D q = new QuadCurve2D.Float();
            q.setCurve(targetX, targetY, anchorX, anchorY, elbowX, elbowY);
            g2.draw(q);
            g2.draw(new Line2D.Double(elbowX, elbowY, linkX, linkY));
        }
        else if (style.equals(PieLabelLinkStyle.CUBIC_CURVE)) {
            CubicCurve2D c = new CubicCurve2D .Float();
            c.setCurve(targetX, targetY, anchorX, anchorY, elbowX, elbowY,
                    linkX, linkY);
            g2.draw(c);
        }
    }

    TextBox tb = record.getLabel();
    tb.draw(g2, (float) targetX, (float) targetY, RectangleAnchor.LEFT);

}
 

import java.awt.geom.CubicCurve2D; //导入方法依赖的package包/类
@Override
public void makeNoise(BufferedImage image) {
    int width = image.getWidth();
    int height = image.getHeight();

    // the curve from where the points are taken
    CubicCurve2D cc = new CubicCurve2D.Float(width * .1f, height * RAND.nextFloat(), width * .1f, height
            * RAND.nextFloat(), width * .25f, height * RAND.nextFloat(), width * .9f, height * RAND.nextFloat());

    // creates an iterator to define the boundary of the flattened curve
    PathIterator pi = cc.getPathIterator(null, 2);
    Point2D tmp[] = new Point2D[200];
    int i = 0;

    // while pi is iterating the curve, adds points to tmp array
    while (!pi.isDone()) {
        float[] coords = new float[6];
        switch (pi.currentSegment(coords)) {
        case PathIterator.SEG_MOVETO:
        case PathIterator.SEG_LINETO:
            tmp[i] = new Point2D.Float(coords[0], coords[1]);
        }
        i++;
        pi.next();
    }

    // the points where the line changes the stroke and direction
    Point2D[] pts = new Point2D[i];
    // copies points from tmp to pts
    System.arraycopy(tmp, 0, pts, 0, i);

    Graphics2D graph = (Graphics2D) image.getGraphics();
    graph.setRenderingHints(new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON));

    graph.setColor(_color);

    // for the maximum 3 point change the stroke and direction
    for (i = 0; i < pts.length - 1; i++) {
        if (i < 3) {
            graph.setStroke(new BasicStroke(_width));
        }
        graph.drawLine((int) pts[i].getX(), (int) pts[i].getY(), (int) pts[i + 1].getX(), (int) pts[i + 1].getY());
    }

    graph.dispose();
}
 

import java.awt.geom.CubicCurve2D; //导入方法依赖的package包/类
/**
 * Returns the path matching this polyline.
 */
private Shape getPolylinePath()
{
	if (this.polylinePathCache == null)
	{
		GeneralPath polylinePath = new GeneralPath();
		if (this.joinStyle == JoinStyle.CURVED)
		{
			for (int i = 0, n = this.closedPath ? this.points.length : this.points.length - 1; i < n; i++)
			{
				CubicCurve2D.Float curve2D = new CubicCurve2D.Float();
				float[] previousPoint = this.points[i == 0 ? this.points.length - 1 : i - 1];
				float[] point = this.points[i];
				float[] nextPoint = this.points[i == this.points.length - 1 ? 0 : i + 1];
				float[] vectorToBisectorPoint = new float[] { nextPoint[0] - previousPoint[0],
						nextPoint[1] - previousPoint[1] };
				float[] nextNextPoint = this.points[(i + 2) % this.points.length];
				float[] vectorToBisectorNextPoint = new float[] { point[0] - nextNextPoint[0],
						point[1] - nextNextPoint[1] };
				curve2D.setCurve(point[0], point[1],
						point[0] + (i != 0 || this.closedPath ? vectorToBisectorPoint[0] / 3.625f : 0),
						point[1] + (i != 0 || this.closedPath ? vectorToBisectorPoint[1] / 3.625f : 0),
						nextPoint[0] + (i != this.points.length - 2 || this.closedPath
								? vectorToBisectorNextPoint[0] / 3.625f : 0),
						nextPoint[1] + (i != this.points.length - 2 || this.closedPath
								? vectorToBisectorNextPoint[1] / 3.625f : 0),
						nextPoint[0], nextPoint[1]);
				polylinePath.append(curve2D, true);
			}
		}
		else
		{
			polylinePath.moveTo(this.points[0][0], this.points[0][1]);
			for (int i = 1; i < this.points.length; i++)
			{
				polylinePath.lineTo(this.points[i][0], this.points[i][1]);
			}
			if (this.closedPath)
			{
				polylinePath.closePath();
			}
		}
		// Cache polylineShape
		this.polylinePathCache = polylinePath;
	}
	return this.polylinePathCache;
}