1626 lines
42 KiB
TypeScript
1626 lines
42 KiB
TypeScript
export class Vector2d
|
||
{
|
||
m_X = 0
|
||
m_Y = 0
|
||
|
||
/** 长度 */
|
||
Length = 0
|
||
/** 角度 */
|
||
Angle = 0
|
||
|
||
constructor(x: number, y: number)
|
||
{
|
||
this.m_X = x
|
||
this.m_Y = y
|
||
|
||
this.GetLength()
|
||
this.GetAngle()
|
||
}
|
||
|
||
private GetLength()
|
||
{
|
||
this.Length = Math.sqrt(this.m_X * this.m_X + this.m_Y * this.m_Y)
|
||
}
|
||
|
||
// 角度
|
||
private GetAngle()
|
||
{
|
||
let a = Math.atan2(this.m_Y, this.m_X)
|
||
if (a < 0)
|
||
a = Math.PI * 2 + a
|
||
this.Angle = a
|
||
}
|
||
|
||
Normal(): Vector2d
|
||
{
|
||
if (this.Length != 0)
|
||
{
|
||
let k = 1 / this.Length
|
||
this.m_X *= k
|
||
this.m_Y *= k
|
||
this.Length = 1
|
||
}
|
||
return this
|
||
}
|
||
|
||
static OpDivide(v: Vector2d, c: number): Vector2d
|
||
{
|
||
return new Vector2d(v.m_X / c, v.m_Y / c)
|
||
}
|
||
|
||
static OpMultiply(v: Vector2d, c: number): Vector2d
|
||
{
|
||
return new Vector2d(v.m_X * c, v.m_Y * c)
|
||
}
|
||
|
||
static OpAdd(v1: Vector2d, v2: Vector2d): Vector2d
|
||
{
|
||
return new Vector2d(v1.m_X + v2.m_X, v1.m_Y + v2.m_Y)
|
||
}
|
||
|
||
static OpMultiplyValue(v1: Vector2d, v2: Vector2d): number
|
||
{
|
||
return v1.m_X * v2.m_X + v1.m_Y * v2.m_Y
|
||
}
|
||
|
||
/** 点积 */
|
||
DotProduct(v1: Vector2d): number
|
||
{
|
||
return Vector2d.OpMultiplyValue(this, v1)
|
||
}
|
||
|
||
/** 叉积 */
|
||
CrossProduct(v: Vector2d): number
|
||
{
|
||
return this.m_X * v.m_Y - this.m_Y * v.m_X
|
||
}
|
||
|
||
IsEqual(v: Vector2d, fuzz = 1e-3): boolean
|
||
{
|
||
return DoubleUtil.EqualX(this.m_X, v.m_X, fuzz) && DoubleUtil.EqualX(this.m_Y, v.m_Y, fuzz)
|
||
}
|
||
|
||
/** 返回和另外一个向量的夹角 */
|
||
AngleTo(v: Vector2d): number
|
||
{
|
||
let an = Math.abs(this.Angle - v.Angle)
|
||
if (DoubleUtil.EqualX(v.Length, 0, 1e-5) || DoubleUtil.EqualX(this.Length, 0, 1e-5))
|
||
{
|
||
return -Math.PI// 随缘给
|
||
}
|
||
else if (Math.abs(Math.sin(an)) < 0)
|
||
{
|
||
return this.Normal().IsEqual(v.Normal()) ? 0 : Math.PI
|
||
}
|
||
else
|
||
{
|
||
let p0 = new Point2d(0, 0)
|
||
let p1 = Point2d.OpAdd(new Point2d(0, 0), this)
|
||
let p2 = Point2d.OpAdd(new Point2d(0, 0), v)
|
||
let s = this.sign(Utils.Det(p1, p0, p2))
|
||
if (an > Math.PI)
|
||
{
|
||
return ((2 * Math.PI) - an) * s
|
||
}
|
||
else
|
||
{
|
||
return an * s
|
||
}
|
||
}
|
||
}
|
||
|
||
private sign(x: number): number
|
||
{
|
||
if (x == 0)
|
||
{
|
||
return 0
|
||
}
|
||
else if (x > 0)
|
||
{
|
||
return -1
|
||
}
|
||
else
|
||
{
|
||
return 1
|
||
}
|
||
}
|
||
}
|
||
|
||
/** CAD 点 */
|
||
export class Point2d
|
||
{
|
||
m_X = 0
|
||
m_Y = 0
|
||
|
||
constructor(x: number, y: number)
|
||
{
|
||
this.m_X = x
|
||
this.m_Y = y
|
||
}
|
||
|
||
DistensTo(pt: Point2d): number
|
||
{
|
||
return Point2d.OpSubtract(pt, this).Length
|
||
}
|
||
|
||
Polar(angle: number, distens: number): Point2d
|
||
{
|
||
let x1 = this.m_X + Math.cos(angle) * distens
|
||
let y1 = this.m_Y + Math.sin(angle) * distens
|
||
return new Point2d(x1, y1)
|
||
}
|
||
|
||
Mid(pt: Point2d): Point2d
|
||
{
|
||
return new Point2d((this.m_X + pt.m_X) * 0.5, (this.m_Y + pt.m_Y) * 0.5)
|
||
}
|
||
|
||
AsVector(): Vector2d
|
||
{
|
||
return new Vector2d(this.m_X, this.m_Y)
|
||
}
|
||
|
||
/** 减以 - */
|
||
static OpSubtract(p1: Point2d, p2: Point2d): Vector2d
|
||
{
|
||
return new Vector2d(p1.m_X - p2.m_X, p1.m_Y - p2.m_Y)
|
||
}
|
||
|
||
static OpAdd(p1: Point2d, p2: Vector2d): Point2d
|
||
{
|
||
return new Point2d(p1.m_X + p2.m_X, p1.m_Y + p2.m_Y)
|
||
}
|
||
}
|
||
|
||
function equaln(v1: number, v2: number, fuzz = 1e-5)
|
||
{
|
||
return Math.abs(v1 - v2) <= fuzz
|
||
}
|
||
function equalp(v1: Point2d, v2: Point2d, fuzz = 1e-5)
|
||
{
|
||
return equaln(v1.m_X, v2.m_X, fuzz) && equaln(v1.m_Y, v2.m_Y, fuzz)
|
||
}
|
||
|
||
/** 二维曲线:直线,圆弧 */
|
||
export abstract class Curve2d
|
||
{
|
||
// 求交点
|
||
abstract IntersectWith(cu: Curve2d, retIns: Point2d[]): void
|
||
abstract Offset(distens: number): Curve2d
|
||
|
||
// 点在线内部
|
||
abstract PtInCurve(pt: Point2d): boolean
|
||
abstract ClosePointTo(pt: Point2d): Point2d
|
||
|
||
// 获得参数 返回0或1
|
||
abstract GetParametersAt(pt: Point2d): number
|
||
|
||
abstract Parse()
|
||
|
||
PtOnCurve(p: Point2d): boolean
|
||
{
|
||
return equalp(p, this.m_StartPoint) || equalp(p, this.m_EndPoint) || this.ParamOnCurve(this.GetParametersAt(p))
|
||
}
|
||
|
||
ParamOnCurve(param: number, fuzz = 1e-6): boolean { return !Number.isNaN(param) && param >= -fuzz && param <= 1 + fuzz }
|
||
|
||
get EndPoint(): Point2d
|
||
{
|
||
return this.m_EndPoint
|
||
}
|
||
|
||
set EndPoint(p: Point2d)
|
||
{
|
||
this.m_EndPoint = p
|
||
try
|
||
{
|
||
this.Parse()
|
||
} catch (error)
|
||
{
|
||
|
||
}
|
||
}
|
||
|
||
get StartPoint(): Point2d
|
||
{
|
||
return this.m_StartPoint
|
||
}
|
||
|
||
set StartPoint(p: Point2d)
|
||
{
|
||
this.m_StartPoint = p
|
||
try
|
||
{
|
||
this.Parse()
|
||
} catch (error)
|
||
{
|
||
|
||
}
|
||
}
|
||
|
||
protected m_StartPoint: Point2d
|
||
protected m_EndPoint: Point2d
|
||
tagData: number // 特殊数据 异形边 封边值
|
||
tagData2: number // 特殊数据 侧孔数
|
||
}
|
||
|
||
/** 直线 */
|
||
export class Line2d extends Curve2d
|
||
{
|
||
get toString()
|
||
{
|
||
return `[${this.m_StartPoint.m_X.toFixed(1)},${this.m_StartPoint.m_Y.toFixed(1)}] [${this.m_EndPoint.m_X.toFixed(1)},${this.m_EndPoint.m_Y.toFixed(1)}]`
|
||
}
|
||
|
||
constructor(p1: Point2d, p2: Point2d)
|
||
{
|
||
super()
|
||
this.m_StartPoint = p1
|
||
this.m_EndPoint = p2
|
||
this.Parse()
|
||
}
|
||
|
||
/** 求交点 */
|
||
IntersectWith(cu: Curve2d, retIns: Point2d[])
|
||
{
|
||
if (cu instanceof Line2d)
|
||
{
|
||
let l = cu as Line2d
|
||
let dx1 = this.StartPoint.m_X - this.EndPoint.m_X
|
||
let dx2 = l.StartPt.m_X - l.EndPt.m_X
|
||
let dx3 = l.EndPt.m_X - this.EndPoint.m_X
|
||
let dy1 = this.StartPoint.m_Y - this.EndPoint.m_Y
|
||
let dy2 = l.StartPt.m_Y - l.EndPt.m_Y
|
||
let dy3 = l.EndPt.m_Y - this.EndPoint.m_Y
|
||
|
||
let det = (dx2 * dy1) - (dy2 * dx1)
|
||
let pt = new Point2d(0, 0)
|
||
|
||
if (DoubleUtil.EqualX(det, 0.0, 1e-5))
|
||
{
|
||
if (DoubleUtil.EqualX(dx2 * dy3, dy2 * dx3, 1e-5))
|
||
{
|
||
if (l.StartPoint.DistensTo(this.EndPoint) < 1e-3)
|
||
{
|
||
retIns.push(this.EndPoint)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
let ratio = ((dx1 * dy3) - (dy1 * dx3)) / det
|
||
pt.m_X = (ratio * dx2) + l.EndPt.m_X
|
||
pt.m_Y = (ratio * dy2) + l.EndPt.m_Y
|
||
retIns.push(pt)
|
||
}
|
||
else
|
||
{
|
||
let arc = cu as Arc2d
|
||
arc.IntersectWith(this, retIns)
|
||
}
|
||
}
|
||
|
||
/** 偏移 */
|
||
Offset(distens: number): Curve2d
|
||
{
|
||
let an = Point2d.OpSubtract(this.EndPt, this.StartPt).Angle - Math.PI * 0.5
|
||
return new Line2d(this.StartPt.Polar(an, distens), this.EndPt.Polar(an, distens))
|
||
}
|
||
|
||
/** 判断点在线内 */
|
||
PtInCurve(pt: Point2d): boolean
|
||
{
|
||
// 首先判断平行
|
||
let minX = Math.min(this.m_StartPoint.m_X, this.m_EndPoint.m_X)
|
||
let maxX = Math.max(this.m_StartPoint.m_X, this.m_EndPoint.m_X)
|
||
|
||
if (DoubleUtil.EqualX(minX, maxX, 1e-3))
|
||
{
|
||
let minY = Math.min(this.m_StartPoint.m_Y, this.m_EndPoint.m_Y)
|
||
let maxY = Math.max(this.m_StartPoint.m_Y, this.m_EndPoint.m_Y)
|
||
return (pt.m_Y >= minY - 1e-4 && pt.m_Y <= maxY + 1e-4)
|
||
}
|
||
|
||
if (pt.m_X >= minX - 0.0001 && pt.m_X <= maxX + 0.0001)
|
||
{
|
||
let vec = Point2d.OpSubtract(this.m_EndPoint, this.m_StartPoint)// 标准向量
|
||
let k = vec.m_Y / vec.m_X
|
||
return DoubleUtil.EqualX(this.m_StartPoint.m_Y + k * (pt.m_X - this.m_StartPoint.m_X), pt.m_Y, 0.01)
|
||
}
|
||
else
|
||
{
|
||
return false
|
||
}
|
||
}
|
||
|
||
ClosePointTo(pt: Point2d): Point2d
|
||
{
|
||
let an = Point2d.OpSubtract(this.m_EndPoint, this.m_StartPoint).Angle + Math.PI / 2
|
||
let vec = new Point2d(0, 0).Polar(an, 1).AsVector()
|
||
let p2 = Point2d.OpAdd(pt, vec)
|
||
let line = new Line2d(pt, p2)
|
||
let ptLst: Point2d[] = []
|
||
this.IntersectWith(line, ptLst)
|
||
return ptLst[0]
|
||
}
|
||
|
||
Parse()
|
||
{
|
||
if (this.EndPoint != null)
|
||
{
|
||
this.m_Length = this.StartPoint.DistensTo(this.EndPoint)
|
||
}
|
||
}
|
||
|
||
GetParametersAt(pt: Point2d): number
|
||
{
|
||
let nearPt = this.ClosePointTo(pt)
|
||
|
||
let vec = Point2d.OpSubtract(nearPt, this.m_StartPoint)
|
||
let vec2 = Point2d.OpSubtract(this.EndPoint, this.StartPoint)
|
||
|
||
let an = vec.DotProduct(vec2)
|
||
|
||
return Math.sign(an) * vec.Length / this.m_Length
|
||
}
|
||
|
||
get StartPt(): Point2d { return this.StartPoint }
|
||
get EndPt(): Point2d { return this.EndPoint }
|
||
|
||
m_Length: number
|
||
|
||
static New(x0: number, y0: number, x1: number, y1: number): Line2d
|
||
{
|
||
let p0 = new Point2d(x0, y0)
|
||
let p1 = new Point2d(x1, y1)
|
||
return new Line2d(p0, p1)
|
||
}
|
||
}
|
||
|
||
/** 圆弧 */
|
||
export class Arc2d extends Curve2d
|
||
{
|
||
constructor(p1: Point2d, p2: Point2d, bul: number)
|
||
{
|
||
super()
|
||
this.m_StartPoint = p1
|
||
this.m_EndPoint = p2
|
||
|
||
this.m_Bul = bul
|
||
let vec = Point2d.OpSubtract(p2, p1)
|
||
let an = vec.Angle
|
||
let length = vec.Length
|
||
|
||
this.m_Radius = length / Math.sin(2 * Math.atan(bul)) / 2
|
||
this.m_AllAngle = Math.atan(bul) * 4
|
||
let delDis = bul * length / 2
|
||
|
||
let toDis = this.m_Radius - delDis
|
||
|
||
an += Math.PI * 0.5
|
||
|
||
this.m_Center = p1.Mid(p2)
|
||
this.m_Center = this.m_Center.Polar(an, toDis)
|
||
|
||
this.m_StartAngle = Point2d.OpSubtract(this.StartPoint, this.m_Center).Angle
|
||
this.m_EndAngle = Point2d.OpSubtract(this.EndPoint, this.m_Center).Angle
|
||
|
||
if (this.m_Bul < 0)
|
||
this.m_Radius = Math.abs(this.m_Radius)
|
||
}
|
||
|
||
/** 圆心 */
|
||
m_Center: Point2d
|
||
/** 半径 */
|
||
m_Radius: number
|
||
/** 起始弧度 */
|
||
m_StartAngle: number
|
||
/** 结束弧度 */
|
||
m_EndAngle: number
|
||
/** 所有的弧度 */
|
||
m_AllAngle: number
|
||
|
||
IntersectWith(cu: Curve2d, retIns: Point2d[])
|
||
{
|
||
if (cu instanceof Line2d)
|
||
{
|
||
let l = cu as Line2d
|
||
let a = DoubleUtil.Sqr(l.EndPt.m_X - l.StartPt.m_X) + DoubleUtil.Sqr(l.EndPt.m_Y - l.StartPt.m_Y)
|
||
|
||
let b = (2.0) * ((l.EndPt.m_X - l.StartPt.m_X) * (l.StartPt.m_X - this.m_Center.m_X)
|
||
+ (l.EndPt.m_Y - l.StartPt.m_Y) * (l.StartPt.m_Y - this.m_Center.m_Y))
|
||
|
||
let c = DoubleUtil.Sqr(this.m_Center.m_X) + DoubleUtil.Sqr(this.m_Center.m_Y)
|
||
+ DoubleUtil.Sqr(l.StartPt.m_X) + DoubleUtil.Sqr(l.StartPt.m_Y)
|
||
- (2.0) * (this.m_Center.m_X * l.StartPt.m_X + this.m_Center.m_Y * l.StartPt.m_Y) - DoubleUtil.Sqr(this.m_Radius)
|
||
|
||
let det = b * b - (4.0) * a * c
|
||
|
||
if (DoubleUtil.EqualX(det, 0.0, 0.1))
|
||
{
|
||
let delta = -b / ((2.0) * a)
|
||
|
||
let pt = new Point2d(l.StartPt.m_X + delta * (l.EndPt.m_X - l.StartPt.m_X), l.StartPt.m_Y + delta * (l.EndPt.m_Y - l.StartPt.m_Y))
|
||
retIns.push(pt)
|
||
return
|
||
}
|
||
else if (det > (0.0))
|
||
{
|
||
let sqrt_det = Math.sqrt(det)
|
||
let delta = (-b + sqrt_det) / ((2.0) * a)
|
||
let p2 = new Point2d(l.StartPt.m_X + delta * (l.EndPt.m_X - l.StartPt.m_X), l.StartPt.m_Y + delta * (l.EndPt.m_Y - l.StartPt.m_Y))
|
||
|
||
delta = (-b - sqrt_det) / ((2.0) * a)
|
||
let p3 = new Point2d(l.StartPt.m_X + delta * (l.EndPt.m_X - l.StartPt.m_X), l.StartPt.m_Y + delta * (l.EndPt.m_Y - l.StartPt.m_Y))
|
||
|
||
retIns.push(p2)
|
||
retIns.push(p3)
|
||
return
|
||
}
|
||
}
|
||
else if (cu instanceof Arc2d)
|
||
{
|
||
let arc = cu as (Arc2d)
|
||
let dist = arc.m_Center.DistensTo(this.m_Center)
|
||
|
||
if (dist < Math.abs(this.m_Radius - cu.m_Radius) - 1e-3
|
||
|| dist > (this.m_Radius + cu.m_Radius + 1e-3))
|
||
return
|
||
|
||
let dstsqr = dist * dist
|
||
let r1sqr = this.m_Radius * this.m_Radius
|
||
let r2sqr = arc.m_Radius * arc.m_Radius
|
||
|
||
let a = (dstsqr - r2sqr + r1sqr) / (2 * dist)
|
||
let h = Math.sqrt(Math.abs(r1sqr - (a * a)))
|
||
|
||
let ratio_a = a / dist
|
||
let ratio_h = h / dist
|
||
|
||
let dx = arc.m_Center.m_X - this.m_Center.m_X
|
||
let dy = arc.m_Center.m_Y - this.m_Center.m_Y
|
||
|
||
let phix = this.m_Center.m_X + (ratio_a * dx)
|
||
let phiy = this.m_Center.m_Y + (ratio_a * dy)
|
||
|
||
dx = dx * ratio_h
|
||
dy = dy * ratio_h
|
||
|
||
let pt = new Point2d(phix + dy, phiy - dx)
|
||
let p2 = new Point2d(phix - dy, phiy + dx)
|
||
retIns.push(pt)
|
||
retIns.push(p2)
|
||
}
|
||
}
|
||
|
||
Offset(distens: number): Curve2d
|
||
{
|
||
let rn = new Arc2d(new Point2d(0, 0), new Point2d(0, 0), 0)
|
||
rn.m_Center = this.m_Center
|
||
rn.m_Radius = this.m_Radius
|
||
rn.m_StartAngle = this.m_StartAngle
|
||
rn.m_EndAngle = this.m_EndAngle
|
||
if (this.m_Bul > 0)
|
||
rn.m_Radius += distens
|
||
else
|
||
rn.m_Radius -= distens
|
||
rn.Bul = this.m_Bul
|
||
rn.ParsePointFormAngle()
|
||
return rn
|
||
}
|
||
|
||
Parse()
|
||
{
|
||
// 解析角度
|
||
this.ParseAngleFormPoint()
|
||
this.ParseAllAngle()
|
||
this.ParseBul()
|
||
}
|
||
|
||
ParseAllAngle()
|
||
{
|
||
this.m_AllAngle = this.ComputeAnlge(this.m_EndAngle)
|
||
}
|
||
|
||
ComputeAnlge(endAngle: number)
|
||
{
|
||
// 顺时针
|
||
if (this.m_Bul < 0)
|
||
{
|
||
if (this.m_StartAngle > endAngle)
|
||
return this.m_StartAngle - endAngle
|
||
else // 越过0点绘制圆弧
|
||
return (Math.PI * 2) - (endAngle - this.m_StartAngle)
|
||
}
|
||
else
|
||
{
|
||
if (endAngle > this.m_StartAngle)
|
||
return endAngle - this.m_StartAngle
|
||
else
|
||
return (Math.PI * 2) - (this.m_StartAngle - endAngle)
|
||
}
|
||
}
|
||
|
||
ParseBul()
|
||
{
|
||
this.m_Bul = Math.tan(this.m_AllAngle * 0.25) * (this.m_Bul < 0 ? -1 : 1)
|
||
}
|
||
|
||
ParsePointFormAngle()
|
||
{
|
||
this.m_StartPoint = this.m_Center.Polar(this.m_StartAngle, this.m_Radius)
|
||
this.m_EndPoint = this.m_Center.Polar(this.m_EndAngle, this.m_Radius)
|
||
}
|
||
|
||
ParseAngleFormPoint()
|
||
{
|
||
this.m_StartAngle = Point2d.OpSubtract(this.StartPoint, this.m_Center).Angle
|
||
this.m_EndAngle = Point2d.OpSubtract(this.EndPoint, this.m_Center).Angle
|
||
}
|
||
|
||
PtInCurve(pt: Point2d): boolean
|
||
{
|
||
let param = this.GetParametersAt(pt)
|
||
return param > -1e-3 && param < 1.0001
|
||
}
|
||
|
||
ClosePointTo(pt: Point2d): Point2d
|
||
{
|
||
return null
|
||
}
|
||
|
||
GetParametersAt(pt: Point2d): number
|
||
{
|
||
let vec = Point2d.OpSubtract(pt, this.m_Center)
|
||
let an = vec.Angle
|
||
this.ParseAllAngle()
|
||
|
||
// 如果以pt为终点,那么所有的角度为
|
||
let ptAllAn = this.ComputeAnlge(an)
|
||
let allAn = this.m_AllAngle
|
||
|
||
// 减去圆弧角度,剩余角度的一半
|
||
let surplusAngleHalf = Math.PI - allAn / 2
|
||
|
||
if (ptAllAn > allAn + surplusAngleHalf)// 返回负数
|
||
return ((ptAllAn - allAn) - (surplusAngleHalf * 2)) / allAn
|
||
else// 返回正数
|
||
return ptAllAn / allAn
|
||
}
|
||
|
||
GetAngleAtParam(param: number)
|
||
{
|
||
return this.clampRad(this.m_StartAngle + param * this.m_AllAngle)
|
||
}
|
||
|
||
private clampRad(an: number)
|
||
{
|
||
an = an % (Math.PI * 2)
|
||
if (an < 0)
|
||
an += Math.PI * 2
|
||
return an
|
||
}
|
||
|
||
/** 凸度. */
|
||
m_Bul: number
|
||
get Bul() { return this.m_Bul }
|
||
set Bul(v: number) { this.m_Bul = v }
|
||
|
||
static New(x0: number, y0: number, x1: number, y1: number, bul: number): Arc2d
|
||
{
|
||
return new Arc2d(new Point2d(x0, y0), new Point2d(x1, y1), bul)
|
||
}
|
||
}
|
||
/** 圆弧 */
|
||
export class Arc2d_new extends Curve2d
|
||
{
|
||
constructor(p1: Point2d, p2: Point2d, bul: number)
|
||
{
|
||
super()
|
||
this.m_StartPoint = p1
|
||
this.m_EndPoint = p2
|
||
|
||
this.m_Bul = bul
|
||
let vec = Point2d.OpSubtract(p2, p1)
|
||
let an = vec.Angle
|
||
let length = vec.Length
|
||
|
||
this.m_Radius = length / Math.sin(2 * Math.atan(bul)) / 2
|
||
this.m_AllAngle = Math.atan(bul) * 4
|
||
let delDis = bul * length / 2
|
||
|
||
let toDis = this.m_Radius - delDis
|
||
|
||
an += Math.PI * 0.5
|
||
|
||
this.m_Center = p1.Mid(p2)
|
||
this.m_Center = this.m_Center.Polar(an, toDis)
|
||
|
||
this.m_StartAngle = Point2d.OpSubtract(this.StartPoint, this.m_Center).Angle
|
||
this.m_EndAngle = Point2d.OpSubtract(this.EndPoint, this.m_Center).Angle
|
||
|
||
if (this.m_Bul < 0)
|
||
this.m_Radius = Math.abs(this.m_Radius)
|
||
}
|
||
|
||
/** 圆心 */
|
||
m_Center: Point2d
|
||
/** 半径 */
|
||
m_Radius: number
|
||
/** 起始弧度 */
|
||
m_StartAngle: number
|
||
/** 结束弧度 */
|
||
m_EndAngle: number
|
||
/** 所有的弧度 */
|
||
m_AllAngle: number
|
||
|
||
IntersectWith(cu: Curve2d, retIns: Point2d[])
|
||
{
|
||
if (cu instanceof Line2d)
|
||
{
|
||
let l = cu as Line2d
|
||
let a = DoubleUtil.Sqr(l.EndPt.m_X - l.StartPt.m_X) + DoubleUtil.Sqr(l.EndPt.m_Y - l.StartPt.m_Y)
|
||
|
||
let b = (2.0) * ((l.EndPt.m_X - l.StartPt.m_X) * (l.StartPt.m_X - this.m_Center.m_X)
|
||
+ (l.EndPt.m_Y - l.StartPt.m_Y) * (l.StartPt.m_Y - this.m_Center.m_Y))
|
||
|
||
let c = DoubleUtil.Sqr(this.m_Center.m_X) + DoubleUtil.Sqr(this.m_Center.m_Y)
|
||
+ DoubleUtil.Sqr(l.StartPt.m_X) + DoubleUtil.Sqr(l.StartPt.m_Y)
|
||
- (2.0) * (this.m_Center.m_X * l.StartPt.m_X + this.m_Center.m_Y * l.StartPt.m_Y) - DoubleUtil.Sqr(this.m_Radius)
|
||
|
||
let det = b * b - (4.0) * a * c
|
||
|
||
if (DoubleUtil.EqualX(det, 0.0, 0.1))
|
||
{
|
||
let delta = -b / ((2.0) * a)
|
||
|
||
let pt = new Point2d(l.StartPt.m_X + delta * (l.EndPt.m_X - l.StartPt.m_X), l.StartPt.m_Y + delta * (l.EndPt.m_Y - l.StartPt.m_Y))
|
||
retIns.push(pt)
|
||
return
|
||
}
|
||
else if (det > (0.0))
|
||
{
|
||
let sqrt_det = Math.sqrt(det)
|
||
let delta = (-b + sqrt_det) / ((2.0) * a)
|
||
let p2 = new Point2d(l.StartPt.m_X + delta * (l.EndPt.m_X - l.StartPt.m_X), l.StartPt.m_Y + delta * (l.EndPt.m_Y - l.StartPt.m_Y))
|
||
|
||
delta = (-b - sqrt_det) / ((2.0) * a)
|
||
let p3 = new Point2d(l.StartPt.m_X + delta * (l.EndPt.m_X - l.StartPt.m_X), l.StartPt.m_Y + delta * (l.EndPt.m_Y - l.StartPt.m_Y))
|
||
|
||
retIns.push(p2)
|
||
retIns.push(p3)
|
||
return
|
||
}
|
||
}
|
||
else if (cu instanceof Arc2d)
|
||
{
|
||
let arc = cu as (Arc2d)
|
||
let dist = arc.m_Center.DistensTo(this.m_Center)
|
||
|
||
if (dist < Math.abs(this.m_Radius - cu.m_Radius) - 1e-3
|
||
|| dist > (this.m_Radius + cu.m_Radius + 1e-3))
|
||
return
|
||
|
||
let dstsqr = dist * dist
|
||
let r1sqr = this.m_Radius * this.m_Radius
|
||
let r2sqr = arc.m_Radius * arc.m_Radius
|
||
|
||
let a = (dstsqr - r2sqr + r1sqr) / (2 * dist)
|
||
let h = Math.sqrt(Math.abs(r1sqr - (a * a)))
|
||
|
||
let ratio_a = a / dist
|
||
let ratio_h = h / dist
|
||
|
||
let dx = arc.m_Center.m_X - this.m_Center.m_X
|
||
let dy = arc.m_Center.m_Y - this.m_Center.m_Y
|
||
|
||
let phix = this.m_Center.m_X + (ratio_a * dx)
|
||
let phiy = this.m_Center.m_Y + (ratio_a * dy)
|
||
|
||
dx = dx * ratio_h
|
||
dy = dy * ratio_h
|
||
|
||
let pt = new Point2d(phix + dy, phiy - dx)
|
||
let p2 = new Point2d(phix - dy, phiy + dx)
|
||
retIns.push(pt)
|
||
retIns.push(p2)
|
||
}
|
||
}
|
||
|
||
Offset(distens: number): Curve2d
|
||
{
|
||
let rn = new Arc2d(new Point2d(0, 0), new Point2d(0, 0), 0)
|
||
rn.m_Center = this.m_Center
|
||
rn.m_Radius = this.m_Radius
|
||
rn.m_StartAngle = this.m_StartAngle
|
||
rn.m_EndAngle = this.m_EndAngle
|
||
if (this.m_Bul > 0)
|
||
rn.m_Radius += distens
|
||
else
|
||
rn.m_Radius -= distens
|
||
rn.Bul = this.m_Bul
|
||
rn.ParsePointFormAngle()
|
||
return rn
|
||
}
|
||
|
||
Parse()
|
||
{
|
||
// 解析角度
|
||
this.ParseAngleFormPoint()
|
||
this.ParseAllAngle()
|
||
this.ParseBul()
|
||
}
|
||
|
||
ParseAllAngle()
|
||
{
|
||
this.m_AllAngle = this.ComputeAnlge(this.m_EndAngle)
|
||
}
|
||
|
||
ComputeAnlge(endAngle: number)
|
||
{
|
||
// 顺时针
|
||
if (this.m_Bul < 0)
|
||
{
|
||
if (this.m_StartAngle > endAngle)
|
||
return this.m_StartAngle - endAngle
|
||
else // 越过0点绘制圆弧
|
||
return (Math.PI * 2) - (endAngle - this.m_StartAngle)
|
||
}
|
||
else
|
||
{
|
||
if (endAngle > this.m_StartAngle)
|
||
return endAngle - this.m_StartAngle
|
||
else
|
||
return (Math.PI * 2) - (this.m_StartAngle - endAngle)
|
||
}
|
||
}
|
||
|
||
ParseBul()
|
||
{
|
||
this.m_Bul = Math.tan(this.m_AllAngle * 0.25) * (this.m_Bul < 0 ? -1 : 1)
|
||
}
|
||
|
||
ParsePointFormAngle()
|
||
{
|
||
this.m_StartPoint = this.m_Center.Polar(this.m_StartAngle, this.m_Radius)
|
||
this.m_EndPoint = this.m_Center.Polar(this.m_EndAngle, this.m_Radius)
|
||
}
|
||
|
||
ParseAngleFormPoint()
|
||
{
|
||
this.m_StartAngle = Point2d.OpSubtract(this.StartPoint, this.m_Center).Angle
|
||
this.m_EndAngle = Point2d.OpSubtract(this.EndPoint, this.m_Center).Angle
|
||
}
|
||
|
||
PtInCurve(pt: Point2d): boolean
|
||
{
|
||
let param = this.GetParametersAt(pt)
|
||
return param > -1e-3 && param < 1.0001
|
||
}
|
||
|
||
ClosePointTo(pt: Point2d): Point2d
|
||
{
|
||
return null
|
||
}
|
||
|
||
GetParametersAt(pt: Point2d): number
|
||
{
|
||
let vec = Point2d.OpSubtract(pt, this.m_Center)
|
||
let an = vec.Angle
|
||
this.ParseAllAngle()
|
||
|
||
// 如果以pt为终点,那么所有的角度为
|
||
let ptAllAn = this.ComputeAnlge(an)
|
||
let allAn = this.m_AllAngle
|
||
|
||
// 减去圆弧角度,剩余角度的一半
|
||
let surplusAngleHalf = Math.PI - allAn / 2
|
||
|
||
if (ptAllAn > allAn + surplusAngleHalf)// 返回负数
|
||
return ((ptAllAn - allAn) - (surplusAngleHalf * 2)) / allAn
|
||
else// 返回正数
|
||
return ptAllAn / allAn
|
||
}
|
||
|
||
GetAngleAtParam(param: number)
|
||
{
|
||
return this.clampRad(this.m_StartAngle + param * this.m_AllAngle)
|
||
}
|
||
|
||
private clampRad(an: number)
|
||
{
|
||
an = an % (Math.PI * 2)
|
||
if (an < 0)
|
||
an += Math.PI * 2
|
||
return an
|
||
}
|
||
|
||
/** 凸度. */
|
||
m_Bul: number
|
||
get Bul() { return this.m_Bul }
|
||
set Bul(v: number) { this.m_Bul = v }
|
||
|
||
static New(x0: number, y0: number, x1: number, y1: number, bul: number): Arc2d
|
||
{
|
||
return new Arc2d(new Point2d(x0, y0), new Point2d(x1, y1), bul)
|
||
}
|
||
}
|
||
function EntityEncode(c: Curve2d)
|
||
{
|
||
if (c instanceof Line2d)
|
||
return 1
|
||
else return 2
|
||
}
|
||
function EntityEncode2(c1: Curve2d, c2: Curve2d)
|
||
{
|
||
return EntityEncode(c1) & EntityEncode(c2)
|
||
}
|
||
|
||
/** CAD 运算库 */
|
||
export class Utils
|
||
{
|
||
static Intersec(e1: Curve2d, e2: Curve2d, oldE1: Curve2d): Point2d
|
||
{
|
||
if (e1.EndPoint.DistensTo(e2.StartPoint) < 1e-2)
|
||
{
|
||
return e1.EndPoint
|
||
}
|
||
let ptsIns: Point2d[] = []
|
||
e1.IntersectWith(e2, ptsIns)
|
||
if (ptsIns.length == 1)
|
||
{
|
||
return ptsIns[0]
|
||
}
|
||
else if (ptsIns.length == 2)
|
||
{
|
||
// 求一个最近的点.
|
||
let pt = oldE1.EndPoint
|
||
let d1 = pt.DistensTo(ptsIns[0])
|
||
let d2 = pt.DistensTo(ptsIns[1])
|
||
return d1 < d2 ? ptsIns[0] : ptsIns[1]
|
||
}
|
||
else // 0点
|
||
{
|
||
return null
|
||
}
|
||
}
|
||
|
||
/** 曲线偏移 */
|
||
|
||
static offsetPoints(points, offsetDistens: number): any[]
|
||
{
|
||
let ens: Curve2d[] = []
|
||
for (let i = 0; i < points.length; i++)
|
||
{
|
||
let j = i + 1
|
||
if (j == points.length)
|
||
j = 0
|
||
|
||
let line = new Line2d(new Point2d(points[i].x, points[i].y), new Point2d(points[j].x, points[j].y))
|
||
if (line.m_Length == 0)
|
||
continue
|
||
ens.push(line)
|
||
}
|
||
|
||
let ens2 = Utils.OffsetCurveList(ens, offsetDistens)
|
||
|
||
let newPs = []
|
||
for (let c of ens2)
|
||
{
|
||
newPs.push({ x: c.StartPoint.m_X, y: c.StartPoint.m_Y })
|
||
}
|
||
return newPs
|
||
}
|
||
|
||
// 1.曲线外偏移.
|
||
//* 2.曲线尝试首尾相连
|
||
//* ->如果两条不相连,导致曲线连接失败,将添加圆弧过度
|
||
//*
|
||
//* 2017-11-17对曲线相连算法进行修改.
|
||
//* 现在会先求出连接点,然后在重新进行曲线连接,避免连接点出错. 参见#118
|
||
static OffsetCurveList(ens: Curve2d[], offsetDistens: number): Curve2d[]
|
||
{
|
||
// 只处理偏移的曲线
|
||
let offEns: Curve2d[] = []
|
||
|
||
ens = ens.filter(e => e.StartPoint.DistensTo(e.EndPoint) > 0.05)
|
||
for (const item of ens)
|
||
{
|
||
offEns.push(item.Offset(offsetDistens))
|
||
}
|
||
// 处理偏移 并且对交点进行处理
|
||
let offEns2: Curve2d[] = []
|
||
let linkPts: Point2d[] = []
|
||
|
||
// 计算链接点,如果有必要会新增圆弧
|
||
for (let i = 0; i < offEns.length; i++)
|
||
{
|
||
let index2 = i + 1 == offEns.length ? 0 : i + 1
|
||
|
||
let e1 = offEns[i]
|
||
let e2 = offEns[index2]
|
||
|
||
offEns2.push(offEns[i])
|
||
|
||
let iPts: Point2d[] = []
|
||
e1.IntersectWith(e2, iPts)
|
||
let tPts = iPts.filter(p => e1.PtOnCurve(p) && e2.PtOnCurve(p))
|
||
|
||
let code = EntityEncode2(e1, e2)
|
||
if (code === 1)
|
||
{
|
||
if (tPts.length > 0)
|
||
linkPts.push(tPts[0])// 直接连接
|
||
else
|
||
{
|
||
let refP = ens[i].EndPoint
|
||
let distSq = iPts[0].DistensTo(refP)
|
||
if (distSq > offsetDistens ** 2 * 2.1) // 补圆弧
|
||
{
|
||
let arc = new Arc2d(e1.EndPoint, e2.StartPoint, Math.sign(offsetDistens))
|
||
arc.m_Center = ens[i].EndPoint
|
||
arc.m_Radius = offsetDistens// 半径
|
||
|
||
linkPts.push(e1.EndPoint)
|
||
linkPts.push(e2.StartPoint)
|
||
offEns2.push(arc)// 添加圆弧.
|
||
}
|
||
else
|
||
linkPts.push(iPts[0])
|
||
}
|
||
}
|
||
else if (
|
||
code === 2
|
||
&& (
|
||
equalp((<Arc2d>e1).m_Center, (<Arc2d>e2).m_Center, 0.1) // 都是圆弧,且同心圆(由于精度丢失,这里我们给0.01的容差)
|
||
|| equalp(e1.EndPoint, e2.StartPoint, 0.1))
|
||
)
|
||
linkPts.push(e1.EndPoint)
|
||
else
|
||
{
|
||
function SelectNearP(pts: Point2d[], refPt: Point2d): Point2d
|
||
{
|
||
if (pts.length > 1)
|
||
{
|
||
let dist1 = refPt.DistensTo(pts[0])
|
||
let dist2 = refPt.DistensTo(pts[1])
|
||
return dist1 <= dist2 ? pts[0] : pts[1]
|
||
}
|
||
return pts[0]
|
||
}
|
||
|
||
let refP = ens[i].EndPoint
|
||
if (tPts.length > 0)
|
||
linkPts.push(SelectNearP(iPts, refP))// 直接连接
|
||
else
|
||
{
|
||
let arc = new Arc2d(e1.EndPoint, e2.StartPoint, Math.sign(offsetDistens))
|
||
arc.m_Center = ens[i].EndPoint
|
||
arc.m_Radius = offsetDistens// 半径
|
||
|
||
linkPts.push(e1.EndPoint)
|
||
linkPts.push(e2.StartPoint)
|
||
offEns2.push(arc)// 添加圆弧.
|
||
}
|
||
}
|
||
}
|
||
|
||
// 更新链接点位置
|
||
for (let i = 0; i < offEns2.length; i++)
|
||
{
|
||
offEns2[i].EndPoint = linkPts[i]
|
||
let nextIndex = i == offEns2.length - 1 ? 0 : i + 1
|
||
offEns2[nextIndex].StartPoint = linkPts[i]
|
||
}
|
||
|
||
// 测试数据
|
||
// TestPolyline([ens, offEns2])
|
||
|
||
return offEns2
|
||
}
|
||
|
||
/** //自交曲线优化 去除自交部分. */
|
||
static RemoveSelfIntersect(cus: Curve2d[]): Curve2d[]
|
||
{
|
||
let res = new Array<Curve2d>()
|
||
let cout = cus.length
|
||
for (let i = 0; i < cout; i++)
|
||
{
|
||
let cu = cus[i]
|
||
res.push(cu)
|
||
for (let j = cout - 2; j > i + 1; j--)
|
||
{
|
||
let cu2 = cus[j]
|
||
|
||
let pts = new Array<Point2d>()
|
||
cu.IntersectWith(cu2, pts)
|
||
|
||
//
|
||
if (pts.length == 0)
|
||
{
|
||
continue
|
||
}
|
||
if (pts.length == 2)
|
||
{
|
||
if (cu instanceof Line2d)
|
||
{
|
||
if (cu.GetParametersAt(pts[0]) > cu.GetParametersAt(pts[1]))
|
||
{
|
||
pts[0] = pts[1]
|
||
}
|
||
}
|
||
else if (cu instanceof Arc2d)
|
||
{
|
||
// 使用上一条线. 因为我们保证它和上一条线是有一个交点的
|
||
|
||
let arc = cu as Arc2d
|
||
|
||
// last cu
|
||
let lastIndex = i - 1
|
||
if (i == 0)
|
||
lastIndex = cout - 1
|
||
|
||
let lastCu = cus[lastIndex]
|
||
|
||
let insPts = new Array<Point2d>()
|
||
lastCu.IntersectWith(cu, insPts)
|
||
|
||
for (let insP of insPts)
|
||
{
|
||
let p1 = arc.GetParametersAt(insP)
|
||
let p2 = arc.GetParametersAt(insP)
|
||
// 从起点圆弧开始
|
||
if (insP.DistensTo(cu.StartPoint) < 1e-3)
|
||
{
|
||
if (p1 > p2)
|
||
{
|
||
pts[0] = pts[1]
|
||
}
|
||
break
|
||
}
|
||
// 从终点圆弧开始.
|
||
else if (insP.DistensTo(cu.EndPoint) < 1e-3)
|
||
{
|
||
if (p1 < p2)
|
||
{
|
||
pts[0] = pts[1]
|
||
}
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (cu.PtInCurve(pts[0]) && cu2.PtInCurve(pts[0]))
|
||
{
|
||
Utils.changeP(cus, cu, i, -1, pts[0])
|
||
Utils.changeP(cus, cu, j, 1, pts[0])
|
||
|
||
i = j - 1
|
||
break
|
||
}
|
||
}
|
||
}
|
||
|
||
Utils.RemoveZeroCurve(res)
|
||
return res
|
||
}
|
||
|
||
static changeP(cus: Curve2d[], cu: Curve2d, index: number, next: number, _pt: Point2d)
|
||
{
|
||
let cout = cus.length
|
||
let lastIndex = index + next
|
||
|
||
let _cu = cus[index]
|
||
if (lastIndex == -1)
|
||
lastIndex = cout - 1
|
||
else if (lastIndex == cout)
|
||
lastIndex = 0
|
||
|
||
let lastCu = cus[lastIndex]
|
||
|
||
let insPts = new Array<Point2d>()
|
||
lastCu.IntersectWith(_cu, insPts)
|
||
|
||
for (const insP of insPts)
|
||
{
|
||
if (insP.DistensTo(_cu.StartPoint) < 1e-3)
|
||
{
|
||
_cu.EndPoint = _pt
|
||
break
|
||
}
|
||
else if (insP.DistensTo(_cu.EndPoint) < 1e-3)
|
||
{
|
||
_cu.StartPoint = _pt
|
||
break
|
||
}
|
||
}
|
||
if (cu instanceof Arc2d)
|
||
{
|
||
cu.Parse()
|
||
}
|
||
}
|
||
|
||
static RemoveZeroCurve(cus: Curve2d[])
|
||
{
|
||
// remove zero length curve
|
||
/*
|
||
cus.RemoveAll((Curve2d o) =>
|
||
{
|
||
if (o is Line2d)
|
||
{
|
||
return ((Line2d)o).m_Length < 1e-3;
|
||
}
|
||
else if (o is Arc2d)
|
||
{
|
||
return ((Arc2d)o).m_AllAngle < 1e-3;
|
||
}
|
||
return false;
|
||
});
|
||
*/
|
||
|
||
let length = cus.length
|
||
let isZero = false
|
||
for (let i = length - 1; i >= 0; i--)
|
||
{
|
||
let o = cus[i]
|
||
|
||
isZero = false
|
||
if (o instanceof Line2d)
|
||
{
|
||
let line = o as Line2d
|
||
isZero = line.m_Length < 1e-3
|
||
}
|
||
else if (o instanceof Arc2d)
|
||
{
|
||
let arc = o as Arc2d
|
||
isZero = arc.m_AllAngle < 1e-3
|
||
}
|
||
|
||
if (isZero)
|
||
{
|
||
cus.splice(i, 1)
|
||
}
|
||
}
|
||
}
|
||
|
||
/** 曲线倒角 */
|
||
static FilletCurveList(culist: Curve2d[], offsetDistens: number): Curve2d[]
|
||
{
|
||
/*
|
||
let rn = new List<Curve2d>();
|
||
let len = cuList.Count;
|
||
for (int i = 0; i < len; i++)
|
||
{
|
||
let en = cuList[i];
|
||
let index =i==len-1 ? 0 : i + 1;
|
||
rn.Add(en);
|
||
if (en is Line2d && cuList[index] is Line2d)
|
||
{
|
||
let l1 = en as Line2d;
|
||
let l2 = cuList[index] as Line2d;
|
||
if (l1.m_Length < offsetDistens || l2.m_Length < offsetDistens
|
||
|| (l1.EndPoint-l1.StartPoint).CrossProduct(l2.EndPoint-l2.StartPoint) <1e-3
|
||
)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
let tempEn1 = en.Offset(-offsetDistens) as Line2d;
|
||
let tempEn2 = cuList[index].Offset(-offsetDistens)as Line2d;
|
||
|
||
let pts = new List<Point2d>();
|
||
tempEn1.IntersectWith(tempEn2, pts);
|
||
if (pts.Count>0 && tempEn1.PtInCurve(pts.First()))
|
||
{
|
||
let pt = pts.First();
|
||
//求交点.
|
||
en.EndPoint= en.ClosePointTo(pt);
|
||
let en2 = cuList[index];
|
||
en2.StartPoint = en2.ClosePointTo(pt);
|
||
|
||
let arc2d = new Arc2d(en.EndPoint, en2.StartPoint, 1);//凸圆弧
|
||
arc2d.m_Center = pt;
|
||
arc2d.m_Radius = pt.DistensTo(en.EndPoint);
|
||
arc2d.Parse();//解析凸度 角度
|
||
rn.Add(arc2d);
|
||
}
|
||
}
|
||
}
|
||
return rn;
|
||
*/
|
||
|
||
let rn = new Array<Curve2d>()
|
||
let len = culist.length
|
||
for (let i = 0; i < len; i++)
|
||
{
|
||
let en = culist[i]
|
||
let index = i == len - 1 ? 0 : i + 1
|
||
rn.push(en)
|
||
|
||
if (en instanceof Line2d && culist[index] instanceof Line2d)
|
||
{
|
||
let l1 = en as Line2d
|
||
let l2 = culist[index] as Line2d
|
||
if (l1.m_Length < offsetDistens || l2.m_Length < offsetDistens
|
||
|| (Point2d.OpSubtract(l1.EndPoint, l1.StartPoint)).CrossProduct(Point2d.OpSubtract(l2.EndPoint, l2.StartPoint)) < 1e-3
|
||
)
|
||
{
|
||
continue
|
||
}
|
||
|
||
let tempEn1 = en.Offset(-offsetDistens) as Line2d
|
||
let tempEn2 = culist[index].Offset(-offsetDistens) as Line2d
|
||
|
||
let pts = new Array<Point2d>()
|
||
tempEn1.IntersectWith(tempEn2, pts)
|
||
if (pts.length > 0 && tempEn1.PtInCurve(pts[0]))
|
||
{
|
||
let pt = pts[0]
|
||
// 求交点.
|
||
en.EndPoint = en.ClosePointTo(pt)
|
||
let en2 = culist[index]
|
||
en2.StartPoint = en2.ClosePointTo(pt)
|
||
|
||
let arc2d = new Arc2d(en.EndPoint, en2.StartPoint, 1)// 凸圆弧
|
||
arc2d.m_Center = pt
|
||
arc2d.m_Radius = pt.DistensTo(en.EndPoint)
|
||
arc2d.Parse()// 解析凸度 角度
|
||
rn.push(arc2d)
|
||
}
|
||
}
|
||
}
|
||
return rn
|
||
}
|
||
|
||
/** 圆弧细分 如果大于90度则分割 */
|
||
static SplitCurveListArc(cuList: Curve2d[]): Curve2d[]
|
||
{
|
||
/* C# 代码
|
||
let rnList = new List<Curve2d>();//返回的曲线表
|
||
foreach (let cu in cuList)
|
||
{
|
||
if (cu is Arc2d)
|
||
{
|
||
let arc = cu as Arc2d;
|
||
arc.Parse();//解析圆弧的凸度 角度
|
||
if (arc.m_AllAngle > Math.PI * 0.5)
|
||
{
|
||
int cout =(int)( arc.m_AllAngle / (Math.PI * 0.5)) + 1;
|
||
let an = arc.m_AllAngle / cout;
|
||
let startAn = arc.m_StartAngle;
|
||
for (int i = 0; i < cout; i++)
|
||
{
|
||
let arcNew = new Arc2d(arc.StartPoint, arc.EndPoint, 0);
|
||
arcNew.m_Radius = arc.m_Radius;
|
||
arcNew.m_Center = arc.m_Center;
|
||
arcNew.m_StartAngle = startAn;
|
||
arcNew.m_EndAngle = arcNew.m_StartAngle + an;
|
||
startAn = arcNew.m_EndAngle;
|
||
rnList.Add(arcNew);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
rnList.Add(cu);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
rnList.Add(cu);
|
||
}
|
||
}
|
||
return rnList;
|
||
|
||
*/
|
||
let rnList = new Array<Curve2d>()// 返回的曲线表
|
||
for (let cu of cuList)
|
||
{
|
||
if (cu instanceof Arc2d)
|
||
{
|
||
let arc = cu as Arc2d
|
||
arc.Parse()// 解析圆弧的凸度 角度
|
||
if (arc.m_AllAngle > Math.PI * 0.5)
|
||
{
|
||
let cout = arc.m_AllAngle / (Math.PI * 0.5) + 1
|
||
let an = arc.m_AllAngle / cout
|
||
let startAn = arc.m_StartAngle
|
||
for (let i = 0; i < cout; i++)
|
||
{
|
||
let arcNew = new Arc2d(arc.StartPoint, arc.EndPoint, 0)
|
||
arcNew.m_Radius = arc.m_Radius
|
||
arcNew.m_Center = arc.m_Center
|
||
arcNew.m_StartAngle = startAn
|
||
arcNew.m_EndAngle = arcNew.m_StartAngle + an
|
||
startAn = arcNew.m_EndAngle
|
||
rnList.push(arcNew)
|
||
}
|
||
}
|
||
else
|
||
{
|
||
rnList.push(cu)
|
||
}
|
||
}
|
||
else
|
||
{
|
||
rnList.push(cu)
|
||
}
|
||
}
|
||
return rnList
|
||
}
|
||
|
||
// 三点面积
|
||
static Det(p1: Point2d, p2: Point2d, p3: Point2d): number
|
||
{
|
||
return this.Det2(p1.AsVector(), p2.AsVector(), p3.AsVector())
|
||
}
|
||
|
||
// 三点面积
|
||
static Det2(p1: Vector2d, p2: Vector2d, p3: Vector2d): number
|
||
{
|
||
return p1.CrossProduct(p2) + p2.CrossProduct(p3) + p3.CrossProduct(p1)
|
||
}
|
||
|
||
//
|
||
static AngleForm3Pt(pSrc: Point2d, p1: Point2d, p2: Point2d): number
|
||
{
|
||
/*
|
||
double angle = 0.0f; // 夹角
|
||
|
||
let vec1 = p1 - pSrc;
|
||
let vec2 = p2 - pSrc;
|
||
|
||
double productValue = vec1 * vec2;
|
||
double cosValue = productValue / (vec1.Length * vec2.Length); // 余弦公式
|
||
|
||
// acos的输入参数范围必须在[-1, 1]之间，否则会"domain error"
|
||
// 对输入参数作校验和处理
|
||
if (cosValue < -1 && cosValue > -2)
|
||
cosValue = -1;
|
||
else if (cosValue > 1 && cosValue < 2)
|
||
cosValue = 1;
|
||
|
||
// acos返回的是弧度值，转换为角度值
|
||
angle = Math.Acos(cosValue) * 180 / Math.PI;
|
||
return angle;
|
||
*/
|
||
let angle = 0.0 // 夹角
|
||
|
||
let vec1 = Point2d.OpSubtract(p1, pSrc)
|
||
let vec2 = Point2d.OpSubtract(p2, pSrc)
|
||
|
||
let productValue = Vector2d.OpMultiplyValue(vec1, vec2)
|
||
let cosValue = productValue / (vec1.Length * vec2.Length) // 余弦公式
|
||
|
||
// acos的输入参数范围必须在[-1, 1]之间，否则会"domain error"
|
||
// 对输入参数作校验和处理
|
||
if (cosValue < -1 && cosValue > -2)
|
||
cosValue = -1
|
||
else if (cosValue > 1 && cosValue < 2)
|
||
cosValue = 1
|
||
|
||
// acos返回的是弧度值，转换为角度值
|
||
angle = Math.acos(cosValue) * 180 / Math.PI
|
||
return angle
|
||
}
|
||
}
|
||
|
||
export class DoubleUtil
|
||
{
|
||
static EqualX(v1: number, v2: number, fuzz: number): boolean
|
||
{
|
||
return (Math.abs(v1 - v2) < fuzz)
|
||
}
|
||
|
||
static Sqr(v: number): number
|
||
{
|
||
return v * v
|
||
}
|
||
}
|
||
|
||
export class CADExt
|
||
{
|
||
static GetX(arc: Curve2d): number
|
||
{
|
||
return Math.min(arc.StartPoint.m_X, arc.EndPoint.m_X)
|
||
}
|
||
|
||
static GetY(arc: Curve2d): number
|
||
{
|
||
return Math.min(arc.StartPoint.m_Y, arc.EndPoint.m_Y)
|
||
}
|
||
|
||
static GetWidth(arc: Curve2d): number
|
||
{
|
||
return Math.abs(arc.StartPoint.m_X - arc.EndPoint.m_X)
|
||
}
|
||
|
||
static GetHeight(arc: Curve2d): number
|
||
{
|
||
return Math.abs(arc.StartPoint.m_Y - arc.EndPoint.m_Y)
|
||
}
|
||
|
||
static GetRadius(p1: Point2d, p2: Point2d, bul: number): number
|
||
{
|
||
// let arc = new Arc2d(p1, p2, bul);
|
||
// return arc.m_Radius;
|
||
// this.m_Radius = length / Math.sin(2 * Math.atan(bul)) / 2;
|
||
return CADExt.getR(p1.m_X, p1.m_Y, p2.m_X, p2.m_Y, bul)
|
||
}
|
||
|
||
static getR(x1: number, y1: number, x2: number, y2: number, bul: number): number
|
||
{
|
||
let length = Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
|
||
return length / Math.sin(2 * Math.atan(bul)) / 2
|
||
}
|
||
|
||
/** 圆弧分割成count段 */
|
||
static SplitArc(arc: Arc2d, count: number): Arc2d[]
|
||
{
|
||
let list: Arc2d[]
|
||
list = []
|
||
|
||
let an = arc.m_AllAngle / count
|
||
let an_0 = arc.m_StartAngle
|
||
for (let i = 0; i < count; i++)
|
||
{
|
||
let arcNew = new Arc2d(arc.StartPoint, arc.EndPoint, 0)
|
||
arcNew.m_Radius = arc.m_Radius
|
||
arcNew.m_Center = arc.m_Center
|
||
arcNew.m_StartAngle = an_0
|
||
arcNew.m_EndAngle = arcNew.m_StartAngle + an
|
||
an_0 = arcNew.m_EndAngle
|
||
arcNew.ParsePointFormAngle()
|
||
|
||
list.push(arcNew)
|
||
}
|
||
return list
|
||
}
|
||
|
||
static SplitArcByCell(ar: Arc2d, cellWidth: number): any[]
|
||
{
|
||
// 弧长
|
||
let fullLenth = Math.abs(ar.m_Radius * (ar.m_EndAngle - ar.m_StartAngle))
|
||
let count = fullLenth / cellWidth
|
||
if (count < 2)
|
||
count = 2
|
||
let childs = CADExt.SplitArc(ar, count)
|
||
let pts = []
|
||
for (let c of childs)
|
||
{
|
||
pts.push({ x: c.StartPoint.m_X, y: c.StartPoint.m_Y })
|
||
}
|
||
pts.push({ x: ar.EndPoint.m_X, y: ar.EndPoint.m_Y })
|
||
return pts
|
||
}
|
||
|
||
/** 根据两点，深的弧度 中间的n个点 */
|
||
static getCurvePoints(x1: number, y1: number, x2: number, y2: number, d: number, num: number): any
|
||
{
|
||
// atan(h/(L/2)) * 4 h:
|
||
let dis = 0.5 * Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
|
||
let mul = d / dis
|
||
let arc = new Arc2d(new Point2d(x1, y1), new Point2d(x2, y2), mul)
|
||
|
||
let arc_list = CADExt.SplitArc(arc, num - 1)
|
||
let points = []
|
||
for (let li of arc_list)
|
||
{
|
||
points.push({ x: li.StartPoint.m_X, y: li.StartPoint.m_Y })
|
||
}
|
||
points.push({ x: x2, y: y2 })
|
||
return points
|
||
}
|
||
|
||
/** 求弧长 */
|
||
static getLength(arc: Arc2d): number
|
||
{
|
||
return arc.m_Radius * Math.abs(arc.m_AllAngle)
|
||
}
|
||
|
||
/** 按固定线长分割圆弧 */
|
||
static getPointsFromCurve(x1: number, y1: number, x2: number, y2: number, bul: number, dis: number)
|
||
{
|
||
let arc = new Arc2d(new Point2d(x1, y1), new Point2d(x2, y2), bul)
|
||
let length = this.getLength(arc)
|
||
let count = Math.max(4, Math.ceil(length / dis))
|
||
let arc_list = CADExt.SplitArc(arc, count)
|
||
let points = []
|
||
for (let li of arc_list)
|
||
{
|
||
points.push({ x: li.StartPoint.m_X, y: li.StartPoint.m_Y })
|
||
}
|
||
points.push({ x: x2, y: y2 })
|
||
return points
|
||
}
|
||
|
||
/** 返回弧形中心点 (不是圆心点) */
|
||
static getCenterPoint(arc: Arc2d): Point2d
|
||
{
|
||
let arcNew = new Arc2d(arc.StartPoint, arc.EndPoint, 0)
|
||
arcNew.m_Radius = arc.m_Radius
|
||
arcNew.m_Center = arc.m_Center
|
||
arcNew.m_StartAngle = arc.m_StartAngle
|
||
arcNew.m_EndAngle = arc.m_StartAngle + arc.m_AllAngle / 2
|
||
arcNew.ParsePointFormAngle()
|
||
return arcNew.EndPoint
|
||
}
|
||
|
||
/** 获得第3点到前2点的距离差 */
|
||
static getDisOff(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): number
|
||
{
|
||
let dis31 = Math.sqrt((x3 - x1) * (x3 - x1) + (y3 - y1) * (y3 - y1))
|
||
let dis32 = Math.sqrt((x3 - x2) * (x3 - x2) + (y3 - y2) * (y3 - y2))
|
||
let dis12 = Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
|
||
return dis31 + dis32 - dis12
|
||
}
|
||
}
|
||
function TestPolyline(offEnsS: Curve2d[][])
|
||
{
|
||
let str = `[${offEnsS.length}`
|
||
for (let i = 0; i < offEnsS.length; i++)
|
||
{
|
||
let offEns = offEnsS[i]
|
||
let linedString = `${offEns.length},`
|
||
for (let cu of offEns)
|
||
{
|
||
let bul = (cu instanceof Arc2d) ? cu.m_Bul : 0
|
||
linedString += `[${cu.StartPoint.m_X},${cu.StartPoint.m_Y}],${bul},`
|
||
}
|
||
str += `,"Polyline",8,2,116,false,1,${7 + i % 2},0,[1,0,0,0,0,1,0,0,0,0,1,0,${Math.floor(i / 2) * 1000},0,0,1],0,0,true,[1,0,0,0,0,1,0,0,0,0,1,0,3000,0,0,1],0,2,${linedString}true`
|
||
}
|
||
str += ']'
|
||
console.log(str)
|
||
copyTextToClipboard(str)
|
||
}
|
||
|
||
let DebugCurves: (Curve2d[])[] = []
|
||
export function CADDebugInit()
|
||
{
|
||
DebugCurves = []
|
||
}
|
||
|
||
export function CADCopyPolylines()
|
||
{
|
||
TestPolyline(DebugCurves)
|
||
DebugCurves = []
|
||
}
|
||
|
||
function fallbackCopyTextToClipboard(text: string)
|
||
{
|
||
let textArea = document.createElement('textarea')
|
||
textArea.value = text
|
||
document.body.appendChild(textArea)
|
||
textArea.focus()
|
||
textArea.select()
|
||
|
||
try
|
||
{
|
||
let successful = document.execCommand('copy')
|
||
} catch (err)
|
||
{
|
||
}
|
||
document.body.removeChild(textArea)
|
||
}
|
||
export async function copyTextToClipboard(text: string)
|
||
{
|
||
if (!navigator.clipboard)
|
||
{
|
||
fallbackCopyTextToClipboard(text)
|
||
return
|
||
}
|
||
return await navigator.clipboard.writeText(text)
|
||
}
|
||
|
||
// ref: https://stackoverflow.com/questions/400212/how-do-i-copy-to-the-clipboard-in-javascript
|
||
|
||
/**
|
||
* 读取剪切板的字符串
|
||
*/
|
||
export async function readClipboardText()
|
||
{
|
||
if (navigator.clipboard)
|
||
return await navigator.clipboard.readText()
|
||
return ''
|
||
}
|