fix: rm custom, add doc

Author: piercus

lib/augmenters/crop.js

@@ -9,15 +9,31 @@ const AbstractAugmenter = require('./abstract');
 */
 
 /**
-* Add blur to the image
+* Crop the image
 * @param {Object} opts options
 * @param {ArraylRTB} opts.percent percent of cropping to do
+* @example
+// Simple usage, crop by 10%, on every side
+new ia.Crop(0.1);
+* @example
+//Simple usage with random variable crop by 10% to 30%
+new ia.Crop(h.number(0.1, 0.3));
+* @example
+//Crop by 10% on left, 20% on top, to 30% on the right, 10% on the bottom
+new ia.Crop([0.1, 0.2, 0.3, 0.1]);
 */
 
 class CropAugmenter extends AbstractAugmenter {
 	constructor(opts) {
-		super(opts);
-		const {percent = 0} = opts;
+		let o;
+		if (typeof (opts) === 'number' || Array.isArray(opts) || hasard.isHasard(opts)) {
+			o = {percent: opts};
+		} else {
+			o = opts;
+		}
+
+		super(o);
+		const {percent} = o;
 		this.percent = this.toSize4(percent);
 		this.percent.forEach(p => {
 			if (p < 0) {

lib/augmenters/custom.js

@@ -7,12 +7,35 @@ const AbstractAugmenter = require('./abstract');
 * @param {ArraylRTB} opts.percent size of padding in percent
 * @param {ColorArgument} [opts.borderValue=[0,0,0]] if borderType is "constant" this is used as border pixel values
 * @param {BorderTypeArgument} [opts.borderType="constant"] "constant", "replicate", "transparent"
+* @example
+// Simple usage, pad by 10%, on every side
+new ia.Pad(0.1);
+* @example
+// pad by 10%, with transparent background
+new ia.Pad({
+	percent: 0.1,
+	borderType: "transparent"
+});
+* @example
+// pad by 10% (left, right), 20% (top, bottom), with constant blue background
+new ia.Pad({
+	percent: [0.1, 0.2],
+	borderType: "transparent",
+	borderValue: [0, 0, 255]
+});
 */
 
 class PadAugmenter extends AbstractAugmenter {
 	constructor(opts) {
-		super(opts);
-		const {borderValue = [0, 0, 0], borderType = 'replicate', percent = 0} = opts;
+		let o;
+		if (typeof (opts) === 'number' || Array.isArray(opts) || hasard.isHasard(opts)) {
+			o = {percent: opts};
+		} else {
+			o = opts;
+		}
+
+		super(o);
+		const {borderValue = [0, 0, 0], borderType = 'replicate', percent = 0} = o;
 		this.percent = this.toSize4(percent);
 		this.percent.forEach(p => {
 			if (p < 0) {

lib/augmenters/pad.js

@@ -3,18 +3,34 @@ const AbstractAugmenter = require('./abstract');
 /**
 * Applies a random four-point perspective transform to the image (kinda like an advanced form of cropping).
 * Each point has a random distance from the image corner, derived from a normal distribution with sigma `sigma`.
-* @param {Object} opts options
-* @param {NumberArgument} opts.sigma the sigma of the normal distribution
-* @param {BooleanArgument} opts.keepSize If `keepSize` is set to True (default), each image will be resized back to its original size.
-* @param {ColorArgument} [opts.borderValue=[0,0,0]] if borderType is "constant" this is used as border pixel values
-* @param {BorderTypeArgument} [opts.borderType="constant"] can be "constant", "replicate", "transparent"
-* @param {Array.<Array.<Number>>} [opts.cornersVariation=null] if set, sigma is not used. For more deterministic behavior, use this to set manually the percent (x,y) variation of each corner
+* @param {Object} sigma options
+* @param {NumberArgument} sigma.sigma the sigma of the normal distribution
+* @param {BooleanArgument} sigma.keepSize If `keepSize` is set to True (default), each image will be resized back to its original size.
+* @param {ColorArgument} [sigma.borderValue=[0,0,0]] if borderType is "constant" this is used as border pixel values
+* @param {BorderTypeArgument} [sigma.borderType="constant"] can be "constant", "replicate", "transparent"
+* @param {Array.<Array.<Number>>} [sigma.cornersVariation=null] if set, sigma is not used. For more deterministic behavior, use this to set manually the percent (x,y) variation of each corner
+* @example
+// Simple usage, perspective transform on a sigma=10% random perspective tarnsform
+new ia.PerspectiveTransform(0.1);
+* @example
+// Now replicate the borders
+new ia.PerspectiveTransform({
+	sigma: 0.1,
+	borderType: "replicate"
+});
 */
 
 class PerspectiveTransformAugmenter extends AbstractAugmenter {
 	constructor(opts) {
-		super(opts);
-		const {sigma, keepSize, borderValue = [0, 0, 0], borderType = 'constant', cornersVariation} = opts;
+		let o;
+		if (typeof (opts) === 'number' || hasard.isHasard(opts)) {
+			o = {sigma: opts};
+		} else {
+			o = opts;
+		}
+
+		super(o);
+		const {sigma, keepSize, borderValue = [0, 0, 0], borderType = 'constant', cornersVariation} = o;
 		this.sigma = this.toSize2(sigma) || [0, 0];
 		this.keepSize = keepSize;
 		this.borderValue = borderValue;

lib/augmenters/perspective-transform.js

@@ -5,12 +5,28 @@ const AbstractAugmenter = require('./abstract');
 * Resize the image
 * @param {Object} opts options
 * @param {ArrayXY} opts.size size of the result image
+* @example
+// Simple usage, resize to 100x100 square
+new ia.Resize(100);
+* @example
+// Simple usage, resize to 100x50 square
+new ia.Resize([100, 50]);
+* @example
+// Explicit form
+new ia.Resize({size: [100, 50]});
 */
 
 class ResizeAugmenter extends AbstractAugmenter {
 	constructor(opts) {
-		super(opts);
-		const {size} = opts;
+		let o;
+		if (typeof (opts) === 'number' || Array.isArray(opts) || hasard.isHasard(opts)) {
+			o = {size: opts};
+		} else {
+			o = opts;
+		}
+
+		super(o);
+		const {size} = o;
 		this.size = this.toSize2(size);
 	}
 

lib/augmenters/resize.js

@@ -5,6 +5,14 @@ const AbstractAugmenter = require('./abstract');
 * Build a sequence of actions
 * @param {Object} opts options
 * @param {Array.<ImageAugment> | Hasard.<Array.<ImageAugment>>} opts.steps steps to be run in sequence
+* @example
+* // Simple usage
+* const img = cv.imread('lenna.jpg');
+* const augmenter = new ia.Sequential([
+* 	new ia.Blur(2),
+* 	new ia.PerspectiveTransform(0.2)
+* ]);
+* const {image} = augmenter.runOnce({image: img});
 */
 
 class Sequential extends AbstractAugmenter {
@@ -17,28 +25,12 @@ class Sequential extends AbstractAugmenter {
 		}
 	}
 
-	runOnce({img, points = [], boxes = []}) {
-		let steps;
-		if (hasard.isHasard(this.steps)) {
-			steps = this.steps.runOnce();
-		} else {
-			steps = this.steps;
-		}
-
-		if (!Array.isArray(steps)) {
-			throw (new TypeError(`${steps} should be an array`));
-		}
-
-		const width = img.cols;
-		const height = img.rows;
-
-		let res = {img, points, width, height, boxes};
-
-		steps.forEach(step => {
-			res = step.runOnce(res);
+	runOnce(o, runOpts) {
+		let current = o;
+		this.steps.forEach(s => {
+			current = s.runOnce(current, runOpts);
 		});
-
-		return res;
+		return current;
 	}
 }
 module.exports = Sequential;