edge-impulse-linux 1.8.10 → 1.9.1

package/examples/ts/classify-camera.ts

@@ -0,0 +1,113 @@
+import { ImageClassifier, LinuxImpulseRunner, Ffmpeg, ICamera, Imagesnap } from "../../library";
+import { RunnerHelloHasAnomaly } from "../../library/classifier/linux-impulse-runner";
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+(async () => {
+    try  {
+
+        // Required arguments:
+        //   arg 2: Path to the model file. e.g. /tmp/model.eim
+        //   arg 3: Name of the camera device, see output of `gst-device-monitor-1.0`. e.g. "HD Pro Webcam C920"
+        // Optional arguments:
+        //   arg 4: desired FPS. e.g. 20, default 5
+        //   arg 5: desired capture width. e.g. 320, default 640
+        //   arg 6: desired capture height. e.g. 200, default 480
+
+        const argModelFile = process.argv[2];
+        const argCamDevice = process.argv[3];
+        const fps = process.argv[4] ? Number(process.argv[4]) : 5;
+        const dimensions = (process.argv[5] && process.argv[6]) ? {
+            width: Number(process.argv[5]),
+            height: Number(process.argv[6])
+        } : {
+            width: 640,
+            height: 480
+        };
+
+        if (!argModelFile) {
+            console.log('Missing one argument (model file)');
+            process.exit(1);
+        }
+
+        let runner = new LinuxImpulseRunner(argModelFile);
+        let model = await runner.init();
+
+        let labels = model.modelParameters.labels;
+        if (model.modelParameters.has_anomaly === RunnerHelloHasAnomaly.VisualGMM) {
+            labels.push('anomaly');
+        }
+
+        console.log('Starting the image classifier for',
+            model.project.owner + ' / ' + model.project.name, '(v' + model.project.deploy_version + ')');
+        console.log('Parameters',
+            'image size', model.modelParameters.image_input_width + 'x' + model.modelParameters.image_input_height + ' px (' +
+                model.modelParameters.image_channel_count + ' channels)',
+            'classes', labels);
+
+        // select a camera... you can implement this interface for other targets :-)
+        let camera: ICamera;
+        if (process.platform === 'darwin') {
+            camera = new Imagesnap();
+        }
+        else if (process.platform === 'linux') {
+            camera = new Ffmpeg(false /* verbose */);
+        }
+        else {
+            throw new Error('Unsupported platform "' + process.platform + '"');
+        }
+        await camera.init();
+
+        const devices = await camera.listDevices();
+        if (devices.length === 0) {
+            throw new Error('Cannot find any webcams');
+        }
+        if (devices.length > 1 && !argCamDevice) {
+            throw new Error('Multiple cameras found (' + devices.map(n => '"' + n + '"').join(', ') + '), add ' +
+                'the camera to use to this script (node classify-camera.js model.eim cameraname)');
+        }
+
+        let device = argCamDevice || devices[0];
+
+        console.log('Using camera', device, 'starting...');
+
+        await camera.start({
+            device: device,
+            intervalMs: 1000 / fps,
+            dimensions: dimensions
+        });
+
+        camera.on('error', error => {
+            console.log('camera error', error);
+            process.exit(1);
+        });
+
+        console.log('Connected to camera');
+
+        let imageClassifier = new ImageClassifier(runner, camera);
+
+        await imageClassifier.start();
+
+        imageClassifier.on('result', (ev, timeMs, imgAsJpg) => {
+            if (ev.result.classification) {
+                // print the raw predicted values for this frame
+                // (turn into string here so the content does not jump around)
+                // eslint-disable-next-line
+                let c = <{ [k: string]: string | number }>(<any>ev.result.classification);
+                for (let k of Object.keys(c)) {
+                    c[k] = (<number>c[k]).toFixed(4);
+                }
+                console.log('classification', timeMs + 'ms.', c);
+            }
+            if (ev.result.bounding_boxes) {
+                console.log('boundingBoxes', timeMs + 'ms.', JSON.stringify(ev.result.bounding_boxes));
+            }
+            if (ev.result.visual_anomaly_grid) {
+                console.log('visual anomalies', timeMs + 'ms.', JSON.stringify(ev.result.visual_anomaly_grid));
+            }
+        });
+    }
+    catch (ex) {
+        console.error(ex);
+        process.exit(1);
+    }
+})();

package/examples/ts/classify-custom-from-test.ts

@@ -0,0 +1,97 @@
+import { LinuxImpulseRunner } from "../../library";
+import fs from 'fs';
+
+// This script expects two arguments:
+// 1. The model file
+// 2. A features file with raw data. You can get this by going to **Live classification > Load sample**
+//    then copy the features from the 'Raw features' block.
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+(async () => {
+    try  {
+        if (!process.argv[2]) {
+            console.log('Missing one argument (model file)');
+            process.exit(1);
+        }
+
+        if (!process.argv[3]) {
+            console.log('Missing second argument (features file)');
+            process.exit(1);
+        }
+
+        // Load the model
+        let runner = new LinuxImpulseRunner(process.argv[2]);
+        let model = await runner.init();
+
+        const windowLengthMs = ((model.modelParameters.input_features_count /
+            model.modelParameters.frequency /
+            model.modelParameters.axis_count) * 1000);
+
+        console.log('Starting the custom classifier for',
+            model.project.owner + ' / ' + model.project.name, '(v' + model.project.deploy_version + ')');
+        console.log('Parameters', 'freq', model.modelParameters.frequency + 'Hz',
+            'window length', windowLengthMs + 'ms.',
+            'classes', model.modelParameters.labels);
+
+        // read the features file (comma separated numbers)
+        // Newlines deliminate samples
+        // Create an array of array of Numbers.  Each inner array is a sample.
+        let samples = (<string>await fs.promises.readFile(process.argv[3], 'utf-8'))
+            .trim().split('\n').map(line => line.split(',').map(n => Number(n)));
+
+        for (let features of samples) {
+            // and classify the data, this should match the classification in the Studio
+            let res = await runner.classify(features);
+
+            console.log('Begin output');
+            if (res.result.classification) {
+                let ret: number[] = [];
+                for (let k of Object.keys(res.result.classification)) {
+                    ret.push(res.result.classification[k]);
+                }
+                if (typeof res.result.visual_anomaly_max === 'number') {
+                    ret.push(res.result.visual_anomaly_max);
+                }
+                else if (typeof res.result.anomaly === 'number') {
+                    ret.push(res.result.anomaly);
+                }
+                console.log('[' + ret.map(x => x.toFixed(5)).join(', ') + ']');
+            }
+            if (res.result.bounding_boxes) {
+                for (let bb of res.result.bounding_boxes) {
+                    if (bb.value === 0) {
+                        continue;
+                    }
+                    console.log(`${bb.label} (${bb.value.toFixed(5)}) ` +
+                        `[ x: ${bb.x}, y: ${bb.y}, width: ${bb.width}, height: ${bb.height} ]`);
+                }
+            }
+            if (res.result.visual_anomaly_grid) {
+                for (let bb of res.result.visual_anomaly_grid) {
+                    console.log(`${bb.label} (${bb.value.toFixed(5)}) ` +
+                        `[ x: ${bb.x}, y: ${bb.y}, width: ${bb.width}, height: ${bb.height} ]`);
+                }
+            }
+            console.log('End output');
+
+            // if you want to fill in data on the fly you can also do this; e.g. if you have 3-axis accelerometer
+            // with 2 second window and 100Hz, then input_features_count=600, axis_count=3
+            // let features = [];
+            // for (let ix = 0; ix <
+            //   model.modelParameters.input_features_count; ix += model.modelParameters.axis_count) {
+            //     features.push(x);
+            //     features.push(y);
+            //     features.push(z);
+            // }
+            // and classify features
+        }
+        await runner.stop();
+    }
+    catch (ex) {
+        console.error(ex);
+        process.exit(1);
+    }
+    finally {
+        process.exit(0);
+    }
+})();

package/examples/ts/classify-custom.ts

@@ -0,0 +1,63 @@
+import { LinuxImpulseRunner } from "../../library";
+import fs from 'fs';
+
+// This script expects two arguments:
+// 1. The model file
+// 2. A features file with raw data. You can get this by going to **Live classification > Load sample**
+//    then copy the features from the 'Raw features' block.
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+(async () => {
+    try  {
+        if (!process.argv[2]) {
+            console.log('Missing one argument (model file)');
+            process.exit(1);
+        }
+
+        if (!process.argv[3]) {
+            console.log('Missing second argument (features file)');
+            process.exit(1);
+        }
+
+        // Load the model
+        let runner = new LinuxImpulseRunner(process.argv[2]);
+        let model = await runner.init();
+
+        const windowLengthMs = ((model.modelParameters.input_features_count /
+            model.modelParameters.frequency /
+            model.modelParameters.axis_count) * 1000);
+
+        console.log('Starting the custom classifier for',
+            model.project.owner + ' / ' + model.project.name, '(v' + model.project.deploy_version + ')');
+        console.log('Parameters', 'freq', model.modelParameters.frequency + 'Hz',
+            'window length', windowLengthMs + 'ms.',
+            'classes', model.modelParameters.labels);
+
+        // read the features file (comma separated numbers)
+        let features = (<string>await fs.promises.readFile(process.argv[3], 'utf-8'))
+            .trim().split(',').map(n => Number(n));
+
+        // and classify the data, this should match the classification in the Studio
+        let res = await runner.classify(features);
+        console.log('classification', res.result, 'timing', res.timing);
+
+        // if you want to fill in data on the fly you can also do this; e.g. if you have 3-axis accelerometer
+        // with 2 second window and 100Hz, then input_features_count=600, axis_count=3
+        // let features = [];
+        // for (let ix = 0; ix < model.modelParameters.input_features_count; ix += model.modelParameters.axis_count) {
+        //     features.push(x);
+        //     features.push(y);
+        //     features.push(z);
+        // }
+        // and classify features
+
+        await runner.stop();
+    }
+    catch (ex) {
+        console.error(ex);
+        process.exit(1);
+    }
+    finally {
+        process.exit(0);
+    }
+})();

package/examples/ts/collect-custom.ts

@@ -0,0 +1,56 @@
+import { DataForwarder, getIps } from '../../library';
+
+// Your API & HMAC keys here (go to your project > Dashboard > Keys to find this)
+const API_KEY = process.env.API_KEY || 'ei_...';
+const HMAC_KEY = process.env.HMAC_KEY || '0';
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+(async () => {
+    try {
+        // instantiate a DataForwarder object to collect custom data from a sensor
+        let dataForwarder = new DataForwarder({
+            // use MAC address of network interface as deviceId
+            deviceId: getIps().length > 0 ? getIps()[0].mac : undefined,
+            deviceType: 'CUSTOM-COLLECTOR',
+            apiKey: API_KEY,
+            // This is the interval between samples (alt. you can use `frequency` here)
+            // here we have new data every 16 ms.
+            intervalMs: 16,
+            hmacKey: HMAC_KEY,
+            // list all the sensors, one item per axis
+            sensors: [
+                { name: 'accX', units: 'm/s2' },
+                { name: 'accY', units: 'm/s2' },
+                { name: 'accZ', units: 'm/s2' },
+            ]
+        });
+
+        // after instantiating the DataForwarder object we'll write new data (grab this data from your sensors)
+        // here we'll collect 2 seconds of data (16ms. = 62.5Hz)
+        for (let ix = 0; ix < 62.5 * 2; ix++) {
+            // make some nice wave forms
+            dataForwarder.addData([
+                Math.sin(ix * 0.1) * 10,
+                Math.cos(ix * 0.1) * 10,
+                (Math.sin(ix * 0.1) + Math.cos(ix * 0.1)) * 10,
+            ]);
+        }
+
+        console.log('Uploading data...');
+
+        // afer you're done, send the data to Edge Impulse
+        await dataForwarder.upload({
+            filename: 'linux-test.json',
+            label: 'linuxtest',
+            // category can either be training, testing or split
+            // (the latter takes the hash of the file and splits it between training/testing automatically)
+            category: 'training',
+        });
+
+        console.log('Uploading data OK');
+    }
+    catch (ex) {
+        console.error(ex);
+        process.exit(1);
+    }
+})();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edge-impulse-linux",
-  "version": "1.8.10",
+  "version": "1.9.1",
   "description": "Node.js SDK and tools for Edge Impulse for Linux",
   "directories": {
     "example": "examples"
@@ -11,7 +11,8 @@
     "fast-lint": "oxlint --symlinks -c ../../.eslintrc.json -A unicorn --deny-warnings --tsconfig ./tsconfig.json .",
     "lint": "npm run fast-lint && npm run eslint",
     "test": "tsc -b . && TS_NODE_PROJECT=./tsconfig.json mocha --config ./test/.mocharc.js",
-    "watch-runner": "func() { tsc-watch -b . --onSuccess \"node build/cli/linux/runner.js $1\" --noClear; }; func"
+    "watch-runner": "func() { tsc-watch -b . --onSuccess \"node build/cli/linux/runner.js $1\" --noClear; }; func",
+    "verify-build": "echo \"import { EdgeImpulseApi } from './build/sdk/studio/index.js'\" | node --input-type=module && [ $(find ./build/sdk -type f | wc -l) -gt 50 ]"
   },
   "bin": {
     "edge-impulse-linux": "build/cli/linux/linux.js",
@@ -33,48 +34,60 @@
   "dependencies": {
     "async-mutex": "0.2.6",
     "borc": "2.1.2",
-    "cbor": "5.0.1",
+    "cbor": "5.0.2",
     "commander": "4.1.1",
-    "express": "4.17.3",
+    "express": "4.21.1",
     "form-data": "4.0.0",
     "inquirer": "7.0.0",
-    "jpeg-js": "0.4.2",
+    "jpeg-js": "0.4.4",
     "multer": "1.4.5-lts.1",
     "node-fetch": "2.6.7",
     "npm-registry-fetch": "5.0.0",
     "request": "2.88.0",
     "request-promise": "4.2.4",
     "sharp": "0.32.6",
-    "socket.io": "2.5.0",
+    "socket.io": "2.5.1",
     "tiny-async-pool": "1.1.0",
     "tsee": "1.3.4",
     "typed-emitter": "1.3.1",
     "wavefile": "11.0.0",
-    "ws": "7.2.0"
+    "ws": "7.5.10"
   },
   "devDependencies": {
-    "@stylistic/eslint-plugin-ts": "2.1.0",
-    "@types/cbor": "2.0.0",
+    "@stylistic/eslint-plugin": "2.8.0",
+    "@types/cbor": "5.0.0",
     "@types/commander": "2.12.2",
-    "@types/express": "4.17.1",
+    "@types/express": "4.17.21",
     "@types/inquirer": "6.5.0",
     "@types/mocha": "9.0.0",
     "@types/multer": "1.4.11",
-    "@types/node": "20.12.7",
+    "@types/node": "20.14.14",
     "@types/npm-registry-fetch": "4.0.1",
     "@types/request": "2.48.3",
-    "@types/request-promise": "4.1.44",
+    "@types/request-promise": "4.1.45",
     "@types/sharp": "0.32.0",
     "@types/socket.io": "2.1.4",
     "@types/tiny-async-pool": "1.0.0",
-    "@types/ws": "6.0.3",
+    "@types/ws": "6.0.4",
     "@typescript-eslint/eslint-plugin": "7.12.0",
     "@typescript-eslint/parser": "7.12.0",
     "eslint": "8.57.0",
-    "oxlint": "0.3.4",
-    "mocha": "9.1.3",
+    "oxlint": "0.5.2",
+    "mocha": "9.2.2",
     "ts-node": "10.9.2",
     "tsc-watch": "6.2.0",
     "typescript": "4.9.5"
-  }
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "build/",
+    "!build/test/",
+    "!build/examples/",
+    "package*.json",
+    "examples/",
+    "test/",
+    "borc/",
+    "utypes.d.ts"
+  ]
 }