Add rescaling and interpolation option

Author: thinknathan

@types/types.d.ts

@@ -5,4 +5,6 @@ declare type Options = {
 	height?: number;
 	canvasWidth?: number;
 	canvasHeight?: number;
+	scale: number;
+	cubic: boolean;
 };

README.md

@@ -25,6 +25,10 @@ Command-line utility that slices input images into segments according to specifi
 -h, --height        Height of each slice                              [number]
 -d, --canvasWidth   Width of canvas for final output                  [number]
 -g, --canvasHeight  Height of canvas for final output                 [number]
+-s, --scale         Rescale the image up or down by this factor, after
+										slicing, but before canvas resize    [number] [default: 1]
+-c, --cubic         Uses bicubic interpolation instead of nearest neighbour if
+										rescaling                       [boolean] [default: false]
 ```
 
 - If `filename` does not include an extension, `.png`, `.gif`, `.jpg` and `.jpeg` will be guessed

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "node-image-slice",
-	"version": "2.1.0",
+	"version": "2.2.0",
 	"description": "Slices an input image into segments according to specified width and height",
 	"repository": {
 		"type": "git",

slice.cjs

@@ -5,85 +5,111 @@ const yargs = require('yargs');
 const os = require('os');
 const processImage_1 = require('./utils/processImage');
 const processPath_1 = require('./utils/processPath');
-// Parse command line arguments
-const options = yargs
-	.option('f', {
-		alias: 'filename',
-		describe: 'Input image filename',
-		type: 'string',
-	})
-	.option('i', {
-		alias: 'folderPath',
-		describe: 'Input folder',
-		type: 'string',
-	})
-	.option('w', {
-		alias: 'width',
-		describe: 'Width of each slice',
-		type: 'number',
-		demandOption: true,
-		coerce: (value) => {
-			if (value < 1) {
-				throw new Error('width should not be lower than 1');
-			}
-			return Math.round(value);
-		},
-	})
-	.option('h', {
-		alias: 'height',
-		describe: 'Height of each slice',
-		type: 'number',
-		coerce: (value) => {
-			if (value !== undefined && value < 1) {
-				throw new Error('height should not be lower than 1');
-			}
-			return Math.round(value);
-		},
-	})
-	.option('d', {
-		alias: 'canvasWidth',
-		describe: 'Width of canvas for final output',
-		type: 'number',
-		coerce: (value) => {
-			if (value !== undefined && value < 1) {
-				throw new Error('canvasWidth should not be lower than 1');
-			}
-			return Math.round(value);
-		},
-	})
-	.option('g', {
-		alias: 'canvasHeight',
-		describe: 'Height of canvas for final output',
-		type: 'number',
-		coerce: (value) => {
-			if (value !== undefined && value < 1) {
-				throw new Error('canvasHeight should not be lower than 1');
-			}
-			return Math.round(value);
-		},
-	}).argv;
-if (options.filename) {
-	// Process a single image
-	const { filename, width, height, canvasWidth, canvasHeight } = options;
-	(0, processImage_1.sliceImage)(
-		filename,
-		width,
-		height,
-		canvasWidth,
-		canvasHeight,
-	);
-} else if (options.folderPath) {
-	// Process all images in a folder, splitting the task into threads
-	let numCores = 2;
-	try {
-		numCores = os.cpus().length;
-	} catch (err) {
-		console.error(err);
+function main() {
+	// Parse command line arguments
+	const options = yargs
+		.option('f', {
+			alias: 'filename',
+			describe: 'Input image filename',
+			type: 'string',
+		})
+		.option('i', {
+			alias: 'folderPath',
+			describe: 'Input folder',
+			type: 'string',
+		})
+		.option('w', {
+			alias: 'width',
+			describe: 'Width of each slice',
+			type: 'number',
+			demandOption: true,
+			coerce: (value) => {
+				if (value < 1) {
+					throw new Error('width should not be lower than 1');
+				}
+				return Math.round(value);
+			},
+		})
+		.option('h', {
+			alias: 'height',
+			describe: 'Height of each slice',
+			type: 'number',
+			coerce: (value) => {
+				if (value !== undefined && value < 1) {
+					throw new Error('height should not be lower than 1');
+				}
+				return Math.round(value);
+			},
+		})
+		.option('d', {
+			alias: 'canvasWidth',
+			describe: 'Width of canvas for final output',
+			type: 'number',
+			coerce: (value) => {
+				if (value !== undefined && value < 1) {
+					throw new Error('canvasWidth should not be lower than 1');
+				}
+				return Math.round(value);
+			},
+		})
+		.option('g', {
+			alias: 'canvasHeight',
+			describe: 'Height of canvas for final output',
+			type: 'number',
+			coerce: (value) => {
+				if (value !== undefined && value < 1) {
+					throw new Error('canvasHeight should not be lower than 1');
+				}
+				return Math.round(value);
+			},
+		})
+		.option('s', {
+			alias: 'scale',
+			describe:
+				'Rescale the image up or down by this factor, after slicing, but before canvas resize',
+			type: 'number',
+			default: 1,
+			coerce: (value) => {
+				if (value <= 0) {
+					throw new Error('scale should be > 0');
+				}
+				return value;
+			},
+		})
+		.option('c', {
+			alias: 'cubic',
+			describe:
+				'Uses bicubic interpolation instead of nearest neighbour if rescaling',
+			type: 'boolean',
+			default: false,
+		}).argv;
+	if (options.filename) {
+		// Process a single image
+		const { filename, width, height, canvasWidth, canvasHeight, scale, cubic } =
+			options;
+		(0, processImage_1.sliceImage)(
+			filename,
+			width,
+			height,
+			canvasWidth,
+			canvasHeight,
+			scale,
+			cubic,
+		);
+	} else if (options.folderPath) {
+		// Process all images in a folder, splitting the task into threads
+		let numCores = 2;
+		try {
+			numCores = os.cpus().length;
+		} catch (err) {
+			console.error(err);
+		}
+		numCores = Math.max(numCores - 1, 1);
+		(0, processPath_1.processPath)(options.folderPath, options, numCores);
+	} else {
+		console.log(
+			'Requires either `filename` or `folderPath`. Run `slice --help` for help.',
+		);
 	}
-	numCores = Math.max(numCores - 1, 1);
-	(0, processPath_1.processPath)(options.folderPath, options, numCores);
-} else {
-	console.log(
-		'Requires either `filename` or `folderPath`. Run `slice --help` for help.',
-	);
 }
+main();