refactor: cleanup unused code

Author: Jack-Works

src/utils/expose.ts

@@ -30,7 +30,11 @@ const algorithms = {
 export function createAPI(_: IO) {
   const { preprocessImage, toPNG: toBuffer, toImageData, defaultRandomSource } = _
   return {
-    async encode(image: ArrayBuffer, mask: ArrayBuffer, options: EncodeOptions) {
+    async encode(
+      image: ArrayBufferLike | ArrayLike<number>,
+      mask: ArrayBufferLike | ArrayLike<number>,
+      options: EncodeOptions,
+    ) {
       const { data, height, width } = await algorithms[options.version].encode(
         preprocessImage(await toImageData(image)),
         preprocessImage(await toImageData(mask)).data,
@@ -39,7 +43,11 @@ export function createAPI(_: IO) {
       )
       return toBuffer(data, height, width)
     },
-    async decode(image: ArrayBuffer, mask: ArrayBuffer, options: DecodeOptions) {
+    async decode(
+      image: ArrayBufferLike | ArrayLike<number>,
+      mask: ArrayBufferLike | ArrayLike<number>,
+      options: DecodeOptions,
+    ) {
       return algorithms[options.version].decode(await toImageData(image), (await toImageData(mask)).data, options)
     },
   }

src/v2/bit.ts

@@ -1,5 +1,5 @@
 import { Options } from '../utils/stego-params.js'
-import { getPos, Accumulator } from './position.js'
+import { getPos } from './position.js'
 import { TransformAlgorithm } from '../utils/transform.js'
 import { DEFAULT_PARAM_COPIES } from '../constant.js'
 
@@ -104,7 +104,7 @@ function code2char(c: number) {
   return URIcharCode.indexOf(c) !== -1 ? URIchars[URIcharCode.indexOf(c)] : ''
 }
 
-export function str2codes(text: string): number[] {
+function str2codes(text: string): number[] {
   const codes: number[] = []
   Array.from(text).map((char) => {
     const URIcodes = Array.from(encodeURI(char))
@@ -113,7 +113,7 @@ export function str2codes(text: string): number[] {
   return codes
 }
 
-export function codes2bits(codes: number[], copies: number): Bit[] {
+function codes2bits(codes: number[], copies: number): Bit[] {
   const bits: Bit[] = []
   const pushByte = (byte: Bit[], n: number) => {
     for (let i = 0; i < 8; i += 1) {
@@ -402,7 +402,7 @@ export function mergeBits(dest: Bit[], ...src: Bit[][]) {
   return dest
 }
 
-export function getBit(block: number[], acc: Accumulator, options: Options) {
+export function getBit(block: number[], options: Options) {
   const [pos1, pos2] = getPos(options)
   if (options.verbose) console.warn('decoded value: ', block[pos1], block[pos2])
   const diff = block[pos1] - block[pos2]

src/v2/position.ts

@@ -1,56 +1,8 @@
 import { Options } from '../utils/stego-params.js'
 import { TransformAlgorithm } from '../utils/transform.js'
-import { hashCode, squareCircleIntersect } from '../utils/helper.js'
-import { Locator } from '../utils/locator.js'
 
-export interface Accumulator {
-  /**
-   * previous bit position
-   */
-  prevPos: number
-  /**
-   * previous hash code
-   */
-  prevCode: string
-  /**
-   * available indices
-   */
-  readonly indices: number[]
-}
-
-export function createAcc({ size, transformAlgorithm }: Options) {
-  switch (transformAlgorithm) {
-    case TransformAlgorithm.FFT1D:
-      return {
-        prevPos: -1,
-        prevCode: '',
-        indices: squareCircleIntersect(size, 3),
-      }
-    default:
-      return {
-        prevPos: -1,
-        prevCode: '',
-        indices: [],
-      }
-  }
-}
-
-export function getPosFromAcc(acc: Accumulator, { c }: Locator, { pass }: Options) {
-  const { prevCode, prevPos, indices } = acc
-
-  if (c !== 0) {
-    return prevPos
-  }
-
-  const [index, code] = hashCode(`${pass}_${prevCode}`, indices.length, [])
-
-  acc.prevCode = code
-  acc.prevPos = indices[index]
-  return indices[index]
-}
-
-export function getPos(options: Options): Array<number> {
-  const { pass, size, transformAlgorithm } = options
+export function getPos(options: Options): [pos1: number, pos2: number] {
+  const { size, transformAlgorithm } = options
 
   switch (transformAlgorithm) {
     case TransformAlgorithm.FFT1D:
@@ -62,6 +14,7 @@ export function getPos(options: Options): Array<number> {
     case TransformAlgorithm.FastDCT:
       return [3 * size + 1, 2 * size + 2]
     default:
+      const _: never = transformAlgorithm
       throw new Error(`unknown algorithm in getPos: ${transformAlgorithm}`)
   }
 }

src/v2/stego.ts

@@ -10,7 +10,7 @@ import {
   updateImgByPixelChannelAt,
 } from '../utils/image.js'
 import { mergeBits, str2bits, setBit, getBit, bits2str, param2bits, Bit, bits2param } from './bit.js'
-import { createAcc, getPos } from './position.js'
+import { getPos } from './position.js'
 import { isPixelVisibleAt, isBlockVisibleAt } from '../utils/mask.js'
 import { rand, randomBits, shuffleGroupBy3, unshuffleGroupBy3 } from '../utils/helper.js'
 import { loc2idx, loc2coord } from '../utils/locator.js'
@@ -183,7 +183,6 @@ export async function decodeImg(imgData: ImageData, maskData: Uint8ClampedArray,
     bit: Bit
     diff: number
   }[] = []
-  const acc = createAcc(options)
   const im = new Array(size * size)
 
   const [width, height] = cropImg(imgData, options)
@@ -205,10 +204,10 @@ export async function decodeImg(imgData: ImageData, maskData: Uint8ClampedArray,
           ', bitId: ' +
           (shuffleArr[i] % (8 * options.copies)),
       )
-      console.warn('bit: ' + getBit(block, acc, options).bit, block)
+      console.warn('bit: ' + getBit(block, options).bit, block)
     }
     // let { bit, diff } = getBit(block, acc, options);
-    richBits.push(getBit(block, acc, options))
+    richBits.push(getBit(block, options))
 
     blockId += 1
 

tests/utils.ts

@@ -4,7 +4,6 @@ import { clamp } from '../src/utils/helper.js'
 import { AlgorithmVersion, Options } from '../src/utils/stego-params.js'
 import { inverseTransform, transform, TransformAlgorithm } from '../src/utils/transform.js'
 import { Bit, getBit as getBitV2, setBit as setBitV2 } from '../src/v2/bit.js'
-import { createAcc } from '../src/v2/position.js'
 
 export function createOptions(transformAlgorithm: TransformAlgorithm) {
   return {
@@ -25,9 +24,8 @@ export function encodeBitbyBlock(bit: Bit, block: number[], transformAlgorithm:
 
 export function decodeBitbyBlock(block: number[], transformAlgorithm: TransformAlgorithm, options: Options): Bit {
   const im = new Array(options.size * options.size)
-  const acc = createAcc(options)
   transform(block, im.fill(0), transformAlgorithm, options)
-  return getBitV2(block, acc, options).bit
+  return getBitV2(block, options).bit
 }
 
 export function normalizeBlock(block: number[]) {