ai-nevermore 0.0.5 → 0.0.6

package/README.md

@@ -29,14 +29,19 @@ Install with `npm install -g ai-nevermore`
 nevermore [command]
 
 Commands:
-  nevermore pseudotext [input-file]  process the input
+  nevermore pseudotext [input-file]   transform text to poison
+  nevermore pseudoimage [input-file]  transform XOR image encoding
 
 Options:
       --version            Show version number                         [boolean]
+  -K, --key                key to use for decoding the image            [string]
   -U, --unified-output     File to generate html + css into             [string]
   -C, --css-output         File to generate css into                    [string]
+  -I, --image-output       File to output image to                      [string]
   -H, --html-output        File to generate html into                   [string]
   -r, --raw-output         Do not wrap the ouput                       [boolean]
+  -E, --encode             inline encoding                             [boolean]
+  -D, --decode             inline decoding                             [boolean]
   -m, --render-mode        output mode
         [string] [choices: "fixed-mode", "inline-mode"] [default: "inline-mode"]
   -s, --size               The size of the font in pixels (required for
@@ -58,6 +63,8 @@ Roadmap
 - [x] raw output mode
 - [x] stdin, stdout support
 - [x] custom dictionary
+- [x] image encoding
+- [ ] web component decoder
 - [ ] self randomizing dictionary
 - [ ] add a replacement mode (opposed to a tokenizer based solution)
 

package/bin/nevermore

@@ -2,9 +2,12 @@
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import { computeIndexKeys, generateHTMLAndCSS } from '../src/index.mjs';
+import { NevermoreImage } from '../src/image.mjs';
+import { Canvas } from '@environment-safe/canvas';
 import { readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 const { cwd } = process;
+const __dirname = import.meta.dirname;
 
 
 const formatHTML = (html, css, isRaw=false)=>{
@@ -13,7 +16,7 @@ const formatHTML = (html, css, isRaw=false)=>{
 };
 
 yargs(hideBin(process.argv))
-    .command('pseudotext [input-file]', 'process the input', (yargs) => {
+    .command('pseudotext [input-file]', 'transform text to poison', (yargs) => {
         return yargs
         .positional('input-file', {
             describe: 'file input'
@@ -72,6 +75,43 @@ yargs(hideBin(process.argv))
                 process.stdout.write(output);
             }
         }
+    }).command('pseudoimage [input-file]', 'transform XOR image encoding', (yargs) => {
+        return yargs
+        .positional('input-file', {
+            describe: 'file input'
+        })
+    }, async (argv) => {
+        let image = null;
+        if(!argv['input-file']){
+            //TODO: pipe support
+            throw new Error('pipe not yet supported');
+        }else{
+            const options = {
+                url: argv['input-file'],
+                maskDir: join(__dirname, '..', 'textures')
+            };
+            if(argv['key']){
+                options.key = argv['key']
+            }
+            image = new NevermoreImage(options);
+            await image.ready;
+        }
+        if(image && argv['image-output']){
+            let canvas = null; 
+            if(argv['encode']){
+                canvas = await image.encode();
+            }
+            if(argv['decode']){
+                canvas = await image.decode();
+            }
+            Canvas.save(argv['image-output'], canvas);
+        }else{
+            throw new Error('piped output not yet supported');
+        }
+    }).option('key', {
+        alias: 'K',
+        type: 'string',
+        description: 'key to use for decoding the image'
     }).option('unified-output', {
         alias: 'U',
         type: 'string',
@@ -80,6 +120,10 @@ yargs(hideBin(process.argv))
         alias: 'C',
         type: 'string',
         description: 'File to generate css into'
+    }).option('image-output', {
+        alias: 'I',
+        type: 'string',
+        description: 'File to output image to'
     }).option('html-output', {
         alias: 'H',
         type: 'string',
@@ -88,6 +132,14 @@ yargs(hideBin(process.argv))
         alias: 'r',
         type: 'boolean',
         description: 'Do not wrap the ouput'
+    }).option('encode', {
+        alias: 'E',
+        type: 'boolean',
+        description: 'inline encoding'
+    }).option('decode', {
+        alias: 'D',
+        type: 'boolean',
+        description: 'inline decoding'
     }).option('render-mode', {
         alias: 'm',
         type: 'string',

package/demo.mjs

@@ -0,0 +1,29 @@
+import { channelXOR, NevermoreImage } from './src/image.mjs';
+import { Canvas, Image } from '@environment-safe/canvas';
+
+(async ()=>{
+    const image = new NevermoreImage({
+        url:'./test.jpg',
+        maskDir: './textures'
+    });
+    await image.ready;
+    const canvas = image.encode();
+    await Canvas.save('./encoded.jpg', canvas);
+    const decoded = image.decode();
+    await Canvas.save('./decoded.jpg', decoded);
+    /*
+    const canvas = await Canvas.load('./test.jpg');
+    const texture = await Canvas.load('./textures/A.jpg');
+    await Canvas.save('./t.jpg', canvas);
+    await Canvas.save('./x.jpg', texture);
+    const pixels = channelXOR(canvas, texture, 'red', 1);
+    const context = canvas.getContext('2d');
+    console.log(pixels, 0, 0, canvas.width, canvas.height)
+    context.putImageData(pixels, 0, 0, 0, 0, canvas.width, canvas.height);
+    await Canvas.save('./out.jpg', canvas);
+    const resetPixels = channelXOR(canvas, texture, 'red', -1);
+    context.putImageData(resetPixels, 0, 0, 0, 0, canvas.width, canvas.height);
+    await Canvas.save('./reset.jpg', canvas);
+    //*/
+    
+})();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ai-nevermore",
-    "version": "0.0.5",
+    "version": "0.0.6",
     "keywords": [
         "adversarial",
         "content",
@@ -18,6 +18,12 @@
         ".": {
             "import": "./src/index.mjs"
         },
+        "./image": {
+            "import": "./src/image.mjs"
+        },
+        "./src/image.mjs": {
+            "import": "./src/image.mjs"
+        },
         "./package.json": {
             "import": "./package.json"
         },
@@ -25,17 +31,20 @@
             "import": "./src/index.mjs"
         }
     },
-    "bin":{
+    "bin": {
         "nevermore": "./bin/nevermore"
     },
-    "scripts":{
+    "scripts": {
         "single-file-demo": "./bin/nevermore pseudotext -U output.html nevermore.txt",
         "pipe-demo": "cat nevermore.txt | ./bin/nevermore pseudotext",
         "demo": "./bin/nevermore pseudotext -H out.html -C out.css nevermore.txt",
+        "image-encode": "./bin/nevermore pseudoimage ./test.jpg --image-output out.jpg --encode",
+        "image-decode": "./bin/nevermore pseudoimage ./out.jpg --image-output decoded.jpg --decode",
         "help": "./bin/nevermore --help"
     },
     "dependencies": {
-        "@environment-safe/file": "^0.4.0",
+        "@environment-safe/canvas": "^4.2.3",
+        "@environment-safe/file": "^0.4.3",
         "object-hash": "^3.0.0",
         "parse-english": "^7.0.0",
         "self-dict": "^1.0.0",

package/src/image.mjs

@@ -0,0 +1,186 @@
+import { Canvas, Image } from '@environment-safe/canvas';
+import { File, Path } from '@environment-safe/file';
+
+export const channelXOR = (imageCanvas, textureCanvas, chn='', direction= 1)=>{
+    const imageContext = imageCanvas.getContext('2d', { willReadFrequently: true });
+    const textureContext = textureCanvas.getContext('2d', { willReadFrequently: true });
+    const texturePixels = textureContext.getImageData(0,0, textureCanvas.width, textureCanvas.height);
+    const newPixels  = imageContext.getImageData(0,0, imageCanvas.width, imageCanvas.height);
+    const sx = imageCanvas.width; //getx
+    const sy = imageCanvas.height; //gety
+    const tx = textureCanvas.width; //getx
+    const ty = textureCanvas.height; //gety
+    let x = null;
+    let y = null;
+    let pxl = null;
+    let tex_r, tex_g, tex_b, mask_offset, pixel_offset, value = null;
+    let channel = '';
+    switch(chn.toLowerCase()){
+        case 'red':
+        case 'r':
+            channel = 'r';
+            break;
+        case 'green':
+        case 'g':
+            channel = 'g';
+            break;
+        case 'blue':
+        case 'b':
+            channel = 'b';
+            break;
+    }
+    //kernel_size = filter.length; //coming soon
+    const intervalWidth = 256;
+    for(y = 0; y < sy; y++){
+        for(x = 0; x < sx; x++){
+            mask_offset = (((y%ty)*((sx%tx)*4)) + ((x%tx)*4));
+            pixel_offset = ((y*(sx*4)) + (x*4));
+            tex_r = texturePixels.data[mask_offset    ];
+            tex_g = texturePixels.data[mask_offset + 1];
+            tex_b = texturePixels.data[mask_offset + 2];
+            if(!(tex_r === tex_g && tex_g === tex_b)){
+                value = Math.floor((tex_r + tex_g + tex_b) / 3);
+            }else{
+                value = tex_r;
+            }
+            if(channel === 'r'){
+                newPixels.data[pixel_offset  ] = (
+                    newPixels.data[pixel_offset  ] + direction*value + intervalWidth
+                )%intervalWidth;
+            }
+            if(channel === 'g'){
+                newPixels.data[pixel_offset+1] = (
+                    newPixels.data[pixel_offset+1] + direction*value + intervalWidth
+                )%intervalWidth;
+            }
+            if(channel === 'b'){
+                newPixels.data[pixel_offset + 2] = (
+                    newPixels.data[pixel_offset+2] + direction*value + intervalWidth
+                )%intervalWidth;
+            }
+        }
+    }
+    return newPixels;
+};
+
+const makeKey = (len, alpha)=>{
+    const alphabet = alpha || 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
+    let key = '';
+    for(let lcv=0; lcv < len; lcv++){
+        key += alphabet[Math.floor(Math.random()*alphabet.length)];
+    }
+    return key;
+}
+
+export class NevermoreImage{
+    constructor(options={}){
+        if(!(
+            options.masks || options.maskDir
+        )) throw new Error('a set of masks are required');
+        this.ready = new Promise(async (resolve, reject)=>{
+            // load all masks
+            // TODO: load from cache
+            let masks = options.masks;
+            const textureWork = [];
+            const textureDictionary = {};
+            if(options.maskDir){
+                const types = ['jpg', 'jpeg', 'gif', 'png'];
+                const files = (await File.list(options.maskDir)).filter((name)=>{
+                    const parts = name.split('.');
+                    const ext = parts.pop().toLowerCase();
+                    return types.indexOf(ext) !== -1;
+                    // TODO: support mime through magic numbers
+                });
+                const fileLoads = [];
+                for(let lcv=0; lcv<files.length; lcv++){
+                    const pth = new Path(files[lcv]);
+                    if(!pth.parsed) throw new Error('path not parsed');
+                    const parsed = pth.parsed.posix || pth.parsed.win32;
+                    const canvasLoad = Canvas.load(
+                        Path.join(options.maskDir, files[lcv])
+                    );
+                    textureWork.push(new Promise(async (resolve)=>{
+                        resolve({
+                            name: parsed.name,
+                            canvas: await canvasLoad
+                        });
+                    }))
+                    fileLoads.push(Canvas.load(Path.join(options.maskDir, files[lcv])));
+                }
+                masks = await Promise.all(fileLoads);
+                const texturesLoaded = await Promise.all(textureWork);
+                for(let lcv=0; lcv<texturesLoaded.length; lcv++){
+                    textureDictionary[
+                        texturesLoaded[lcv].name
+                    ] = texturesLoaded[lcv].canvas;
+                };
+                this.textureDictionary = textureDictionary;
+            }
+            this.masks = masks;
+            this.canvas = options.image;
+            // masks loaded, now load the base image
+            if(options.url){
+                this.canvas = await Canvas.load(options.url);
+            }
+            if(!this.canvas){
+                return reject(new Error(
+                    'no base image provided to Image File'
+                ));
+            }
+            //make an id
+            this.key = options.key || `${makeKey(5)}-${makeKey(5)}-${makeKey(5)}`;
+            console.log('KEY:', this.key);
+            //we're ready to do work
+            resolve();
+        });
+    }
+    
+    transform(options={}){
+        const { channelKeys, direction, key } = options;
+        let pixels = null;
+        let channelKey = null;
+        const canvas = this.canvas;
+        for(let lcv=0; lcv < channelKeys.r.length; lcv++){
+            const texture = this.textureDictionary[channelKeys.r[lcv]];
+            const pixels = channelXOR(canvas, texture, 'red', direction);
+            const context = canvas.getContext('2d');
+            context.putImageData(pixels, 0, 0, 0, 0, canvas.width, canvas.height);
+        }
+        for(let lcv=0; lcv < channelKeys.r.length; lcv++){
+            const texture = this.textureDictionary[channelKeys.r[lcv]];
+            const pixels = channelXOR(canvas, texture, 'green', direction);
+            const context = canvas.getContext('2d');
+            context.putImageData(pixels, 0, 0, 0, 0, canvas.width, canvas.height);
+        }
+        for(let lcv=0; lcv < channelKeys.r.length; lcv++){
+            const texture = this.textureDictionary[channelKeys.r[lcv]];
+            const pixels = channelXOR(canvas, texture, 'blue', direction);
+            const context = canvas.getContext('2d');
+            context.putImageData(pixels, 0, 0, 0, 0, canvas.width, canvas.height);
+        }
+        // should this mutate? current answer: yes
+        return canvas;
+    }
+    
+    encode(options={}){
+        const key = options.key || this.key;
+        const parts = key.split('-')
+        const channelKeys = {
+            r: parts[0].split(''), 
+            g: parts[1].split(''), 
+            b: parts[2].split('')
+        }
+        return this.transform({ channelKeys, key, direction: 1 });
+    }
+    
+    decode(options={}){
+        const key = options.key || this.key;
+        const parts = key.split('-');
+        const channelKeys = {
+            r: parts[0].split('').reverse(), 
+            g: parts[1].split('').reverse(), 
+            b: parts[2].split('').reverse()
+        }
+        return this.transform({ channelKeys, key, direction: -1 });
+    }
+}