pam-diff

pam-diff

Measure differences between pixel arrays extracted from pam images. Works well with node module pipe2pam to extract pam images from an ffmpeg pipe. Supported tupltypes are rgb, rgb_alpha, and grayscale. It is currently being used for a video motion detection project.

Installation:

npm install pam-diff --save

Changelog:

version 1.2.1:

• Set defaults if configuration object is not passed in constructor.

version 1.2.0:

• Dropping support for node.js < 14.
• Data event emitted for all results returned from pixel-change.
• Initialized event emitted after first chunk parsed.
• Debug object attached to output if debug property is set to true.
• Updated docs to show deprecations.

version 1.1.0:

• Percent is now a float to allow for more precise results.
• Sync option is removed.

Usage Options:

When comparing 2 equally sized buffers of grayscale, rgb, or rgba pixels, there are several options:

• all (default)

  • All pixels will be targeted when checking for differences.
  • To use this option, set the configuration object without creating any regions.

  const pamDiff = new PamDiff({ difference: 5, percent: 5 });
  

• regions

  • Specific regions of pixels will be targeted when checking for differences and the rest will be ignored.
  • To use this option, create a regions array and pass it to the constructor.

  const region1 = {
    name: 'region1',
    difference: 12,
    percent: 22,
    polygon: [
      { x: 0, y: 0 },
      { x: 0, y: 224 },
      { x: 99, y: 224 },
      { x: 99, y: 0 },
    ],
  };
  const region2 = {
    name: 'region2',
    difference: 14,
    percent: 10,
    polygon: [
      { x: 100, y: 0 },
      { x: 100, y: 224 },
      { x: 199, y: 224 },
      { x: 199, y: 0 },
    ],
  };
  const regions = [region1, region2];
  const pamDiff = new PamDiff({ regions: regions });
  

• mask

  • Specific regions of pixels will be ignored when checking for differences.
  • To use this option, create a regions array and set the mask option to true.
  • difference and percent of the individual region is ignored. Set global values.

  const region1 = {
    name: 'region1',
    polygon: [
      { x: 0, y: 0 },
      { x: 0, y: 224 },
      { x: 99, y: 224 },
      { x: 99, y: 0 },
    ],
  };
  const region2 = {
    name: 'region2',
    polygon: [
      { x: 100, y: 0 },
      { x: 100, y: 224 },
      { x: 199, y: 224 },
      { x: 199, y: 0 },
    ],
  };
  const regions = [region1, region2];
  const pamDiff = new PamDiff({ difference: 12, percent: 10, mask: true, regions: regions });
  

Getting results back from the pixel difference detection:

• event

  • A diff event will be emitted when there is a pixel difference detection.

   pamDiff.on('diff', data => {
     console.log(data);
   });
  

  • A data event will be emitted regardless of pixel difference detection.

   pamDiff.on('data', data => {
     console.log(data);
   });
  

• callback (deprecated)

  • A callback function will be called with a data object passed as the only argument.
  • The callback can be passed as the 2nd argument to the constructor, or it can be added later.
  • Deprecated. Scheduled to be removed.

  /* callback function */
  function myCallback(data) {
    console.log(data);
  }
  
  /* via the constructor */
  const pamDiff = new pamDiff({ difference: 10, percent: 20 }, myCallback);
  
  /* via the setter */
  pamDiff.callback = myCallback;
  
  /* via the chain-able setter */
  pamDiff.setCallback(myCallback).setDifference(10).setPercent(20);
  
  /* remove the callback */
  pamDiff.callback = null;
  

Expected results:

• When targeting all pixels:

  {
      trigger: [
          { name: 'all', percent: 13 }
      ],
      pam: <Buffer>,
      headers: <Buffer>,
      pixels: <Buffer>
  }
  

• When targeting regions of pixels:

  {
      trigger: [
          { name: 'region1', percent: 13 },
          { name: 'region2', percent: 22 }
      ],
      pam: <Buffer>,
      headers: <Buffer>,
     pixels: <Buffer>
  }
  

• When targeting all pixels ignored by mask:

  {
      trigger: [
          { name: 'mask', percent: 13 }
      ],
      pam: <Buffer>,
      headers: <Buffer>,
      pixels: <Buffer>
  }
  

• When targeting all pixels and setting {response: "bounds"}:

  {
      trigger: [
          { name: 'all', percent: 13, minX: 42, maxX: 399, minY: 113, maxY: 198 }
      ],
      pam: <Buffer>,
      headers: <Buffer>,
      pixels: <Buffer>
  }
  

• When targeting all pixels and setting {response: "blobs"}:

  {
      trigger: [
          {
              name: "all",
              percent: 9,
              minX: 137,
              maxX: 1782,
              minY: 392,
              maxY: 695,
              blobs: [
                  {
                      label: 0,
                      percent: 3,
                      minX: 1192,
                      maxX: 1486,
                      minY: 392,
                      maxY: 695
                  },
                  {
                      label: 1,
                      percent: 3,
                      minX: 1488,
                      maxX: 1782,
                      minY: 392,
                      maxY: 695
                  }
              ]
          }
      ],
      pam: <Buffer>,
      headers: <Buffer>,
      pixels: <Buffer>
  }
  

Other Resources:

View the docs, tests, or examples for more implementations.