Feature node libs

.gitignore

@@ -4,6 +4,7 @@ build/*.a
 node_modules
 docs/*
 emscripten/build
+emscripten/zlib/build
 python-bindings/build
 python-bindings/dist
 python-bindings/emscripten

README.md

@@ -96,6 +96,34 @@ then:
 import { ARToolkitNFT, ARControllerNFT } from '@webarkit/jsartoolkit-nft'
 ```
 
+The package ships an [`exports`](https://nodejs.org/api/packages.html#package-entry-points) map, so the right build is picked automatically per environment:
+
+- in a **browser / bundler**, `@webarkit/jsartoolkit-nft` resolves to the UMD build (`dist/ARToolkitNFT.js`);
+- in **Node.js**, it resolves to the Node build (`dist/ARToolkitNFT_node.js`, CommonJS).
+
+```javascript
+// browser / bundler -> UMD build
+import { ARToolkitNFT, ARControllerNFT } from '@webarkit/jsartoolkit-nft'
+
+// Node.js -> Node build
+const { ARToolkitNFT, ARControllerNFT } = require('@webarkit/jsartoolkit-nft')
+```
+
+You can also target a specific build through a named subpath:
+
+| Import | Build |
+| --- | --- |
+| `@webarkit/jsartoolkit-nft` | UMD (browser) / Node (Node.js) |
+| `@webarkit/jsartoolkit-nft/simd` | SIMD WASM build |
+| `@webarkit/jsartoolkit-nft/td` | threaded (pthread) build |
+| `@webarkit/jsartoolkit-nft/node` | Node build |
+
+```javascript
+import '@webarkit/jsartoolkit-nft/simd'
+```
+
+The raw `dist/*` deep-imports (e.g. `@webarkit/jsartoolkit-nft/dist/ARToolkitNFT_simd.js`) still work, and `<script>` / `importScripts` URLs are not affected by the `exports` map. In Node the build is CommonJS, so use `require()` or a default `import` (named `import { ... }` will come with a future ESM build).
+
 **Note**: All the examples in the repository are running the code inside a Worker (don't use it in the main thread!). So i you need to import the library in a worker you need to use the `importScripts` function.
 
 ```javascript
@@ -169,6 +197,65 @@ The Python bindings are built and tested on **Linux**, **macOS** and **Windows**
 
 For full build-from-source instructions, local development tips and the TestPyPI publishing workflow, see [`python-bindings/README.md`](python-bindings/README.md).
 
+## Node.js 🟢 (experimental)
+
+❕❕❕ ATTENTION: Node.js support is experimental and under active development. The API may change without notice and it is not yet recommended for production use.
+
+**JSARToolKitNFT** ships a dedicated Node.js build (`dist/ARToolkitNFT_node.js`), compiled from the same TypeScript sources and WebARKitLib C/C++ core as the browser build. It lets you run NFT marker detection server-side on static image data, without a browser, camera or `<canvas>`.
+
+When you install the package, Node automatically resolves to this build (see the [`exports`](#using-the-library-) map):
+
+```javascript
+// CommonJS — resolves to the Node build in Node.js
+const { ARControllerNFT } = require('@webarkit/jsartoolkit-nft');
+// or the explicit subpath
+const { ARControllerNFT } = require('@webarkit/jsartoolkit-nft/node');
+```
+
+A minimal example decoding an image with [sharp](https://github.com/lovell/sharp) and feeding the RGBA pixels to the controller:
+
+```javascript
+const { ARControllerNFT } = require('@webarkit/jsartoolkit-nft');
+const sharp = require('sharp');
+
+async function init() {
+  const arControllerNFT = await new ARControllerNFT(2000, 1500, '/camera_para.dat');
+  const ar = await arControllerNFT._initialize();
+
+  // process() expects RGBA pixel data, so add the alpha channel.
+  const data = await sharp('pinball-demo.jpg').ensureAlpha().raw().toBuffer();
+  const imageData = new Uint8Array(data.buffer);
+
+  ar.on('getNFTMarker', (e) => console.log('NFT marker detected: ', e));
+
+  ar.loadNFTMarker('DataNFT/pinball', (id) => {
+    ar.trackNFTMarkerId(id);
+    // NFT tracking needs several iterations before it locks on.
+    for (let i = 0; i < 10; i++) ar.process(imageData);
+  });
+}
+
+init();
+```
+
+### What works
+
+- Loading NFT marker datasets (`.fset`, `.fset3`, `.iset`)
+- KPM-based marker detection and AR2 tracking with pose matrix output
+- Event listener for `getNFTMarker`
+- Decoding image input via [sharp](https://github.com/lovell/sharp) or the [canvas](https://github.com/Automattic/node-canvas) package (`process()` expects **RGBA** pixel data)
+
+### Not yet implemented
+
+- Native ESM consumption (`import { ARControllerNFT } from ...`): the Node build is CommonJS for now, so use `require()` or a default `import`
+- Live camera capture (the examples process a single static image)
+
+Runnable examples live in [`examples/node`](examples/node): [`example_dist.js`](examples/node/example_dist.js) (sharp + the Node build) and [`example_canvas.js`](examples/node/example_canvas.js) (the [canvas](https://github.com/Automattic/node-canvas) package). Run one with:
+
+```bash
+cd examples/node && node example_dist.js
+```
+
 ## Project Structure 📂
 
 - `build/` (compiled debug and minified versions of JSARToolKitNFT)

build/artoolkitNFT.debug.js

@@ -766,7 +766,7 @@ var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIR
     this._src = "";
     this.complete = false;
   };
-  // ARToolKit exported JS API
+  // ARToolKitNFT exported JS API
   const artoolkitNFT = {
     UNKNOWN_MARKER: -1,
     NFT_MARKER: 0,

dist/ARToolkitNFT_node.js.LICENSE.txt

@@ -0,0 +1 @@
+/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */

examples/node/example_build.js

@@ -0,0 +1,76 @@
+const Module = require('../../build/artoolkitNFT_node_wasm.js');
+
+console.log('This is a test importing artoolkitNFT_node_wasm with Nodejs')
+
+var scope;
+if (typeof global !== 'undefined') {
+    scope = global;
+} else {
+    scope = self;
+}
+
+// ARToolKitNFT exported JS API
+//
+var artoolkitNFT = {
+
+    UNKNOWN_MARKER: -1,
+    NFT_MARKER: 0, // 0,
+
+};
+
+var FUNCTIONS = [
+    'setup',
+    'teardown',
+
+    'setupAR2',
+
+    'setLogLevel',
+    'getLogLevel',
+
+    'setDebugMode',
+    'getDebugMode',
+
+    'getProcessingImage',
+
+    'detectMarker',
+    'detectNFTMarker',
+    'getNFTMarker',
+    'getNFTData',
+
+    'setProjectionNearPlane',
+    'getProjectionNearPlane',
+
+    'setProjectionFarPlane',
+    'getProjectionFarPlane',
+
+    'setThresholdMode',
+    'getThresholdMode',
+
+    'setThreshold',
+    'getThreshold',
+
+    'setImageProcMode',
+    'getImageProcMode',
+];
+
+function runWhenLoaded() {
+    FUNCTIONS.forEach(function (n) {
+        artoolkitNFT[n] = Module[n];
+    });
+
+    for (var m in Module) {
+        if (m.match(/^AR/))
+            artoolkitNFT[m] = Module[m];
+    }
+}
+
+/* Exports */
+scope.artoolkitNFT = artoolkitNFT;
+
+Module.onRuntimeInitialized = async function () {
+    runWhenLoaded();
+
+    console.log(artoolkitNFT);
+
+    artoolkitNFT.setup(640, 480, 0);
+}

examples/node/example_canvas.js

@@ -0,0 +1,54 @@
+const jsartoolkitNFT = require ('../../dist/ARToolkitNFT_node.js');
+const { createCanvas, loadImage } = require('canvas');
+const fs = require('fs');
+
+// Polyfill for requestAnimationFrame in Node.js
+global.requestAnimationFrame = function(callback) {
+    return setImmediate(callback);
+};
+
+global.cancelAnimationFrame = function(id) {
+    clearImmediate(id);
+};
+
+async function init() {
+    console.log(__dirname + '/camera_para.dat');
+
+    let arControllerNFT = new jsartoolkitNFT.ARControllerNFT(2000, 1500, '/camera_para.dat');
+    let ar = await arControllerNFT._initialize();
+    loadImage('pinball-demo.jpg').then((image) => {
+
+        console.log('image: ', image.width, image.height);
+        const canvas = createCanvas(image.width, image.height);
+        const ctx = canvas.getContext('2d');
+        ctx.drawImage(image, 0, 0, image.width, image.height);
+        const imgData = ctx.getImageData(0, 0, image.width, image.height);
+        ar.on('getNFTMarker', function(e){
+            console.log("NFT marker detected: ", e.data.marker);
+        });
+        const cameraMatrix = ar.getCameraMatrix();
+        ar.loadNFTMarker('DataNFT/pinball', function (id) {
+            console.log('marker id is: ', id);
+            ar.trackNFTMarkerId(id);
+            let marker = ar.getNFTData(id, 0);
+            console.log("cameraMatrix: ", cameraMatrix);
+        });
+
+        function processFrame() {
+            if (ar && typeof ar.process === 'function') {
+                ar.process(imgData.data);
+            }
+            requestAnimationFrame(processFrame);
+        }
+
+        processFrame();
+
+        // Save the canvas to a PNG file
+        const out = fs.createWriteStream(__dirname + '/output.png');
+        const stream = canvas.createPNGStream();
+        stream.pipe(out);
+        out.on('finish', () => console.log('The PNG file was created.'));
+    });
+}
+
+init();

examples/node/example_dist.js

@@ -0,0 +1,31 @@
+const jsartoolkitNFT = require('../../dist/ARToolkitNFT_node.js')
+const sharp = require('sharp')
+
+async function init() {
+    const arControllerNFT = await new jsartoolkitNFT.ARControllerNFT(2000, 1500, '/camera_para.dat');
+    const ar = await arControllerNFT._initialize();
+
+    // process() expects RGBA pixel data, so add the alpha channel.
+    const data = await sharp("pinball-demo.jpg").ensureAlpha().raw().toBuffer();
+    const imageData = new Uint8Array(data.buffer);
+
+    ar.on('getNFTMarker', function (e) {
+        console.log("NFT marker detected: ", e.data.marker);
+    });
+
+    const cameraMatrix = ar.getCameraMatrix();
+    ar.loadNFTMarker('DataNFT/pinball', function (id) {
+        console.log('marker id is: ', id);
+        ar.trackNFTMarkerId(id);
+        const marker = ar.getNFTData(ar.id, 0);
+        console.log("nftMarker data: ", marker);
+        console.log("cameraMatrix: ", cameraMatrix);
+        // process() must run after the marker is loaded; NFT tracking
+        // needs several iterations before it locks on.
+        for (let i = 0; i < 10; i++) {
+            ar.process(imageData);
+        }
+    });
+}
+
+init()

examples/node/run.sh

@@ -0,0 +1 @@
+node example_build.js

examples/node/test.js

@@ -0,0 +1,10 @@
+const fs = require("fs");
+
+let data = fs.readFileSync('../Data/camera_para.dat', {encoding: 'binary'},function(err){
+    console.log(error);
+})
+console.log('data is: ', data);
+
+fs.readFile('../Data/camera_para.dat', {encoding: 'binary'}, function (err, data) {
+console.log(data);
+})

js/artoolkitNFT.api.js

@@ -824,7 +824,7 @@
 
 
 
-    // ARToolKit exported JS API
+    // ARToolKitNFT exported JS API
     //
     const artoolkitNFT = {