pixel-data-js 0.27.0 → 0.28.0

package/src/PixelData/fillPixelDataFast.ts

@@ -1,10 +1,12 @@
-import type { Color32, IPixelData32, Rect } from '../_types'
-import { makeClippedRect, resolveRectClipping } from '../Internal/resolveClipping'
+import type { Color32 } from '../_types'
+import type { Rect } from '../Rect/_rect-types'
+import { makeClippedRect, resolveRectClipping } from '../Rect/resolveClipping'
+import type { PixelData32 } from './_pixelData-types'
 
 const SCRATCH_RECT = makeClippedRect()
 
 /**
- * Fills a region or the {@link IPixelData32} buffer with a solid color.
+ * Fills a region or the {@link PixelData32} buffer with a solid color.
  * This function is faster than {@link fillPixelData} but does not
  * return a boolean value indicating changes were made.
  *
@@ -14,7 +16,7 @@ const SCRATCH_RECT = makeClippedRect()
  * buffer is filled.
  */
 export function fillPixelDataFast(
-  target: IPixelData32,
+  target: PixelData32,
   color: Color32,
   rect?: Partial<Rect>,
 ): void
@@ -27,7 +29,7 @@ export function fillPixelDataFast(
  * @param h - Height of the fill area.
  */
 export function fillPixelDataFast(
-  dst: IPixelData32,
+  dst: PixelData32,
   color: Color32,
   x: number,
   y: number,
@@ -35,7 +37,7 @@ export function fillPixelDataFast(
   h: number,
 ): void
 export function fillPixelDataFast(
-  dst: IPixelData32,
+  dst: PixelData32,
   color: Color32,
   _x?: Partial<Rect> | number,
   _y?: number,
@@ -50,8 +52,8 @@ export function fillPixelDataFast(
   if (typeof _x === 'object') {
     x = _x.x ?? 0
     y = _x.y ?? 0
-    w = _x.w ?? dst.width
-    h = _x.h ?? dst.height
+    w = _x.w ?? dst.w
+    h = _x.h ?? dst.h
   } else if (typeof _x === 'number') {
     x = _x
     y = _y!
@@ -60,11 +62,11 @@ export function fillPixelDataFast(
   } else {
     x = 0
     y = 0
-    w = dst.width
-    h = dst.height
+    w = dst.w
+    h = dst.h
   }
 
-  const clip = resolveRectClipping(x, y, w, h, dst.width, dst.height, SCRATCH_RECT)
+  const clip = resolveRectClipping(x, y, w, h, dst.w, dst.h, SCRATCH_RECT)
 
   if (!clip.inBounds) return
 
@@ -76,11 +78,11 @@ export function fillPixelDataFast(
     h: actualH,
   } = clip
 
-  const dst32 = dst.data32
-  const dw = dst.width
+  const dst32 = dst.data
+  const dw = dst.w
 
   // Optimization: If filling the entire buffer, use the native .fill()
-  if (actualW === dw && actualH === dst.height && finalX === 0 && finalY === 0) {
+  if (actualW === dw && actualH === dst.h && finalX === 0 && finalY === 0) {
     dst32.fill(color)
     return
   }

package/src/PixelData/invertPixelData.ts

@@ -1,10 +1,11 @@
-import { type IPixelData32, type PixelMutateOptions } from '../_types'
-import { makeClippedRect, resolveRectClipping } from '../Internal/resolveClipping'
+import { type PixelMutateOptions } from '../_types'
+import { makeClippedRect, resolveRectClipping } from '../Rect/resolveClipping'
+import type { PixelData32 } from './_pixelData-types'
 
 const SCRATCH_RECT = makeClippedRect()
 
 export function invertPixelData(
-  target: IPixelData32,
+  target: PixelData32,
   opts?: PixelMutateOptions,
 ): boolean {
   const mask = opts?.mask
@@ -12,11 +13,11 @@ export function invertPixelData(
   const targetY = opts?.y ?? 0
   const mx = opts?.mx ?? 0
   const my = opts?.my ?? 0
-  const width = opts?.w ?? target.width
-  const height = opts?.h ?? target.height
+  const width = opts?.w ?? target.w
+  const height = opts?.h ?? target.h
   const invertMask = opts?.invertMask ?? false
 
-  const clip = resolveRectClipping(targetX, targetY, width, height, target.width, target.height, SCRATCH_RECT)
+  const clip = resolveRectClipping(targetX, targetY, width, height, target.w, target.h, SCRATCH_RECT)
 
   if (!clip.inBounds) return false
 
@@ -27,8 +28,8 @@ export function invertPixelData(
     h: actualH,
   } = clip
 
-  const dst32 = target.data32
-  const dw = target.width
+  const dst32 = target.data
+  const dw = target.w
   const mPitch = mask?.w ?? width
 
   const dx = x - targetX

package/src/PixelData/pixelDataToAlphaMask.ts

@@ -1,24 +1,25 @@
-import type { AlphaMask, IPixelData32 } from '../_types'
+import type { AlphaMask } from '../Mask/_mask-types'
 import { makeAlphaMask } from '../Mask/AlphaMask'
+import type { PixelData32 } from './_pixelData-types'
 
 /**
  * Extracts the alpha channel from PixelData into a single-channel mask.
  * Returns a Uint8Array branded as AlphaMask.
  */
 export function pixelDataToAlphaMask(
-  pixelData: IPixelData32,
+  pixelData: PixelData32,
 ): AlphaMask {
   const {
-    data32,
-    width,
-    height,
+    data,
+    w,
+    h,
   } = pixelData
-  const len = data32.length
-  const mask = makeAlphaMask(width, height)
+  const len = data.length
+  const mask = makeAlphaMask(w, h)
   const maskData = mask.data
 
   for (let i = 0; i < len; i++) {
-    const val = data32[i]
+    const val = data[i]
 
     // Extract the Alpha byte (top 8 bits in ABGR / Little-Endian)
     // Shift right by 24 moves the 4th byte to the 1st position

package/src/PixelData/reflectPixelData.ts

@@ -1,9 +1,9 @@
-import type { IPixelData32 } from '../_types'
+import type { PixelData32 } from './_pixelData-types'
 
-export function reflectPixelDataHorizontal(pixelData: IPixelData32): void {
-  const width = pixelData.width
-  const height = pixelData.height
-  const data = pixelData.data32
+export function reflectPixelDataHorizontal(pixelData: PixelData32): void {
+  const width = pixelData.w
+  const height = pixelData.h
+  const data = pixelData.data
   const halfWidth = Math.floor(width / 2)
 
   for (let y = 0; y < height; y++) {
@@ -20,10 +20,10 @@ export function reflectPixelDataHorizontal(pixelData: IPixelData32): void {
   }
 }
 
-export function reflectPixelDataVertical(pixelData: IPixelData32): void {
-  const width = pixelData.width
-  const height = pixelData.height
-  const data = pixelData.data32
+export function reflectPixelDataVertical(pixelData: PixelData32): void {
+  const width = pixelData.w
+  const height = pixelData.h
+  const data = pixelData.data
   const halfHeight = Math.floor(height / 2)
 
   for (let y = 0; y < halfHeight; y++) {

package/src/PixelData/resamplePixelData.ts

@@ -1,19 +1,30 @@
-import { type IPixelData32, PixelData } from '../index'
-import { resample32 } from '../Internal/resample32'
+import { resampleUint32Array } from '../Algorithm/resampleUint32Array'
+import { type MutablePixelData32, type PixelData, type PixelData32, uInt32ArrayToImageData } from '../index'
 
 /**
  * Resamples PixelData by a specific factor using nearest neighbor.
  * Factor > 1 upscales, Factor < 1 downscales.
  */
 export function resamplePixelData(
-  pixelData: IPixelData32,
+  pixelData: PixelData32,
   factor: number,
 ): PixelData {
-  const { data, width, height } = resample32(pixelData.data32, pixelData.width, pixelData.height, factor)
 
-  return new PixelData(new ImageData(
-    new Uint8ClampedArray(data.buffer) as ImageDataArray,
-    width,
-    height,
-  ))
+  const output = {} as MutablePixelData32
+
+  const resampled = resampleUint32Array(pixelData.data, pixelData.w, pixelData.h, factor, output) as PixelData
+
+  (resampled as any).imageData = uInt32ArrayToImageData(resampled.data, resampled.w, resampled.h)
+
+  return resampled
+}
+
+export function resamplePixelDataInPlace(
+  pixelData: PixelData32,
+  factor: number,
+): void {
+
+  const resampled = resampleUint32Array(pixelData.data, pixelData.w, pixelData.h, factor, pixelData) as PixelData
+
+  (resampled as any).imageData = uInt32ArrayToImageData(resampled.data, resampled.w, resampled.h)
 }

package/src/PixelData/rotatePixelData.ts

@@ -1,4 +1,5 @@
-import { PixelData } from './PixelData'
+import type { PixelData } from './_pixelData-types'
+import { setPixelData } from './PixelData'
 
 /**
  * Rotates pixel data 90 degrees clockwise.
@@ -6,9 +7,9 @@ import { PixelData } from './PixelData'
  * If rectangular, it replaces the internal ImageData with a new rotated version.
  */
 export function rotatePixelData(pixelData: PixelData): void {
-  const width = pixelData.width
-  const height = pixelData.height
-  const data = pixelData.data32
+  const width = pixelData.w
+  const height = pixelData.h
+  const data = pixelData.data
 
   if (width === height) {
     rotateSquareInPlace(pixelData)
@@ -38,12 +39,12 @@ export function rotatePixelData(pixelData: PixelData): void {
     newHeight,
   )
 
-  pixelData.set(newImageData)
+  setPixelData(pixelData, newImageData)
 }
 
 function rotateSquareInPlace(pixelData: PixelData): void {
-  const n = pixelData.width
-  const data = pixelData.data32
+  const n = pixelData.w
+  const data = pixelData.data
 
   for (let i = 0; i < n / 2; i++) {
     for (let j = i; j < n - i - 1; j++) {

package/src/PixelData/uInt32ArrayToPixelData.ts

@@ -0,0 +1,15 @@
+import { makePixelData, type PixelData } from '../index'
+
+export function uInt32ArrayToPixelData(
+  data: Uint32Array,
+  width: number,
+  height: number,
+): PixelData {
+  const buffer = data.buffer as ArrayBuffer
+  const byteOffset = data.byteOffset
+  const byteLength = data.byteLength
+  const clampedArray = new Uint8ClampedArray(buffer, byteOffset, byteLength)
+  const imageData = new ImageData(clampedArray, width, height)
+
+  return makePixelData(imageData)
+}

package/src/PixelData/writePaintBufferToPixelData.ts

@@ -1,13 +1,13 @@
-import type { IPixelData } from '../_types'
-import type { PaintBuffer } from '../Paint/PaintBuffer'
+import type { ColorPaintBuffer } from '../Paint/ColorPaintBuffer'
+import type { PixelData } from './_pixelData-types'
 import { writePixelDataBuffer } from './writePixelDataBuffer'
 
 /**
  * @param writePixelDataBufferFn - @hidden
  */
 export function writePaintBufferToPixelData(
-  target: IPixelData,
-  paintBuffer: PaintBuffer,
+  target: PixelData,
+  paintBuffer: ColorPaintBuffer,
   writePixelDataBufferFn = writePixelDataBuffer,
 ) {
   const tileShift = paintBuffer.config.tileShift
@@ -20,7 +20,7 @@ export function writePaintBufferToPixelData(
       const dx = tile.tx << tileShift
       const dy = tile.ty << tileShift
 
-      writePixelDataBufferFn(target, tile.data32, dx, dy, tile.width, tile.height)
+      writePixelDataBufferFn(target, tile.data, dx, dy, tile.w, tile.h)
     }
   }
 }

package/src/PixelData/writePixelDataBuffer.ts

@@ -1,21 +1,22 @@
-import { type IPixelData32, type Rect } from '../_types'
-import { makeClippedBlit, resolveBlitClipping } from '../Internal/resolveClipping'
+import type { Rect } from '../Rect/_rect-types'
+import { makeClippedBlit, resolveBlitClipping } from '../Rect/resolveClipping'
+import type { PixelData32 } from './_pixelData-types'
 
 const SCRATCH_BLIT = makeClippedBlit()
 
 /**
- * Copies a pixel buffer into a specific region of a {@link IPixelData32} object.
+ * Copies a pixel buffer into a specific region of a {@link PixelData32} object.
  *
  * This function performs a direct memory copy from a {@link Uint32Array}
  * into the target buffer.
  */
 export function writePixelDataBuffer(
-  target: IPixelData32,
+  target: PixelData32,
   data: Uint32Array,
   rect: Rect,
 ): void
 export function writePixelDataBuffer(
-  target: IPixelData32,
+  target: PixelData32,
   data: Uint32Array,
   x: number,
   y: number,
@@ -23,7 +24,7 @@ export function writePixelDataBuffer(
   h: number,
 ): void
 export function writePixelDataBuffer(
-  target: IPixelData32,
+  target: PixelData32,
   data: Uint32Array,
   _x: Rect | number,
   _y?: number,
@@ -39,9 +40,9 @@ export function writePixelDataBuffer(
       h: _h!,
     }
 
-  const dstW = target.width
-  const dstH = target.height
-  const dstData = target.data32
+  const dstW = target.w
+  const dstH = target.h
+  const dstData = target.data
 
   // treat the source buffer as a Source Image starting at 0,0 with size w,h
   const clip = resolveBlitClipping(

package/src/Rect/_rect-types.ts

@@ -0,0 +1,7 @@
+/** Rectangle definition */
+export type Rect = {
+  x: number
+  y: number
+  w: number
+  h: number
+}

package/src/Rect/getRectsBounds.ts

@@ -1,4 +1,4 @@
-import type { Rect } from '../_types'
+import type { Rect } from './_rect-types'
 
 export function getRectsBounds<T extends Rect>(rects: T[]): T {
   if (rects.length === 1) return { ...rects[0] }

package/src/Rect/trimMaskRectBounds.ts

@@ -1,5 +1,6 @@
-import type { NullableMaskRect, Rect } from '../_types'
+import type { NullableMaskRect } from '../Mask/_mask-types'
 import { extractMaskBuffer } from '../Mask/extractMaskBuffer'
+import type { Rect } from './_rect-types'
 
 /**
  * Intersects a target rectangle with a boundary, trimming dimensions and masks in-place.

package/src/Rect/trimRectBounds.ts

@@ -1,4 +1,4 @@
-import { type Rect } from '../_types'
+import type { Rect } from './_rect-types'
 
 export function trimRectBounds(
   x: number,

package/src/Tile/MaskTile.ts

@@ -0,0 +1,40 @@
+import { MaskType } from '../Mask/_mask-types'
+import { type AlphaMaskTile, type BinaryMaskTile, type TileFactory, TileType } from './_tile-types'
+
+export const makeAlphaMaskTile: TileFactory<AlphaMaskTile> = (
+  id: number,
+  tx: number,
+  ty: number,
+  tileSize: number,
+  tileArea: number,
+) => {
+  return {
+    tileType: TileType.MASK,
+    type: MaskType.ALPHA,
+    data: new Uint8Array(tileArea),
+    w: tileSize,
+    h: tileSize,
+    id,
+    tx,
+    ty,
+  }
+}
+
+export const makeBinaryMaskTile: TileFactory<BinaryMaskTile> = (
+  id: number,
+  tx: number,
+  ty: number,
+  tileSize: number,
+  tileArea: number,
+) => {
+  return {
+    tileType: TileType.MASK,
+    type: MaskType.BINARY,
+    data: new Uint8Array(tileArea),
+    w: tileSize,
+    h: tileSize,
+    id,
+    tx,
+    ty,
+  }
+}

package/src/Tile/PixelTile.ts

@@ -0,0 +1,23 @@
+import { type PixelTile, TileType } from './_tile-types'
+
+export function makePixelTile(
+  id: number,
+  tx: number,
+  ty: number,
+  tileSize: number,
+  tileArea: number,
+): PixelTile {
+  const data32 = new Uint32Array(tileArea)
+  const data8 = new Uint8ClampedArray(data32.buffer) as Uint8ClampedArray<ArrayBuffer>
+
+  return {
+    tileType: TileType.PIXEL,
+    id,
+    tx,
+    ty,
+    w: tileSize,
+    h: tileSize,
+    data: data32,
+    imageData: new ImageData(data8, tileSize, tileSize),
+  }
+}

package/src/{PixelTile/PixelTilePool.ts → Tile/TilePool.ts}

@@ -1,15 +1,15 @@
 import type { PixelEngineConfig } from '../History/PixelEngineConfig'
+import type { Tile, TileFactory } from './_tile-types'
 
-import { PixelTile } from './PixelTile'
-
-export class PixelTilePool {
-  public pool: PixelTile[]
+export class TilePool<T extends Tile> {
+  public pool: T[]
 
   private tileSize: number
   private tileArea: number
 
   constructor(
     config: PixelEngineConfig,
+    private tileFactory: TileFactory<T>,
   ) {
     this.pool = []
     this.tileSize = config.tileSize
@@ -20,7 +20,7 @@ export class PixelTilePool {
     id: number,
     tx: number,
     ty: number,
-  ): PixelTile {
+  ): T {
     let tile = this.pool.pop()
 
     if (tile) {
@@ -29,12 +29,12 @@ export class PixelTilePool {
       tile.ty = ty
 
       // Wipe dirty memory from previous uses before handing it out
-      tile.data32.fill(0)
+      tile.data.fill(0)
 
       return tile
     }
 
-    return new PixelTile(
+    return this.tileFactory(
       id,
       tx,
       ty,
@@ -43,11 +43,11 @@ export class PixelTilePool {
     )
   }
 
-  releaseTile(tile: PixelTile): void {
+  releaseTile(tile: T): void {
     this.pool.push(tile)
   }
 
-  releaseTiles(tiles: (PixelTile | undefined)[]): void {
+  releaseTiles(tiles: (T | undefined)[]): void {
     let length = tiles.length
 
     for (let i = 0; i < length; i++) {

package/src/Tile/_tile-types.ts

@@ -0,0 +1,33 @@
+import type { AlphaMask, BinaryMask } from '../Mask/_mask-types'
+import type { PixelData } from '../PixelData/_pixelData-types'
+
+export const enum TileType {
+  PIXEL,
+  MASK,
+}
+
+interface BaseTile {
+  tileType: TileType,
+  id: number
+  tx: number
+  ty: number
+}
+
+export interface PixelTile extends PixelData, BaseTile {
+}
+
+export interface AlphaMaskTile extends AlphaMask, BaseTile {
+}
+
+export interface BinaryMaskTile extends BinaryMask, BaseTile {
+}
+
+export type Tile = PixelTile | AlphaMaskTile | BinaryMaskTile
+
+export type TileFactory<T extends Tile> = (
+  id: number,
+  tx: number,
+  ty: number,
+  tileSize: number,
+  tileArea: number,
+) => T

package/src/_errors.ts

@@ -0,0 +1 @@
+export * as ERRORS from './Internal/_errors'