pixel-data-js 0.9.2 → 0.10.1

package/dist/index.dev.cjs

@@ -114,6 +114,9 @@ __export(src_exports, {
   pixelDataToAlphaMask: () => pixelDataToAlphaMask,
   reflectPixelDataHorizontal: () => reflectPixelDataHorizontal,
   reflectPixelDataVertical: () => reflectPixelDataVertical,
+  resampleImageData: () => resampleImageData,
+  resampleIndexedImage: () => resampleIndexedImage,
+  resamplePixelData: () => resamplePixelData,
   resizeImageData: () => resizeImageData,
   rotatePixelData: () => rotatePixelData,
   screenFast: () => screenFast,
@@ -1638,6 +1641,31 @@ function invertImageData(imageData) {
   return imageData;
 }
 
+// src/ImageData/resampleImageData.ts
+function resampleImageData(source, factor) {
+  const srcW = source.width;
+  const srcH = source.height;
+  const dstW = Math.max(1, srcW * factor | 0);
+  const dstH = Math.max(1, srcH * factor | 0);
+  const srcData = source.data;
+  const dstData = new Uint8ClampedArray(dstW * dstH * 4);
+  for (let y = 0; y < dstH; y++) {
+    const srcY = y / factor | 0;
+    const srcRowOffset = srcY * srcW * 4;
+    const dstRowOffset = y * dstW * 4;
+    for (let x = 0; x < dstW; x++) {
+      const srcX = x / factor | 0;
+      const srcIdx = srcRowOffset + srcX * 4;
+      const dstIdx = dstRowOffset + x * 4;
+      dstData[dstIdx] = srcData[srcIdx];
+      dstData[dstIdx + 1] = srcData[srcIdx + 1];
+      dstData[dstIdx + 2] = srcData[srcIdx + 2];
+      dstData[dstIdx + 3] = srcData[srcIdx + 3];
+    }
+  }
+  return new ImageData(dstData, dstW, dstH);
+}
+
 // src/ImageData/resizeImageData.ts
 function resizeImageData(current, newWidth, newHeight, offsetX = 0, offsetY = 0) {
   const result = new ImageData(newWidth, newHeight);
@@ -1732,10 +1760,12 @@ function writeImageDataPixels(imageData, data, _x, _y, _w, _h) {
 }
 
 // src/IndexedImage/IndexedImage.ts
-function makeIndexedImage(imageData) {
-  const width = imageData.width;
-  const height = imageData.height;
-  const rawData = new Uint32Array(imageData.data.buffer);
+function makeIndexedImage(imageOrData, width, height) {
+  const isImageData = "width" in imageOrData;
+  const actualWidth = isImageData ? imageOrData.width : width;
+  const actualHeight = isImageData ? imageOrData.height : height;
+  const buffer = isImageData ? imageOrData.data.buffer : imageOrData.buffer;
+  const rawData = new Uint32Array(buffer);
   const indexedData = new Int32Array(rawData.length);
   const colorMap = /* @__PURE__ */ new Map();
   const transparentColor = 0;
@@ -1745,7 +1775,7 @@ function makeIndexedImage(imageData) {
     const pixel = rawData[i];
     const alpha = pixel >>> 24 & 255;
     const isTransparent = alpha === 0;
-    const colorKey = isTransparent ? transparentColor : pixel;
+    const colorKey = isTransparent ? transparentColor : pixel >>> 0;
     let id = colorMap.get(colorKey);
     if (id === void 0) {
       id = colorMap.size;
@@ -1753,16 +1783,28 @@ function makeIndexedImage(imageData) {
     }
     indexedData[i] = id;
   }
-  const palette = new Int32Array(colorMap.keys());
+  const palette = Uint32Array.from(colorMap.keys());
   return {
-    width,
-    height,
+    width: actualWidth,
+    height: actualHeight,
     data: indexedData,
     transparentPalletIndex,
     palette
   };
 }
 
+// src/IndexedImage/getIndexedImageColorCounts.ts
+function getIndexedImageColorCounts(indexedImage) {
+  const data = indexedImage.data;
+  const palette = indexedImage.palette;
+  const frequencies = new Int32Array(palette.length);
+  for (let i = 0; i < data.length; i++) {
+    const colorIndex = data[i];
+    frequencies[colorIndex]++;
+  }
+  return frequencies;
+}
+
 // src/IndexedImage/indexedImageToAverageColor.ts
 function indexedImageToAverageColor(indexedImage, includeTransparent = false) {
   const { data, palette, transparentPalletIndex } = indexedImage;
@@ -1805,16 +1847,30 @@ function indexedImageToAverageColor(indexedImage, includeTransparent = false) {
   return packColor(r, g, b, a);
 }
 
-// src/IndexedImage/getIndexedImageColorCounts.ts
-function getIndexedImageColorCounts(indexedImage) {
-  const data = indexedImage.data;
-  const palette = indexedImage.palette;
-  const frequencies = new Int32Array(palette.length);
-  for (let i = 0; i < data.length; i++) {
-    const colorIndex = data[i];
-    frequencies[colorIndex]++;
+// src/IndexedImage/resampleIndexedImage.ts
+function resampleIndexedImage(source, factor) {
+  const srcW = source.width;
+  const srcH = source.height;
+  const dstW = srcW * factor;
+  const dstH = srcH * factor;
+  const srcData = source.data;
+  const dstData = new Int32Array(dstW * dstH);
+  for (let y = 0; y < dstH; y++) {
+    const srcY = y / factor | 0;
+    const rowOffset = srcY * srcW;
+    const dstOffset = y * dstW;
+    for (let x = 0; x < dstW; x++) {
+      const srcX = x / factor | 0;
+      dstData[dstOffset + x] = srcData[rowOffset + srcX];
+    }
   }
-  return frequencies;
+  return {
+    width: dstW,
+    height: dstH,
+    data: dstData,
+    palette: source.palette,
+    transparentPalletIndex: source.transparentPalletIndex
+  };
 }
 
 // src/Input/fileInputChangeToImageData.ts
@@ -2441,6 +2497,28 @@ function reflectPixelDataVertical(pixelData) {
   }
 }
 
+// src/PixelData/resamplePixelData.ts
+function resamplePixelData(pixelData, factor) {
+  const dstW = Math.max(1, pixelData.width * factor | 0);
+  const dstH = Math.max(1, pixelData.height * factor | 0);
+  const dstBuffer = new Uint8ClampedArray(dstW * dstH * 4);
+  const dstData32 = new Uint32Array(dstBuffer.buffer);
+  for (let y = 0; y < dstH; y++) {
+    const srcY = y / factor | 0;
+    const srcRowOffset = srcY * pixelData.width;
+    const dstRowOffset = y * dstW;
+    for (let x = 0; x < dstW; x++) {
+      const srcX = x / factor | 0;
+      dstData32[dstRowOffset + x] = pixelData.data32[srcRowOffset + srcX];
+    }
+  }
+  return new PixelData({
+    data: dstBuffer,
+    width: dstW,
+    height: dstH
+  });
+}
+
 // src/PixelData/rotatePixelData.ts
 function rotatePixelData(pixelData) {
   const width = pixelData.width;
@@ -2579,6 +2657,9 @@ function rotateSquareInPlace(pixelData) {
   pixelDataToAlphaMask,
   reflectPixelDataHorizontal,
   reflectPixelDataVertical,
+  resampleImageData,
+  resampleIndexedImage,
+  resamplePixelData,
   resizeImageData,
   rotatePixelData,
   screenFast,