import math.geom2d.polygon.Polyline2D; //导入依赖的package包/类
/**
 * Assumes the curve is open, and returns an instance of Polyline2D.
 * 
 * @param n
 *            the number of edges of the resulting polyline
 * @return a new Polyline2D approximating the original curve
 */
protected Polyline2D asPolylineOpen(int n) {
    // Check that the curve is bounded
    if (!this.isBounded())
        throw new UnboundedShape2DException(this);

    // compute start and increment values
    double t0 = this.t0();
    double dt = (this.t1() - t0) / n;

    // allocate array of points, and compute each value.
    // Computes also value for last point.
    Point2D[] points = new Point2D[n + 1];
    for (int i = 0; i < n + 1; i++)
        points[i] = this.point(t0 + i * dt);

    return new Polyline2D(points);
}
 

import math.geom2d.polygon.Polyline2D; //导入依赖的package包/类
public Polyline2D asPolyline(int n) {
	// Check that the curve is bounded
       if (!this.isBounded())
           throw new UnboundedShape2DException(this);

       // compute start and increment values
       double t0 = this.t0();
       double dt = (this.t1() - t0) / n;

       // allocate array of points, and compute each value.
       Point2D[] points = new Point2D[n+1];
       for(int i = 0; i < n+1;i++)
       	points[i] = this.point(t0 + i*dt);

       return new Polyline2D(points);
}
 

import math.geom2d.polygon.Polyline2D; //导入依赖的package包/类
public Polyline2D getAsPolyline(int n) {
    Point2D[] points = new Point2D[n+1];
    double t0 = this.getT0();
    double t1 = this.getT1();
    double dt = (t1-t0)/n;
    for (int i = 0; i<n; i++)
        points[i] = this.getPoint(i*dt+t0);
    return new Polyline2D(points);
}
 

import math.geom2d.polygon.Polyline2D; //导入依赖的package包/类
/**
 * Extracts a portion of the boundary of a bounded box.
 * 
 * @param box the box from which one extract a portion of boundary
 * @param p0 the first point of the portion
 * @param p1 the last point of the portion
 * @return the portion of the bounding box boundary as a Polyline2D
 */
public final static Polyline2D getBoundaryPortion(Box2D box, Point2D p0,
        Point2D p1) {
    Boundary2D boundary = box.getBoundary();

    // position of start and end points
    double t0 = boundary.getPosition(p0);
    double t1 = boundary.getPosition(p1);

    // curve index of each point
    int ind0 = (int) Math.floor(t0);
    int ind1 = (int) Math.floor(t1);

    // Simple case: returns a polyline with only 2 vertices
    if (ind0==ind1&&t0<t1)
        return new Polyline2D(new Point2D[] { p0, p1 });

    // Create an array to store vertices
    // Array can contain at most 6 vertices: 4 for the box corners,
    // and 2 for curve extremities.
    ArrayList<Point2D> vertices = new ArrayList<Point2D>(6);

    // add the first point.
    vertices.add(p0);

    // compute index of first box boundary edge
    int ind = (ind0+1)%4;

    // add all vertices segments between the 2 end points
    while (ind!=ind1) {
        vertices.add(boundary.getPoint(ind));
        ind = (ind+1)%4;
    }
    vertices.add(boundary.getPoint(ind));

    // add the last line segment
    vertices.add(p1);

    return new Polyline2D(vertices);
}
 

import math.geom2d.polygon.Polyline2D; //导入依赖的package包/类
private Polyline2D createRectangle(GraphicInfo graphicInfo) {
    Polyline2D rectangle = new Polyline2D(new Point2D(graphicInfo.getX(),
            graphicInfo.getY()), new Point2D(graphicInfo.getX()
            + graphicInfo.getWidth(), graphicInfo.getY()), new Point2D(
            graphicInfo.getX() + graphicInfo.getWidth(), graphicInfo.getY()
                    + graphicInfo.getHeight()), new Point2D(
            graphicInfo.getX(), graphicInfo.getY()
                    + graphicInfo.getHeight()), new Point2D(
            graphicInfo.getX(), graphicInfo.getY()));

    return rectangle;
}
 

import math.geom2d.polygon.Polyline2D; //导入依赖的package包/类
private Polyline2D createGateway(GraphicInfo graphicInfo) {
    double middleX = graphicInfo.getX() + (graphicInfo.getWidth() / 2);
    double middleY = graphicInfo.getY() + (graphicInfo.getHeight() / 2);

    Polyline2D gatewayRectangle = new Polyline2D(new Point2D(
            graphicInfo.getX(), middleY), new Point2D(middleX,
            graphicInfo.getY()), new Point2D(graphicInfo.getX()
            + graphicInfo.getWidth(), middleY), new Point2D(middleX,
            graphicInfo.getY() + graphicInfo.getHeight()), new Point2D(
            graphicInfo.getX(), middleY));

    return gatewayRectangle;
}
 

import math.geom2d.polygon.Polyline2D; //导入依赖的package包/类
/**
 * Converts this PolyCurve2D into a polyline with the given number of edges.
 * 
 * @param n
 *            the number of edges of the result polyline
 * @see Polyline2D
 */
public Polyline2D asPolyline(int n) {
    Point2D[] points = new Point2D[n + 1];
    double t0 = this.t0();
    double t1 = this.t1();
    double dt = (t1 - t0) / n;
    for (int i = 0; i < n; i++)
        points[i] = this.point(i * dt + t0);
    return new Polyline2D(points);
}
 

import math.geom2d.polygon.Polyline2D; //导入依赖的package包/类
public Polyline2D asPolyline(int n) {

        // compute increment value
        double dt = 1.0 / n;

        // allocate array of points, and compute each value.
        // Computes also value for last point.
        Point2D[] points = new Point2D[n + 1];
        for (int i = 0; i < n + 1; i++)
            points[i] = this.point(i * dt);

        return new Polyline2D(points);
    }
 

import math.geom2d.polygon.Polyline2D; //导入依赖的package包/类
public CirculinearContinuousCurve2D createCap(Point2D center,
		Vector2D direction, double dist) {
	double theta = direction.angle();
	Point2D p1 = Point2D.createPolar(center, dist, theta-Math.PI/2);
	Point2D p2 = Point2D.createPolar(center, dist, theta);
	Point2D p3 = Point2D.createPolar(center, dist, theta+Math.PI/2);
	return new Polyline2D(new Point2D[]{p1, p2, p3});
}
 

import math.geom2d.polygon.Polyline2D; //导入依赖的package包/类
/**
 * Portion of code shared by the two public methods.
 */
private Polyline2D createCap(Point2D center, double theta, double dist) {
	Point2D p1 = Point2D.createPolar(center, dist, theta-Math.PI/2);
	Point2D p4 = Point2D.createPolar(center, dist, theta+Math.PI/2);
	Point2D p2 = Point2D.createPolar(p1, dist, theta);
	Point2D p3 = Point2D.createPolar(p4, dist, theta);
	return new Polyline2D(new Point2D[]{p1, p2, p3, p4});
}
 

import math.geom2d.polygon.Polyline2D; //导入依赖的package包/类
/**
   * Extracts a portion of the boundary of a bounded box.
   * 
   * @param box the box from which one extract a portion of boundary
   * @param p0 the first point of the portion
   * @param p1 the last point of the portion
   * @return the portion of the bounding box boundary as a Polyline2D
   */
  public final static Polyline2D getBoundaryPortion(Box2D box, Point2D p0,
          Point2D p1) {
      Boundary2D boundary = box.boundary();

      // position of start and end points
      double t0 = boundary.position(p0);
      double t1 = boundary.position(p1);

      // curve index of each point
      int ind0 = (int) Math.floor(t0);
      int ind1 = (int) Math.floor(t1);

      // Simple case: returns a polyline with only 2 vertices
if (ind0 == ind1 && t0 < t1)
	return new Polyline2D(new Point2D[] { p0, p1 });

      // Create an array to store vertices
      // Array can contain at most 6 vertices: 4 for the box corners,
      // and 2 for curve extremities.
      ArrayList<Point2D> vertices = new ArrayList<Point2D>(6);

      // add the first point.
      vertices.add(p0);

// compute index of first box boundary edge
int ind = (ind0 + 1) % 4;

// add all vertices segments between the 2 end points
while (ind != ind1) {
	vertices.add(boundary.point(ind));
	ind = (ind + 1) % 4;
}
      vertices.add(boundary.point(ind));

      // add the last line segment
      vertices.add(p1);

      return new Polyline2D(vertices);
  }
 

import math.geom2d.polygon.Polyline2D; //导入依赖的package包/类
public Polyline2D asPolyline(int n) {

        // compute increment value
        double dt = Math.abs(this.angleExtent) / n;

        // allocate array of points, and compute each value.
        // Computes also value for last point.
        Point2D[] points = new Point2D[n + 1];
        for (int i = 0; i < n + 1; i++)
            points[i] = this.point(i * dt);

        return new Polyline2D(points);
    }
 

import math.geom2d.polygon.Polyline2D; //导入依赖的package包/类
public Polyline2D asPolyline(int n) {

        // compute increment value
        double dt = Math.abs(this.angleExtent) / n;

        // allocate array of points, and compute each value.
        // Computes also value for last point.
        Point2D[] points = new Point2D[n + 1];
        for (int i = 0; i < n + 1; i++)
        	points[i] = this.point(i * dt);

        return new Polyline2D(points);
	}
 

import math.geom2d.polygon.Polyline2D; //导入依赖的package包/类
private Polyline2D createRectangle(Bounds graphicInfo) {
  Polyline2D rectangle = new Polyline2D(new Point2D(graphicInfo.getX(), graphicInfo.getY()),
      new Point2D(graphicInfo.getX() + graphicInfo.getWidth(), graphicInfo.getY()),
      new Point2D(graphicInfo.getX() + graphicInfo.getWidth(), graphicInfo.getY() + graphicInfo.getHeight()),
      new Point2D(graphicInfo.getX(), graphicInfo.getY() + graphicInfo.getHeight()),
      new Point2D(graphicInfo.getX(), graphicInfo.getY()));
  return rectangle;
}
 

import math.geom2d.polygon.Polyline2D; //导入依赖的package包/类
private Polyline2D createGateway(Bounds graphicInfo) {
  
  double middleX = graphicInfo.getX() + (graphicInfo.getWidth() / 2);
  double middleY = graphicInfo.getY() + (graphicInfo.getHeight() / 2);
  
  Polyline2D gatewayRectangle = new Polyline2D(new Point2D(graphicInfo.getX(), middleY),
      new Point2D(middleX, graphicInfo.getY()),
      new Point2D(graphicInfo.getX() + graphicInfo.getWidth(), middleY),
      new Point2D(middleX, graphicInfo.getY() + graphicInfo.getHeight()),
      new Point2D(graphicInfo.getX(), middleY));
  
  return gatewayRectangle;
}
 

import math.geom2d.polygon.Polyline2D; //导入依赖的package包/类
/**
    * Throws an exception when called.
    */
@Override
   public Polyline2D getAsPolyline(int n) {
       throw new UnboundedShapeException(this);
   }
 

import math.geom2d.polygon.Polyline2D; //导入依赖的package包/类
/**
 * Throws an exception when called.
 */
@Override
public Polyline2D asPolyline(int n) {
    throw new UnboundedShape2DException(this);
}
 

import math.geom2d.polygon.Polyline2D; //导入依赖的package包/类
/**
 * Returns an approximation of the curve as a polyline with <code>n</code>
 * line segments. If the curve is closed, the method should return an
 * instance of Ring2D.
 * 
 * @param n the number of line segments
 * @return a polyline with <code>n</code> line segments.
 */
public abstract Polyline2D getAsPolyline(int n);