Java Point2D.equals方法代码示例

import java.awt.geom.Point2D; //导入方法依赖的package包/类
/**
 * Gets the intersection points.
 *
 * @param line
 *          the line
 * @param rectangle
 *          the rectangle
 * @return the intersection points
 */
public static List<Point2D> getIntersectionPoints(final Line2D line, final Rectangle2D rectangle) {
  final ArrayList<Point2D> intersectionPoints = new ArrayList<>();
  final Line2D[] lines = getLines(rectangle);
  final Line2D topLine = lines[0];
  final Line2D bottomLine = lines[1];
  final Line2D leftLine = lines[2];
  final Line2D rightLine = lines[3];

  // Top line
  final Point2D p1 = getIntersectionPoint(line, topLine);
  if (p1 != null && contains(rectangle, p1)) {
    intersectionPoints.add(p1);
  }

  // Bottom line
  final Point2D p2 = getIntersectionPoint(line, bottomLine);
  if (p2 != null && contains(rectangle, p2) && !intersectionPoints.contains(p2)) {
    intersectionPoints.add(p2);
  }

  // Left side...
  final Point2D p3 = getIntersectionPoint(line, leftLine);
  if (p3 != null && !p3.equals(p1) && !p3.equals(p2) && contains(rectangle, p3) && !intersectionPoints.contains(p3)) {
    intersectionPoints.add(p3);
  }

  // Right side
  final Point2D p4 = getIntersectionPoint(line, rightLine);
  if (p4 != null && !p4.equals(p1) && !p4.equals(p2) && contains(rectangle, p4) && !intersectionPoints.contains(p4)) {
    intersectionPoints.add(p4);
  }

  intersectionPoints.removeAll(Collections.singleton(null));
  return intersectionPoints;
}
 

import java.awt.geom.Point2D; //导入方法依赖的package包/类
/**
 * Creates the undoable move action.
 */
private void createUndoableMoveAction() {
	if (this.nodesMovedOldPositions!=null) {
		if (this.nodesMovedOldPositions.size()>0) {
			// --- Get selected GraphNodes ----------
			Set<GraphNode> nodesSelected = this.getVisViewer().getPickedVertexState().getPicked();
			if (this.nodesMovedOldPositions.size()==nodesSelected.size()) {
				for (GraphNode node : nodesSelected) {
					Point2D pointCurrent = new Point2D.Double(node.getPosition().getX(), node.getPosition().getY());
					Point2D pointStored  = this.nodesMovedOldPositions.get(node.getId());
					if (pointCurrent.equals(pointStored)==false) {
						this.basicGraphGUI.getGraphEnvironmentController().getNetworkModelAdapter().setGraphNodesMoved(this.getVisViewer(), this.nodesMovedOldPositions);
						break;
					}
				} // end for
				
			} else {
				// --- Should never happen ------------
				this.basicGraphGUI.getGraphEnvironmentController().getNetworkModelAdapter().setGraphNodesMoved(this.getVisViewer(), this.nodesMovedOldPositions);
			}
		}
		this.nodesMovedOldPositions = null;
	}
}
 

import java.awt.geom.Point2D; //导入方法依赖的package包/类
/**
 * Creates an edge vector from a list of points. The edge vector is the
 * vector from the first to the last point, if they are distinct; otherwise,
 * it is the average of the edge points; if that yields <code>(0,0)</code>,
 * the edge vector is given by {@link #DEFAULT_EDGE_VECTOR}.
 *
 * @param points the list of points; should not be empty
 * @param isLoop flag indicating that the underlying edge is a loop
 * @see EdgeView#getLabelVector()
 */
private static Point2D version2LabelVector(List<Point2D> points, boolean isLoop) {
    Point2D result = null;
    // first try a vector from the first to the last point
    Point2D begin = points.get(0);
    Point2D end = points.get(points.size() - 1);
    if (!(isLoop || begin.equals(end))) {
        double dx = end.getX() - begin.getX();
        double dy = end.getY() - begin.getY();
        result = new Point2D.Double(dx, dy);
    } else if (points.size() > 0) {
        // the first and last point coincide; try taking the max of all
        // points
        double sumX = 0;
        double sumY = 0;
        for (Point2D point : points) {
            sumX += point.getX() - begin.getX();
            sumY += point.getY() - begin.getY();
        }
        // double the average (why? don't know; see
        // EdgeView#getLabelVector())
        int n = points.size() / 2;
        result = new Point2D.Double(sumX / n, sumY / n);
    }
    if (result == null || result.getX() == 0 && result.getY() == 0) {
        // nothing worked
        result = DEFAULT_EDGE_VECTOR;
    }
    return result;
}
 

import java.awt.geom.Point2D; //导入方法依赖的package包/类
/**
 * Intersects.
 *
 * @param line
 *          the line
 * @param rectangle
 *          the rectangle
 * @return the point2 d
 */
public static Point2D getIntersectionPoint(final Line2D line, final Rectangle2D rectangle) {
  final List<Point2D> intersectionPoints = getIntersectionPoints(line, rectangle);
  for (final Point2D p : intersectionPoints) {
    if (p != null && !p.equals(line.getP1()) && contains(rectangle, p)) {
      return p;
    }
  }
  return null;
}
 

import java.awt.geom.Point2D; //导入方法依赖的package包/类
/**
 * Compares this object with the specified object for order, based on
 * the outlier's point.
 *
 * @param   o the Object to be compared.
 * @return  a negative integer, zero, or a positive integer as this object
 *      is less than, equal to, or greater than the specified object.
 *
 */
public int compareTo(Object o) {
    Outlier outlier = (Outlier) o;
    Point2D p1 = getPoint();
    Point2D p2 = outlier.getPoint();
    if (p1.equals(p2)) {
        return 0;
    } 
    else if ((p1.getX() < p2.getX()) || (p1.getY() < p2.getY())) {
        return -1;
    } 
    else {
        return 1;
    } 
}
 

import java.awt.geom.Point2D; //导入方法依赖的package包/类
/**
 * Compares this object with the specified object for order, based on
 * the outlier's point.
 *
 * @param   o the Object to be compared.
 * @return A negative integer, zero, or a positive integer as this object
 *      is less than, equal to, or greater than the specified object.
 *
 */
public int compareTo(Object o) {
    Outlier outlier = (Outlier) o;
    Point2D p1 = getPoint();
    Point2D p2 = outlier.getPoint();
    if (p1.equals(p2)) {
        return 0;
    } 
    else if ((p1.getX() < p2.getX()) || (p1.getY() < p2.getY())) {
        return -1;
    } 
    else {
        return 1;
    } 
}
 

import java.awt.geom.Point2D; //导入方法依赖的package包/类
static void testGetCurrentPoint(Path2D pathA, Path2D pathB) {
    final Point2D ptA = pathA.getCurrentPoint();
    final Point2D ptB = pathA.getCurrentPoint();
    if (((ptA == null) && (ptB != null))
        || ((ptA != null) && !ptA.equals(ptB)))
    {
        throw new IllegalStateException("getCurrentPoint() are not equals ["
            + ptA + "|" + ptB + "] !");
    }
    log("testGetCurrentPoint: passed.");
}
 

import java.awt.geom.Point2D; //导入方法依赖的package包/类
private static boolean startsNotAt(Point2D startLocation, List<Point2D> points) {
	return !startLocation.equals(firstLocation(points));
}
 

import java.awt.geom.Point2D; //导入方法依赖的package包/类
private static boolean endsNotAt(Point2D endLocation, List<Point2D> points) {
	return !endLocation.equals(lastLocation(points));
}
 

import java.awt.geom.Point2D; //导入方法依赖的package包/类
/**
 * Constructs a {@code LinearGradientPaint}.
 *
 * @param start the gradient axis start {@code Point2D} in user space
 * @param end the gradient axis end {@code Point2D} in user space
 * @param fractions numbers ranging from 0.0 to 1.0 specifying the
 *                  distribution of colors along the gradient
 * @param colors array of colors corresponding to each fractional value
 * @param cycleMethod either {@code NO_CYCLE}, {@code REFLECT},
 *                    or {@code REPEAT}
 * @param colorSpace which color space to use for interpolation,
 *                   either {@code SRGB} or {@code LINEAR_RGB}
 * @param gradientTransform transform to apply to the gradient
 *
 * @throws NullPointerException
 * if one of the points is null,
 * or {@code fractions} array is null,
 * or {@code colors} array is null,
 * or {@code cycleMethod} is null,
 * or {@code colorSpace} is null,
 * or {@code gradientTransform} is null
 * @throws IllegalArgumentException
 * if start and end points are the same points,
 * or {@code fractions.length != colors.length},
 * or {@code colors} is less than 2 in size,
 * or a {@code fractions} value is less than 0.0 or greater than 1.0,
 * or the {@code fractions} are not provided in strictly increasing order
 */
@ConstructorProperties({ "startPoint", "endPoint", "fractions", "colors", "cycleMethod", "colorSpace", "transform" })
public LinearGradientPaint(Point2D start, Point2D end,
                           float[] fractions, Color[] colors,
                           CycleMethod cycleMethod,
                           ColorSpaceType colorSpace,
                           AffineTransform gradientTransform)
{
    super(fractions, colors, cycleMethod, colorSpace, gradientTransform);

    // check input parameters
    if (start == null || end == null) {
        throw new NullPointerException("Start and end points must be" +
                                       "non-null");
    }

    if (start.equals(end)) {
        throw new IllegalArgumentException("Start point cannot equal" +
                                           "endpoint");
    }

    // copy the points...
    this.start = new Point2D.Double(start.getX(), start.getY());
    this.end = new Point2D.Double(end.getX(), end.getY());
}
 

import java.awt.geom.Point2D; //导入方法依赖的package包/类
/**
 * Indicates whether a given label position is the default position.
 * @param labelPosition the label position to be tested
 * @return <code>true</code> if <code>labelPosition</code> is the
 *         default label position
 */
static public boolean isDefaultLabelPosition(Point2D labelPosition) {
    return labelPosition == null || labelPosition.equals(defaultLabelPosition);
}