feat: WIP additive truncated

Author: piercus

lib/augmenters/abstract.js

@@ -60,17 +60,23 @@ class AbstractAugmenter extends Abstract {
 
 		const o2 = Object.assign({}, metadata, params1);
 		const {nImages} = metadata;
-
-		const params = this.buildHasard(o2);
-
-		debug(`runOnce ${this._name}`);
-		const resolved = [];
-
-		// Every image hasard is generated independantly
-		for (let i = 0; i < nImages; i++) {
-			const resolvedParams = hasard.isHasard(params) ? params.runOnce(runOpts) : params;
-			resolved.push(resolvedParams);
+		
+		let resolved = [];
+		
+		if(typeof(this.buildAllImagesHasard) === 'function'){
+			resolved = this.buildAllImagesHasard(o2).runOnce(runOpts);
+		} else {
+			debug(`runOnce ${this._name}`);
+			const params = this.buildHasard(o2);
+			// Every image hasard is generated independantly
+			for (let i = 0; i < nImages; i++) {
+				const resolvedParams = hasard.isHasard(params) ? params.runOnce(runOpts) : params;
+				resolved.push(resolvedParams);
+			}
 		}
+		
+
+	
 
 		// Console.log({resolved, params})
 		debug(`augment ${this._name}`);

lib/augmenters/additive.js

@@ -14,13 +14,11 @@ class AdditiveAugmenter extends AbstractAugmenter {
 		this.generator = new Generator(opts2);
 	}
 
-	buildParams({width, height, channels}) {
-		return this.generator.build({width, height, channels});
+	buildAllImagesHasard({nImages, width, height, channels}) {
+		return this.generator.build({nImages, width, height, channels});
 	}
-
-	augmentImage({image}, params) {
-		// Console.log(image, generated)
-		return this.backend.addNoise(image, params.image);
+	augment(attrs, params, runOpts) {
+		return {images: this.backend.addNoise(attrs.images, params.images)};
 	}
 }
 

test/augmenters/additive-truncated-normal-noise.js

@@ -0,0 +1,65 @@
+const path = require('path');
+const test = require('ava');
+const AdditiveTruncatedNormalNoise = require('../../lib/augmenters/additive-truncated-normal-noise');
+const macroAugmenter = require('../macros/augmenter');
+
+const mean = 10;
+const nImages = 2;
+
+test.only('additiveTruncatedNormalNoise not perChannel', macroAugmenter, AdditiveTruncatedNormalNoise, {
+	inputFilenames: new Array(nImages).fill('lenna.png'),
+	backends:[
+		require('@tensorflow/tfjs-node-gpu')
+	],
+	// Backends: ['tfjs'],
+	// backends: ['opencv4nodejs'],
+	expectImg(t, mats1, mats2, backend) {
+		const mat1 = backend.splitImages(mats1)[0];
+		const mat2 = backend.splitImages(mats2)[0];
+		const metadata = backend.getMetadata(mats1);
+		const diff = backend.diff(mat1, mat2);
+		const norm = backend.normL1(diff) / (metadata.width * metadata.height * 3);
+		const tolerance = 100 / Math.sqrt((metadata.width * metadata.height * 3));
+		t.true(Math.abs(norm - mean) < tolerance);
+
+		// Console.log(diff.getDataAsArray().slice(0,30).map(v => v.slice(440, 450)))
+
+		let count = 0;
+		const m2 = backend.imageToArray(mat2);
+
+		backend.forEachPixel(diff, ([b, g, r], rowIndex, colIndex) => {
+			// Console.log({rowIndex, colIndex})
+			if (m2[rowIndex][colIndex].indexOf(255) === -1 && m2[rowIndex][colIndex].indexOf(0) === -1 && (r !== g || g !== b)) {
+				count++;
+			}
+		});
+		t.is(count, 0);
+	},
+	options: {
+		mean,
+		std: 2,
+		perChannel: false
+	}
+});
+
+test('additiveTruncatedNormalNoise per Channel', macroAugmenter, AdditiveTruncatedNormalNoise, {
+	inputFilename: 'lenna.png',
+	expectImg(t, mats1, mats2, backend) {
+		const mat1 = backend.splitImages(mats1)[0];
+		const mat2 = backend.splitImages(mats2)[0];
+		const diff = backend.diff(mat1, mat2);
+		let count = 0;
+		const m2 = backend.imageToArray(mat2);
+		backend.forEachPixel(diff, ([b, g, r], rowIndex, colIndex) => {
+			if (m2[rowIndex][colIndex].indexOf(255) === -1 && m2[rowIndex][colIndex].indexOf(0) === -1 && (r !== g || g !== b)) {
+				count++;
+			}
+		});
+		t.not(count, 0);
+	},
+	options: {
+		mean,
+		sigma: 2,
+		perChannel: true
+	}
+});

test/macros/augmenter.js

@@ -7,28 +7,37 @@ const allBackends = require('../../lib/backend');
 module.exports = function (t, Cstr, {
 	inputFilename,
 	outputFilename,
+	inputFilenames = [],
 	options,
 	debugOutput,
 	inputPoints,
 	outputPoints,
 	expectImg,
-	backends = ['opencv4nodejs', 'tfjs']
+	backends = [
+		require('@tensorflow/tfjs-node-gpu'),
+		require('opencv4nodejs')
+	]
 }) {
 	return PromiseBlue.map(backends, bKey => {
 		const backend = allBackends.get(bKey);
 		const inst = new Cstr(Object.assign({}, options, {backend: bKey}));
-		const input = path.join(__dirname, '../data', bKey, inputFilename);
+		let inputs
+		if(inputFilename){
+			inputs = [path.join(__dirname, '../data', backend.key, inputFilename)];
+		} else { // if(inputFilenames)
+			inputs = inputFilenames.map(inF => path.join(__dirname, '../data', backend.key, inF));
+		}
 		let output;
 		if (outputFilename) {
-			output = path.join(__dirname, '../data', bKey, outputFilename);
+			output = path.join(__dirname, '../data', backend.key, outputFilename);
 		}
 
-		return backend.readImages([input])
+		return backend.readImages(inputs)
 			.then(images => {
-				debug(`${Cstr.name}/${bKey} start `);
+				debug(`${Cstr.name}/${backend.key} start `);
 				return inst.runAugmenter({images})
 					.then(res => {
-						debug(`${Cstr.name}/${bKey} end`);
+						debug(`${Cstr.name}/${backend.key} end`);
 						if (!debugOutput) {
 							return Promise.resolve(res);
 						}