package com.sundablog.clipper;
import java.util.Comparator;
/**
* 点的抽象基类，使用泛型实现，支持不同数值类型的坐标表示
* @param <T> 坐标类型，必须是Number的子类并且实现Comparable接口
*/
public abstract class Point<T extends Number & Comparable<T>> {
/**
* 双精度浮点型点类，继承自Point<Double>
* 用于需要高精度浮点坐标的场景
*/
public static class DoublePoint extends Point<Double> {
/**
* 默认构造函数，创建坐标为(0,0,0)的点
*/
public DoublePoint() {
this( 0, 0 );
}
/**
* 创建指定x,y坐标的点，z坐标默认为0
* @param x x坐标值
* @param y y坐标值
*/
public DoublePoint( double x, double y ) {
this( x, y, 0 );
}
/**
* 创建指定x,y,z坐标的点
* @param x x坐标值
* @param y y坐标值
* @param z z坐标值（默认为高度或权重）
*/
public DoublePoint( double x, double y, double z ) {
super( x, y, z );
}
/**
* 拷贝构造函数，创建另一个点的副本
* @param other 要复制的点对象
*/
public DoublePoint( DoublePoint other ) {
super( other );
}
/**
* 获取x坐标值
* @return x坐标的double值
*/
public double getX() {
return x;
}
/**
* 获取y坐标值
* @return y坐标的double值
*/
public double getY() {
return y;
}
/**
* 获取z坐标值
* @return z坐标的double值
*/
public double getZ() {
return z;
}
}
/**
* 长整型点类，继承自Point<Long>
* 用于需要精确整数坐标的场景，避免浮点数精度问题
*/
public static class LongPoint extends Point<Long> {
/**
* 计算两点之间的斜率倒数(deltaX/deltaY)
* @param pt1 第一个点
* @param pt2 第二个点
* @return 斜率倒数，如果是水平线则返回Edge.HORIZONTAL
*/
public static double getDeltaX(LongPoint pt1, LongPoint pt2 ) {
if (pt1.getY() == pt2.getY()) {
return Edge.HORIZONTAL;
}
else {
return (double) (pt2.getX() - pt1.getX()) / (pt2.getY() - pt1.getY());
}
}
/**
* 默认构造函数，创建坐标为(0,0,0)的点
*/
public LongPoint() {
this( 0, 0 );
}
/**
* 创建指定x,y坐标的点，z坐标默认为0
* @param x x坐标值
* @param y y坐标值
*/
public LongPoint( long x, long y ) {
this( x, y, 0 );
}
/**
* 创建指定x,y,z坐标的点
* @param x x坐标值
* @param y y坐标值
* @param z z坐标值（默认为高度或权重）
*/
public LongPoint( long x, long y, long z ) {
super( x, y, z );
}
/**
* 拷贝构造函数，创建另一个点的副本
* @param other 要复制的点对象
*/
public LongPoint( LongPoint other ) {
super( other );
}
/**
* 获取x坐标值
* @return x坐标的long值
*/
public long getX() {
return x;
}
/**
* 获取y坐标值
* @return y坐标的long值
*/
public long getY() {
return y;
}
/**
* 获取z坐标值
* @return z坐标的long值
*/
public long getZ() {
return z;
}
}
/**
* 数值比较器，用于比较泛型数值类型
*/
private static class NumberComparator<T extends Number & Comparable<T>> implements Comparator<T> {
/**
* 比较两个数值对象
* @param a 第一个数值对象
* @param b 第二个数值对象
* @return 比较结果，如果a小于b返回负数，等于返回0，大于返回正数
*/
@Override
public int compare( T a, T b ) throws ClassCastException {
return a.compareTo( b );
}
}
/**
* 判断两个点是否在指定距离平方内
* @param pt1 第一个点
* @param pt2 第二个点
* @param distSqrd 距离平方阈值
* @return 如果两点距离小于等于阈值返回true
*/
static boolean arePointsClose(Point<? extends Number> pt1, Point<? extends Number> pt2, double distSqrd ) {
final double dx = pt1.x.doubleValue() - pt2.x.doubleValue();
final double dy = pt1.y.doubleValue() - pt2.y.doubleValue();
return dx * dx + dy * dy <= distSqrd;
}
/**
* 计算点到直线的垂直距离平方
* @param pt 要计算距离的点
* @param ln1 直线上的第一个点
* @param ln2 直线上的第二个点
* @return 点到直线的距离平方
*/
static double distanceFromLineSqrd(Point<? extends Number> pt, Point<? extends Number> ln1, Point<? extends Number> ln2 ) {
//The equation of a line in general form (Ax + By + C = 0)
//given 2 points (x¹,y¹) & (x²,y²) is ...
//(y¹ - y²)x + (x² - x¹)y + (y² - y¹)x¹ - (x² - x¹)y¹ = 0
//A = (y¹ - y²); B = (x² - x¹); C = (y² - y¹)x¹ - (x² - x¹)y¹
//perpendicular distance of point (x³,y³) = (Ax³ + By³ + C)/Sqrt(A² + B²)
//see http://en.wikipedia.org/wiki/Perpendicular_distance
final double A = ln1.y.doubleValue() - ln2.y.doubleValue();
final double B = ln2.x.doubleValue() - ln1.x.doubleValue();
double C = A * ln1.x.doubleValue() + B * ln1.y.doubleValue();
C = A * pt.x.doubleValue() + B * pt.y.doubleValue() - C;
return C * C / (A * A + B * B);
}
/**
* 获取两点向量的单位法向量
* @param pt1 向量起点
* @param pt2 向量终点
* @return 单位法向量，方向为逆时针旋转90度
*/
static DoublePoint getUnitNormal( LongPoint pt1, LongPoint pt2 ) {
double dx = pt2.x - pt1.x;
double dy = pt2.y - pt1.y;
if (dx == 0 && dy == 0) { // 处理零向量情况
return new DoublePoint();
}
final double f = 1 * 1.0 / Math.sqrt( dx * dx + dy * dy ); // 计算单位向量缩放因子
dx *= f;
dy *= f;
return new DoublePoint( dy, -dx ); // 逆时针旋转90度得到法向量
}
/**
* 判断点pt2是否在点pt1和pt3之间（直线上）
* @param pt1 第一个点
* @param pt2 要检查的中间点
* @param pt3 第三个点
* @return 如果pt2在pt1和pt3之间返回true
*/
protected static boolean isPt2BetweenPt1AndPt3( LongPoint pt1, LongPoint pt2, LongPoint pt3 ) {
if (pt1.equals( pt3 ) || pt1.equals( pt2 ) || pt3.equals( pt2 )) { // 排除相同点的情况
return false;
}
else if (pt1.x != pt3.x) { // 在x轴上检查
return pt2.x > pt1.x == pt2.x < pt3.x; // pt2的x坐标在pt1和pt3之间
}
else { // 在y轴上检查
return pt2.y > pt1.y == pt2.y < pt3.y; // pt2的y坐标在pt1和pt3之间
}
}
/**
* 判断三个点是否共线（斜率相同）
* @param pt1 第一个点
* @param pt2 第二个点（公共点）
* @param pt3 第三个点
* @return 如果三点共线返回true
*/
protected static boolean slopesEqual( LongPoint pt1, LongPoint pt2, LongPoint pt3 ) {
return (pt1.y - pt2.y) * (pt2.x - pt3.x) - (pt1.x - pt2.x) * (pt2.y - pt3.y) == 0;
}
/**
* 判断两条线段是否平行（斜率相同）
* @param pt1 第一条线段的第一个点
* @param pt2 第一条线段的第二个点
* @param pt3 第二条线段的第一个点
* @param pt4 第二条线段的第二个点
* @return 如果两线段平行返回true
*/
protected static boolean slopesEqual( LongPoint pt1, LongPoint pt2, LongPoint pt3, LongPoint pt4 ) {
return (pt1.y - pt2.y) * (pt3.x - pt4.x) - (pt1.x - pt2.x) * (pt3.y - pt4.y) == 0;
}
/**
* 判断三个点是否近似共线（允许一定距离误差）
* @param pt1 第一个点
* @param pt2 第二个点
* @param pt3 第三个点
* @param distSqrd 距离平方阈值
* @return 如果三点近似共线返回true
*/
static boolean slopesNearCollinear( LongPoint pt1, LongPoint pt2, LongPoint pt3, double distSqrd ) {
//this function is more accurate when the point that's GEOMETRICALLY
//between the other 2 points is the one that's tested for distance.
//nb: with 'spikes', either pt1 or pt3 is geometrically between the other pts
if (Math.abs( pt1.x - pt2.x ) > Math.abs( pt1.y - pt2.y )) { // 水平方向变化更大
if (pt1.x > pt2.x == pt1.x < pt3.x) { // pt1在中间
return distanceFromLineSqrd( pt1, pt2, pt3 ) < distSqrd;
}
else if (pt2.x > pt1.x == pt2.x < pt3.x) { // pt2在中间
return distanceFromLineSqrd( pt2, pt1, pt3 ) < distSqrd;
}
else { // pt3在中间
return distanceFromLineSqrd( pt3, pt1, pt2 ) < distSqrd;
}
}
else { // 垂直方向变化更大
if (pt1.y > pt2.y == pt1.y < pt3.y) { // pt1在中间
return distanceFromLineSqrd( pt1, pt2, pt3 ) < distSqrd;
}
else if (pt2.y > pt1.y == pt2.y < pt3.y) { // pt2在中间
return distanceFromLineSqrd( pt2, pt1, pt3 ) < distSqrd;
}
else { // pt3在中间
return distanceFromLineSqrd( pt3, pt1, pt2 ) < distSqrd;
}
}
}
/**
* 数值比较器的静态实例
*/
private final static NumberComparator NUMBER_COMPARATOR = new NumberComparator();
/**
* x坐标值
*/
protected T x;
/**
* y坐标值
*/
protected T y;
/**
* z坐标值（通常用于高度或权重）
*/
protected T z;
/**
* 拷贝构造函数
* @param pt 要复制的点对象
*/
protected Point( Point<T> pt ) {
this( pt.x, pt.y, pt.z );
}
/**
* 构造函数，指定x,y,z坐标值
* @param x x坐标值
* @param y y坐标值
* @param z z坐标值
*/
protected Point( T x, T y, T z ) {
this.x = x;
this.y = y;
this.z = z;
}
/**
* 比较两个点是否相等（仅比较x和y坐标）
* @param obj 要比较的对象
* @return 如果是相同点返回true
*/
@Override
public boolean equals( Object obj ) {
if (obj == null) {
return false;
}
if (obj instanceof Point<?>) {
final Point<?> a = (Point<?>) obj;
return NUMBER_COMPARATOR.compare( x, a.x ) == 0 && NUMBER_COMPARATOR.compare( y, a.y ) == 0;
}
else {
return false;
}
}
/**
* 设置当前点的坐标为另一个点的坐标
* @param other 要复制的点对象
*/
public void set( Point<T> other ) {
x = other.x;
y = other.y;
z = other.z;
}
/**
* 设置x坐标
* @param x 新的x坐标值
*/
public void setX( T x ) {
this.x = x;
}
/**
* 设置y坐标
* @param y 新的y坐标值
*/
public void setY( T y ) {
this.y = y;
}
/**
* 设置z坐标
* @param z 新的z坐标值
*/
public void setZ( T z ) {
this.z = z;
}
/**
* 返回点的字符串表示
* @return 包含x,y,z坐标的字符串
*/
@Override
public String toString() {
return "Point [x=" + x + ", y=" + y + ", z=" + z + "]";
}
}// end struct IntPoint
最后修改：2025 年 12 月 03 日
© 允许规范转载