From ec2790652c9c5c226b68af920d0daf62dbb4bdc8 Mon Sep 17 00:00:00 2001 From: Chinmay Pandhare Date: Wed, 14 Jun 2017 08:20:01 +0530 Subject: [PATCH] Phase 1 Completion --- index.js | 6 +- output.txt | 1 + src/ImageSequencer.js | 346 +++++++++++++++++++++++-------- src/ImageSequencerNode.js | 173 ---------------- src/Modules.js | 7 +- src/ModulesNode.js | 9 - src/modules/DoNothing.js | 14 +- src/modules/DoNothingPix.js | 20 +- src/modules/GreenChannel.js | 20 +- src/modules/NdviRed.js | 20 +- src/modules/PixelManipulation.js | 12 +- src/modules/_Step.js | 11 + test/image-sequencer.js | 57 ++--- 13 files changed, 344 insertions(+), 352 deletions(-) create mode 100644 output.txt delete mode 100644 src/ImageSequencerNode.js delete mode 100644 src/ModulesNode.js create mode 100644 src/modules/_Step.js diff --git a/index.js b/index.js index 357aefe6..25b3e0c4 100644 --- a/index.js +++ b/index.js @@ -1,8 +1,4 @@ console.log('\x1b[31m%s\x1b[0m',"This is the output of the module"); require('./src/ImageSequencerNode'); sequencer = ImageSequencer(); -sequencer.loadImage('sundar','examples/SundarPichai.jpeg',function(){ - sequencer.loadImage('timetable','examples/test.png',function(){ - sequencer.addSteps('do-nothing-pix'); - }); -}); +sequencer.loadImages({red:'../../red.jpg'}); diff --git a/output.txt b/output.txt new file mode 100644 index 00000000..b09a535c --- /dev/null +++ b/output.txt @@ -0,0 +1 @@ +data:image/jpeg;base64,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 \ No newline at end of file diff --git a/src/ImageSequencer.js b/src/ImageSequencer.js index c63eaa1d..c74a18ae 100644 --- a/src/ImageSequencer.js +++ b/src/ImageSequencer.js @@ -1,132 +1,314 @@ -if (typeof window !== 'undefined') window.$ = window.jQuery = require('jquery'); +if (typeof window !== 'undefined') {window.$ = window.jQuery = require('jquery'); isBrowser = true} else {window = global; var isBrowser = false} ImageSequencer = function ImageSequencer(options) { options = options || {}; options.inBrowser = options.inBrowser || isBrowser; - if (options.inBrowser) options.ui = options.ui || require('./UserInterface'); + // if (options.inBrowser) options.ui = options.ui || require('./UserInterface'); options.sequencerCounter = 0; + function CImage(src) { + datauri = (options.inBrowser)?(src):require('urify')(src); + image = { + src: datauri, + format: datauri.split(':')[1].split(';')[0].split('/')[1] + } + return image; + } + + function objTypeOf(object){ + return Object.prototype.toString.call(object).split(" ")[1].slice(0,-1) + } + + function log(color,msg) { + if(options.ui!="none") { + if(arguments.length==1) console.log(arguments[0]); + else if(arguments.length==2) console.log(color,msg); + } + } + var image, steps = [], - modules = require('./Modules'), - images = []; + modules = require('./ModulesNode'), + images = {}; // if in browser, prompt for an image - if (options.imageSelect || options.inBrowser) addStep('image-select'); - else if (options.imageUrl) loadImage(imageUrl); + // if (options.imageSelect || options.inBrowser) addStep('image-select'); + // else if (options.imageUrl) loadImage(imageUrl); - // soon, detect local or URL? - function addStep(name, o) { - console.log('adding step "' + name + '"'); - - if (typeof(window) != "undefined") - for(var variable in window) - if(window[variable] == this) - options.instanceName = variable; + function addStep(image, name, o) { + log('\x1b[36m%s\x1b[0m','adding step \"' + name + '\" to \"' + image + '\".'); o = o || {}; o.id = options.sequencerCounter++; //Gives a Unique ID to each step o.name = o.name || name; o.selector = o.selector || 'ismod-' + name; o.container = o.container || options.selector; + o.image = image; var module = modules[name](o); - - steps.push(module); + images[image].steps.push(module); function defaultSetupModule() { - if (options.ui) module.options.ui = options.ui({ + if (options.ui && options.ui!="none") module.options.ui = options.ui({ selector: o.selector, title: module.options.title, - id: o.id, - instanceName: options.instanceName + id: o.id }); } + if (module.hasOwnProperty('setup')) module.setup(); // add a default UI, unless the module has one specified + else defaultSetupModule.apply(module); // run default setup() in scope of module (is this right?) - if (name === "image-select") { + // tell the UI that a step has been added. - module.setup(); // just set up initial ImageSelect; it has own UI + return true; + } - } else { - - // add a default UI, unless the module has one specified - if (module.hasOwnProperty('setup')) module.setup(); - else { - defaultSetupModule.apply(module); // run default setup() in scope of module (is this right?) + function addSteps(){ + argtype = []; + json_q = {}; + for (i in images) { + lastimage = i; } - - var previousStep = steps[steps.length - 2]; - - if (previousStep) { - // connect output of last step to input of this step - previousStep.options.output = function output(image) { - if (sequencer.steps[0].options.initialImage) { - options.initialImage = sequencer.steps[0].options.initialImage; + for (var arg in arguments) { + argtype.push(objTypeOf(arguments[arg])); + } + if (arguments.length == 1) { + if(argtype[0] == "Object") + json_q = arguments[0]; + else + for (i in images) + json_q[i] = (argtype[0]=="Array")?arguments[0]:[arguments[0]]; + } + else if (arguments.length == 2) { + if(argtype[1]=="String") arguments[1] = [arguments[1]]; + if(argtype[0]=="String") + json_q[arguments[0]] = arguments[1]; + else if(argtype[0]=="Array") + for (var i in arguments[0]) { + json_q[arguments[0][i]] = arguments[1]; } - log('running module "' + name + '"'); - // display the image in any available ui - if (previousStep.options.ui && previousStep.options.ui.display) previousStep.options.ui.display(image); - module.draw(image); + } + for (i in json_q) + for (j in json_q[i]) + addStep.call(this,i,json_q[i][j]); + + } + + function removeStep(image,index) { + //remove the step from images[image].steps and redraw remaining images + if(index>0) { + log('\x1b[31m%s\x1b[0m',"Removing "+index+" from "+image); + images[image].steps.splice(index,1); + } + //tell the UI a step has been removed + + } + + function removeSteps(image,index) { + run = {}; + this_ = this; + + if(arguments.length==2) { + removeStep(image,index); + run[image] = index; + } + else if(arguments.length==1) { + if (typeof(arguments[0])=="number" || objTypeOf(arguments[0])=="Array") { + indx = arguments[0]; + arguments[0] = {}; + for (img in this_.images) arguments[0][img] = indx; + } + if (objTypeOf(arguments[0])=='Object') { + for (img in arguments[0]) { + var indexes = arguments[0][img]; + if (typeof(indexes) == "number") + {removeStep(img,indexes); run[img]=indexes;} + else if (objTypeOf(indexes) == "Array") { + indexes = indexes.sort(function(a,b){return b-a}); + run[img] = indexes[indexes.length-1]; + for (i in indexes) + removeStep(img,indexes[i]); + } + } + } // end if argument is object + } + + this.run(run) + } + + function insertStep(image, index, name, o) { + log('\x1b[36m%s\x1b[0m','inserting step \"' + name + '\" to \"' + image + '\" at \"'+index+'\".'); + + o = o || {}; + o.id = options.sequencerCounter++; //Gives a Unique ID to each step + o.name = o.name || name; + o.selector = o.selector || 'ismod-' + name; + o.container = o.container || options.selector; + o.image = image; + + var module = modules[name](o); + images[image].steps.splice(index, 0, module); + + function defaultSetupModule() { + if (options.ui && options.ui!="none") module.options.ui = options.ui({ + selector: o.selector, + title: module.options.title, + id: o.id + }); + } + if (module.hasOwnProperty('setup')) module.setup(); // add a default UI, unless the module has one specified + else defaultSetupModule.apply(module); // run default setup() in scope of module (is this right?) + + // tell the UI that a step has been inserted. + + return true; + } + + function insertSteps(image, index, name, o) { + run = {}; + this_ = this; + + if(arguments.length==4 || arguments.length==3) { + o = o || {}; + size = this_.images[image].steps.length; + index = (index==size)?index:index%size; + if (index<0) index += size+1; + insertStep(image,index,name, o); + run[image] = index; + } + else if(arguments.length==1) { + if (objTypeOf(arguments[0])=='Object') { + for (img in arguments[0]) { + var details = arguments[0][img]; + if (objTypeOf(details) == "Object") + {insertStep(img,details.index,details.name,details.o); run[img]=details.index;} + else if (objTypeOf(details) == "Array") { + details = details.sort(function(a,b){return b.index-a.index}); + run[img] = details[details.length-1].index; + for (i in details) + insertStep(img,details[i].index,details[i].name,details[i].o); + } + } + } // end if argument is object + } + + this.run(run) + } + + function run(t_image,t_from) { + log('\x1b[31m%s\x1b[0m',"Running the Sequencer!"); + this_ = this; + runimg = {}; + json_q = {}; + for (image in images) { + runimg[image] = 0; + } + function drawStep(drawarray,pos) { + if(pos>=drawarray.length) return true; + image = drawarray[pos].image; + i = drawarray[pos].i; + images[image].steps[i].draw.call(this_,function(){ + drawStep(drawarray,++pos); + }); + } + function drawSteps(json_q) { + drawarray = []; + for (image in json_q) { + no_steps = images[image].steps.length; + init = json_q[image]; + for(i = 0; i < no_steps-init; i++) { + drawarray.push({image: image,i: init+i}); } } - + drawStep(drawarray,0); } - - // Pre-set the initial output behavior of the final step, - // which will be changed if an additional step is added. - module.options.output = function output(image) { - if (module.options.ui && module.options.ui.display) module.options.ui.display(image); + function filter(json_q){ + for (image in json_q) { + prevstep = images[image].steps[json_q[image]-1]; + while (typeof(prevstep) == "undefined" || typeof(prevstep.output) == "undefined") { + prevstep = images[image].steps[(--json_q[image]) - 1]; + } + } + return json_q; } - + if (arguments.length == 0) { + for (image in images) + json_q[image] = 1; + } + else if (arguments.length == 1) { + if (typeof(arguments[0]) == "string") + json_q[arguments[0]] = 1; + else if (typeof(arguments[0]) == "number") + for (image in images) + json_q[image] = arguments[0]; + else if (objTypeOf(arguments[0]) == "Array") + for (image in arguments[0]) + json_q[arguments[0][image]] = 1; + else if (objTypeOf(arguments[0]) == "Object") + json_q = arguments[0]; + } + else if (arguments.length == 2) { + json_q[t_image] = t_from; + } + json_q = filter(json_q); + drawSteps(json_q); } - function removeStep (id) { - for (i=0;i