Kinect For Windows Interactions Gallery

As the Kinect For Windows SDK has started to evolve, the team has been adding some nice little controls which are quite useful and also controls everyone was writing in one way or another to solve the same issues. I think it’s a really good step so we’re not all spending a bunch of time writing similar controls plus it means there should be some consistency going forward if people use the supplied controls. This will help users with the learning curve with many of the applications.

When you first look through the interactions gallery it’s a bit overwhelming as there’s a bunch of controls and the interaction stream to deal with all at once. For this reason I wanted to do a set of posts so we can concentrate on them one at a time.

• KinectSensorUI
• KinectRegion
• KinectUserViewer
• KinectTileButton
• KinectCirceButton
• KinectScrollViewer
• InteractionStream

Project Information URL: http://www.soulsolutions.com.au/Blog/tabid/73/EntryId/851/Kinect-For-Windows-Interactions-Gallery.aspx

Contact Information:

• Blog: http://www.soulsolutions.com.au/Blog/

Imagine this...

Building Windows 8 MVVM app... Gaa, don't like the available templates, but good enough to start with. hack, hack, hack.

Building second app. Ahh, templates again... hack, hack, hack...

Third app. Project templates... Oh this is silly, enough! Creating own darn project templates. And while I'm at it, Item templates too!

That took a bit, but now, wow, building app's is faster, with much less hacking.

App four, five, six... This is nice! You know, having gotten so much from the community, it would be cool to gave back. Bet there are others who could use these templates! ...

Windows Store MVVM Templates for Visual Studio

If you have ever tried to create a Windows Store application using the MVVM pattern then you will probably have found that the Visual Studio project and item templates are a bit cumbersome. I often find myself adding a new page to my projects using one of the default templates, only to need to rewrite it to follow the MVVM pattern before I can even start adding application specific logic. What if there was a way to take advantage of the selection of project and page templates provided by Visual Studio, but have them produce fully MVVM compliant code?

Well today I’d like to announce the release of a free extension for Visual Studio 2012 (including the Express editions for Windows 8) that provides just that. It is based upon the open source Okra App Framework, and provides almost all of the Visual Studio Windows Store templates in an MVVM friendly manner.

Installing the Extension

The “Windows Store MVVM Templates for the Okra App Framework” ...

What Templates are Provided?

There are two types of template included, project templates and item templates. The project templates are designed to get you started with a new application and provide exactly the same behaviour as the default Visual Studio templates (but written following the MVVM pattern).

• Okra Basic App - A single-page Okra App Framework project with no predefined controls or layout.
• Okra Grid App - A three-page Okra App Framework project that navigates among grouped items arranged in a grid. Dedicated pages display group and item details.
• Okra Split App - A two-page Okra App Framework project that navigates among grouped items. The first page allows group selection while the second displays an item list alongside details for the selected item.

...

Also included are a number of item templates that allow you to add new pages to any existing Okra App Framework based application, whether created using the project templates or not.

• Basic Page (MVVM)
• Split Page (MVVM)
• Items Page (MVVM)
• Item Detail Page (MVVM)
• Grouped Items Page (MVVM)
• Group Detail Page (MVVM)
• Search Contract (MVVM)
• Share Target Contract (MVVM)
• Settings Pane (MVVM)

...

What do the MVVM Pages Look Like?

All the page templates (and each of the pages in the project templates) include the following files,

...

If you're building Modern UI MVVM app's, looks like this should really help speed up your delivery and help you focus on what will make your app great...

New course: Building a Real Application with Kinect

John Sonmez has published a new course: Building a Real Application with Kinect

Have you played with Microsoft Kinect? Do you think it’s legit? Wouldn’t it be awesome if you could write your own Kinect enabled applications to take advantage of this awesome piece of technology? Well, I have great news… John has written a course so you can 

In this course he will walk you through the creation of a real application using the Kinect. You’ll be building a Fruit Ninja clone called Shape Ninja which will be capable of detecting chopping gestures and responding to audio commands. You will start off by learning a little bit about the Kinect itself and the Kinect SDK. Then, John shows you just how easy it is to get color image and depth data from the Kinect. You’ll make your application be able to detect and respond to a chopping gesture. He wraps things up by teaching you how to use the Microsoft Speech Platform SDK in combination with the Kinect’s audio sensors to implement real voice commands for our application.

If you’ve been waiting to check out the Kinect, but you didn’t know where to start, or perhaps you thought it would be difficult to learn; this course will get you up and running with the Kinect in no time. Click here to get started now. We hope you enjoy the course!

Project Information URL: http://blog.pluralsight.com/2013/05/01/new-course-building-a-real-application-with-kinect/, http://www.pluralsight.com/training/Courses/TableOfContents/building-real-kinect-application

Contact Information:

• Blog: http://blog.pluralsight.com
• Twitter: @pluralsight

But what if you don't have a Kinect? Or use of your hands? Or have limited movement or space?

You all know I have this thing for Emotiv. So lets put all this together.

What if you could...

Use your brain as mouse control (with EPOC by Emotiv)

Can you imagine that there is an easier way to control the mouse, than with your head? The answer could be: With your mind.

Electroencephalography (EEG) was already established in 1924. In the past it was used mainly for medical reasons. But now you can also use this technology, to control your computer.

Emotiv EPOC

Emotiv has developed a Neuroheadset called EPOC. It reads your brainwaves and on this ground it is able to detect your current feelings like boredom, frustration, meditation and excitement. Your mind sends also certain signal patterns when your face is showing facial expressions. So EPOC can detect facial expressions like smiling, lowering and raising your eyebrows, clenching your teeths or blinking your eyes. This is quite similar to the facial expression detection, which is provided by Kinect for Windows SDK. Furthermore EPOC has a Gyroscope, which recognizes your head movement very accurate. So we developed a version of FaceMouse especially for EPOC.

FaceMouse for EPOC

You can replace your mouse with Emotiv EPOC, the revolutionary brain computer interface. Within Emotiv Control Panel there is already a Mouse Emulator which uses the EPOC Gyroscope to control the cursor of your mouse. EmoKey, an app developed by Emotiv, provides basic functionality for clicking by using EPOC, but this method has several disadvantages:

• In EmoKey clicks are sometimes not executed correctly in special kinds of application windows.
• It is not possible to send a scroll command with EmoKey.

FaceMouse for EPOC sends mouseclicks directly to the operating system, independent from the currently active application window. Also it is possible to scroll or drag & drop, which is not possible with EmoKey.

Just activate the Mouse Emulator in Emotiv Control Panel and use this simple App. It is the easiest way to replace your mouse with EPOC.

FaceMouse

This is a small Windows application, which enhances the possibilities to use EPOC as mouse control. Within Emotiv Control Panel you find a Mouse Emulator which uses the EPOC Gyroskop to control the cursor of your mouse. EmoKey provides basic functionality for clicking by using EPOC, but this method has several disadvantages:

In EmoKey clicks are sometimes not executed correctly in special kinds of application windows. Also it is not possible to send a scroll command with EmoKey.

This application sends mouseclicks directly to the operating system, independent from the currently active application window. Also it is possible to scroll or point & click. FaceMouse uses data from Expressiv Suite.

Just activate the Mouse Emulator in Emotiv Control Panel and use this simple App. It is the easiest way to replace your mouse with EPOC.

Mouse control with your face, head and mind... That's just cool

Kinect No Need 4 Green – The Green Screen without a Green Screen

This little piece of software allows you to produce easily, quickly and cheaply the type of picture that you would normally need a proper green screen setup to create. The software uses a Kinect for Windows or Kinect for XBOX360 device connected to a Windows 7 or 8 pc.

All you need to do is stand in front of the device and it will cut you out. You can choose between different backdrops, which you can add to by copying your own pictures (JPEG or PNG) into the PICTURES sub-folder. You can zoom in & out and move the cut out image using the keyboard or by on-screen controls.  You can take snapshot pictures of what is displayed in the window and these pictures are saved into the SNAPSHOTS sub-folder.

The keyboard controls are as below:-
SPACE bar takes a snapshot photo
W,A,S,D keys move the cut-out image left, right, up and down
+ and – keys zoom the cut-out image in and out
UP and DOWN keys allow you to adjust the viewing angle of the Kinect Device
LEFT and RIGHT keys allow you to choose the backdrop picture
M toggles mirroring mode on and off
F11 toggles full screen mode on and off
C toggles depth cut off mode on and off. This mode changes the way Kinect cuts the image out, by cutting out based on the distance from Kinect, rather than trying to cut out individual people. When in this mode the < key and the > key allow you to adjust the cut off distance.

Project Information URL: http://drenton72.wordpress.com/2013/05/10/kinect-no-need-4-green-the-green-screen-without-a-green-screen/

Project Download URL: Click here to download No Need 4 Green version 1

Project Source URL: Click here to download No Need 4 Green version 1 with C# source code

Contact Information:

• Blog: http://drenton72.wordpress.com
• Twitter: @drenton72

Update: Since the writing of this post David has already released a v2!

Kinect NoNeed4Green v2

I've already made some changes to my NoNeed4Green, so here is version 2. The main addition being the facility to add foreground pictures. The foreground pictures have their own sub-folder called foreground and they use PNG files only, as you need images with transparent backgrounds for it to work. This allows you to put objects in front of the live cut-outs of people as well as having a background behind them. This lets you do things like putting someone behind the desk of the oval office or behind the desk of the BBC newsroom or on the bow of the Titanic. You can also now resize and move all 3 layers. Layer 1 is the background, layer 2 is the live cut-outs of people, while layer 3 are the foreground objects.

...

There is a few new keyboard controls as well :-

H toggles between hiding all on-screen buttons and revealing them. Keys 1,2,3 select layers 1,2 and 3 to allow you to move and resize them.

...

Project Information URL: http://drenton72.wordpress.com/2013/05/12/kinect-noneed4green-v2/

Project Download URL: Click here to download No Need 4 Green version 2

Project Source URL: Click here to download No Need 4 Green version 2

What?

NUIverse

NUIverse is an application, written to give me a sandbox for exploring “Natural User Interaction” with a large, multi-dimensional dataset. This build for the Samsung SUR40 with Microsoft PixelSense demonstrates multi-touch gestures, multi-user and multi-directional UI, and object-interaction with transparent Byte Tags. This site provides brief instructions for installing, using, and configuring NUIverse.

NUIverse is not intented as an accurate simulation of the solar system and surrounding universe, since it was written in my spare time and the focus was on interaction rather than accuracy. There are many existing applications available for this purpose, such as Microsoft WorldWide Telescope, Celestia, Space Engine etc.

The following video shows the application demonstrated on a Samsung SUR40 with Microsoft PixelSense at WPC 2012.

NUIverse for Windows

As previously discussed, my manipulation processor now supports WM_TOUCH messages, which means that I can do native multitouch on both Windows 7 and Windows 8. I have therefore updated NUIverse for a Windows-release, as shown below in Figure 1.

There are some key differences to the PixelSense-release, as follows:

• No support for tagged objects, since it does not use the Surface 2.0 runtime, nor require PixelSense hardware (though it will run on the latter outside of the Surface Shell).
• Since horizontal form-factor multitouch hardware is generally less-common than vertical form-factors, I have added a single-orientation configuration setting. This is true by default, since even if mounted horizontally, many touchscreens will not deliver the multitouch performance required for simultaneous multi-user interaction.
• Since the Surface Shell added chrome to close the application and by default the application runs full-screen, either drag in a menu control (see note below) and use the exit menu, or press ESC if a keyboard is present.

One of the current issues when running a full-screen desktop app on Windows 8 is that the operating system captures initial touches used for edge-swipes. If touch is maintained after an initial edge-swipe, further edge-swipes are not captured and therefore will add NUIverse controls to the screen. An alternative is to touch the screen and simultaneously edge-swipe, or to use two fingers when edge-swiping.

Several key configuration settings (in NUIverse.exe.config) are worth mentioning. Note that there is no graphical interface for these settings, and that the configuration file needs to be edited by hand (I would recommend saving a copy first):

• PixelWidth and PixelHeight control the resolution used for both windowed and full-screen mode.
• FullScreen controls whether the application runs full-screen (true) or windowed (false).
• For the configuration settings specified in mm to work correctly, set PixelsPerMm to the appropriate value, taking account physical screen size and either PixelWidth or PixelHeight (square pixels are assumed).

To install NUIverse for Windows, proceed as folows:

1. Install the XNA 4.0 runtime.
2. Download and extract NUIverse for Windows (2.75Mb) to a suitable location.
3. Low-resolution textures for several planets and moons are included, but extras can be created or downloaded from http://nuiverse.com.

Here's a snap of the app running on my Windows 8 notebook;

I said there was extensibility?

Extensibility Model Part 2

I previously mentioned that I had implemented an extensibility model, and thought it useful to discuss an example of adding a simple model to earth orbit, as shown below in Figure 1 (further images of which are in the gallery).

Figure 1. Model added to earth orbit. Colonial Raptor model (based on new TV series) by Coxxon.

The "extra" is defined as a folder containing the following items:

• A model in XNB format. XNA has built-in content importers for .x and .fbx (2009.1) formats.
• An optional pair of textures for both diffuse and emissive textures. These are standard image files.
• An XML file defining the "extra", in this case as shown below in Listing 1.

This configuration file specifies that the model should be added to the planetoid "earth" in the "solar" system, both of which are defined in system.xml configuration file.

In order to scale the model correctly, a scale factor is applied to normalize the model to unit length. This can either be applied in the XML scale attribute, or specified in the XNA content processor scale attribute, in which case the XML attribute can be set to 1. A size attribute then defines the maximum length of the model in km. The Colonial Raptor shown in Figure 1 was defined with a size of 8.6m.

The textures are defined in sub-folders "texture" and "emissive". If an emissive texture is not available, an all-black image (e.g. JPEG file) can be used.

The rotation period defines how long it takes for the model to rotate while orbiting the planetoid. If this is the same as the P orbital element, then the same face of the model is presented to the planetoid throughout the orbit. The remaining standard orbital elements specify that the model is in a circular equatorial orbit at an altitude of 500km (the earth has a radius of 6,371km).

Make sure you read through the rest of his NUIverse, and other, articles as they are very interesting and informative... (like his holographic Princes Leia recording post... that's just cool!)

Lose your Occlusion

Depth-sensing cameras like the Kinect give us the opportunity to mix physical environments and virtual environments, creating new immersive experiences. In this Second Story Labs experiment, we demonstrate how the use of multiple cameras helps solve problems with occlusion or “holes” the use of a single camera creates.

If you’ve ever worked with a Microsoft Kinect, you know that occlusion is no laughing matter. It’s responsible for gaping holes in people’s chests, disappearing necks, the noseless faces of zombies. Humans are full of convexities, and to a Kinect that means that we are also full of holes. We’ve dealt with this in lots of creative ways—filling in gaps with best estimates, “blurring” data, hiding holes with smoke and mirrors. But the best and perhaps most obvious solution to the dilemma of occlusion is simply to add more Kinects. A second gunman, if you will, shooting from an angle that will cover the first Kinect’s blind spot.

In this case, we are calibrating two Kinects in space about a meter apart and angled inward toward their subject. This way we can “see” our way around noses, arms, and other pesky occlusions. Then all we have to do is combine their data into a single mesh, and the rest is up to our imaginations.

At full resolution, we can actually get a pretty accurate model of a person’s face. And all of this is being rendered in real time, so that a user’s reality can be “augmented” while they interact. Here we have added three-dimensional models and rain particles to the virtual space to put the user into an imaginary landscape.

Project Information URL: http://blog.secondstory.com/2013/03/18/lose-your-occlusion-2/

from Vimeo.

Contact Information:

• Blog: http://blog.secondstory.com/
• Twitter: @2storypdx

Today...

Kinect Magic Cursor version 1.7 with Gesture support

I am releasing a new version of Kinect Magic Cursor which works much like the last version except it now uses gestures to simulate the left mouse button, instead of raising your left hand. So now your right hand controls the mouse pointer and you can PRESS with your left hand to simulate a single left mouse button click. You can also GRIP (make a fist) with your right hand to simulate holding down the left mouse button for dragging, selecting etc. To stop holding it down you simply RELEASE (stop making a fist). I went with the LEFT hand for PRESS rather than the right hand as I found pressing with the RIGHT hand tending to move the cursor and made it hard to click on small buttons.

Project Information URL: http://drenton72.wordpress.com/2013/05/09/kinect-magic-cursor-version-1-7-with-gesture-support/

Project Download URL: Click here to download Kinect Magic Cursor V1.7

Project Source URL: Click here to download Kinect Magic Cursor v1.7 with C# source

Contact Information:

• Blog: http://drenton72.wordpress.com
• Twitter: @drenton72

Windows 8 Platformer Game Starter Kit

Platformer Game Starter Kit(includes 2 HTML5-based examples)

Don't start from scratch. Our Platformer Game Starter Kit for Windows 8 will get you going with full code & free game art.

How

---

Feel free to take the examples, mix them up and build your own great game for the Windows Store following these steps:

1. Download your free Visual Studio for Windows 8 for all the tools you will need.
2. Download the Platformer Game Starter Kit.
3. Mix it up and build your own epic game.
4. Open a Windows Store Developer Account.
5. Let us know about it and we can even give you free advice on making it great and help pass store certification.
6. Publish it to the Windows Store.

We know everyone is not a game artist, so we have provided you with some free game art and other places you can find royalty-free art for your game.

Ludus Game Starter Kit

An HTML5 Platformer Game Starter Kit for Windows8 Store

by Christer (McFunkypants) Kaitila http://mcfunkypants.com

Source: https://github.com/mcfunkypants/ludus

Demos: http://www.mcfunkypants.com/ludus

Welcome to Ludus, brave adventurer!

Ludus is a dirt-simple game engine that uses html5 canvas. It was designed specifically for mario/sonic style platformer games but could be used for any genre with minimal changes. It boasts great performance, and requires only free tools.

The word Ludus means PLAY/GAME/TRAINING in latin. The Ludus engine is designed to be a great way to learn to make games.

Sure, there are bigger and more complex game engines.

This one is designed to be easy to play around with.

Why? It was created to run real-world games that have a beginning, middle, and end. It was optimized to run on less powerful systems and touch-screen tablets. It is simple, but goes beyond the level of a "tech demo" to encapsulate all the required functionality you might need to make a polished game, such as GUI and sound.

...

IT'S POSSIBLE TO MAKE A GAME USING LUDUS IN A WEEKEND.

You could make your own game just by changing the artwork: it is possible to make a new game without ever touching a line of code. All you would need to do is modify the .png and .mp3 art assets as well as the level#.js level data files.

The best tool to create in-game worlds is TILED (http://www.mapeditor.org) which exports data in .json format.

Check out the example .tmx source files and see if you can make your own game! Once you've made a level, export as .json and then run the _buildlevels.bat file to convert JSON to JSONP data to a new level#.js file.

The one important thing to remember is that each layer is important. The order matters. The bottom-most layer is for regular world tiles that the player will collide with. The rest are for pickups, bouncy platforms, dangerous spikes, and so on.

Additionally, you should modify the game settings in the MAP MENU -> MAP PROPERTIES dialog. Gravity, speed and the player's starting position are all stored there.

HACKING THE SOURCE CODE

The only source code file you will want to modify, if you choose to start coding, is ludus.js. Inside, you'll notice all sorts of variables at the top which you can modify to your heart's content. Note that some of these variables are overwritten by whatever is defined inside the level data.

With regard to the structure of the code, the most important thing to know is that the game is controlled by STATE objects.

Each state (title screen, in-game, and between level transitions) is a class object that has a .setup(), .update() and .draw() function. You could add new states for things like boss battles, inventory screens or a high score table.

See these class constructors: function TitleScreenState() function LevelTransitionScreenState() function PlayState()

HAVE FUN!

...

Let's take a peek at the two included example games (In Visual Studio of course!)...

Both games ran for me the first time with no issues and were fun (in a platformer kind of way). Sure there's only 3 levels, but hey, if there was too much done it would take all the coding fun away!

So either start from scratch or copy off of these, this kit and the provided free artwork, framework and code will have you building your next great Windows 8 game...

Okay, maybe this isn't "hacking" nor all the hardcore [at all] but for a non-circuit guy like me, it is...

Arduino Fun – Door Entry Alarm

Physical computing and “internet of things” is a super exciting area that is unfolding right now. Even decades back one could hook up sensors and remotely get those data and process it. What is special now is that powerful micro-controllers are dirt cheap and most of us have in our pockets a really powerful computing device. Connecting everything wirelessly is also very easy now and almost every home has a wireless network.

All of these put together can create some really compelling and cool stuff where data travels from sensor over wireless networks into the cloud and finally into the cell phone we carry everywhere. I finally want to create a smart door so that I can get an notification while at work when someone knocks at our home door. Maybe I can remotely open the door. The possibilities are endless, but time is not, so lets see how far I get in some reasonable amount of time.

...

The Project

I decided to start out with making a simple entry alarm and see how much time it takes to get everything done. In college I built something similar, but without a microcontroller (based on 555 IC and IR photo-transistors) and it took decent amount of time to hook up all the components. Basically the idea is that across the door there will be some source of light and a sensor will be on the other side. When someone passes in between the light on the sensor will be obstructed and this will sound an alarm.

When I last did it in college I really made it robust by using pulsating (at fixed frequency) IR LED as source and IR sensors. Now for this project I relied on visible light and the photo-resistor that came with the kit.

...

Now, get building!

Kinect Interactions with(out) WPF – Part III: Demystifying the Interaction Stream

 In this part of my Kinect Interaction blog post series, we go deep into the rabbit hole, and examine the foundation of Kinect Interactions – the InteractionStream, upon which the entire library is built. This is a risky ride – with no official documentation, we can only count on our trusty reflector, the source code of the Kinect Interaction SDK and careful exploration.

You only need to access the treasures of InteractionStream, if you want to go beyond what the KinectRegion and other controls provide. For example, you want to create your own KinectRegion, you want to zoom a map by gripping it with two hands, or want to build your entirely new interaction model, using two hands along with the press and grip gestures.

Initializing the InteractionStream

Initializing the InteractionStream is much like initializing the DepthStream or the SkeletonStream. If you have a KinectSensor object, all you need are the next two lines of code:

...

It seems like we are on track. Just pass an initialized KinectSensor object and this DummyInteractionClient to the constructort of the InteractionStream, and we should be all set, right? Well, not quite. The InteractionFrameReady event does not fire.

Interaction Needs Skeleton and Depth

It turns out, that for the InteractionStream to work, it needs to process the data from both the depth and the skeleton streams. So, we need to initiate all three of the streams. This is what the entire OnLoaded method (which you have to wire up either in XAML or in the constructor of the page) looks like:

...

It doesn’t seem so simple now, so let's walk through each line of code and see what they do. The first five lines define local variables that hold a reference to the Kinect sensor the application will use, the InteractionStream itself, the skeletons identified by the SkeletonStream, and the hand position information about the users as determined by the InteractionStream.

...

Dissecting InteractionFrameReadyEventArgs

So, now that we have finally made the InteractionStream call the InteractionFrameReady event, we can start analyzing what kind of data we can get to. The first step is to get our hand on an InteractionFrame, and the interaction data it contains:

Summary

I’ve shown you how you can get started with the InteractionStream and acquire information about the hands of the users, detect active hands, pressing (IsPressed and PressExtent), and open / closed hands (HandEventType and our custom LastHandEventType). What I’ve shown here does not require WPF – you can use this from any .NET application, be it XNA, Windows Forms or even Command Line.

Project Information URL: http://dotneteers.net/blogs/vbandi/archive/2013/05/03/kinect-interactions-with-wpf-part-iii-demystifying-the-interaction-stream.aspx

Project Source URL: Source Download

private Dictionary<int, InteractionHandEventType> _lastLeftHandEvents = new Dictionary<int, InteractionHandEventType>(); private Dictionary<int, InteractionHandEventType> _lastRightHandEvents = new Dictionary<int, InteractionHandEventType>();
Dictionary<int, InteractionHandEventType>();
  
private void InteractionStreamOnInteractionFrameReady(object sender, 
ctionFrameReadyEventArgs args)
{
     using (var iaf = args.OpenInteractionFrame()) //dispose as soon as 
le
     {
         if (iaf == null)
             return;
  
         iaf.CopyInteractionDataTo(_userInfos);
     }
  
     StringBuilder dump = new StringBuilder();
  
     var hasUser = false;
     foreach (var userInfo in _userInfos)
     {
         var userID = userInfo.SkeletonTrackingId;
         if (userID == 0)
             continue;
  
         hasUser = true;
         dump.AppendLine("User ID = " + userID);
         dump.AppendLine("  Hands: ");
         var hands = userInfo.HandPointers;
         if (hands.Count == 0)
             dump.AppendLine("    No hands");
         else
         {
             foreach (var hand in hands)
             {
                 var lastHandEvents = hand.HandType == 
ctionHandType.Left
                                             ? _lastLeftHandEvents
                                             : _lastRightHandEvents;
  
                 if (hand.HandEventType != 
ctionHandEventType.None)
                     lastHandEvents[userID] = hand.HandEventType;
  
                 var lastHandEvent = lastHandEvents.ContainsKey(userID)
                                         ? lastHandEvents[userID]
                                         : 
ctionHandEventType.None;
  
                 dump.AppendLine();
                 dump.AppendLine("    HandType: " + hand.HandType);
                 dump.AppendLine("    HandEventType: " + 
andEventType);
                 dump.AppendLine("    LastHandEventType: " + 
ndEvent);
                 dump.AppendLine("    IsActive: " + hand.IsActive);
                 dump.AppendLine("    IsPrimaryForUser: " + 
sPrimaryForUser);
                 dump.AppendLine("    IsInteractive: " + 
sInteractive);
                 dump.AppendLine("    PressExtent: " + 
ressExtent.ToString("N3"));
                 dump.AppendLine("    IsPressed: " + hand.IsPressed);
                 dump.AppendLine("    IsTracked: " + hand.IsTracked);
                 dump.AppendLine("    X: " + hand.X.ToString("N3"));
                 dump.AppendLine("    Y: " + hand.Y.ToString("N3"));
                 dump.AppendLine("    RawX: " + 
awX.ToString("N3"));
                 dump.AppendLine("    RawY: " + 
awY.ToString("N3"));
                 dump.AppendLine("    RawZ: " + 
awZ.ToString("N3"));
             }
         }
  
         tb.Text = dump.ToString();
     }
  
     if (!hasUser)
         tb.Text = "No user detected.";
}

Contact Information:

• Blog: http://dotneteers.net/blogs/vbandi/
• Twitter: @vbandi

Building Portable Libraries?

Wonder what all the weird and wild code paths your code might have, but it hurts your brain to try to write every possible path in your unit tests?

Want a free extension that throws everything at your code, but the kitchen sink? (though I think that's an option too...

Introducing: Code Digger, an extension for VS2012

Today, the Pex team at Microsoft Research (Nikolai Tillmann and Peli de Halleux) is happy to announce that Code Digger, an extension for Visual Studio 2012, has shipped to the Visual Studio Gallery. After shipping the Moles framework as Fakes in Visual Studio 2012, this is the next step of bringing our research projects to the latest and greatest development environment

...

What is Code Digger?

Code Digger generates interesting values that show different behaviors of your .NET code. The result is a table showing for which inputs your code produces which outputs.

What is the relation between Pex and Code Digger?

Under the hood, Code Digger uses the Pex engine and Microsoft Research’s Z3 constraint solver to systematically analyze all branches in the code, trying to generate a test suite that achieves high code coverage. Working together with Peter Provost from the Visual Studio product group, we tried to create a really simple user interface. We want to bring the idea of code exploration to every programmer’s fingertips. This is different from the Pex Power Tools where we gave you many options to configure, and you had to embrace the idea of (Parameterized) Unit Testing to get all benefits. Code Digger is not a full replacement of Pex, it is merely the first extension that the Pex team ships for Visual Studio 2012 – stay tuned for more.

Limitations

Code Digger only works on public .NET code that resides in Portable Class Libraries.

By restricting the code exploration to Portable Class Libraries, we avoid problems with code that has dependencies on a particular platform which the Pex engine does not understand.

...

Microsoft Code Digger

Overview

Code Digger analyzes possible execution paths through your .NET code. The result is a table where each row shows a unique behavior of your code. The table helps you understand the behavior of the code, and it may also uncover hidden bugs.

Through the new context menu item "Generate Inputs / Outputs Table" in the Visual Studio editor, you can invoke Code Digger to analyze your code. Code Digger computes and displays input-output pairs. Code Digger systematically hunts for bugs, exceptions, and assertion failures.

Code Digger only works on public .NET code that resides in Portable Class Libraries.

Under the hood, Code Digger uses the Pex engine and Microsoft Research’s Z3 constraint solver to systematically analyze all branches in the code, trying to generate a test suite that achieves high code coverage.

Code Digger is the first extension from the Pex team at Microsoft Research for Visual Studio 2012. Stay tuned for future extensions that bring more aspects of the rich experience of the Pex Visual Studio 2010 Power Tools to the latest version of Visual Studio. If you have feedback for us, or bug reports, feel free to write an email to the Pex team at Microsoft Research. If you have used Pex before, let us know if you are missing a particular feature.

To stay up-to-date, like Pex and Moles on Facebook.

...

Walkthrough

After you have installed the Code Digger extension for Visual Studio 2012, create a “Portable Class Library” project.

...

Write some public code, right-click on it, and select “Generate Inputs / Outputs Table”.

Wait a moment, and you will see a table, listing interesting parameter values which cover all the corner cases in your code.

...

Today's comes from Ben Lower...

Using Kinect InteractionStream Outside of WPF

Last month with the release of version 1.7 of our SDK and toolkit we introduced something called the InteractionStream.  Included in this release were two new samples called Controls Basics and Interaction Gallery which, among other things, show how to use the new InteractionStream along with new interactions like Press and Grip.  Both of these new samples are written using managed code (C#) and WPF.

One question I’ve been hearing from developers is, “I don’t want to use WPF but I still want to use InteractionStream with managed code.  How do I do this?”  In this post I’m going to show how to do exactly that.  I’m going to take it to the extreme by removing the UI layer completely:  we’ll use a console app using C#.

The way our application will work is summarized in the diagram below:

There are a few things to note here:

1. Upon starting the program, we initialize our sensor, interactions, and create FrameReady event handlers.
2. Our sensor is generating data for every frame.  We use our FrameReady event handlers to respond and handle depth, skeleton, and interaction frames.
3. The program implements the IInteractionClient interface which requires us to implement a method called GetInteractionInfoAtLocation which gives us back information about interactions happening with a particular user at a specified location:
   ...

4. The other noteworthy part of our program is in the InteractionFrameReady method.  This is where we process information about our users, route our UI events, handle things like Grip and GripRelease, etc.

Project Information URL: http://blogs.msdn.com/b/k4wdev/archive/2013/05/01/using-kinect-interactionstream-outside-of-wpf.aspx

Project Source URL: sample code

Contact Information:

• Blog: http://blogs.msdn.com/b/k4wdev

Marcus has provided a great example of streamlining Kinect for Windows SDK development. It's simple, yet, when you see it, you'll know you want to grab this... (plus you've got to love that he's released the source too)

Fluent Kinect

Since I have been playing around with the Kinect for Windows SDK I’ve created a lot of little new projects and samples to try things out. Starting point was always something like this:

Because I most often use the 640×480 option anyway, the format is an optional parameter when enabling the streams and it defaults to *640x480Fps30.

I’ve extracted the two little lines that gets the first connected Kinect Sensor to a class called KinectConnector. At the moment an exception is thrown when no Kinect unit is connected. This is not a very good way of handling this scenario and will be changed in the future.

Now the code is even cleaner:

var sensor = KinectConnector.GetKinect()
.EnableColorStream()
.EnableSkeletonStream()
.EnableDepthStream()
.Seated()
.NearMode()
.Start();

For an even shorter and quicker Setup I’ve implemented the method ‘KickStart’ which enables the three streams and calls Start() on the KinectSensor object.

For future ‘try out samples’ I’ll just have to code this now:

var sensor = KinectConnector.GetKinect()
.KickStart();

Project Information URL: http://passiondev.wordpress.com/2013/05/03/fluent-kinect/

Project Download URL: FluentKinect

Project Source URL: FluentKinect

Contact Information:

• Blog: http://passiondev.wordpress.com/
• Twitter: @MarcusKohnert

TouchDevelop has been highlighted before, Develop for Windows Phone, with Windows Phone... TouchDevelop, yet this time, David's hours of videos and pages of curriculum will take you from getting started to creating your first series of games...

TouchDevelop Curriculum Video Tutorials

Video Tutorials on Microsoft's new development platform TouchDevelop which allows anyone to create games or apps for mobile devices using a mobile device.

Yes that means program and playtest apps on your WP or Surface, Android Phone or Tablet and even on any iOS Tablet or Phone. All you need is a device with an HTML5 compatible browser.

Curriculum

Here's three examples of the games David helps you create...

If you are trying to pickup TouchDevelop, or looking to get someone in your life excited about development, this is your ticket to Ninja-dom (well, ticket to get you stared at least...)

Solar Tracker

Project Description
This project is deployed to a netduino, it uses a Arduino Compatible Mega Motor Shield, a linear actuator and a photocell out of a garden light to move a set of solar panel so that they face the sun throughout the day.

Required components
Netduino version 4.2 .NetMF

Motor shield http://www.robotshop.com/ca/arduino-compatible-mega-motor-shield-1a-5-28v-2.html

12V DC 12 in. Stroke Linear Actuator

Completed unit

And of course the source is available (which is the real cool part of this project)

Here's the Program.cs. It gives you a real nice feel for all the features to play with and code to check out...

public class Program
{
     private const int IterationTimeout = 5000;
     private static LinearActuator _linearActuator;
     private static LightSensor _lightSensor;
     private static readonly LcdText _lcdText = new LcdText();
     private static Thread _workerThread;
     private static long _lastTime;
     private static bool _setup;
     public static void Main()
     {
         _workerThread = new Thread(UpdateLCD);
         _workerThread.Start();
         InitializeActuator();
         InitializeLightSensor();

         var button = new InterruptPort(Pins.GPIO_PIN_A3, true, Port.ResistorMode.PullUp, Port.InterruptMode.InterruptEdgeLow);
         button.OnInterrupt += button_OnInterrupt;

         Thread.Sleep(Timeout.Infinite);

     }


     static void button_OnInterrupt(uint data1, uint data2, DateTime time)
     {
         var currentTime = time.Ticks;
         var delta = currentTime - _lastTime;
         if (delta > 500)
         {
             _lastTime = currentTime;
             if (_setup == false)
             {
                 _setup = true;
                 if (_linearActuator.IsTracking == false)
                 {
                     _linearActuator.SetupDaylength(_lightSensor.LenghtOfDaylight.Ticks / TimeSpan.TicksPerMillisecond);
                 }
             }
             _linearActuator.Step(null);
             _lcdText.DebugLine2 = "Force step, Pos:" + _linearActuator.CurrentPosition;
         }
     }


     private static void UpdateLCD()
     {
         var lcd = new Lcd { Visible = true };
         lcd.Clear();
         lcd.ShowCursor = true;
         // set up the LCD's number of columns and rows: 
         lcd.Begin(24, 2);
         bool toggleDebug = false;
         while (true)
         {
             lcd.Clear();
             if (toggleDebug)
             {
                 lcd.SetCursorPosition(0, 0);
                 lcd.Write(_lcdText.DebugLine1);
                 lcd.SetCursorPosition(0, 1);
                 lcd.Write(_lcdText.DebugLine2);
             }
             else
             {
                 lcd.SetCursorPosition(0, 0);
                 lcd.Write(_lcdText.ActuatorText);
                 lcd.SetCursorPosition(0, 1);
                 lcd.Write(_lcdText.SensorText);
             }
             toggleDebug = _lcdText.HasDebug ? !toggleDebug : false;
             Thread.Sleep(IterationTimeout);
         }
     }

     private static void InitializeActuator()
     {
         _linearActuator = new LinearActuator(_lcdText);
         return;
     }

     private static void InitializeLightSensor()
     {
         _lightSensor = new LightSensor(_lcdText);
         _lightSensor.Dusk += LightSensorDusk;
         _lightSensor.Dawn += LightSensorDawn;
     }

     static void LightSensorDawn(object sender, EventArgs e)
     {
         _linearActuator.GoEast();
         // start tracking
         _linearActuator.StartTracking(_lightSensor.LenghtOfDaylight.Ticks / TimeSpan.TicksPerMillisecond);
     }

     static void LightSensorDusk(object sender, EventArgs e)
     {
         // stop tracking and return to east
         _lcdText.ActuatorText = "Waiting for morning";
         _linearActuator.GoEast();
     }
}

Use your face as mouse control with Kinect

Replace your mouse with your face. Control the cursor just by moving your head. Click by winking your eyes, scroll by raising and lowering your eyebrows. All of that is possible now with FaceMouse Kinect.

During the usage of our KinectMouse, we figured out that it is very exhausting for your arm, if you have to control the mouse cursor all the time with your hand. So we were looking for a more easier method to control the mouse cursor with Kinect. All you have to do is moving your head and using some facial expressions for certain mouse actions.

...

How does our application work?

Cursor Moving

It is really easy: Just move your head to control the cursor. Make sure that Kinect can see your face as well as your chest. Sometimes the inital recognition is better when you are waving. It is normal that Kinect needs a few seconds to identify your face correctly. In contrast to KinectMouse, FaceMouse Kinect is more precise when you are more close to the sensor (but not too close) as the sensor has a more detailed view on your face this way. One meter should be a sufficient distance.

Left Click

Just wink with your right eye about a second...

Right Click...

Double Click...

Scrolling

Raise your eyebrows for scrolling up and lower it for scrolling down

Drag & Drop

Open your mouth for starting drag & drop. Move your head to move the cursor and keep your mouth open. For dropping, just close your mouth

Find the correct settings for yourself

Every face is different. It could be that the preselected settings in FaceMouse Kinect are not optimal for you. Just play a bit with the thresholds until you are satisfied.

• ClickDelay: .
• Headrotation Smoothing Filter Values: ...
• Percentage of horizontal edge Pixels: ....
• Used frames for closed eye detection: ....
• Eye closed filter threshold: ...
• Double click second eye threshold: ....
• Brow raiser start threshold:  ...
• Brow lowerer start threshold: ....
• Mouth open start threshold: ....
• Mouth open confirmation: ...
• Mouth open end threshold: ...
• Scroll multiplier up: ...
• Scroll multiplier down: ...
• Head to Screen relation X – Width: ...
• Head to Screen relation Y – Height: ...

I’m always happy to get some feedback. So please comment and let me know, if you are satisfied with this app. If you have any questions, feel free to ask. [Please click through and comment on the original post]

Project Information URL: http://futuretechblog.com/?p=71

Project Download URL: Download FaceMouse Kinect

Contact Information:

• Blog: http://futuretechblog.com/

Visual Studio has these cool things to help you in your debugging, called Visualizers. They help you see beyond the code and into the data, using a custom dialog or interface. And while there's a number in the box, they can't build one for everything.

But Visual Studio being what it is, you can create your own...

Visual Studio Visualizer: Part 1

Add a Visual Studio Visualizer to look data from: 

• Dataset; 
• DataTable; 
• DataRow; 
• DataView; 
• DataRowView; 
• DataRowCollection.

Using the code

Visit the project home page, download your flavor (2010 or 2012), unzip, and place the DLLs in the right folder, Documents\Visual Studio xxxx\Visualizers. 

When debugging with VS there is a extra option for visualizer, for the DataSet, DataTable, DataRow, and DataView objects. 

Points of Interest

For some reason arrays are not allowed for visualizing within visual studio debug, but when using the VisualizerDevelopmentHost class to test the visualizer, an array is allowed.

This project shows a work around to make a non-serializable object available to our custom visualizer. 

Create a visualizer

This project was created using visual studio express, any edition can be used.

First create a class library project then add a reference to the Visual Studio Visualizer API, the DLL can be found on: (Visual Studio installation folder)\Common7\IDE\ReferenceAssemblies\v2.0 Microsoft.VisualStudio.DebuggerVisualizers.dll. 

Add references to the types of objects, the visualizer will receive:

[assembly: System.Diagnostics.DebuggerVisualizer(
    typeof(DSVisualizer), typeof(VisualizerObjectSource), Target = typeof(DataSet), Description = "My DataSet Visualizer")]
[assembly: System.Diagnostics.DebuggerVisualizer(
    typeof(DTVisualizer), typeof(VisualizerObjectSource), Target = typeof(DataTable), 
    Description = "My DataTable Visualizer")]
[assembly: System.Diagnostics.DebuggerVisualizer(
    typeof(DRVisualizer), typeof(DataRowVisualizerObjectSource), 
    Target = typeof(DataRow), Description = "My DataRow Visualizer")]
[assembly: System.Diagnostics.DebuggerVisualizer(
    typeof(DVVisualizer), typeof(DataRowVisualizerObjectSource), 
    Target = typeof(DataView), Description = "My DataView Visualizer")]
[assembly: System.Diagnostics.DebuggerVisualizer(
    typeof(DRVVisualizer), typeof(DataRowVisualizerObjectSource), 
    Target = typeof(DataRowView), Description = "My DataRowView Visualizer")]
[assembly: System.Diagnostics.DebuggerVisualizer(
    typeof(DRCollectionVisualizer), typeof(DataRowVisualizerObjectSource), 
    Target = typeof(DataRowCollection), Description = "My DataRowCollection Visualizer")]

This can be inside any cs file of the project, but it must be outside any namespace declaration. As you can see, some types use VisualizerObjectSource and others use DataRowVisualizerObjectSource, this is because the DataRow type needs some massage before we can use it, this is covered later.  

The class that will get the object to visualize must inherits from DialogDebuggerVisualizer. 

This will allow to override the Show method: 

...

Visual Studio Watchers

This project contains some visualizers to work with Visual Studio.

Currently this project has visualizers for:

• DataSet
• DataTable
• DataRow
• DataView
• DataRowView
• DataRowCollection

There next visualizers will be for entity framework objects (trying to do a visualizer for all custom objects), StringBuilder, string and XDocument.

Introduction

Place the dll's in the right folder, Documents\Visual Studio xxxx\Visualizers.
When debugging with VS there is a extra option for visualizer, for the DataSet, DataTable, DataRow and DataView objects.

DataSet

The dataset visualizer mainpage, show a tree and a datagrid. In the tree all of the datatables are available:

...

And as you expect the source for all this is available too...

Use your hand instead a mouse (with Kinect for Windows)

Within an university programming project we tried out several methods to control the mouse cursor with Kinect for Windows. One of the results is a small application, which lets you control the Windows mouse cursor with your hands. Generally the cursor moves like the Kinect cursor on Xbox, but in our opinion there are several disadvantages on the Xbox Kinect mouse control:

1. On Xbox you need to hold the cursor for about a second over a tile if you want to click on it. This is an unnecessary delay. So we were looking for a clicking method, which is as fast as a click on a PC mouse.
2. With the Xbox Kinect control you only have the opportunity to make a standard click. There is neither a possibility for a right click nor a possibility for a double click and also no possibilty for Drag & Drop. But you need all of these special mouse actions, when you are working with your PC.

How does our application work?

Cursor Moving

Just move your hand for controlling the cursor. The recognition of your hand is a bit insensitive when you are too close to the sensor. If the cursor is too much jumping, just go one or two steps back. When you start the application it takes a moment for the sensor to recognize your hand. Make sure that Kinect can see your face as well as your chest and both of your hands. Sometimes the inital recognition is better when you are waving.

Left Click ...

Double Click ...

Right Click ...

Drag & Drop ...

Project Information URL: http://futuretechblog.com/?p=26

Project Download URL: Download KinectMouse

Contact Information:

• Blog: http://futuretechblog.com

Game Starterkit for Windows 8 with leaderboard in Windows Azure

This Game Starter Kit for Windows 8 contains what you need to get started with game programming for Windows 8, including online high score in Windows Azure. The game kit is written in HTML and JavaScript.

Download now – follow instructions below to make it work.

Before we start, let me show you what you get with this solution.

Example game
The kit comes with an example game that you can modify and play with. The code is all in one file so it’s easy to play with for beginners. Feel free to use it however you like.

The kit will get updated with cooler and more advanced game that you can use as a basis when developing your own. Follow this blog to get the updates!

...

If you want to learn how to create this game that comes with this starter kit, you can read the guide here (slightly different graphics):

Part I:
http://digitalerr0r.wordpress.com/2012/09/19/html5-game-development-for-windows-8-1-getting-started/

Part II:
http://digitalerr0r.wordpress.com/2012/09/20/html5-game-development-for-windows-8-2-adding-a-player/

Part III:
http://digitalerr0r.wordpress.com/2012/09/20/html5-game-development-for-windows-8-3-finishing-your-first-game/

• Implementation of high score in Windows Azure
  The kit also enables support for Windows Azure and handles the connection, and got functions to check if you are having a internet connection. You need to have your own Windows Azure account, and set up the service/datatable yourself.
• Snap view
• Tiles
• Settings charm implementation

Let’s get you up and running!

Follow this guide to get everything up and running with the starter kit.

1) Install the tools

2) Get an account on Windows Azure

3) Create your Mobile Service and Database

4) Configure

5) Build your solution and make sure it works

Go back to the solution, make sure you have the correct URL and Application Key in your solution, and then Build and run the project.

The game starts up, and when you die, your score will be uploaded to this table. Check that the column Score is created, and that it contains the correct score value you wanted.

Go to the Data tab and the table to see your scores:

Now, be creative. There are a lot of funny little games you can create by just modifying this simple template.

...

Download now

Here's a snap of the Solution;

And a snip, once you've set everything up, on how easy it is to talk to Windows Azure Mobile Services

If you're creating a Windows 8 or Windows Phone 8 app (or iOS or Android) Windows Azure can really ease your cross platform data needs (Yeah, I know the irony in that, but it's true).

So anyway.. you've got your starter kit, you've got your cloud storage, now just add some "You"...

.NET Gadgeteer Core 2.42.700

The .NET Gadgeteer Core installer includes the core libraries and end user project templates for Microsoft .NET Gadgeteer. This is a prerequisite for end users to build and deploy .NET Gadgeteer projects. It includes a project template wizard in the New Project dialog in Visual Studio 2012 or 2010 (or express versions) under the Gadgeteer tab - ".NET Gadgeteer Application". This template uses a graphical designer built for Visual Studio which allows end users to visually configure .NET Gadgeteer hardware builds and then write the software logic for that hardware in C# or Visual Basic.

The .NET Gadgeteer Builder Templates installer is for hardware vendors who are building modules, mainboards or kits comprising multiple modules/mainboards. This adds additional project templates for modules, mainboards and kits. Each template includes instructions on how to use it, and automatically builds an MSI installer which can be distributed to end users.

If you are a prospective module or mainboard builder you should also look at the Module Builder's Guide and Mainboard Builder's Guide, which includes the full specifications for what it means to be ".NET Gadgeteer compatible" and other helpful examples and guidelines.

Neither installer includes libraries for specific hardware modules/mainboards, so by themselves these installers do not enable users to use .NET Gadgeteer hardware. Hardware manufacturers should release installers (based on the templates above) for their hardware.

================================================================
Microsoft .NET Gadgeteer Core
RELEASE NOTES
Version 2.42.700 19 April 2013
...

================================================================
Change Log
================================================================
Version 2.42.700, 19 April 2013
MAJOR CHANGES

• VS 2012 support (if using NETMF 4.3 SDK) added alongside VS 2010 support (using NETMF 4.2 or earlier) (When using VS 2012 you can target NETMF 4.2 or 4.1 devices too)
• Visual Studio Express 2012 for Windows Desktop support (and older 2010 Express version support maintained)
• Application template wizard which checks for compatibility between VS, NETMF SDK and mainboard
• Power consumption data is specifiable in GadgeteerHardware.xml schema and shown in VS designer

MINOR CHANGES

• Socket type D and H compatibility check fixed
• Managed software I2C (used by DaisyLink) uses repeated start condition when appropriate
• Added StorageDevice.DeleteDirectory method and fixed StorageDevice.Delete to delete files
• Text templates no longer used by designer, avoiding permissions warning
• License updated to clarify that VS extensions are binary-only

**** ALPHA SUPPORT *****
This release also includes alpha support for the following. This is for evaluation purposes only, and features may change.

• NETMF 4.3, with feature changes:
• AnalogOutput uses NETMF native support

...

And remember, the source for all of this, and even some 3D models, are available;

Frog Makes Star Trek’s Voice-Controlled Computers A Reality

Those are iconic words to any Star Trek fan--it’s the preferred drink of Captain Picard, as ordered from the Enterprise’s always-listening computer system. They also represent a vision of voice-activated, ubiquitous computing interfaces that took hold in sci-fi books and film nearly 70 years ago.

It’s taken a long time for our world to sync up to Picard’s, but with the advent of Kinect and voice recognition systems, it’s finally happening. "Writers from Heinlein to Doctorow envisioned a far more heads-up, cooperative, and simple way of engaging with technology," explain a team of Frog technologists behind RoomE, a heads-up computing project. “We think we’ve also reached a point in our technological evolution that will allow many of these visions to become real.“ Devised and built by Frog Fellow Jared Ficklin, RoomE is one of the first working examples of a type of ubiquitous computing interface only imagined for decades.

...

Installed at Frog’s Austin offices, RoomE’s hardware is all off-the-shelf: two Kinects provide an array of voice and motion sensors, while a series of projectors are positioned to turn any surface into a screen. The software is custom-built, using Microsoft Speech Recognition Engine, Computer Vision, and the Kinect SDK. “A lot of people seem to be working on various pieces, but no one has yet to combine them,” says Ficklin. “That’s one reason we had to build one for ourselves.” On YouTube, Ficklin uploads videos of himself pointing to certain lamps in an office and, in a friendly Texas lilt, telling RoomE to “turn on those lights.” He also turns them back on with a hand motion and then orders takeout from Yelp, tweets, controls the thermostat, and checks out the CCTV feed from the backyard--all using voice commands. "RoomE leverages the elegance of context," the team at Frog explains. "The system knows who is in the room and what is in the room via computer vision. Therefore when the command is issued, RoomE calculates where the command came from, and, by putting the context together, the results can be placed where they best serve the user."

...

Read more about RoomE here. Or, for those interested in building their own system, the team has published a great cookbook-style guide (PDF).

Project Information URL: http://www.fastcodesign.com/1672284/frog-makes-star-treks-voice-controlled-computers-a-reality#1

PowerShell and the Kinect

A few months back I wrote a “module” for scripting the Kinect with PowerShell. It’s located at: https://github.com/adminian/PowerKinect. Recently a new Kinect SDK was released. I’m going to be testing out the new SDK to make sure everything works as expected.

More info about the new SDK: http://blogs.msdn.com/b/kinectforwindows/archive/2013/03/18/the-latest-kinect-for-windows-sdk-is-here.aspx.

Currently there are only two gestures: right hand swipe and left hand swipe. There is also a function that starts PowerPoint and allows you to control your presentation.

Gary Siepser, a fellow PFE and PowerShell Guru, jumped in and started helping out. He’s written the Audio control functions for the module. We’ll be integrating them into the repo soon! I’ll be posting more about Scripting the Kinect, but for now go clone the repo and give it a try!

Project Information URL: http://adminian.com/2013/03/24/powershell-and-the-kinect/

PowerKinect

A module to control the Kinect from PowerShell.

Currently we only support Kinect SDK version 1.6. Download located here: http://go.microsoft.com/fwlink/?LinkID=262831

Sample-KinectScripts.ps1 has a dependency on ShowUI: http://showui.codeplex.com/

The following is PowerKinects Hello world...

Start-Kinect

Enable-SkeletonStream

Add-RightHandGesture -action { notepad }

Add-LeftHandGesture -action { ps notepad | kill }

That's it!

Project Source URL: https://github.com/adminian/PowerKinect

$global:ie = New-Object -ComObject InternetExplorer.Application
$global:ie.GoHome()
$global:ie.Visible = $true
sleep 1
$global:ie.Navigate("http://www.microsoft.com")
sleep 1
$global:ie.Navigate("http://www.adminian.com")
sleep 1
$global:ie.Navigate("http://powershellsaturday.com/003/")
sleep 1

Add-RightHandGesture -action { $global:ie.GoForward() }
Add-LeftHandGesture -action { $global:ie.GoBack() }

Contact Information:

• Blog: http://adminian.com/
• Twitter: @Admnian

So why am I highlighting it here? But it looks like a awesome resource that you can code against, build awesome app's using it's data, and it's all open, as in open, open, open...

Digital Public Library of America (dp.la)

The Digital Public Library of America brings together the riches of America’s libraries, archives, and museums, and makes them freely available to the world. It strives to contain the full breadth of human expression, from the written word, to works of art and culture, to records of America’s heritage, to the efforts and data of science. The DPLA aims to expand this crucial realm of openly available materials, and make those riches more easily discovered and more widely usable and used, through its three main elements:

1. A portal that delivers students, teachers, scholars, and the public to incredible resources, wherever they may be in America. Far more than a search engine, the portal provides innovative ways to search and scan through the united collection of millions of items, including by timeline, map, format, and topic.

2. A platform that enables new and transformative uses of our digitized cultural heritage. With an application programming interface (API) and maximally open data, the DPLA can be used by software developers, researchers, and others to create novel environments for learning, tools for discovery, and engaging apps.

3. An advocate for a strong public option in the twenty-first century. For most of American history, the ability to access materials for free through public libraries has been a central part of our culture, producing generations of avid readers and a knowledgeable, engaged citizenry. The DPLA will work, along with like-minded organizations and individuals, to ensure that this critical, open intellectual landscape remains vibrant and broad in the face of increasingly restrictive digital options. The DPLA will seek to multiply openly accessible materials to strengthen the public option that libraries represent in their communities.

Open platform, open data and open API...

The platform (so you can see how the built it all, which is kind of cool)

The data;

The API...

Welcome!

Welcome to the DPLA API Codex! This is where you can find authoritative documentation for the DPLA API and resources you can use to make the most of it. We’re happy to have you. (Wondering why we built an API in the first place?  Check out our philosophy.)

What now?

• If you’ve never played (or worked) with an API before, head on over to API Basics.  We’ll get you started accessing some of our data.
• If you’re already familiar with APIs in general and you just want to know how to get at our data, skip the basics and dive right into requests (Make sure you get an API key first.)
• Once you’ve got some shiny new JSON-LD, how can you tell what it all means?  In responses, we explore the structure of objects and define the fields within those objects that the API will return.
• Ready to start building something against our API, but want to know how we operate? We’ve got you. Check out our policies.
• Uh oh.  You’re lost. We’re lost. Everything’s broken. I’m confused.  Time to check out our troubleshooting and FAQ page!
• Confused by the terminology we’re using? Check out the glossary of terms.
• Did we miss/break/overlook/forget something? Tell us.

The essentials

Need to start right now? Here’s a cheat sheet.

• http://api.dp.la/v2 is the base URL of the DPLA API.
• items and collections are the two resource types you can request.
• In order to pass requests to the API, you’ll need to request an API key first. You also need to append &api_key=$YOUR_KEY (where $YOUR_KEY is your 32-character key) to any requests you make.
• All records are returned as structured, wonderful, JSON-LD objects.   And we have reasons for that.
• We’ve got a boatload of fields you can query, and a whole bunch of ways you can query them.
• Dive head first into a bucket full of kitten metadata: http://api.dp.la/v2/items?q=kittens&api_key=. (Copy and paste the URL into your browser and add your API key on the end.)

...

API Basics

...

A request is a URL sent to the web server over HTTP with the expectation of getting resource items back in the form of human-readable text or data. The URL supplies the web server with everything it needs to create and return a correct response. This is called a RESTful approach to API design and is employed by the DPLA API.

Who should use this?

This API is intended for use by large organizations and lone individuals alike, and our audience’s level of technical sophistication is deliberately quite varied.

How do I use it?

All you need to do to use the DPLA API is:

1. Request an API key from DPLA.
2. Fire up your web browser and enter your request into the URL bar.
3. Read the response.

The DPLA API offers metadata (and meta-metadata) on two types of resources: items and collections. In short, items represent single physical objects indexed by a DPLA data provider, and collections are logical groupings of items. For simplicity’s sake, let’s try a simple search for items—i.e., a full-text search of all of the fields associated with items for a single term.

Let’s say you really want to know more about weasels. Compose your search query by taking the URL of the API and append your request to it like so:

http://api.dp.la/v2/items?q=weasels&api_key=

http://api.dp.la/v2 specifies the API and the correct version; items indicates the type of resource you’re requesting; ?q= begins your request, and the unadorned, unqualified search term weasels will be interpreted as a request for a full-text search.

Remember: You must enter your 32-character API key after the &api_key= parameter in included in every example request, and in general.

Now let’s look at typical results (to simplify things, we’re only reproducing the first result here):

...

Open, open, open... Now it's up to you to build some cool apps (hopefully Windows apps . If you do, let us know...

Kinect Interaction with WPF Part II: Getting Started Easier [KinectChooserEx]

In the previous post of this series, I have introduced the Kinect for Windows SDK 1.7, and the key controls and concepts within its Kinect Interactions toolkit. If you have followed through that post, you have seen all the work and code you need to get the basics running. Most of the initialization code was biolerplate, and code that you can easily copy and paste into your own project.

I have packaged up the initialization code into a UserControl called KinectChooserEx, and wired up a couple of dependency properties.

Note: I could have inherited from KinectChooser instead of packaging it into a user control. But I ran into some serious strong name issues, and wanted more consistent naming for the properties, so it was better to hide some internal workings.

The NearMode property is a boolean value, and can be used to turn Near Mode on and off. Changing Near Mode also sets the EnableTrackingInNearRange of the SkeletonStream. You will probably want to keep NearMode as false if you are using a Kinect for XBox sensor instead of a Kinect for Windows one. Otherwise the interaction engine works better at close range, so I have set NearMode to be true by default.

The other property is KinectSensor, which contains null if no sensor is initialized, or a KinectSensor object if one is.

Both of these properties are bindable. With KinectChooserEx, you can finally get started with your own Kinect project purely in Blend, without writing a single line of code (at least for the interaction part). Here is a step by step tutorial on how to do this:

• Create a New Project and Add KinectChooserEx.xaml and KinectChooserEx.xaml.cs

Create a new WPF project, and add the necessary references as described in my previous post. Drag and drop the KinectChooserEx.xaml and KinectChooserEx.xaml.cs files from Explorer into the project. You will also want to add the KinectInteraction170_32.dll and KinectInteraction170_64.dll files at this point (again, see my previous post).

• Add KinectChooserEx to the MainPage
• Adding a KinectRegion
• Adding a KinectUserViewer control
• Let’s See it Work!
• Using the Near Mode

Project Information URL: http://dotneteers.net/blogs/vbandi/archive/2013/04/19/kinect-interaction-with-wpf-part-ii-getting-started-easier.aspx

Project Download URL: http://sdrv.ms/117qGxo

Project Source URL: http://sdrv.ms/117qGxo

Contact Information:

• Blog: http://dotneteers.net/blogs/vbandi/
• Twitter: @vbandi