Skip to content

Measure pixel differences between pam image pixel arrays. Pam is an image type similar to ppm, pbm, and pgm. It has a small header that is followed by an uncompressed array of pixel data.

License

Notifications You must be signed in to change notification settings

kevinGodell/pam-diff

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

pam-diff

Buy me a coffee Donate via PayPal Build Status Build Status GitHub Issues GitHub License npm

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:
  1. 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);
     });
  2. 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:
  1. When targeting all pixels:

    {
        trigger: [
            { name: 'all', percent: 13 }
        ],
        pam: <Buffer>,
        headers: <Buffer>,
        pixels: <Buffer>
    }
    
  2. When targeting regions of pixels:

    {
        trigger: [
            { name: 'region1', percent: 13 },
            { name: 'region2', percent: 22 }
        ],
        pam: <Buffer>,
        headers: <Buffer>,
       pixels: <Buffer>
    }
    
  3. When targeting all pixels ignored by mask:

    {
        trigger: [
            { name: 'mask', percent: 13 }
        ],
        pam: <Buffer>,
        headers: <Buffer>,
        pixels: <Buffer>
    }
    
  4. 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>
    }
    
  5. 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.

About

Measure pixel differences between pam image pixel arrays. Pam is an image type similar to ppm, pbm, and pgm. It has a small header that is followed by an uncompressed array of pixel data.

Resources

License

Stars

Watchers

Forks

Packages

No packages published