/*
* Copyright 2000-2009 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.intellij.util.ui;
import javax.swing.*;
import java.awt.*;
import java.awt.geom.AffineTransform;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.util.TreeMap;
public class GeometryUtil implements SwingConstants {
private static final int myArrowSize = 9;
private static final Shape myArrowPolygon = new Polygon(new int[] {0, myArrowSize, 0, 0}, new int[] {0, myArrowSize /2, myArrowSize, 0}, 4);
public static Point getIntersectionPoint(Line2D aSegment, Rectangle aRectangle) {
if (segmentOutsideRectangle(aRectangle, aSegment)) {
throw new IllegalArgumentException("Segment " + toString(aSegment) + " lies out of rectangle " + aRectangle + " or intersects more than one bound");
}
if (segmentInsideRectangle(aRectangle, aSegment)) {
return null;
}
Line2D[] bounds = new Line2D[4];
bounds[0] = getTopOf(aRectangle);
bounds[1] = getRightOf(aRectangle);
bounds[2] = getBottomOf(aRectangle);
bounds[3] = getLeftOf(aRectangle);
for (int i = 0; i < bounds.length; i++) {
if (bounds[i].intersectsLine(aSegment)) {
return getIntersectionPoint(aSegment, bounds[i]);
}
}
return null;
}
public static Line2D.Double getLeftOf(Rectangle aRectangle) {
return new Line2D.Double(aRectangle.getX(), aRectangle.getY(), aRectangle.getX(), aRectangle.getY() + aRectangle.getHeight());
}
public static Line2D.Double getBottomOf(Rectangle aRectangle) {
return new Line2D.Double(aRectangle.getX(), aRectangle.getY() + aRectangle.getHeight(), aRectangle.getX() + aRectangle.getWidth(), aRectangle.getY() + aRectangle.getHeight());
}
public static Line2D.Double getRightOf(Rectangle aRectangle) {
return new Line2D.Double(aRectangle.getX() + aRectangle.getWidth(), aRectangle.getY(), aRectangle.getX() + aRectangle.getWidth(), aRectangle.getY() + aRectangle.getHeight());
}
public static Line2D.Double getTopOf(Rectangle aRectangle) {
return new Line2D.Double(aRectangle.getX(), aRectangle.getY(), aRectangle.getX() + aRectangle.getWidth(), aRectangle.getY());
}
private static boolean segmentInsideRectangle(Rectangle aRectangle, Line2D aSegment) {
return isWithin(aRectangle, aSegment.getP1()) && isWithin(aRectangle, aSegment.getP2());
}
private static boolean segmentOutsideRectangle(Rectangle aRectangle, Line2D aSegment) {
return (!isWithin(aRectangle, aSegment.getP1())) && (!isWithin(aRectangle, aSegment.getP2()));
}
public static boolean isWithin(Rectangle aRectangle, Point2D aPoint) {
return
(aPoint.getX() > aRectangle.getX()) && (aPoint.getX() < aRectangle.getX() + aRectangle.getBounds().width)
&&
((aPoint.getY() > aRectangle.getY()) && (aPoint.getY() < aRectangle.getY() + aRectangle.getBounds().height));
}
public static Point getIntersectionPoint(Line2D aFirst, Line2D aSecond) {
double firstDeltaX = aFirst.getX2() - aFirst.getX1();
double firstDeltaY = aFirst.getY2() - aFirst.getY1();
double kFirst = firstDeltaY / firstDeltaX;
double bFirst = aFirst.getY1() - kFirst * aFirst.getX1();
double secondDeltaX = aSecond.getX2() - aSecond.getX1();
double secondDeltaY = aSecond.getY2() - aSecond.getY1();
double kSecond = secondDeltaY / secondDeltaX;
double bSecond = aSecond.getY1() - kSecond * aSecond.getX1();
double xIntersection = -100000000;
double yIntersection = -100000000;
double deltaK = (kFirst - kSecond);
if (linesAreAngledAndParallel(kFirst, kSecond)) {
return null;
}
if (Double.isInfinite(deltaK) || (0 == deltaK)) {
if (firstDeltaX == secondDeltaX && 0 == firstDeltaX) {
return null;
}
if (firstDeltaY == secondDeltaY && 0 == firstDeltaY) {
return null;
}
if ((0 == firstDeltaX) && (0 == secondDeltaY)) {
xIntersection = aFirst.getX1();
yIntersection = aSecond.getY1();
}
else if ((0 == secondDeltaX) && (0 == firstDeltaY)) {
xIntersection = aSecond.getX1();
yIntersection = aFirst.getY1();
}
else {
if (0 == firstDeltaX) {
xIntersection = aFirst.getX1();
yIntersection = kSecond * xIntersection + bSecond;
}
else {
xIntersection = aSecond.getX1();
yIntersection = kFirst * xIntersection + bFirst;
}
}
}
else {
xIntersection = (bSecond - bFirst) / deltaK;
yIntersection = kFirst * xIntersection + bFirst;
}
return new Point((int) xIntersection, (int) yIntersection);
}
private static boolean linesAreAngledAndParallel(double aKFirst, double aKSecond) {
return (aKFirst == aKSecond) && (0 != aKFirst);
}
public static String toString(Line2D aLine) {
return aLine.getP1() + ":" + aLine.getP2();
}
public static boolean intersects(Rectangle aRectangle, Line2D aLine) {
if (aLine == null || aRectangle == null) {
return false;
}
return (!segmentOutsideRectangle(aRectangle, aLine)) && (!segmentInsideRectangle(aRectangle, aLine));
}
public static int getPointPositionOnRectangle(Rectangle aRectangle, Point aPoint, int aEpsilon) {
final int ERROR_CODE = Integer.MIN_VALUE;
if (pointOnBound(getTopOf(aRectangle), aPoint, aEpsilon)) {
return TOP;
}
else if (pointOnBound(getBottomOf(aRectangle), aPoint, aEpsilon)) {
return BOTTOM;
}
else if (pointOnBound(getLeftOf(aRectangle), aPoint, aEpsilon)) {
return LEFT;
}
else if (pointOnBound(getRightOf(aRectangle), aPoint, aEpsilon)) {
return RIGHT;
}
else {
return ERROR_CODE;
}
}
private static boolean pointOnBound(Line2D aTop, Point aPoint, int aEpsilon) {
return withinRange(aTop.getX1(), aTop.getX2(), aPoint.getX(), aEpsilon) && withinRange(aTop.getY1(), aTop.getY2(), aPoint.getY(), aEpsilon);
}
private static boolean withinRange(double aLeft, double aRight, double aValue, int aEpsilon) {
return ((aLeft - aEpsilon) <= aValue) && ((aRight + aEpsilon) >= aValue);
}
// public static Point shiftByY(Line2D aLine, Point aPoint, int aPointDeltaY) {
// return new Point((int) (aPoint.getX() + getShiftByY(aLine, aPointDeltaY)), (int) (aPoint.getY() + aPointDeltaY));
// }
//
// public static Point shiftByX(Line2D aLine, Point aPoint, int aPointDeltaX) {
// return new Point((int) (aPoint.getX() + aPointDeltaX), (int) (aPoint.getY() + getShiftByX(aLine, aPointDeltaX)));
// }
public static double getShiftByY(Line2D aLine, double aPointDeltaY) {
return aPointDeltaY * ((aLine.getX2() - aLine.getX1()) / (aLine.getY2() - aLine.getY1()));
}
public static double getShiftByX(Line2D aLine, double aPointDeltaX) {
double width = aLine.getX2() - aLine.getX1();
double height = aLine.getY2() - aLine.getY1();
return aPointDeltaX * (height / width);
}
public static Shape getArrowShape(Line2D line, Point2D intersectionPoint) {
final double deltaY = line.getP2().getY() - line.getP1().getY();
final double length = Math.sqrt(Math.pow(deltaY, 2) + Math.pow(line.getP2().getX() - line.getP1().getX(), 2));
double theta = Math.asin(deltaY / length);
if (line.getP1().getX() > line.getP2().getX()) {
theta = Math.PI - theta;
}
AffineTransform rotate = AffineTransform.getRotateInstance(theta, myArrowSize, myArrowSize / 2);
Shape polygon = rotate.createTransformedShape(myArrowPolygon);
AffineTransform move = AffineTransform.getTranslateInstance(intersectionPoint.getX() - myArrowSize, intersectionPoint.getY() - myArrowSize /2);
polygon = move.createTransformedShape(polygon);
return polygon;
}
private static class OrientedPoint extends Point {
private final int myOrientation;
public OrientedPoint(double x, double y, int aOrientation) {
super((int) x, (int) y);
myOrientation = aOrientation;
}
public int getOrientation() {
return myOrientation;
}
}
public static int getClosestToLineRectangleCorner(Rectangle aRectange, Line2D aSegment) {
Point northWest = new OrientedPoint(aRectange.getX(), aRectange.getY(), NORTH_WEST);
Point northEast = new OrientedPoint(aRectange.getMaxX(), aRectange.getY(), NORTH_EAST);
Point southEast = new OrientedPoint(aRectange.getMaxX(), aRectange.getMaxY(), SOUTH_EAST);
Point southWest = new OrientedPoint(aRectange.getX(), aRectange.getMaxY(), SOUTH_WEST);
TreeMap sorter = new TreeMap();
sorter.put(getDistance(aSegment, northWest), northWest);
sorter.put(getDistance(aSegment, southWest), southWest);
sorter.put(getDistance(aSegment, southEast), southEast);
sorter.put(getDistance(aSegment, northEast), northEast);
return ((OrientedPoint) sorter.get(sorter.firstKey())).getOrientation();
}
private static Double getDistance(Line2D aSegment, Point aPoint) {
double lenght1 = getLineLength(aSegment.getX1(), aSegment.getY1(), aPoint.getX(), aPoint.getY());
double lenght2 = getLineLength(aSegment.getX2(), aSegment.getY2(), aPoint.getX(), aPoint.getY());
return new Double(lenght1 + lenght2);
}
public static double getLineLength(double aX1, double aY1, double aX2, double aY2) {
double deltaX = aX2 - aX1;
double deltaY = aY2 - aY1;
return Math.hypot(deltaX, deltaY);
}
public static double cos(Line2D aLine) {
final double length = getLineLength(aLine.getX1(), aLine.getY1(), aLine.getX2(), aLine.getY2());
if (length == 0) {
throw new IllegalArgumentException(toString(aLine) + " has a zero length");
}
double deltaX = aLine.getX2() - aLine.getX1();
return deltaX / length;
}
public static double sin(Line2D aLine) {
final double length = getLineLength(aLine.getX1(), aLine.getY1(), aLine.getX2(), aLine.getY2());
if (length == 0) {
throw new IllegalArgumentException(toString(aLine) + " has a zero length");
}
double deltaY = aLine.getY2() - aLine.getY1();
return deltaY / length;
}
}