当前位置：首页 > JavaScript

js实现卷积

2026-02-02 00:53:01JavaScript

实现卷积的基本概念

卷积是一种数学运算，常用于信号处理、图像处理等领域。在JavaScript中实现卷积，需要理解卷积核（Kernel）与输入数据的滑动窗口相乘并求和的过程。

定义卷积函数

以下是一个基本的二维卷积函数实现，适用于图像或矩阵数据：

js实现卷积

function convolve2D(input, kernel, padding = 0, stride = 1) {
  const inputHeight = input.length;
  const inputWidth = input[0].length;
  const kernelHeight = kernel.length;
  const kernelWidth = kernel[0].length;

  // 计算输出尺寸
  const outputHeight = Math.floor((inputHeight + 2 * padding - kernelHeight) / stride) + 1;
  const outputWidth = Math.floor((inputWidth + 2 * padding - kernelWidth) / stride) + 1;

  // 初始化输出矩阵
  const output = new Array(outputHeight);
  for (let i = 0; i < outputHeight; i++) {
    output[i] = new Array(outputWidth).fill(0);
  }

  // 添加padding
  const paddedInput = new Array(inputHeight + 2 * padding);
  for (let i = 0; i < inputHeight + 2 * padding; i++) {
    paddedInput[i] = new Array(inputWidth + 2 * padding).fill(0);
    for (let j = 0; j < inputWidth + 2 * padding; j++) {
      if (i >= padding && i < inputHeight + padding && j >= padding && j < inputWidth + padding) {
        paddedInput[i][j] = input[i - padding][j - padding];
      }
    }
  }

  // 执行卷积
  for (let y = 0; y < outputHeight; y++) {
    for (let x = 0; x < outputWidth; x++) {
      let sum = 0;
      for (let ky = 0; ky < kernelHeight; ky++) {
        for (let kx = 0; kx < kernelWidth; kx++) {
          const inputY = y * stride + ky;
          const inputX = x * stride + kx;
          sum += paddedInput[inputY][inputX] * kernel[ky][kx];
        }
      }
      output[y][x] = sum;
    }
  }

  return output;
}

使用示例

// 输入矩阵
const input = [
  [1, 2, 3, 4],
  [5, 6, 7, 8],
  [9, 10, 11, 12],
  [13, 14, 15, 16]
];

// 卷积核（例如边缘检测）
const kernel = [
  [-1, -1, -1],
  [-1,  8, -1],
  [-1, -1, -1]
];

// 执行卷积
const result = convolve2D(input, kernel, 1, 1);
console.log(result);

性能优化建议

对于大型数据或实时应用，可以考虑以下优化方法：

js实现卷积

使用TypedArray（如Float32Array）代替普通数组
利用Web Workers进行并行计算
考虑使用WebGL通过GPU加速计算

一维卷积实现

如果需要处理一维信号（如音频），可以使用简化的一维卷积：

function convolve1D(signal, kernel) {
  const resultLength = signal.length + kernel.length - 1;
  const result = new Array(resultLength).fill(0);

  for (let i = 0; i < signal.length; i++) {
    for (let j = 0; j < kernel.length; j++) {
      result[i + j] += signal[i] * kernel[j];
    }
  }

  return result;
}