My Entries and Lessons Learned from Perceptual Challenge

My Entries and Lessons Learned from Perceptual Challenge

Here are my entries for the Perceptual Challenge submitted a few Wednesday's ago. To add more value to the Show&Tell, I thought I’d also include my lessons learned while making each of these apps.

My workflow in Unity is based on exposing properties such as openness, confidence, worldPosition, etc., as public getters -- keeping just one script that has access to the SDK as an “interface” (call it IntelPerC.cs). Each Update(), scripts that utilize gesture interface input would poll the corresponding getter in IntelPerC.cs. The notes below beginning with PerC explain which input data is used from the Intel Perceptual Camera SDK. 

5 posts / 0 new
Last post
For more complete information about compiler optimizations, see our Optimization Notice. 

HomeUI is a home styling app that uses the Intel PerC SDK to make things like rotating objects and changing views intuitive -- while keeping the UI simple and maintaining the precision of using a mouse pointer. Originally a motion-gesture interface for ProtoAR, this turned into a separate app due to a home-specific floorplan-selection addition. 

The main screen features mouse-click-select-click-drop selection and movement of furniture pieces, while using your free hand to rotate a selected object (PerC: palm normal vector). 

Moving your hand from up to down or down to up fast enough, you can either lower or raise the walls from floorplan to a SketchUp-like 3D view (PerC: world coordinate deviation along vertical direction greater than 0.5 per frame). 

Moving your free hand into the camera, you jump into first-person view, where you can navigate and continue placing furniture as if you are inside the home. Moving your hand away, you return to floorplan view (PerC: goCursor.transform.position = new Vector3(-ipc.GetWorldPosition().x,ipc.GetWorldPosition().z,ipc.GetWorldPosition().y) * 10f; // where z axis above/below a certain threshhold). 

Moving your head to the right, your screen is extended into two possible views (PerC: Deviation of faceRectCenter > 55 right-screen extension or <-75 return to left-screen). If your cursor is touching the furniture-selection plane, you see an extended selection of similar furniture. Otherwise, you see the floorplan selection mode, where you can choose another room to decorate.   

For head-in, this app works well with the false-positive of the head being interpreted by the Gestures API as hand-closed. It’s intuitive to think that if you move your head forward (or fist forward), you’d get “into the scene”, i.e., invoke the 3D walkthrough mode. 

However, I am still uncertain how to precisely have the head move left/right via face-rectangle detection. The high rate of false positives here makes for a super-quick-swiping but annoying user experience. 

Early Tech Demo 

Puppets of Myth is (actually!) a high-fantasy game designed from the ground up for input via Intel Perceptual SDK -- what’s shown, currently, is just a demo, of course. The open/close hand factor was the only gesture I could get to reliably detect each time, and so, the main game interaction is with a hand-open-close gesture -- as if you are grabbing or “biting” the enemy; pulling your hand away from the scene is an intuitive gesture to retreat, and putting your hand close is a gesture to advance. Moving your head around controls the camera. These hand and head motifs are both teased upon in the two scenes before the battle scene included in the game demo.  

In Scene 1 - Your head position is tracked relative to your face rectangle position on the screen rectangle, and this controls which direction the camera points (PerC HeadMovementFreeForm.cs deviation from the center based on buffer). A white paper notepad on the 3D table shows the raw blob label feed. You may have to stand up to see the rest of the room and ceiling (and observe its blemish of being installed at an odd angle). Your hand position controls a 3D hand in a very limited space, between hand-closing to turn the page on the left and right sides of the book (PerC: based on WorldPosition with just a (1,1,2) multiplier, hand open confidence >55,<5). 

In Scene 2 - For character selection, there are just three, so hand worldPosition is rounded to three discrete positions (PerC: -3f*ipc.GetWorldPosition ().x <-0.25, 0.5 to 0.2, 0.25). As your wooden disk is moved, each character becomes alive. Open-close to confirm (only Lan, the warrior, is available). 

In Scene 3 - The gameplay is kept very simple, and this scene is also left as an infinite-length test for head movement (face rectangle) tracked into discrete-camera positions and hand movement and gesture-speed. Once the camera tracks your hand, each open-close gesture (PerC: Hand open-to-close within 0.5 seconds - you have to close your hand fast enough as well!) instantly triggers the character’s fight action; pull your hand out to retreat and hand in (PerC: WorldPosition) to get into the enemy’s fight radius. Head movement is still a bit rough and based on speed of head movement (PerC: HeadMovement.cs face rectangle deviation.x from last x >35 cycle next right cam, <-35 cycle next left cam), but if you lean your head quickly to the far right, the camera veers to the right viewpoint; similarly, quickly to the far left, left viewpoint; and center, the center viewpoint. 

Gesture Clay could be better if I didn’t try using both depth and hand position without properly mapping each to the other. The sculpting is actually done with data from depth, while the red ball is from worldPosition of your hand. This is why they don’t perfectly line up. This was one of my first experiments with PerC, and I didn’t get time to make more finetunings before the contest deadline.

Primitives 3D was an app I hacked together for the Sunday deadline, in a worst case scenario where I only get the consolation prize of $100 for submitting by an early deadline (hopefully I even get that)! It is a voice-activation-gesture-based simple model viewer that confirms viewing a model up-close by open-closing and by saying the name of the object. 

I could not get dictation mode to work, so I ended up using the freeform voice query with homonym checks (i.e., a large conditional database where “cube” and “queued” and “cute” and “cool be” etc were checked for to load the cube object), which turned out to work well for most of the objects, and kind of well for all (i.e., articulate very clearly and wait). 

A major bug from Intel PerC SDK on Unity framework is that apparently voice + gestures don’t work together sometimes.. for some reason, the voice often stops detecting after the second or third run of an PerC program.   

Overall, I found that many of the supposedly-supported gestures could not be reliably depended-upon. Even with GetOpenCertain() and GetClosedCertain() getters (see above) with setting open being less than 5 and closed being greater than 80 on the openness parameter, random false positives still occur -- if you put your head into the picture, that’s often assumed to be your fist, or closed hand!  

One of my entries - ShelvesOS for the Creative UI category - did not make it in. I’ll leave that one for next time. 

Leave a Comment

Please sign in to add a comment. Not a member? Join today