16mm
/
v2f
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Converted codebase to typescript. 

Added new feature, custom page sizes.
Use arguments -w,--width and -l,--length to specify the size in inches.
Still defaults to 8.5x11in
This commit is contained in:
mmcwilliams 2019-04-17 14:45:32 -04:00
parent 4120e19291
commit 0001f73329
4 changed files with 3700 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3303
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

14
package.json
View File

@ -1,10 +1,12 @@
{ {
"name": "v2f", "name": "v2f",
"version": "1.1.0", "version": "1.2.0",
"description": "Turn a video into strips of precise 16mm-size stills", "description": "Turn a video into strips of precise 16mm-size stills",
"main": "v2f.js", "main": "v2f.js",
"scripts": { "scripts": {
"test": "echo \"Error: no test specified\" && exit 1" "test": "echo \"Error: no test specified\" && exit 1",
"build": "./node_modules/.bin/nexe ./ --build",
"compile": "./node_modules/.bin/tsc ./src/v2f.ts --outFile ./v2f.js --noImplicitAny --lib ES2017 --lib ES2016 -t ES2016"
}, },
"author": "mmcwilliams", "author": "mmcwilliams",
"license": "MIT", "license": "MIT",
@ -17,7 +19,13 @@
} }
}, },
"dependencies": { "dependencies": {
"async": "^2.5.0", "async": "^2.6.2",
"commander": "^2.11.0" "commander": "^2.11.0"
},
"devDependencies": {
"@types/node": "^11.13.4",
"jsdoc-to-markdown": "^4.0.1",
"nexe": "^3.1.0",
"typescript": "^3.4.3"
} }
} }

225
src/v2f.ts Normal file
View File

@ -0,0 +1,225 @@
'use strict'
const cmd = require('commander')
const async = require('async')
const exec = require('child_process').exec
const fs = require('fs')
const path = require('path')
const os = require('os')
const osTmp : string = os.tmpdir()
const TMP : string = path.join(osTmp, '/v2f/')
class Dimensions{
h : number;
w : number;
o : number;
dpi : number;
film : any;
constructor (filmStr : string, dpi : number) {
const IN : number = dpi / 25.4
const film : any = this._gauge(filmStr)
this.h = Math.round(film.h * IN) //frame height
this.w = Math.round(film.w * IN) //frame width
this.o = Math.round(film.o * IN) //space between columns
this.dpi = dpi
this.film = film
}
_gauge (film : string) {
if (film === '16mm') {
return {
h: 7.62,
w : 10.5,
o : 16
}
} else if (film === 'super16'){
return {
h: 7.62,
w : 12.75,
o : 16
}
} else if (film === '35mm') {
return {
h : 19.05,
w : 22,
o : 35
}
} else {
error('Film type not found, see --help for more info')
}
}
}
/**
*
*
* @function
* @param {Object} Commander object
*/
function initialize (command : any) {
const dpi : number = command.dpi || 300
const film : string = command.film || '16mm'
const input : string = command.input || command.args[0] || error('No input file, see --help for more info')
const output : string = command.output || command.args[1] || error('No ouput directory, see --help for more info')
const dim : any = new Dimensions(film, dpi)
const pageW : number = command.width || 8.5
const pageL : number = command.length || 11
if (!fs.existsSync(input)) error(`Video "${input}" cannot be found`)
async.series([
(next : any)=> {
convert(input, dim, next)
},
(next : any) => {
stitch(output, dim, next, pageW, pageL)
},
cleanup
], () => {
console.log(`Finished creating pages`)
})
}
/** *
* Create image sequence from source video, using
*
* @function
* @param {String} input file path (absolute)
* @param {Integer} dpi target printing dpi
* @param {Integer} length strip length in frames
*
*/
function convert (input : string, dim : any, next : any) {
const file : string = input.split('/').pop()
const execStr : string = `avconv -i "${input}" -s ${dim.w}x${dim.h} -qscale 1 "${TMP}v2f_sequence_%04d.jpg"`
console.log(`Converting ${file}...`)
console.log(`Exporting all frames with aspect ratio: ${dim.w / dim.h}...`)
if (!fs.existsSync(TMP)) fs.mkdirSync(TMP)
exec(execStr, (ste : any, std : string) => {
if (ste) {
return error(ste)
}
console.log('Frames exported successfully!')
next()
})
}
/** *
* Stitch rendered frames into strips
* @function
* @param {String} output Path of folder containing frames
* @param {Object} dim Dimensions object
* @param {Function} next Async lib callback function
* @param {Integer} pageW Page width in inches
* @param {Integer} pageL Page length in inches
*
*/
function stitch (output : string, dim : any, next : any, pageW : number, pageL : number) {
const length : number = Math.floor((pageL * dim.dpi) / dim.h) - 1
const width : number = Math.floor((pageW * dim.dpi / dim.o)) - 1
const loc : string = TMP.substring(0, TMP.length - 1)
const diff : number = Math.round((dim.o - dim.w) / 2)
let page : number = 0
let pageCount : number = 0
let cmd : string = `find "${loc}" -type f -name "v2f_sequence_*.jpg"`
console.log('Stitching frames into sheets...')
console.log(`Sheets will contain ${width}x${length} frames...`)
exec(cmd, (ste : any, std : string) => {
if (ste) {
return error(ste)
}
let jobs : any[] = []
let cmds : string[] = []
let frames : string[] = std.split('\n')
let execStr : string = 'montage '
let pagePath : string = ``
let i : number = 0
frames = frames.filter((elem : string) => {
if (elem.indexOf('find: ') === -1) {
return elem
}
})
frames.sort()
for (let frame of frames) {
execStr += `${frame} `
if ((i + 1) % (width * length) === 0 || i === frames.length - 1) {
pagePath = path.join(output, `./page_${pad(page)}.jpg`)
execStr += `\ -tile 1x${length} -geometry ${dim.w}x${dim.h}+${diff}+0 miff:- |\ \nmontage - -geometry +0+0 -tile ${width}x1 -density ${dim.dpi} "${pagePath}"`
cmds.push(execStr)
execStr = 'montage '
page++
}
i++
}
jobs = cmds.map((cmd : string) => {
return (cb : any) => {
exec(cmd, (err : any, std : string, ste : string) => {
if (err) {
return error(err)
}
console.log(`Created page of ${width}x${length} frames!`)
cb()
})
}
})
async.series(jobs, next)
})
}
function cleanup (next : any) {
console.log('Cleaning up...');
exec(`rm -r "${TMP}"`, (err : any) => {
if (err) console.error(err)
if (next) next()
})
}
function pad (n : number) {
return ('00000' + n).slice(-5)
}
var error = function (err : any) {
if (process.argv.indexOf('-v') !== -1 || process.argv.indexOf('--verbose') !== -1){
console.error(err)
} else {
console.error('Error running program. Run in verbose mode for more info (-v,--verbose)')
}
process.exit(1)
}
process.on('uncaughtException', err => {
error(err)
})
//convert(process.argv[2], process.argv[3])
//fix for nexe
let args = [].concat(process.argv)
if (args[1].indexOf('v2f.js') === -1) {
args.reverse()
args.push('node')
args.reverse()
}
cmd.arguments('<input> <output>')
.version('1.1.0')
.option('-i, --input <path>', 'Video source to print to film strip, anything that avconv can read')
.option('-o, --output <path>', 'Output directory, will render images on specified page size')
.option('-d, --dpi <dpi>', 'DPI output pages')
.option('-f, --film <gauge>', 'Choose film gauge: 16mm, super16, 35mm')
.option('-w, --width <inches>', 'Output page width, in inches. Default 8.5')
.option('-l, --length <inches>', 'Output page length, in inches. Default 11')
.option('-v, --verbose', 'Run in verbose mode')
.parse(args)
initialize(cmd)

341
v2f.js Executable file → Normal file
View File

@ -1,79 +1,77 @@
/*jshint strict: true, esversion:6, node: true, asi: true*/ 'use strict';
const cmd = require('commander');
'use strict' const async = require('async');
const cmd = require('commander') const exec = require('child_process').exec;
const async = require('async') const fs = require('fs');
const exec = require('child_process').exec const path = require('path');
const fs = require('fs') const os = require('os');
const path = require('path') const osTmp = os.tmpdir();
const TMP = path.join(osTmp, '/v2f/');
const TMP = '/tmp/v2f/' class Dimensions {
constructor(filmStr, dpi) {
class Dimensions{ const IN = dpi / 25.4;
constructor (filmStr, dpi) { const film = this._gauge(filmStr);
const IN = dpi / 25.4 this.h = Math.round(film.h * IN); //frame height
const film = this._gauge(filmStr) this.w = Math.round(film.w * IN); //frame width
this.o = Math.round(film.o * IN); //space between columns
this.h = Math.round(film.h * IN) //frame height this.dpi = dpi;
this.w = Math.round(film.w * IN) //frame width this.film = film;
this.o = Math.round(film.o * IN) //space between columns }
this.dpi = dpi _gauge(film) {
this.film = film if (film === '16mm') {
} return {
h: 7.62,
_gauge (film) { w: 10.5,
if (film === '16mm') { o: 16
return { };
h: 7.62, }
w : 10.5, else if (film === 'super16') {
o : 16 return {
} h: 7.62,
} else if (film === 'super16'){ w: 12.75,
return { o: 16
h: 7.62, };
w : 12.75, }
o : 16 else if (film === '35mm') {
} return {
} else if (film === '35mm') { h: 19.05,
return { w: 22,
h : 19.05, o: 35
w : 22, };
o : 35 }
} else {
} else { error('Film type not found, see --help for more info');
error('Film type not found, see --help for more info') }
} }
}
} }
/** /**
* *
* *
* @function * @function
* @param {Object} Commander object * @param {Object} Commander object
*/ */
function initialize (command) { function initialize(command) {
const dpi = command.dpi || 300 const dpi = command.dpi || 300;
const film = command.film || '16mm' const film = command.film || '16mm';
const input = command.input || command.args[0] || error('No input file, see --help for more info') const input = command.input || command.args[0] || error('No input file, see --help for more info');
const output = command.output || command.args[1] || error('No ouput directory, see --help for more info') const output = command.output || command.args[1] || error('No ouput directory, see --help for more info');
const dim = new Dimensions(film, dpi) const dim = new Dimensions(film, dpi);
const pageW = command.width || 8.5;
if (!fs.existsSync(input)) error(`Video "${input}" cannot be found`) const pageL = command.length || 11;
if (!fs.existsSync(input))
async.series([ error(`Video "${input}" cannot be found`);
next => { async.series([
convert(input, dim, next) (next) => {
}, convert(input, dim, next);
next => { },
stitch(output, dim, next) (next) => {
}, stitch(output, dim, next, pageW, pageL);
cleanup },
], () => { cleanup
console.log(`Finished creating pages`) ], () => {
}) console.log(`Finished creating pages`);
});
} }
/** * /** *
* Create image sequence from source video, using * Create image sequence from source video, using
* *
@ -83,24 +81,21 @@ function initialize (command) {
* @param {Integer} length strip length in frames * @param {Integer} length strip length in frames
* *
*/ */
function convert (input, dim, next) { function convert(input, dim, next) {
const file = input.split('/').pop() const file = input.split('/').pop();
const execStr = `avconv -i "${input}" -s ${dim.w}x${dim.h} -qscale 1 "${TMP}v2f_sequence_%04d.jpg"` const execStr = `avconv -i "${input}" -s ${dim.w}x${dim.h} -qscale 1 "${TMP}v2f_sequence_%04d.jpg"`;
console.log(`Converting ${file}...`);
console.log(`Converting ${file}...`) console.log(`Exporting all frames with aspect ratio: ${dim.w / dim.h}...`);
console.log(`Exporting all frames with aspect ratio: ${dim.w / dim.h}...`) if (!fs.existsSync(TMP))
fs.mkdirSync(TMP);
if (!fs.existsSync(TMP)) fs.mkdirSync(TMP) exec(execStr, (ste, std) => {
if (ste) {
exec(execStr, (ste, std) => { return error(ste);
if (ste) { }
return error(ste) console.log('Frames exported successfully!');
} next();
console.log('Frames exported successfully!') });
next()
})
} }
/** * /** *
* Stitch rendered frames into strips * Stitch rendered frames into strips
@ -108,105 +103,101 @@ function convert (input, dim, next) {
* @param {String} output Path of folder containing frames * @param {String} output Path of folder containing frames
* @param {Object} dim Dimensions object * @param {Object} dim Dimensions object
* @param {Function} next Async lib callback function * @param {Function} next Async lib callback function
* @param {Integer} pageW Page width in inches
* @param {Integer} pageL Page length in inches
* *
*/ */
function stitch (output, dim, next) { function stitch(output, dim, next, pageW, pageL) {
const length = Math.floor((11 * dim.dpi) / dim.h) - 1 const length = Math.floor((pageL * dim.dpi) / dim.h) - 1;
const width = Math.floor((8.5 * dim.dpi / dim.o)) - 1 const width = Math.floor((pageW * dim.dpi / dim.o)) - 1;
const loc = TMP.substring(0, TMP.length - 1) const loc = TMP.substring(0, TMP.length - 1);
const diff = Math.round((dim.o - dim.w) / 2) const diff = Math.round((dim.o - dim.w) / 2);
let page = 0 let page = 0;
let pageCount = 0 let pageCount = 0;
let cmd = `find "${loc}" -type f -name "v2f_sequence_*.jpg"` let cmd = `find "${loc}" -type f -name "v2f_sequence_*.jpg"`;
console.log('Stitching frames into sheets...');
console.log('Stitching frames into sheets...') console.log(`Sheets will contain ${width}x${length} frames...`);
console.log(`Sheets will contain ${width}x${length} frames...`) exec(cmd, (ste, std) => {
if (ste) {
exec(cmd, (ste, std) => { return error(ste);
if (ste) { }
return error(ste) let jobs = [];
} let cmds = [];
let jobs = [] let frames = std.split('\n');
let cmds = [] let execStr = 'montage ';
let frames = std.split('\n') let pagePath = ``;
let execStr = 'montage ' let i = 0;
let pagePath = `` frames = frames.filter((elem) => {
let i = 0 if (elem.indexOf('find: ') === -1) {
return elem;
frames = frames.filter(elem => { }
if (elem.indexOf('find: ') === -1) { });
return elem frames.sort();
} for (let frame of frames) {
}) execStr += `${frame} `;
frames.sort() if ((i + 1) % (width * length) === 0 || i === frames.length - 1) {
for (let frame of frames) { pagePath = path.join(output, `./page_${pad(page)}.jpg`);
execStr += `${frame} ` execStr += `\ -tile 1x${length} -geometry ${dim.w}x${dim.h}+${diff}+0 miff:- |\ \nmontage - -geometry +0+0 -tile ${width}x1 -density ${dim.dpi} "${pagePath}"`;
if ((i + 1) % (width * length) === 0 || i === frames.length - 1) { cmds.push(execStr);
pagePath = path.join(output, `./page_${pad(page)}.jpg`) execStr = 'montage ';
execStr += `\ -tile 1x${length} -geometry ${dim.w}x${dim.h}+${diff}+0 miff:- |\ \nmontage - -geometry +0+0 -tile ${width}x1 -density ${dim.dpi} "${pagePath}"` page++;
cmds.push(execStr) }
execStr = 'montage ' i++;
page++ }
} jobs = cmds.map((cmd) => {
i++ return (cb) => {
} exec(cmd, (err, std, ste) => {
jobs = cmds.map(cmd => { if (err) {
return cb => { return error(err);
exec(cmd, (err, std, ste) => { }
if (err) { console.log(`Created page of ${width}x${length} frames!`);
return error(err) cb();
} });
console.log(`Created page of ${width}x${length} frames!`) };
cb() });
}) async.series(jobs, next);
} });
})
async.series(jobs, next)
})
} }
function cleanup(next) {
function cleanup (next) { console.log('Cleaning up...');
console.log('Cleaning up...'); exec(`rm -r "${TMP}"`, (err) => {
exec(`rm -r "${TMP}"`, (err) => { if (err)
if (err) console.error(err) console.error(err);
if (next) next() if (next)
}) next();
});
} }
function pad(n) {
function pad (n) { return ('00000' + n).slice(-5);
return ('00000' + n).slice(-5)
} }
var error = function (err) { var error = function (err) {
if (process.argv.indexOf('-v') !== -1 || process.argv.indexOf('--verbose') !== -1){ if (process.argv.indexOf('-v') !== -1 || process.argv.indexOf('--verbose') !== -1) {
console.error(err) console.error(err);
} else { }
console.error('Error running program. Run in verbose mode for more info (-v,--verbose)') else {
} console.error('Error running program. Run in verbose mode for more info (-v,--verbose)');
process.exit(1) }
} process.exit(1);
};
process.on('uncaughtException', err => { process.on('uncaughtException', err => {
error(err) error(err);
}) });
//convert(process.argv[2], process.argv[3]) //convert(process.argv[2], process.argv[3])
//fix for nexe //fix for nexe
let args = [].concat(process.argv) let args = [].concat(process.argv);
if (args[1].indexOf('v2f.js') === -1) { if (args[1].indexOf('v2f.js') === -1) {
args.reverse() args.reverse();
args.push('node') args.push('node');
args.reverse() args.reverse();
} }
cmd.arguments('<input> <output>') cmd.arguments('<input> <output>')
.version('1.1.0') .version('1.1.0')
.option('-i, --input <path>', 'Video source to print to film strip, anything that avconv can read') .option('-i, --input <path>', 'Video source to print to film strip, anything that avconv can read')
.option('-o, --output <path>', 'Output directory, will print images on A4 standard paper file') .option('-o, --output <path>', 'Output directory, will render images on specified page size')
.option('-d, --dpi <dpi>', 'DPI output pages') .option('-d, --dpi <dpi>', 'DPI output pages')
.option('-f, --film <gauge>', 'Choose film gauge: 16mm, super16, 35mm') .option('-f, --film <gauge>', 'Choose film gauge: 16mm, super16, 35mm')
.option('-v, --verbose', 'Run in verbose mode') .option('-w, --width <inches>', 'Output page width, in inches. Default 8.5')
.parse(args) .option('-l, --length <inches>', 'Output page length, in inches. Default 11')
.option('-v, --verbose', 'Run in verbose mode')
initialize(cmd) .parse(args);
initialize(cmd);