feat: first version of image-augment

Author: piercus

.gitignore

@@ -0,0 +1,4 @@
+node_modules
+package-lock.json
+.DS_Store
+.nyc

.travis.yml

@@ -0,0 +1,19 @@
+language: node_js
+node_js:
+  - '8'
+install:
+  - npm install -g codecov nyc npx
+  - npm install
+
+script:
+  - npm run lint
+  - npm test
+
+after_success:
+  - npm run report-coverage
+
+deploy:
+  provider: script
+  skip_cleanup: true
+  script:
+    - npm run semantic-release

README.md

@@ -1 +1,45 @@
 # image-augment
+
+This library has been freely inspired from [imgaug](https://github.com/aleju/imgaug)
+
+It is made to work with [hasard](https://www.npmjs.com/package/hasard)
+
+## Simple Example
+
+```javascript
+const ia = require('image-augment');
+
+// random example images
+const images = new Array(50).fill(1).map( () => {
+	return new ia.RandomImage({
+		width: 128
+		height: 128
+	});
+};
+
+const sometimes = ((aug) => ia.sometimes({p : 0.5, augmenter: aug}))
+
+const seq = new ia.Sequential({
+	sequence : [
+		new ia.Fliplr({p: 0.5}),
+		new ia.Flipud({p: 0.5}),
+		sometimes(new ia.CropAndPad(
+				p:[-0.05, 0.1],
+				padMode:ia.ALL,
+				padCval: [0, 255]
+		)),
+		sometimes(new ia.Affine({
+				scale:{"x": [0.8, 1.2], "y": [0.8, 1.2]},// scale images to 80-120% of their size, individually per axis
+				translate_percent:{"x": [-0.2, 0.2], "y": [-0.2, 0.2]}, // translate by -20 to +20 percent (per axis)
+				rotate:[-45, 45], // rotate by -45 to +45 degrees
+				shear:[-16, 16], // shear by -16 to +16 degrees
+				order:[0, 1], // use nearest neighbour or bilinear interpolation (fast)
+				cval:[0, 255], // if mode is constant, use a cval between 0 and 255
+				mode:ia.ALL // use any of scikit-image's warping modes (see 2nd image from the top for examples)
+		))
+	],
+	randomOrder : true
+})
+
+augmented = seq.augmentImagesAsync(images)
+```

doc/HEADER.md

@@ -0,0 +1,108 @@
+[![Build Status](https://travis-ci.com/piercus/image-augment.svg?branch=master)](https://travis-ci.com/piercus/image-augment)
+
+[![codecov](https://codecov.io/gh/piercus/image-augment/branch/master/graph/badge.svg)](https://codecov.io/gh/piercus/image-augment)
+
+## Installation
+
+```
+npm install image-augment
+```
+
+## Description
+
+Image augmentation library for machinie learning in javascript.
+
+This library has been freely inspired from [imgaug](https://github.com/aleju/imgaug)
+
+It is using [hasard](https://www.npmjs.com/package/hasard) for random variable manipulation.
+Currently the only backend available is [opencv4nodejs](https://github.com/justadudewhohacks/opencv4nodejs).
+
+Future work : 
+* add more augmenters
+* make it work in the browser with tensorflowjs (without opencv4nodejs)
+
+Please open issues if you want a specific augmenter/backend compatibilty
+
+## Simple Usage
+
+```javascript
+const ia = require('image-augment');
+const cv = require('opencv4nodejs');
+
+const image = cv.readImage('lena.png');
+
+const blurred = ia.blur({ kernel: 3 }).runOnce({image: img})
+
+cv.writeImage('lena-blurred-3x3.png');
+```
+| Input | Output |
+|---|---|
+| <img src="./test/data/lena.png"/> | <img src="./test/data/lena-blurred-3x3.png"/> |
+
+## Simple Usage with a random variable
+
+All parameters can be set as random variables using [hasard](https://www.npmjs.com/package/hasard) library
+
+```javascript
+const ia = require('image-augment');
+const hasard = require('hasard');
+const cv = require('opencv4nodejs');
+
+const image = cv.readImage('filename.png');
+
+const blurred = ia.blur({ kernel: h.integer([0,10]) }).run({image: img, number : 5})
+
+cv.writeImage('output.png');
+```
+
+| Input | Output |
+|---|---|
+| <img src="./test/data/lena.png"/> | <img src="./test/data/lena-blurred-3x3.png"/> |
+
+
+This library has been freely inspired from [imgaug](https://github.com/aleju/imgaug)
+
+It is made to work with [hasard](https://www.npmjs.com/package/hasard) and [opencv4nodejs](https://github.com/justadudewhohacks/opencv4nodejs)
+
+# image-augment
+
+
+## Simple Example
+
+```javascript
+const ia = require('image-augment');
+
+// random example images
+const images = new Array(50).fill(1).map( () => {
+	return new ia.RandomImage({
+		width: 128
+		height: 128
+	});
+};
+
+const sometimes = ((aug) => ia.sometimes({p : 0.5, augmenter: aug}))
+
+const seq = new ia.Sequential({
+	sequence : [
+		new ia.Fliplr({p: 0.5}),
+		new ia.Flipud({p: 0.5}),
+		sometimes(new ia.CropAndPad(
+				p:[-0.05, 0.1],
+				padMode:ia.ALL,
+				padCval: [0, 255]
+		)),
+		sometimes(new ia.Affine({
+				scale:{"x": [0.8, 1.2], "y": [0.8, 1.2]},// scale images to 80-120% of their size, individually per axis
+				translate_percent:{"x": [-0.2, 0.2], "y": [-0.2, 0.2]}, // translate by -20 to +20 percent (per axis)
+				rotate:[-45, 45], // rotate by -45 to +45 degrees
+				shear:[-16, 16], // shear by -16 to +16 degrees
+				order:[0, 1], // use nearest neighbour or bilinear interpolation (fast)
+				cval:[0, 255], // if mode is constant, use a cval between 0 and 255
+				mode:ia.ALL // use any of scikit-image's warping modes (see 2nd image from the top for examples)
+		))
+	],
+	randomOrder : true
+})
+
+augmented = seq.augmentImagesAsync(images)
+```

lib/augmenters/abstract.js

@@ -0,0 +1,118 @@
+const hasard = require('hasard');
+const backends = require('../backend');
+
+class AbstractAugmenter {
+	constructor(opts) {
+		this.backend = opts.backend ? backends.get(opts.backend) : backends.getDefault();
+	}
+
+	runOnce(o) {
+		const metadata = this.backend.getMetadata(o.img);
+		const o2 = Object.assign({}, {boxes: [], points: []}, metadata, o);
+		const params = this.buildParams(o);
+		const resolved = params.runOnce();
+		return this.augment(o2, resolved);
+	}
+
+	toSize2(opt) {
+		const fn = function (size) {
+			if (typeof (size) === 'number') {
+				return [size, size];
+			}
+
+			if (Array.isArray(size)) {
+				if (opt.length === 2) {
+					return size;
+				}
+
+				throw new Error(`${size} whould be a length-2 array or a number`);
+			}
+		};
+
+		if (hasard.isHasard(opt)) {
+			return hasard.fn(fn)(opt);
+		}
+
+		return fn(opt);
+	}
+
+	toSize4(opt) {
+		const fn = function (size) {
+			if (typeof (size) === 'number') {
+				return [size, size, size, size];
+			}
+
+			if (Array.isArray(size)) {
+				if (opt.length === 2) {
+					return [size[0], size[0], size[1], size[1]];
+				}
+
+				if (opt.length === 4) {
+					return size;
+				}
+
+				throw new Error(`${size} whould be a number, a length-2 or a lenght-4 array`);
+			}
+		};
+
+		if (hasard.isHasard(opt)) {
+			return hasard.fn(fn)(opt);
+		}
+
+		return fn(opt);
+	}
+
+	/**
+	* @param {PipedImageAttribute} imgAttributes
+	* @param {AugmenterRandomProperties} augmenterRandomProperties
+	* @returns {PipedImageAttribute}
+	*/
+	augment(attr, opts) {
+		return {
+			img: this.augmentImage(attr, opts),
+			boxes: this.augmentBoxes(attr, opts),
+			points: this.augmentPoints(attr, opts)
+		};
+	}
+
+	augmentImage({img}) {
+		return img;
+	}
+
+	augmentPoints({points}) {
+		return points;
+	}
+
+	augmentBoxes(attr, opts) {
+		const {boxes} = attr;
+		const points = boxes.map(b => {
+			return [
+				this.backend.point(b[0], b[1]),
+				this.backend.point(b[0] + b[2], b[1]),
+				this.backend.point(b[0], b[1] + b[3]),
+				this.backend.point(b[0] + b[2], b[1] + b[3])
+			];
+		}).reduce((a, b) => a.concat(b), []);
+
+		const pointsAfter = this.augmentPoints(Object.assign({}, attr, {points}), opts);
+
+		const boxesAfter = [];
+		for (let i = 0; i < boxes.length; i++) {
+			const left = Math.min(...pointsAfter.map(p => p.x));
+			const right = Math.max(...pointsAfter.map(p => p.x));
+			const top = Math.min(...pointsAfter.map(p => p.y));
+			const bottom = Math.max(...pointsAfter.map(p => p.y));
+
+			boxesAfter.push([
+				left,
+				top,
+				right - left,
+				bottom - top
+			]);
+		}
+
+		return boxesAfter;
+	}
+}
+
+module.exports = AbstractAugmenter;

lib/augmenters/additive-poisson-noise.js

@@ -0,0 +1,74 @@
+const h = require('hasard');
+const AbstractAugmenter = require('./abstract');
+
+/**
+* Adds noise sampled from a poisson distribution with `lambda` being the exponent.
+* If perChannel is true, then the sampled values may be different per channel (and pixel).
+* if `scale` is defined (0 < scale < 1), then the noise can apply at a less granular scale
+* @param {Number} opts.lambda
+* @param {Number} [opts.scale=1]
+* @param {Number} [opts.perChannel=false]
+*/
+
+class AdditivePoissonNoiseAugmenter extends AbstractAugmenter {
+	constructor(opts) {
+		super(opts);
+		const {lambda, scale, perChannel} = opts;
+		this.lambda = lambda;
+		this.scale = scale;
+		this.perChannel = perChannel;
+	}
+
+	buildParams({width, height, channels}) {
+		const scaleRef = h.reference(this.scale);
+
+		console.log([width, height, channels, this.lambda]);
+
+		const hasardPixelValue = h.multiply(
+			h.if(h.boolean(), -1, 1),
+			h.integer({
+				type: 'poisson',
+				lambda: this.lambda
+			})
+		);
+
+		const hasardPixelValueRef = h.reference({
+			source: hasardPixelValue,
+			inScope: 'colorPixel'
+		});
+		return h.object({
+			noise: h.matrix({
+				shape: [height, width, 4],
+				value: h.if(this.perChannel,
+					h.array([
+						hasardPixelValue,
+						hasardPixelValue,
+						hasardPixelValue,
+						0
+					]),
+					h.array({
+						values: [
+							hasardPixelValueRef,
+							hasardPixelValueRef,
+							hasardPixelValueRef,
+							0
+						],
+						scope: 'colorPixel'
+					})
+				)
+			}),
+			scale: scaleRef
+		});
+	}
+
+	/**
+	* @param {PipedImageAttribute} imgAttributes
+	* @param {AugmenterRandomProperties} augmenterRandomProperties
+	* @returns {PipedImageAttribute}
+	*/
+	augmentImage({img}, {noise, scale}) {
+		return this.backend.addNoise(img, {noise, scale});
+	}
+}
+
+module.exports = AdditivePoissonNoiseAugmenter;