cut-abstractions/samples/handleAbility/common/core/Path.ts

import { Box2 } from '../Box2.js'  
import { clipperCpp } from '../ClipperCpp.js'
import type { NestFiler } from '../Filer.js'
import type { Point } from '../Point.js' 
import { equaln } from '../Util.js'  
import { Vector2 } from '../Vector2.js' 

/**
 * 轮廓路径类
 * 可以求NFP，和保存NFPCahce
 * 因为NFP结果是按照最低点移动的,所以将点旋转后,按照盒子将点移动到0点.
 */
export class Path
{
  Id: number
  Points: Point[]
  OutsideNFPCache: { [key: number]: Point[][] } = {}
  InsideNFPCache: { [key: number]: Point[][] } = {}

  constructor(public OrigionPoints?: Point[], rotation: number = 0)
  {
    if (OrigionPoints)
      this.Init(OrigionPoints, rotation)
  }

  Origion: Path
  // 点表在旋转后的原始最小点.使用这个点将轮廓移动到0点
  OrigionMinPoint: Vector2
  Rotation: number

  Size: Vector2// 序列化
  private Init(origionPoints: Point[], rotation: number)
  {
    this.Rotation = rotation
    if (rotation === 0)
      this.Points = origionPoints.map((p) => { return { ...p } })
    else
    {
      let c = Math.cos(rotation)
      let s = Math.sin(rotation)

      let npts: Point[] = []
      for (let p of origionPoints)
      {
        let x = p.x
        let y = p.y
        const x1 = x * c - y * s
        const y1 = x * s + y * c
        npts.push({ x: x1, y: y1 })
      }
      this.Points = npts
    }

    let box = new Box2()
    let v2 = new Vector2()
    for (let p of this.Points)
    {
      v2.x = p.x
      v2.y = p.y
      box.expandByPoint(v2)
    }

    this.OrigionMinPoint = box.min
    this.Size = box.max.sub(box.min)

    for (let p of this.Points)
    {
      p.x -= box.min.x
      p.y -= box.min.y
    }
  }

  GetNFPs(path: Path, outside: boolean): Point[][]
  {
    // 寻找内轮廓时,面积应该比本path小,这个判断移交给使用者自己判断
    // if (!outside && this.Area < path.Area) return [];
    let nfps = clipperCpp.lib.minkowskiSumPath(this.BigIntPoints, path.MirrorPoints, true)

    // 必须删除自交,否则将会出错
    nfps = clipperCpp.lib.simplifyPolygons(nfps)
    nfps = nfps.filter((nfp) =>
    {
      let area = Area(nfp)
      // if (area > 1) return outside;//第一个不一定是外轮廓,但是面积为正时肯定为外轮廓 (因为使用了简化多段线,所以这个代码已经不能有了)
      if (Math.abs(area) < 10)
        return false// 应该不用在移除这个了

      let { x, y } = nfp[0]
      if (outside)
      {
        if (this.Area > path.Area)
        {
          let p = { x: path.InPoint.x + x, y: path.InPoint.y + y }
          if (p.x < 0 || p.y < 0 || p.x > this.BigSize.x || p.y > this.BigSize.y)
            return true
          let dir = clipperCpp.lib.pointInPolygon(p, this.BigIntPoints)
          return dir === 0
        }
        else
        {
          let p = { x: this.InPoint.x - x, y: this.InPoint.y - y }
          if (p.x < 0 || p.y < 0 || p.x > path.BigSize.x || p.y > path.BigSize.y)
            return true
          let dir = clipperCpp.lib.pointInPolygon(p, path.BigIntPoints)
          return dir === 0
        }
      }
      else
      {
        let p = { x: path.InPoint.x + x, y: path.InPoint.y + y }
        if (p.x < 0 || p.y < 0 || p.x > this.BigSize.x || p.y > this.BigSize.y)
          return false
        let dir = clipperCpp.lib.pointInPolygon(p, this.BigIntPoints)
        return dir === 1
      }
    })
    return nfps
  }

  GetOutsideNFP(path: Path): Point[][]
  {
    let nfps = this.OutsideNFPCache[path.Id]
    if (nfps)
      return nfps

    if (this.IsRect && path.IsRect)
    {
      let [ax, ay] = [this.Size.x * 1e4, this.Size.y * 1e4]
      let [bx, by] = [path.Size.x * 1e4, path.Size.y * 1e4]
      nfps = [[
        { x: -bx, y: -by },
        { x: ax, y: -by },
        { x: ax, y: ay },
        { x: -bx, y: ay },
      ]]
    }
    else
      nfps = this.GetNFPs(path, true)
    this.OutsideNFPCache[path.Id] = nfps
    // 虽然有这种神奇的特性，但是好像并不会提高性能。
    // path.OutsideNFPCache[this.id] = (this, nfps.map(nfp =>
    // {
    //     return nfp.map(p =>
    //     {
    //         return { x: -p.x, y: -p.y };
    //     });
    // }));
    return nfps
  }

  GetInsideNFP(path: Path): Point[][]
  {
    if (path.Area > this.Area)
      return
    let nfp = this.InsideNFPCache[path.Id]
    if (nfp)
      return nfp

    let nfps: Point[][]
    if (this.IsRect)
    {
      let [ax, ay] = [this.Size.x * 1e4, this.Size.y * 1e4]
      let [bx, by] = [path.Size.x * 1e4, path.Size.y * 1e4]

      let l = ax - bx
      let h = ay - by

      const MinNumber = 200// 清理的数值是100,所以200是可以接受的, 200=0.020问题不大(过盈配合)
      if (l < -MinNumber || h < -MinNumber)
        return

      if (l < MinNumber)
        l = MinNumber
      else
        l += MinNumber

      if (h < MinNumber)
        h = MinNumber
      else
        h += MinNumber

      nfps = [[
        { x: 0, y: 0 },
        { x: l, y: 0 },
        { x: l, y: h },
        { x: 0, y: h },
      ]]
    }
    else
      nfps = this.GetNFPs(path, false)

    if (path.Id !== undefined)
      this.InsideNFPCache[path.Id] = nfps
    return nfps
  }

  private _InPoint: Point

  /**
   * 用这个点来检测是否在Path内部
   */
  private get InPoint()
  {
    if (this._InPoint)
      return this._InPoint
    let mp = { x: (this.Points[0].x + this.Points[1].x) / 2, y: (this.Points[0].y + this.Points[1].y) / 2 }
    let normal = new Vector2(this.Points[1].x - this.Points[0].x, this.Points[1].y - this.Points[0].y).normalize()
    // [normal.x, normal.y] = [normal.y, -normal.x];
    mp.x -= normal.y
    mp.y += normal.x

    mp.x *= 1e4
    mp.y *= 1e4
    this._InPoint = mp
    return mp
  }

  protected _BigIntPoints: Point[]
  get BigIntPoints()
  {
    if (this._BigIntPoints)
      return this._BigIntPoints
    this._BigIntPoints = this.Points.map((p) =>
    {
      return {
        x: Math.round(p.x * 1e4),
        y: Math.round(p.y * 1e4),
      }
    })
    return this._BigIntPoints
  }

  private _BigSize: Vector2
  get BigSize()
  {
    if (this._BigSize)
      return this._BigSize
    this._BigSize = new Vector2(this.Size.x * 1e4, this.Size.y * 1e4)
    return this._BigSize
  }

  protected _MirrorPoints: Point[]
  get MirrorPoints()
  {
    if (!this._MirrorPoints)
      this._MirrorPoints = this.BigIntPoints.map((p) =>
      {
        return { x: -p.x, y: -p.y }
      })

    return this._MirrorPoints
  }

  protected _BoundingBox: Box2
  get BoundingBox()
  {
    if (!this._BoundingBox)
     {
      this._BoundingBox = new Box2(new Vector2(), this.Size)
     }
    return this._BoundingBox
  }

  protected _Area: number
  get Area()
  {
    if (this._Area === undefined)
      this._Area = Area(this.Points)
    return this._Area
  }

  set Area(a: number)
  {
    this._Area = a
  }

  private _IsRect: boolean
  get IsRect()
  {
    if (this._IsRect === undefined)
    {
      let s = this.BoundingBox.getSize(new Vector2())
      this._IsRect = equaln(this.Area, s.x * s.y, 1)
    }
    return this._IsRect
  }

  ReadFile(file: NestFiler): void
  {
    let ver = file.Read()
    this.Id = file.Read()
    let arr = file.Read()
    this.Points = []
    for (let i = 0; i < arr.length; i += 2)
    {
      let p = { x: arr[i], y: arr[i + 1] }
      this.Points.push(p)
    }

    this.Size = new Vector2(file.Read(), file.Read())
    this._Area = file.Read()
    let id = file.Read()
    if (id !== -1)
    {
      this.Origion = id
      this.Rotation = file.Read()
      this.OrigionMinPoint = new Vector2(file.Read(), file.Read())
    }
  }

  WriteFile(file: NestFiler): void
  {
    file.Write(1)// ver
    file.Write(this.Id)
    let arr: number[] = []
    for (let p of this.Points)
      arr.push(p.x, p.y)
    file.Write(arr)

    file.Write(this.Size.x)
    file.Write(this.Size.y)
    file.Write(this._Area)
    if (this.Origion && this.Origion.Id)
    {
      // 如果有原始的id,则传递它,以便后续进行NFP复用.
      file.Write(this.Origion.Id)
      file.Write(this.Rotation)
      file.Write(this.OrigionMinPoint.x)
      file.Write(this.OrigionMinPoint.y)
    }
    else
      file.Write(-1)
  }
}

// 点表面积
export function Area(pts: Point[]): number
{
  let cnt = pts.length
  if (cnt < 3)
    return 0
  let a = 0
  for (let i = 0, j = cnt - 1; i < cnt; ++i)
  {
    a += (pts[j].x + pts[i].x) * (pts[j].y - pts[i].y)
    j = i
  }
  return -a * 0.5
}

/**
 * 平移点表,返回新点表
 */
export function TranslatePath(pts: Point[], p: Point): Point[]
{
  return pts.map((px) =>
  {
    return { x: p.x + px.x, y: p.y + px.y }
  })
}

export function TranslatePath_Self(pts: Point[], mx: number, my: number): Point[]
{
  for (let pt of pts)
  {
    pt.x += mx
    pt.y += my
  }
  return pts
}

// 缩放点表,返回原始点表
export function PathScale(pts: Point[], scale: number): Point[]
{
  for (let p of pts)
  {
    p.x *= scale
    p.y *= scale
  }
  return pts
}