erasure.test.js

import {
  computeErasureIntervals,
  combineErasureIntervals,
  spreadErasureIntervals,
  flattenErasureIntervals,
} from "../src/erasure.js"

describe("erasure intervals", () => {
  it("computes simple erasure intervals", () => {
    const points = [[0, 0], [100, 100]]
    const erasureCenter = [50, 50]
    const erasureRadius = 25 * Math.SQRT2

    const erasureIntervals = computeErasureIntervals(
      points,
      erasureCenter,
      erasureRadius,
    )

    expect(erasureIntervals).toStrictEqual({ 0: [[0.25, 0.75]] })
  })

  it("computes complex erasure intervals", () => {
    const points = [[0, 0], [100, 100], [0, 200]]
    const erasureCenter = [100, 100]
    const erasureRadius = 25 * Math.SQRT2

    const erasureIntervals = computeErasureIntervals(
      points,
      erasureCenter,
      erasureRadius,
    )

    expect(erasureIntervals).toStrictEqual({ 0: [[0.75, 1]], 1: [[0, 0.25]] })
  })

  it("computes erasure intervals when point projection is not on the segment", () => {
    const points = [[800, 400], [800, 450], [800, 500]]
    const erasureCenter = [800, 432]
    const erasureRadius = 20 //* Math.SQRT2

    const erasureIntervals = computeErasureIntervals(
      points,
      erasureCenter,
      erasureRadius,
    )

    expect(erasureIntervals).toStrictEqual({ 0: [[0.24, 1]], 1: [[0, 0.04]] })
  })

  it("computes erasure intervals ???", () => {
    const points = [[100, 100], [1100, 100]]
    const erasureCenter = [448, 86]
    const erasureRadius = 100

    const erasureIntervals = computeErasureIntervals(
      points,
      erasureCenter,
      erasureRadius,
    )

    expect(erasureIntervals).toStrictEqual({
      0: [[0.2489848496441075, 0.4470151503558925]],
    })
  })

  it("combines distinct intervals", () => {
    const i1 = { 0: [[0.1, 0.6]] }
    const i2 = { 0: [[0.7, 0.8]] }

    const combined = combineErasureIntervals(i1, i2)
    const expected = { 0: [[0.1, 0.6], [0.7, 0.8]] }

    expect(combined).toStrictEqual(expected)
  })

  it("combines overlapping intervals", () => {
    const i1 = { 0: [[0.1, 0.6]] }
    const i2 = { 0: [[0.5, 0.8]] }

    const combined = combineErasureIntervals(i1, i2)
    const expected = { 0: [[0.1, 0.8]] }

    expect(combined).toStrictEqual(expected)
  })

  it("combines overlapping inside intervals", () => {
    const i1 = { 0: [[0.1, 0.6]] }
    const i2 = { 0: [[0.2, 0.3]] }

    const combined = combineErasureIntervals(i1, i2)
    const expected = { 0: [[0.1, 0.6]] }

    expect(combined).toStrictEqual(expected)
  })

  it("spreads flattened intervals", () => {
    const il = [[0.1, 1.25], [1.5, 2.0], [7.5, 7.75]]

    const spread = spreadErasureIntervals(il)
    const expected = {
      0: [[0.1, 1.0]],
      1: [[0.0, 0.25], [0.5, 1.0]],
      7: [[0.5, 0.75]],
    }

    expect(spread).toStrictEqual(expected)
  })

  it("spreads singulatity intervals", () => {
    const il = [[0.0, 0.0], [3.5, 3.5], [99.0, 99.0]]

    const spread = spreadErasureIntervals(il)
    const expected = { 0: [[0.0, 0.0]], 3: [[0.5, 0.5]], 99: [[0.0, 0.0]] }

    expect(spread).toStrictEqual(expected)
  })

  it("flattens spread intervals", () => {
    const is = {
      0: [[0.1, 1.0]],
      1: [[0.0, 0.3], [0.4, 1.0]],
      7: [[0.35, 0.75]],
    }

    const flattened = flattenErasureIntervals(is)
    const expected = [[0.1, 1.0], [1.0, 1.3], [1.4, 2.0], [7.35, 7.75]]

    expect(flattened).toStrictEqual(expected)
  })
})