pixel-data-js 0.13.0 → 0.15.0

package/dist/index.dev.cjs

@@ -64,8 +64,9 @@ __export(src_exports, {
   dividePerfect: () => dividePerfect,
   exclusionFast: () => exclusionFast,
   exclusionPerfect: () => exclusionPerfect,
-  extractImageDataPixels: () => extractImageDataPixels,
+  extractImageDataBuffer: () => extractImageDataBuffer,
   extractMask: () => extractMask,
+  extractPixelDataBuffer: () => extractPixelDataBuffer,
   fileInputChangeToImageData: () => fileInputChangeToImageData,
   fileToImageData: () => fileToImageData,
   fillPixelData: () => fillPixelData,
@@ -80,6 +81,7 @@ __export(src_exports, {
   imageDataToAlphaMask: () => imageDataToAlphaMask,
   imageDataToDataUrl: () => imageDataToDataUrl,
   imageDataToImgBlob: () => imageDataToImgBlob,
+  imageDataToUInt32Array: () => imageDataToUInt32Array,
   imgBlobToImageData: () => imgBlobToImageData,
   indexedImageToAverageColor: () => indexedImageToAverageColor,
   indexedImageToImageData: () => indexedImageToImageData,
@@ -703,8 +705,8 @@ function color32ToCssRGBA(color) {
   return `rgba(${r},${g},${b},${alpha})`;
 }
 
-// src/ImageData/extractImageDataPixels.ts
-function extractImageDataPixels(imageData, _x, _y, _w, _h) {
+// src/ImageData/extractImageDataBuffer.ts
+function extractImageDataBuffer(imageData, _x, _y, _w, _h) {
   const { x, y, w, h } = typeof _x === "object" ? _x : { x: _x, y: _y, w: _w, h: _h };
   const { width: srcW, height: srcH, data: src } = imageData;
   if (w <= 0 || h <= 0) return new Uint8ClampedArray(0);
@@ -977,7 +979,7 @@ function floodFillSelection(img, startX, startY, {
     selectionRect,
     { x: 0, y: 0, w: width, h: height }
   );
-  const extracted = extractImageDataPixels(
+  const extracted = extractImageDataBuffer(
     imageData,
     selectionRect.x,
     selectionRect.y,
@@ -1650,6 +1652,16 @@ function imageDataToDataUrl(imageData) {
 }
 imageDataToDataUrl.reset = get.reset;
 
+// src/ImageData/imageDataToUInt32Array.ts
+function imageDataToUInt32Array(imageData) {
+  return new Uint32Array(
+    imageData.data.buffer,
+    imageData.data.byteOffset,
+    // Shift right by 2 is a fast bitwise division by 4.
+    imageData.data.byteLength >> 2
+  );
+}
+
 // src/ImageData/invertImageData.ts
 function invertImageData(imageData) {
   const data = imageData.data;
@@ -2185,28 +2197,34 @@ function mergeMasks(dst, dstWidth, src, opts) {
 
 // src/PixelData/PixelData.ts
 var PixelData = class _PixelData {
+  data32;
+  imageData;
+  get width() {
+    return this.imageData.width;
+  }
+  get height() {
+    return this.imageData.height;
+  }
   constructor(imageData) {
+    this.data32 = imageDataToUInt32Array(imageData);
     this.imageData = imageData;
-    this.width = imageData.width;
-    this.height = imageData.height;
-    this.data32 = new Uint32Array(
-      imageData.data.buffer,
-      imageData.data.byteOffset,
-      // Shift right by 2 is a fast bitwise division by 4.
-      imageData.data.byteLength >> 2
-    );
   }
-  data32;
-  width;
-  height;
+  set(imageData) {
+    this.imageData = imageData;
+    this.data32 = imageDataToUInt32Array(imageData);
+  }
+  /**
+   * Creates a deep copy of the PixelData using the environment's ImageData constructor.
+   */
   copy() {
-    const buffer = new Uint8ClampedArray(this.data32.buffer.slice(0));
-    const imageData = {
-      data: buffer,
-      width: this.width,
-      height: this.height
-    };
-    return new _PixelData(imageData);
+    const buffer = new Uint8ClampedArray(this.imageData.data);
+    const ImageConstructor = typeof ImageData !== "undefined" ? ImageData : this.imageData.constructor;
+    const newImageData = new ImageConstructor(
+      buffer,
+      this.width,
+      this.height
+    );
+    return new _PixelData(newImageData);
   }
 };
 
@@ -2590,6 +2608,38 @@ function clearPixelData(dst, rect) {
   fillPixelData(dst, 0, rect);
 }
 
+// src/PixelData/extractPixelDataBuffer.ts
+function extractPixelDataBuffer(source, _x, _y, _w, _h) {
+  const { x, y, w, h } = typeof _x === "object" ? _x : { x: _x, y: _y, w: _w, h: _h };
+  const srcW = source.width;
+  const srcH = source.height;
+  const srcData = source.data32;
+  if (w <= 0 || h <= 0) {
+    return new Uint32Array(0);
+  }
+  const dstImageData = new ImageData(w, h);
+  const dstData = new Uint32Array(dstImageData.data.buffer);
+  const x0 = Math.max(0, x);
+  const y0 = Math.max(0, y);
+  const x1 = Math.min(srcW, x + w);
+  const y1 = Math.min(srcH, y + h);
+  if (x1 <= x0 || y1 <= y0) {
+    return dstData;
+  }
+  const copyWidth = x1 - x0;
+  const copyHeight = y1 - y0;
+  for (let row = 0; row < copyHeight; row++) {
+    const srcRow = y0 + row;
+    const srcStart = srcRow * srcW + x0;
+    const dstRow = y0 - y + row;
+    const dstCol = x0 - x;
+    const dstStart = dstRow * w + dstCol;
+    const chunk = srcData.subarray(srcStart, srcStart + copyWidth);
+    dstData.set(chunk, dstStart);
+  }
+  return dstData;
+}
+
 // src/PixelData/invertPixelData.ts
 function invertPixelData(pixelData) {
   const data32 = pixelData.data32;
@@ -2638,11 +2688,11 @@ function reflectPixelDataVertical(pixelData) {
 // src/PixelData/resamplePixelData.ts
 function resamplePixelData(pixelData, factor) {
   const { data, width, height } = resample32(pixelData.data32, pixelData.width, pixelData.height, factor);
-  return new PixelData({
+  return new PixelData(new ImageData(
+    new Uint8ClampedArray(data.buffer),
     width,
-    height,
-    data: new Uint8ClampedArray(data.buffer)
-  });
+    height
+  ));
 }
 
 // src/PixelData/rotatePixelData.ts
@@ -2656,30 +2706,33 @@ function rotatePixelData(pixelData) {
   }
   const newWidth = height;
   const newHeight = width;
-  const newData = new Uint32Array(data.length);
+  const newData32 = new Uint32Array(data.length);
   for (let y = 0; y < height; y++) {
     for (let x = 0; x < width; x++) {
       const oldIdx = y * width + x;
       const newX = height - 1 - y;
       const newY = x;
       const newIdx = newY * newWidth + newX;
-      newData[newIdx] = data[oldIdx];
+      newData32[newIdx] = data[oldIdx];
     }
   }
-  pixelData.width = newWidth;
-  pixelData.height = newHeight;
-  pixelData.data32 = newData;
+  const newImageData = new ImageData(
+    new Uint8ClampedArray(newData32.buffer),
+    newWidth,
+    newHeight
+  );
+  pixelData.set(newImageData);
 }
 function rotateSquareInPlace(pixelData) {
   const n = pixelData.width;
   const data = pixelData.data32;
   for (let i = 0; i < n / 2; i++) {
     for (let j = i; j < n - i - 1; j++) {
-      const temp = data[i * n + j];
       const top = i * n + j;
       const right = j * n + (n - 1 - i);
       const bottom = (n - 1 - i) * n + (n - 1 - j);
       const left = (n - 1 - j) * n + i;
+      const temp = data[top];
       data[top] = data[left];
       data[left] = data[bottom];
       data[bottom] = data[right];
@@ -2733,8 +2786,9 @@ function rotateSquareInPlace(pixelData) {
   dividePerfect,
   exclusionFast,
   exclusionPerfect,
-  extractImageDataPixels,
+  extractImageDataBuffer,
   extractMask,
+  extractPixelDataBuffer,
   fileInputChangeToImageData,
   fileToImageData,
   fillPixelData,
@@ -2749,6 +2803,7 @@ function rotateSquareInPlace(pixelData) {
   imageDataToAlphaMask,
   imageDataToDataUrl,
   imageDataToImgBlob,
+  imageDataToUInt32Array,
   imgBlobToImageData,
   indexedImageToAverageColor,
   indexedImageToImageData,