Merge pull request #46 from artoolkit/nft

Merging NFT tracking dev branch - thanks @kig

Author: jeromeetienne

.gitignore

@@ -1,3 +1,4 @@
 doc/reference
 node_modules
-build/libar.bc
+build/*.bc
+emscripten/jpeg-6b/

README.md

@@ -23,14 +23,17 @@ Emscripten port of [ARToolKit](https://github.com/artoolkit/artoolkit5) to JavaS
   - or, set the `ARTOOLKIT5_ROOT` environment variable to point to your ARToolKit5 clone
   - or, change the `tools/makem.js` file to point to your artoolkit5 clone (line 62, 83, 107, 140)
 
-3. Building
+3. Copy libjpeg-6b to emscripten/jpeg-6b
+  - or, set the `LIBJPEG_ROOT` environment variable to point to your libjpeg source directory
+
+4. Building
   1. Make sure `EMSCRIPTEN` env variable is set (e.g. `EMSCRIPTEN=/usr/lib/emsdk_portable/emscripten/master/ node tools/makem.js`
   2. Rename the `ARTOOLKIT5_ROOT/include/AR/config.h.in` file to `config.h`
   3. Run `npm run build`
 
 During development, you can run ```npm run watch```, it will rebuild the library everytime you change ```./js/``` directory.
 
-4. The built ASM.js files are in `/build`. There's a build with debug symbols in `artoolkit.debug.js` and the optimized build with bundled JS API in `artoolkit.min.js`.
+5. The built ASM.js files are in `/build`. There's a build with debug symbols in `artoolkit.debug.js` and the optimized build with bundled JS API in `artoolkit.min.js`.
 
 # ARToolKit JS API
 

build/artoolkit.debug.js

@@ -7,8 +7,11 @@ EMSCRIPTEN_BINDINGS(constant_bindings) {
 	function("setup", &setup);
 	function("teardown", &teardown);
 
+	function("setupAR2", &setupAR2);
+
 	function("_addMarker", &addMarker);
 	function("_addMultiMarker", &addMultiMarker);
+	function("_addNFTMarker", &addNFTMarker);
 
 	function("getMultiMarkerNum", &getMultiMarkerNum);
 	function("getMultiMarkerCount", &getMultiMarkerCount);
@@ -27,8 +30,11 @@ EMSCRIPTEN_BINDINGS(constant_bindings) {
 	function("detectMarker", &detectMarker);
 	function("getMarkerNum", &getMarkerNum);
 
+	function("detectNFTMarker", &detectNFTMarker);
+
 	function("getMultiEachMarker", &getMultiEachMarkerInfo);
 	function("getMarker", &getMarkerInfo);
+	function("getNFTMarker", &getNFTMarkerInfo);
 
 
 	/* AR Toolkit C APIS */

build/artoolkit.min.js

@@ -8,6 +8,9 @@
 #include <vector>
 #include <unordered_map>
 #include <AR/config.h>
+#include <AR/arFilterTransMat.h>
+#include <AR2/tracking.h>
+#include <KPM/kpm.h>
 
 struct multi_marker {
 	int id;
@@ -31,6 +34,12 @@ struct arController {
 	ARMultiMarkerInfoT *arMultiMarkerHandle = NULL;
 	AR3DHandle* ar3DHandle;
 
+	KpmHandle* kpmHandle;
+	AR2HandleT* ar2Handle;
+
+	int surfaceSetCount = 0; // Running NFT marker id
+	std::unordered_map<int, AR2SurfaceSetT*> surfaceSets;
+
 	ARdouble nearPlane = 0.0001;
 	ARdouble farPlane = 1000.0;
 
@@ -63,6 +72,212 @@ static ARMarkerInfo gMarkerInfo;
 
 extern "C" {
 
+	/**
+		NFT API bindings
+	*/
+
+	int getNFTMarkerInfo(int id, int markerIndex) {
+		if (arControllers.find(id) == arControllers.end()) { return ARCONTROLLER_NOT_FOUND; }
+		arController *arc = &(arControllers[id]);
+
+		if (arc->surfaceSetCount <= markerIndex) {
+			return MARKER_INDEX_OUT_OF_BOUNDS;
+		}
+
+		KpmResult *kpmResult = NULL;
+		int kpmResultNum = -1;
+
+        kpmGetResult( arc->kpmHandle, &kpmResult, &kpmResultNum );
+
+		int i, j, k;
+        int flag = -1;
+        float err = -1;
+        float trans[3][4];
+        for( i = 0; i < kpmResultNum; i++ ) {
+            if (kpmResult[i].pageNo == markerIndex && kpmResult[i].camPoseF == 0 ) {
+	            if( flag == -1 || err > kpmResult[i].error ) { // Take the first or best result.
+	                flag = i;
+	                err = kpmResult[i].error;
+	            }
+	        }
+        }
+
+        if (flag > -1) {
+            for (j = 0; j < 3; j++) {
+            	for (k = 0; k < 4; k++) {
+            		trans[j][k] = kpmResult[flag].camPose[j][k];
+            	}
+            }
+			EM_ASM_({
+				var $a = arguments;
+				var i = 0;
+				if (!artoolkit["NFTMarkerInfo"]) {
+					artoolkit["NFTMarkerInfo"] = ({
+						id: 0,
+						error: -1,
+						found: 0,
+						pose: [0,0,0,0, 0,0,0,0, 0,0,0,0]
+					});
+				}
+				var markerInfo = artoolkit["NFTMarkerInfo"];
+				markerInfo["id"] = $a[i++];
+				markerInfo["error"] = $a[i++];
+				markerInfo["found"] = 1;
+				markerInfo["pose"][0] = $a[i++];
+				markerInfo["pose"][1] = $a[i++];
+				markerInfo["pose"][2] = $a[i++];
+				markerInfo["pose"][3] = $a[i++];
+				markerInfo["pose"][4] = $a[i++];
+				markerInfo["pose"][5] = $a[i++];
+				markerInfo["pose"][6] = $a[i++];
+				markerInfo["pose"][7] = $a[i++];
+				markerInfo["pose"][8] = $a[i++];
+				markerInfo["pose"][9] = $a[i++];
+				markerInfo["pose"][10] = $a[i++];
+				markerInfo["pose"][11] = $a[i++];
+			},
+				markerIndex,
+				err,
+
+				trans[0][0],
+				trans[0][1],
+				trans[0][2],
+				trans[0][3],
+
+				trans[1][0],
+				trans[1][1],
+				trans[1][2],
+				trans[1][3],
+
+				trans[2][0],
+				trans[2][1],
+				trans[2][2],
+				trans[2][3]
+			);
+        } else {
+			EM_ASM_({
+				var $a = arguments;
+				var i = 0;
+				if (!artoolkit["NFTMarkerInfo"]) {
+					artoolkit["NFTMarkerInfo"] = ({
+						id: 0,
+						error: -1,
+						found: 0,
+						pose: [0,0,0,0, 0,0,0,0, 0,0,0,0]
+					});
+				}
+				var markerInfo = artoolkit["NFTMarkerInfo"];
+				markerInfo["id"] = $a[i++];
+				markerInfo["error"] = -1;
+				markerInfo["found"] = 0;
+				markerInfo["pose"][0] = 0;
+				markerInfo["pose"][1] = 0;
+				markerInfo["pose"][2] = 0;
+				markerInfo["pose"][3] = 0;
+				markerInfo["pose"][4] = 0;
+				markerInfo["pose"][5] = 0;
+				markerInfo["pose"][6] = 0;
+				markerInfo["pose"][7] = 0;
+				markerInfo["pose"][8] = 0;
+				markerInfo["pose"][9] = 0;
+				markerInfo["pose"][10] = 0;
+				markerInfo["pose"][11] = 0;
+			},
+				markerIndex
+			);
+        }
+
+		return 0;
+	}
+
+	int detectNFTMarker(int id) {
+		if (arControllers.find(id) == arControllers.end()) { return -1; }
+		arController *arc = &(arControllers[id]);
+
+		KpmResult *kpmResult = NULL;
+		int kpmResultNum = -1;
+
+        kpmMatching( arc->kpmHandle, arc->videoFrame );
+        kpmGetResult( arc->kpmHandle, &kpmResult, &kpmResultNum );
+        return kpmResultNum;
+	}
+
+	KpmHandle *createKpmHandle(ARParamLT *cparamLT) {
+		KpmHandle *kpmHandle;
+	    kpmHandle = kpmCreateHandle(cparamLT, AR_PIXEL_FORMAT_RGBA);
+		return kpmHandle;
+	}
+
+	int getKpmImageWidth(KpmHandle *kpmHandle) {
+		return kpmHandleGetXSize(kpmHandle);
+	}
+
+	int getKpmImageHeight(KpmHandle *kpmHandle) {
+		return kpmHandleGetYSize(kpmHandle);
+	}
+
+	int getKpmPixelSize(KpmHandle *kpmHandle) {
+		return arUtilGetPixelSize(kpmHandleGetPixelFormat(kpmHandle));
+	}
+
+	int setupAR2(int id) {
+		if (arControllers.find(id) == arControllers.end()) { return -1; }
+		arController *arc = &(arControllers[id]);
+
+		arc->kpmHandle = createKpmHandle(arc->paramLT);
+
+		return 0;
+	}
+
+	int loadNFTMarker(arController *arc, int surfaceSetCount, const char* datasetPathname) {
+		int i, pageNo;
+		AR2SurfaceSetT *surfaceSet;
+		KpmRefDataSet *refDataSet;
+
+		KpmHandle *kpmHandle = arc->kpmHandle;
+
+		refDataSet = NULL;
+
+		// Load KPM data.
+		KpmRefDataSet  *refDataSet2;
+		ARLOGi("Reading %s.fset3\n", datasetPathname);
+		if (kpmLoadRefDataSet(datasetPathname, "fset3", &refDataSet2) < 0 ) {
+			ARLOGe("Error reading KPM data from %s.fset3\n", datasetPathname);
+			pageNo = -1;
+			return (FALSE);
+		}
+		pageNo = surfaceSetCount;
+		ARLOGi("  Assigned page no. %d.\n", surfaceSetCount);
+		if (kpmChangePageNoOfRefDataSet(refDataSet2, KpmChangePageNoAllPages, surfaceSetCount) < 0) {
+		    ARLOGe("Error: kpmChangePageNoOfRefDataSet\n");
+		    return (FALSE);
+		}
+		if (kpmMergeRefDataSet(&refDataSet, &refDataSet2) < 0) {
+		    ARLOGe("Error: kpmMergeRefDataSet\n");
+		    return (FALSE);
+		}
+		ARLOGi("  Done.\n");
+
+		// Load AR2 data.
+		ARLOGi("Reading %s.fset\n", datasetPathname);
+
+		if ((surfaceSet = ar2ReadSurfaceSet(datasetPathname, "fset", NULL)) == NULL ) {
+		    ARLOGe("Error reading data from %s.fset\n", datasetPathname);
+		}
+		ARLOGi("  Done.\n");
+
+		arc->surfaceSets[surfaceSetCount] = surfaceSet;
+
+		if (kpmSetRefDataSet(kpmHandle, refDataSet) < 0) {
+		    ARLOGe("Error: kpmSetRefDataSet\n");
+		    return (FALSE);
+		}
+		kpmDeleteRefDataSet(&refDataSet);
+
+		ARLOGi("Loading of NFT data complete.\n");
+		return (TRUE);
+	}
+
 	/***************
 	 * Set Log Level
 	 ****************/
@@ -186,6 +401,8 @@ extern "C" {
 
 		arglCameraFrustum(&((arc->paramLT)->param), arc->nearPlane, arc->farPlane, arc->cameraLens);
 
+		arc->kpmHandle = createKpmHandle(arc->paramLT);
+
 		return 0;
 	}
 
@@ -240,6 +457,22 @@ extern "C" {
 		return arc->patt_id;
 	}
 
+	int addNFTMarker(int id, std::string datasetPathname) {
+		if (arControllers.find(id) == arControllers.end()) { return -1; }
+		arController *arc = &(arControllers[id]);
+
+		// Load marker(s).
+		int patt_id = arc->surfaceSetCount;
+		if (!loadNFTMarker(arc, patt_id, datasetPathname.c_str())) {
+			ARLOGe("ARToolKitJS(): Unable to set up NFT marker.\n");
+			return -1;
+		}
+
+		arc->surfaceSetCount++;
+
+		return patt_id;
+	}
+
 	int addMultiMarker(int id, std::string patt_name) {
 		if (arControllers.find(id) == arControllers.end()) { return -1; }
 		arController *arc = &(arControllers[id]);