Function convolution

plugins/plugin-color/src/index.ts:569–657

* Adds each element of the image to its local neighbors, weighted by the kernel * @example * ```ts * import { Jimp } from "jimp"; * * const image = await Jimp.read("test/image.png"); * * image.convolute([ * [-1, -1, 0], * [-1, 1, 1], * [0, 1, 1], * ]); * ```

(image: I, options: ConvolutionOptions)

   * ```
   */
  convolution<I extends JimpClass>(image: I, options: ConvolutionOptions) {
    const parsed = ConvolutionOptionsSchema.parse(options);
    const { kernel, edgeHandling = Edge.EXTEND } =
      "kernel" in parsed ? parsed : { kernel: parsed, edgeHandling: undefined };

    if (!kernel[0]) {
      throw new Error("kernel must be a matrix");
    }

    const newData = Buffer.from(image.bitmap.data);
    const kRows = kernel.length;
    const kCols = kernel[0].length;
    const rowEnd = Math.floor(kRows / 2);
    const colEnd = Math.floor(kCols / 2);
    const rowIni = -rowEnd;
    const colIni = -colEnd;

    let weight;
    let rSum;
    let gSum;
    let bSum;
    let ri;
    let gi;
    let bi;
    let xi;
    let yi;
    let idxi;

    image.scan((x, y, idx) => {
      bSum = 0;
      gSum = 0;
      rSum = 0;

      for (let row = rowIni; row <= rowEnd; row++) {
        for (let col = colIni; col <= colEnd; col++) {
          xi = x + col;
          yi = y + row;
          weight = kernel[row + rowEnd]![col + colEnd]!;
          idxi = image.getPixelIndex(xi, yi, edgeHandling);

          if (idxi === -1) {
            bi = 0;
            gi = 0;
            ri = 0;
          } else {
            ri = image.bitmap.data[idxi + 0]!;
            gi = image.bitmap.data[idxi + 1]!;
            bi = image.bitmap.data[idxi + 2]!;
          }

          rSum += weight * ri;
          gSum += weight * gi;
          bSum += weight * bi;
        }
      }

      if (rSum < 0) {
        rSum = 0;