added a crop and jointop operations

Author: Laura Devendorf

src/app/mixer/provider/operation.service.ts

@@ -404,64 +404,64 @@ export class OperationService {
       }        
     }
 
-    // const reverse: Operation = {
-    //   name: 'reverse section',
-    //   dx: 'uses the second draft input to reverse the first image. ',
-    //   params: [
-    //     {name: 'left offset',
-    //     min: 0,
-    //     max: 10000,
-    //     value: 0,
-    //     dx: "the amount to offset the added inputs from the left"
-    //     },
-    //     {name: 'top offset',
-    //     min: 0,
-    //     max: 10000,
-    //     value: 0,
-    //     dx: "the amount to offset the overlaying inputs from the top"
-    //     }
-    //   ],
-    //   max_inputs: 100,
-    //   perform: (inputs: Array<Draft>, input_params: Array<number>):Array<Draft> => {
-
-    //     if(inputs.length < 1) return [];
-
-    //     const first: Draft = inputs.shift();
-
-    //     const outputs: Array<Draft> = [];
-
-
-    //     let width: number = utilInstance.getMaxWarps(inputs) + input_params[0];
-    //     let height: number = utilInstance.getMaxWefts(inputs) + input_params[1];
-    //     if(first.warps > width) width = first.warps;
-    //     if(first.wefts > height) height = first.wefts;
-
-    //     //initialize the base container with the first draft at 0,0, unset for anythign wider
-    //     const init_draft: Draft = new Draft({wefts: height, warps: width});
+    const knockout: Operation = {
+      name: 'knockout',
+      dx: 'overlays the input drafts. Flips the value of overlapping cells of the same value, effectively knocking out the image of the second draft upon the first',
+      params: [
+        {name: 'left offset',
+        min: 0,
+        max: 10000,
+        value: 0,
+        dx: "the amount to offset the added inputs from the left"
+        },
+        {name: 'top offset',
+        min: 0,
+        max: 10000,
+        value: 0,
+        dx: "the amount to offset the overlaying inputs from the top"
+        }
+      ],
+      max_inputs: 100,
+      perform: (inputs: Array<Draft>, input_params: Array<number>)=> {
+
+        if(inputs.length < 1) return Promise.resolve([]);
+
+        const first: Draft = inputs.shift();
+
+        const outputs: Array<Draft> = [];
+
+
+        let width: number = utilInstance.getMaxWarps(inputs) + input_params[0];
+        let height: number = utilInstance.getMaxWefts(inputs) + input_params[1];
+        if(first.warps > width) width = first.warps;
+        if(first.wefts > height) height = first.wefts;
+
+        //initialize the base container with the first draft at 0,0, unset for anythign wider
+        const init_draft: Draft = new Draft({wefts: height, warps: width});
 
-    //     first.pattern.forEach((row, i) => {
-    //         row.forEach((cell, j) => {
-    //           init_draft.pattern[i][j].setHeddle(cell.getHeddle());
-    //         });
-    //       });
-
-    //     //now merge in all of the additional inputs offset by the inputs
-    //     const d: Draft = inputs.reduce((acc, input) => {
-    //       input.pattern.forEach((row, i) => {
-    //         row.forEach((cell, j) => {
-    //           //if i or j is less than input params 
-    //           const adj_i: number = i+input_params[1];
-    //           const adj_j: number = j+input_params[0];
-    //           acc.pattern[adj_i][adj_j].setHeddle(utilInstance.computeFilter('neq', cell.getHeddle(), acc.pattern[adj_i][adj_j].getHeddle()));
-    //         });
-    //       });
-    //       return acc;
-
-    //     }, init_draft);
-    //     outputs.push(d);
-    //     return outputs;
-    //   }        
-    // }
+        first.pattern.forEach((row, i) => {
+            row.forEach((cell, j) => {
+              init_draft.pattern[i][j].setHeddle(cell.getHeddle());
+            });
+          });
+
+        //now merge in all of the additional inputs offset by the inputs
+        const d: Draft = inputs.reduce((acc, input) => {
+          input.pattern.forEach((row, i) => {
+            row.forEach((cell, j) => {
+              //if i or j is less than input params 
+              const adj_i: number = i+input_params[1];
+              const adj_j: number = j+input_params[0];
+              acc.pattern[adj_i][adj_j].setHeddle(utilInstance.computeFilter('neq', cell.getHeddle(), acc.pattern[adj_i][adj_j].getHeddle()));
+            });
+          });
+          return acc;
+
+        }, init_draft);
+        outputs.push(d);
+        return Promise.resolve(outputs);
+      }        
+    }
 
     const mask: Operation = {
       name: 'mask',
@@ -862,6 +862,64 @@ export class OperationService {
       }
 
     }
+
+    const crop: Operation = {
+      name: 'crop',
+      dx: 'crops to a region of the input draft. The crop size and placement is given by the parameters',
+      params: [
+        {name: 'left',
+        min: 0,
+        max: 10000,
+        value: 0,
+        dx: 'number of pics from the left to start the cut'
+        },
+        {name: 'top',
+        min: 0,
+        max: 10000,
+        value: 0,
+        dx: 'number of pics from the top to start the cut'
+        },
+        {name: 'width',
+        min: 1,
+        max: 10000,
+        value: 10,
+        dx: 'total width of cut'
+        },
+        {name: 'height',
+        min: 1,
+        max: 10000,
+        value: 10,
+        dx: 'height of the cutting box'
+        }
+      ],
+      max_inputs: 1,
+      perform: (inputs: Array<Draft>, input_params: Array<number>) => {
+
+
+
+        const outputs: Array<Draft> = inputs.map(input => {
+            const new_warps = input_params[2];
+            const new_wefts = input_params[3];
+
+            const d: Draft = new Draft({warps: new_warps, wefts: new_wefts});
+
+            //unset all cells to default
+            d.pattern.forEach((row, i) => {
+              row.forEach((cell, j) => {
+
+                if((i+input_params[1] >= input.pattern.length) || (j+input_params[0] >= input.pattern[0].length)) cell.setHeddle(null);
+                else cell.setHeddle(input.pattern[i+input_params[1]][j+input_params[0]].getHeddle());
+               
+              });
+            });
+
+            return d;
+        });
+
+        return Promise.resolve(outputs);
+      }
+          
+    }
 
     const rib: Operation = {
       name: 'rib',
@@ -1071,7 +1129,7 @@ export class OperationService {
       }
     }
 
-    const mirrorx: Operation = {
+    const flipx: Operation = {
       name: 'flip horiz',
       dx: 'generates an output that is the left-right mirror of the input',
       params: [],
@@ -1086,7 +1144,7 @@ export class OperationService {
       }
     }
 
-    const mirrory: Operation = {
+    const flipy: Operation = {
       name: 'flip vert',
       dx: 'generates an output that is the top-bottom mirror of the input',
       params: [],
@@ -1408,6 +1466,39 @@ export class OperationService {
 
     }
 
+    const jointop: Operation = {
+      name: 'join top',
+      dx: 'attaches inputs toether into one draft in a column orientation',
+      params: [],
+      max_inputs: 100, 
+      perform: (inputs: Array<Draft>, input_params: Array<number>) => {
+          
+        const total:number = inputs.reduce((acc, draft)=>{
+            return acc + draft.wefts;
+        }, 0);
+
+        const max_warps:number = utilInstance.getMaxWarps(inputs);
+        
+        const combined: {d: Draft, n: number} = inputs.reduce((acc, input, ndx) => {
+
+          input.pattern.forEach((row, i) => {
+            row.forEach((cell, j) => {
+              acc.d.pattern[acc.n + i][j].setHeddle(cell.getHeddle());
+            });
+          });
+
+          acc.n = input.pattern.length;
+          return acc;
+
+        }, {d: new Draft({warps: max_warps, wefts: total}), n: 0});
+
+
+        return Promise.resolve([combined.d]);
+        
+      }
+    }
+
+
     const joinleft: Operation = {
       name: 'join left',
       dx: 'attaches inputs toether into one draft with each iniput side by side',
@@ -1544,15 +1635,16 @@ export class OperationService {
     this.ops.push(interlace);
     this.ops.push(invert);
     this.ops.push(replicate);
-    this.ops.push(mirrorx);
-    this.ops.push(mirrory);
+    this.ops.push(flipx);
+    this.ops.push(flipy);
     this.ops.push(shiftx);
     this.ops.push(shifty);
     this.ops.push(layer);
     this.ops.push(selvedge);
     this.ops.push(bindweftfloats);
     this.ops.push(bindwarpfloats);
     this.ops.push(joinleft);
+    this.ops.push(jointop);
     this.ops.push(slope);
     this.ops.push(tile);
     this.ops.push(stretch);
@@ -1569,7 +1661,8 @@ export class OperationService {
     this.ops.push(germanify);
     this.ops.push(crackleify);
     this.ops.push(variants);
-    // this.ops.push(reverse);
+    this.ops.push(knockout);
+    this.ops.push(crop);
 
 
     //** Give it a classification here */
@@ -1586,12 +1679,12 @@ export class OperationService {
 
     this.classification.push(
       {category: 'transformations',
-      ops: [fill, invert, mirrorx, mirrory, shiftx, shifty, rotate, slope, stretch, resize, margin]}
+      ops: [fill, invert, flipx, flipy, shiftx, shifty, rotate, slope, stretch, resize, margin, crop]}
     );
 
     this.classification.push(
       {category: 'compose',
-      ops: [replicate, interlace, layer, tile, joinleft, selvedge,atop, overlay, mask, bindweftfloats, bindwarpfloats]}
+      ops: [replicate, interlace, layer, tile, joinleft, jointop, selvedge, atop, overlay, mask, knockout, bindweftfloats, bindwarpfloats]}
     );
 
     this.classification.push(