yongjun21

import SparseBitmask from "./SparseBitmask";
import { bitmaskFromWeightedRuns } from "./bitmaskHelpers";
import { OrderedMap } from "./OrderedCollections";
import { range } from "./base";

export function cutAndPasteBitmask3d(
  from: SparseBitmask,
  fromWidth: number,
  fromHeight: number,
  fromDepth: number,

yongjun21

/**
 * Calculates an ideal viewBox that centers on a target object
 * @param objectBBox - Bounding box of the target object
 * @param assetWidth - Width of the asset
 * @param assetHeight - Height of the asset
 * @param targetCoverage - target percentage of the viewport width or height the object should take up
 * @param viewportAspectRatio - Aspect ratio of the viewport
 * @param minFit - Minimum width and height of the viewport
 * @returns - [offsetX, offsetY, viewportWidth, viewportHeight]
 */

yongjun21

import _noop from "lodash/noop";

import SparseBitmask from "../../utils/SparseBitmask";
import { OrderedSet, OrderedMap } from "../../utils/OrderedCollections";
import { range } from "../../utils/base";

interface RunNode<T> {
  currState: OrderedSet<number>;
  diff: Set<number>;
  pending: Set<number>;

yongjun21

import SparseBitmask, {
  unionRunEnds,
  intersectionRunEnds,
  subtractionRunEnds,
} from "./SparseBitmask";
import {
  cutAndPasteBitmask3d,
  getBoundingBox3d,
  getCentroid3d,
  getWindowedRunLengths3d,

yongjun21

import {
  iterFilter,
  iterFilterIndex,
  range,
  ArrayConstructor,
  ArrayLike,
} from "./base";

import { OrderedSet } from "./OrderedCollections";

yongjun21

export class OrderedSet<T> {
  private heap: T[] = [];
  private sorted: T[] = [];
  private heapIndex = new Map<T, number>();
  private comparator: (item: T) => any;

  constructor(comparator: (item: T) => any = item => item) {
    this.comparator = comparator;
  }

yongjun21

import { Stack } from './common.js';

export function decodeBitmask(
  encoded: Uint8Array,
  maxIndex: number
): Iterable<number> {
  return {
    *[Symbol.iterator]() {
      const n = maxIndex + 1;
      const depth = Math.ceil(Math.log2(n));

yongjun21

const MAX_LEVEL = 30;
const STACK = new Float32Array((7 * MAX_LEVEL + 1) * 4);

interface OctreeHeader {
  version: number;
  precision: number;
  maxLevel: number;
  nodeCounts: number[];
  leafCount: number;
  dataStartOffset: number;

yongjun21

yongjun21

class MinHeap {
  constructor (comparator = (a, b) => a - b) {
    this._data = []
    this._comparator = comparator
  }

  push (...values) {
    for (const v of values) {
      let cIndex = this._data.push(v) - 1
      while (cIndex > 0) {