DIY Dashboard

The dashboard I’m posting here have the following features:

• RPM lights
• Gear indicator
• Pit limiter, rev limiter and low fuel indicators
• 5 general purpose switches and buttons
• 1 rotary encoder for dialing

I bought all the components that I needed (with the exception of the Arduino itself) in a regular electronic component shop. You can see the parts list below and it’s also included in the RAR file at the end of the post. The total cost of this project was about U$ 27,00 excluding the Arduino (43,00 brazilian reais) and was really fun to do it. For it to work, I had to assemble everything into a perfboard, code the Arduino firmare to receive the data from the computer and light up the whole thing and also code the server software that grabs the data from the iRacing API and send it through a USB serial connection to the Arduino.

...

In the pictures below you can take a look on how it looks like inside the dashboard. I don’t have much electronics and soldering experience so it turned out not that beautiful, but hey, it works! You can also see the schematics for all the electronic components.

...

I’m releasing all the schematics, parts list, source code and firmware for this project. In the RAR is included:

• VB.NET source code for interfacing with iRacing API, Arduino serial port and PPJoy DLL
• iWrapClient.dll and PPJoyDLL.dll (I coded it too, but I’m releasing only the DLL)
• Arduino source code ready for upload to the board
• Schematics
• Parts list

You've got to love the Windows 95 cup. I've got one of those somewhere I think...lol

Anyway...

As he promised the rar includes the schematic, parts list and the code;

If you've wondered what it would be like to add a "real world" interface to a game this might be a good weekend project for you...

Coding4Fun Kinect Toolkit

Updated for Kinect for Windows SDK v1.0!

This project requires the Kinect for Windows SDK. If you want to learn how to use the Kinect for Windows SDK, head over to the Channel 9 and their quick start series. This toolkit contains both a WinForm and WPF version.

WPF:

Depth Data Extension Methods:

• ImageFrame.ToBitmapSource()
  • returns BitmapSource
• int[].ToBitmapSource()
  • returns BitmapSource
• int[].ToBitmapSource(int width, int height, int minimumDistance, Color highlightColor)
  • returns BitmapSource
• ImageFrame.ToDepthArray()
  • returns int[]
• int[].GetMidpoint(int startX, int startY, int endX, int endY, int minimumDistance)
  • returns Point
• BitmapSource.Save(string fileName, ImageFormat format)
  • returns nothing

Skeleton Data Extension Methods:

• Joint.ScaleTo(int width, int height)
  • Scales a Joint's Position to the maximum width and height specified
• Joint.ScaleTo(int width, int height, float maxSkeletonX, float maxSkeletonY)
  • Scales a Joint's Position to the maximum width and height specified

Controls:

• Hover Button

WinForm:

Depth Data Extension Methods:

• ImageFrame.ToBitmap()
  • returns Bitmap
• int[].ToBitmap()
  • returns Bitmap
• int[].ToBitmap(int width, int height, int minimumDistance, Color highlightColor)
  • returns Bitmap
• ImageFrame.ToDepthArray()
  • returns int[]
• int[].GetMidpoint(int startX, int startY, int endX, int endY, int minimumDistance)
  • returns Point
• Bitmap.Save(string fileName, ImageFormat format)
  • returns nothing

Skeleton Data Extension Methods:

• Joint.ScaleTo(int width, int height)
  • Scales a Joint's Position to the maximum width and height specified
• Joint.ScaleTo(int width, int height, float maxSkeletonX, float maxSkeletonY)
  • Scales a Joint's Position to the maximum width and height specified

Project Information URL: http://c4fkinect.codeplex.com/

Project Download URL: http://c4fkinect.codeplex.com/releases/view/81523

Project Source URL: http://c4fkinect.codeplex.com/SourceControl/list/changesets

Runs with v1? Yes

void sensor_ColorFrameReady(AllFramesReadyEventArgs e)
{
    using (ColorImageFrame colorFrame = e.OpenColorImageFrame())
    {
        if (colorFrame == null)
        {
            return; 
        }

        //set image
        ColorImage.Source = colorFrame.ToBitmapSource();

        if (_saveColorFrame)
        {
            //save image

            colorFrame.ToBitmapSource().Save(DateTime.Now.ToString("yyyyMMddHHmmss") + "_color.jpg", ImageFormat.Jpeg);
        }
    }            
}

void sensor_DepthFrameReady(AllFramesReadyEventArgs e)
{
    using (DepthImageFrame depthFrame = e.OpenDepthImageFrame())
    {
        if (depthFrame == null)
        {
            return; 
        }

        //turn raw data into an array of distances; 
        var depthArray = depthFrame.ToDepthArray();

        MidPointDistanceViaGetDistanceText.Text = depthFrame.GetDistance(depthFrame.Width/2, depthFrame.Height/2).ToString();

        //image
        DepthImageWithMinDistance.Source = depthArray.ToBitmapSource(depthFrame.Width, depthFrame.Height,
                                                                    _minDistance, Colors.Red);

        //image
        DepthImage.Source = depthFrame.ToBitmapSource();

        if (_saveDepthFrame)
        {
            _saveDepthFrame = false;
            depthFrame.ToBitmapSource().Save(DateTime.Now.ToString("yyyyMMddHHmmss") + "_depth.jpg", ImageFormat.Jpeg);
        }
    }
}

Today, let's look at a new Coding4Fun Kinect project and one that could open up some very interesting ways to build awesome apps.

Image the Kinect (and PC) in one room and your app in another (room, building, state, country). Say something that can run on the machine that has the Kinect connected to it but send the camera, depth, skeleton and audio to an app running on another computer or device, like a Windows Phone 7...

You don't need to imagine, because there's the...

Coding4Fun Kinect Service

The Coding4Fun Kinect Service allows you to stream Kinect color, depth, skeleton, and audio from one PC to another PC or a Windows Phone via sockets. Both server and client libraries are available to send and receive the data. Please review the included WPF and Windows Phone samples for a quick explanation of how to use the libraries. Also check out the Documentation tab for more information and sample usage.

This project requires the Kinect for Windows SDK v1.0. If you want to learn how to use the Kinect for Windows SDK, head over to the Channel 9 and view the Quickstart series.

...

Project Information URL: http://kinectservice.codeplex.com/

Project Download URL: http://kinectservice.codeplex.com/releases/view/81291

Project Source URL: http://kinectservice.codeplex.com/SourceControl/list/changesets

Runs with v1? Yes

Here's the C# Solution;

And the VB (yes, there's a full VB.Net version) Solution;

Here's a snip of code from the C# Phone Sample;

void client_ColorFrameReady(object sender, ColorFrameReadyEventArgs e)
{
    if(e.ColorFrame.BitmapImage != null)
        this.Color.Source = e.ColorFrame.BitmapImage;
}

void client_DepthFrameReady(object sender, DepthFrameReadyEventArgs e)
{
    if(_outputBitmap == null)
    {
        this._outputBitmap = new WriteableBitmap(
            e.DepthFrame.ImageFrame.Width, 
            e.DepthFrame.ImageFrame.Height);

        this.Depth.Source = this._outputBitmap;
    }

    byte[] convertedDepthBits = this.ConvertDepthFrame(e.DepthFrame.DepthData, e);

    Buffer.BlockCopy(convertedDepthBits, 0, _outputBitmap.Pixels, 0, convertedDepthBits.Length);
    _outputBitmap.Invalidate();
}

void client_AudioFrameReady(object sender, AudioFrameReadyEventArgs e)
{
    _kinectSound.SubmitBuffer(e.AudioFrame.AudioData);

    if(_kinectSound.State != SoundState.Playing)
        _kinectSound.Play();
}

private void client_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
    Skeleton skeleton = (from s in e.SkeletonFrame.Skeletons
                             where s.TrackingState == SkeletonTrackingState.Tracked
                             select s).FirstOrDefault();

    if(skeleton == null)
        return;

    SetEllipsePosition(headEllipse, skeleton.Joints[(int)JointType.Head]);
    SetEllipsePosition(leftEllipse, skeleton.Joints[(int)JointType.HandLeft]);
    SetEllipsePosition(rightEllipse, skeleton.Joints[(int)JointType.HandRight]);
}

Contact Information:

• Blog: http://www.brianpeek.com/
• Twitter: @BrianPeek

Terrain Rendering

Terrain Rendering is a game technology code sample that demonstrates how to render large-scale terrains in real time by efficiently distributing the tasks between the CPU and the GPU. This article provides an overview of the terrain-rendering application and includes a link to the free code.

Introduction

This sample demonstrates how to render large-scale terrains on Intel® microarchitecture codename Sandy Bridge in real time by efficiently distributing the tasks between the CPU cores and the processor graphics unit. The sample pre-processes an input height map into a hierarchical quadtree representation which is used to render the terrain with adaptively selected level of detail (LOD). The adaptive simplified triangulation calculated during the pre-processing is compactly encoded to save runtime processing and memory space. LOD construction is asynchronously performed by the CPU cores while rendering is done by the processor graphics unit.

Application

Terrain Rendering is an application using DXUT and Microsoft DirectX* 11 with D3D_FEATURE_LEVEL_10_0. The application handles all rendering, user interaction and GUI. Upon initialization, the application loads all models, allocates resources and compiles shaders. On the first run, the application pre-calculates triangulation, which can take some time (up to one minute), and stores it on the disk. On subsequent runs, the application loads the data from the disk.

Overview

Terrain rendering demonstrates how to render large-scale terrains on Intel microarchitecture codename Sandy Bridge in real time by efficiently distributing the tasks between the CPU cores and the processor graphics unit. The terrain rendering can be optimized by constructing simplified triangulation, which is adaptive to the terrain surface characteristics. Such triangulation contains more primitives in sharp regions with high-frequency details and allocates a small number of large triangles for flat areas. This significantly reduces the total triangle count while providing almost the same visual quality (compare fig. 1 and 2).

Full-resolution triangulation (fig. 1) is more than 5x redundant compared to adaptive (fig. 2), which results in nearly 3x lower performance with almost the same visual quality.

Pre-computing adaptive triangulation is a complex and computation-intensive task. Doing this at runtime could require a significant amount of time and would lead to perceptible stalls or delays. To solve this problem, the application pre-computes adaptive triangulation for the whole terrain at the pre-process stage and stores the resulting data on the disk in a compact representation (see section 4). For example, the whole encoded triangulation for an 8192×8192 terrain consumes approximately 6 MB (compare this to 128 MB required to store the height map). At the runtime stage, this data is used to efficiently construct the triangulation.

...

SNB Terrain

This sample demonstrates how to render large-scale terrains on Intel® microarchitecture code name Sandy Bridge in real time by efficiently distributing the tasks between the CPU cores and the processor graphics unit. The input height map is preprocessed into a hierarchical quad tree representation which is used to render the terrain with adaptively selected level of detail (LOD). The adaptive simplified triangulation is compactly encoded to save runtime processing and memory space. LOD construction is asynchronously performed by the CPU cores while rendering is done by the processor graphics unit, which provides stable frame rate.

System Requirements

Hardware:

• CPU: Intel® Advanced Vector Extensions (Intel® AVX)-enabled x86 (Intel® microarchictecture code name Sandy Bridge or better suggested)
• GFX: uses Microsoft DirectX* 11 graphics API on Microsoft DirectX* 10 (or better) hardware
• OS: Microsoft Windows* 7 SP1 (for Intel AVX support)
• MEM: 2 GB of RAM or better

Software:

Toolkits Supported:

• Microsoft DirectX* SDK (June 2010 release or later)
• Microsoft Windows* SDK May 2010

Compilers Supported:

• Microsoft Visual Studio* 2010 (Intel AVX support required) or Intel® C++ Compiler version 11

Libraries Required:

• Microsoft* C Run-Time Libraries (CRT) 2008/2010

Getting this to compile and run on my notebook wasn't hard, once I got the DirectX SDK installed. Here's some snaps of it running on my notebook;

Here's a snap of the Solution;

So what good is this? I'm not really sure...lol. I just thought it was pretty cool and fun, to be able to "fly" around the terrain, to play with the settings and know that I've got the source for how it was generated. That said, the best part was the original CodeProject article with the details and depth it went into. If you've ever wondered about terrain retendering, this is an article you might want to check out...

If you have, or download, beta 2 based code/project and it doesn't compile, one of your first stops should be this post collection.

Kinect for Windows – Code Migration from Beta2 to v1.0 (C#/VB)

There have been a number of significant changes and improvements in our APIs since Beta2. This set of documents attempts to detail the changes to facilitate code migration from beta 2 to v1.

API Change Details

[these links take you to a seperate post with details]

• Namespace and Assembly Name changes
• Runtime type (Rename to KinectSensor, refactoring)
• ColorImage API changes
• DepthImage API changes
• Skeleton API changes
• Mapping API changes (Skeleton -> Depth, Depth -> Color)
• Audio API changes
• Speech API changes

Adapting to API Changes

In order to adapt to this change, C#/VB developers should:

• Backup code projects (if not using source control, such as TFS)
• Uninstall Beta 2 SDK (including speech runtime 10.x components).
• Install Kinect for Windows SDK v1.
• Migrate code to use v1 APIs and best practices via one of the migration techniques below
• If you need help with the answer, go the Kinect for Windows forums. Search for other similar issues first. If needed, create a new issue. Please prefix the title of the forum post with “Migration issue:”. (for example: “Migration Issue: Runtime.Sensors replacement?”)
• If you figured out the answer, and want to suggest improvements to the details and techniques in these documents, please leave a comment (We generally will respond to that feedback, but won’t show the comments, as it may get unwieldy).

Where to go for help

Code Migration Techniques (C#/VB)

There are three major approaches to migration

1) RECOMMENDED: Use a migration reference assembly to assist with learning about API changes

2) RECOMMENDED: Go back to the examples you may have started from, find the newest versions of those, and transfer your improvements to this new version.

3) NOT RECOMMENDED: Change reference assembly, (recompile -> search for info -> change -> adapt -> repeat)

...

Project Information URL: http://robrelyea.wordpress.com/2012/02/01/k4w-code-migration-from-beta2-to-v1-0-managed/

Contact Information:

• Blog: http://robrelyea.wordpress.com/
• Twitter: @rrelyea

Now that the Kinect for Windows SDK is in a v1 state and we can start officially deploying Kinect for Windows SDK based applications, one of the things we're going to be facing is just that, deployment and setup issues. Rob Relyea has kicked off helping us with just that, providing suggestions and tips...

Kinect Apps – ensuring Kinect Runtime is installed

Kinect for Windows 1.0 enabled apps should ensure that the Kinect Runtime is installed wherever the app is installed.

[Note: Kinect for Windows 1.0's latest public preview is beta 2. Parts of this blog post may be applicable to beta 2, but is primarily focused on the final v1.0 version, coming February 1st. Since v1.0 is not yet released, information I give here may change when it does release. I also am filtering this information to ensure that I am not giving away details that we don't yet want to release.]

Guidelines

App installers should install its dependencies, including Kinect Runtime – CRITICAL

Kinect for Windows 1.0 will have a KinectRuntime-v1.0-Setup.exe that your app installer MUST chain install. In addition to installing Kinect specific software (drivers + runtime), KinectRuntime-v1.0-Setup.exe will ensure the following dependencies are installed:

• VCRT x86 and/or x64
• .NET 4 client profile (or later 4.x versions like .NET 4.5)
• Microsoft Speech Runtime v11 x86 and/or x64

Running an app should provide a decent user experience if Kinect Runtime isn’t installed

...

Project Information URL: http://robrelyea.wordpress.com/2012/01/11/kinect-apps-ensuring-kinect-runtime-is-installed/

public partial class App : Application
    {
        protected override void OnStartup(StartupEventArgs e)
        {
            if (IsKinectRuntimeInstalled)
            {
                //go ahead and load the StartupUri as defined in App.xaml
                base.OnStartup(e);
            }
            else
            {
                MessageBox.Show(Assembly.GetExecutingAssembly().FullName + " is not able to excecute."
                + "An important dependency should have been installed by its setup program: Microsoft Kinect Runtime 1.0");
            }
        }

        public bool IsKinectRuntimeInstalled {
            get
            {
                bool isInstalled;
                try
                {
                    TestForKinectTypeLoadException();
                    isInstalled = true;
                }
                catch (FileNotFoundException)
                {
                    isInstalled = false;
                }
                return isInstalled;
            }
        }

        // This Microsoft.Kinect.dll based type, must be isolated in its own method
        // as the CLR will attempt to load the Microsoft.Kinect.dll assembly it when this method is executed.
        private void TestForKinectTypeLoadException()
        {
#pragma warning disable 219 //ignore the fact that status is unused code after this set.
            var status = KinectStatus.Disconnected;
#pragma warning restore 219
        }
    }

Contact Information:

• Blog: http://robrelyea.wordpress.com/
• Twitter: @rrelyea

Today we're going to highlight a cool series by Dan Fernandez that will get going with Kinect for Windows SDK Development.

And remember if you're new to .Net development and would like to get up to speed on C# or VB.Net, you'll want to check out, C# Fundamentals: Development for Absolute Beginners and/or Visual Basic Fundamentals: Development for Absolute Beginners

Kinect for Windows Quickstart Series

This series includes everything you need to get started building applications using the Kinect for Windows SDK. You'll learn how to setup and configure the Kinect SDK using Visual Studio Express, how the Kinect color and depth camera work and how to use skeletal tracking to track joint positions in your application. You'll also learn how to use sound source localization to locate the direction of sound, how to use the Kinect to record audio, and how to use speech recognition to control your application via voice commands.

• Installing and Using the Kinect Sensor
• Setting up your Development Environment
• Camera Fundamentals
• Working with Depth Data
• Skeletal Tracking Fundamentals
• Audio Fundamentals

Project Information URL: http://channel9.msdn.com/Series/KinectQuickstart

This week we're highlighting another framework that while only available in binary form (through of course the demos and samples include their source) is also free, has been around a while longer, and has a much broader deployment reach, including not only Windows Phone 7, but also XBox 360, Windows and even the Zune!

DPSF (Dynamic Particle System Framework)

DPSF (Dynamic Particle System Framework) is a tried and tested, free programmer's tool for creating custom particle systems in XNA quickly and easily.

Incorporate particle effects into your project within a matter of minutes by using the provided Default Classes.

Unlike other particle system APIs / libraries, DPSF is flexible and allows you to code your own custom behaviors into the particle system; You are not limited to only using the parameters provided by the framework. You can create and control your own particle properties to make just about any effect you can imagine; If you can code it, you can create it in DPSF.

Upload particle systems you create to the DPSF forums and download particle systems created by others.

Check out the demo videos to see some of the things you can do with DPSF, or go ahead and download DPSF and try it out for yourself.

If you use DPSF in your project, be sure to post a link to your project on the the DPSF forums.

Features

Here is a list of some of the features DPSF provides:

• A single API for multiple platforms: supports 2D and 3D particles for Windows, Xbox 360, Windows Phone 7, and Zune.
• Easily integrates with graphics engines, including Synapse Gaming's SunBurn engine.
• Full API documentation is provided in the help file, as well as in the online help documentation.
• Tutorials and their source code are provided in the installer. The tutorials (without source code) are also available in the online help documentation.
• Allows particle systems to be created in minutes by using the Default Particle Systems provided; Just set values for the built-in parameters, such as position, velocity, acceleration, rotation, external force, start/end color, etc.
• The Default Particle Systems may be extended, allowing you to provide any extra required functionality. Want your particles to have a weight property that determines how fast they accelerate? Or do you want your particles to follow a specific path or pattern? You can code the behavior to make it happen!
• Templates to start from are provided to make creating new particle systems quick and easy.
• You write the particle system code, giving you full control over the particle system and its particles, allowing you to create any type of particle system effects you desire. Your imagination is the limit.
• Easy to integrate into existing projects; just add a reference to a dll file.
• Use the built-in Effects (i.e. shaders) as well as custom Effects.
• Modify the default Effect (i.e. shaders) to create new custom Effects quickly and easily.
• Particle System Managers are provided to make updating and drawing many particle systems easy.
• An Animations class is provided for easily creating animated particles.
• Easily create a sequence of images, tile-sets, or animated gifs displaying particle system animations.
• Particle systems may be implemented as DrawableGameComponents if required.

Check out these videos;

DPSF show's its maturity in a number of ways. First, there's good documentation.

Secondly there's a nice set of tutorials;

And finally the demo app is pretty awesome, showing off many of the capabilities of the framework. The demo ran for me the first time, with only a reference fix-up required;

All I needed to do was point that DPSF reference to the folder where I installed the framework and all was well.

One of my favorites (not sure why, maybe because the dog is cute...lol) is the Photo demo.

This demo shows off some of the cool things that DPSF can do. From 3D features;

To different ways the photo can be "particle'ized"

And yes, you get the source for this demo and particle systems.

If you are looking around for a mature particle system, one with a price and license that's hard to beat, you run, not walk, and check out DPSF.

If you follow Pete, it probably won't surprise you to know he's gotten his hands on a PIX-6T4 and has shared his recent experience building the kit and writing his first "real" game for it.

Assembling the PIX-6T4 Netduino-powered Hand-Held Game System

I recently picked up a PIX-6T4 build by Fabien Royer (with games by Fabien Royer and Bertrand Le Roy). This is a 64 pixel, two joystick/button, monophonic sound hand-held game device based around the Netduino Mini from Secret Labs. You create games in C# using Visual studio.

Disclaimer: I work for Microsoft and I enjoy working in the .NET Micro Framework as well as C++ on other microcontrollers. I purchased this product on my own, at full price; this is not a sample or review unit. Presumably, I got the same package of goodies everyone else gets.

Unboxing

The kit came in a regular USPS shipping box inside which were four bags. Two bags had components, and two had joysticks.

Conclusion

I'm impressed with what Fabien has come up with here, and the stock games he and Bertrand have done are just perfect. I think the board and enclosure could use a little more design to make it more compact and also more hand-friendly, but overall, I think this is an excellent way to get into Netduino programming using something fun and exciting. Also, because of the display technology, you are constrained to creating games with very simple graphics (just LEDs) so, by necessity, you avoid that common barrier to entry. Sometimes constraint is a good thing.

Congratulations Fabien and Bertrand!

My First Real PIX-6T4 Game: Sixty4Racer

After assembling my Netduino-powered PIX-6T4, I wanted to go and write a simple game. This post describes the construction of that game, including all source code.

Concept

When you have 64 monochrome red pixels, you need to keep the graphics simple. I decided on a game inspired by the classic Atari River Raid game. This is essentially a vertical scrolling game where you need to dodge obstacles with your boat. Variations included things like Spy Hunter on the C64 and many many others. Most of those games also involved shooting and enemies, but that's a but more complex than you can reasonably do on this board. I won't enable moving walls like Laser Gates, but I'll leave things open enough not to make it impossible to do that in the future.

The game had to be small enough that I could figure out the API, and then design, code, and blog about it in a single evening after my kids went to bed The PIX-6T4 is fun, but I have way too many projects on my backlog to be able to devote any significant time to it (here's a taste: a ShapeOko CNC mill, an AVR MIDI->CV Converter, the final touches on the MIDI Thru Box, several MFOS Synth Modules, Several Gadgeteer Board Concepts, a Win8 XAML book, chapters to review in my Silverlight 5 book, and much much more). In fact, that was one of the big selling points of this device: simple gameplay and quick to develop for. Combined with the great library Fabien designed, and my past experience with Netduino and, more specifically, C#, and this should be an evening project.

Screen Design

Back in the 80s, in 7th grade, I used to design single-color sprites for the commodore 64. The sprites themselves were 3 bytes wide, with each pixel represented as a single bit in the byte. I used to define them on graph paper, but alas, the notebooks I filled with sprites and BASIC listings have long since disappeared.

...

...

First Iteration: Creating the scrolling playfield

I called my project PeteBrown.Sixty4Racer. Just as in the previous post, I copied over the Program.cs file from another project and used that as the start. Please read my previous post to see what references you need and whatnot.

The first class I created was the one that manages the creation of the screens.

...

Second Iteration: Adding in the player

The PIX-6T4 libraries have built-in the concept of a PlayerMissile. This is a single pixel on the playfield. It may move, so it has X and Y speed. You can show or hide it, so it has Visibility. And most importantly, it has collision detection with other PlayerMissile instances. For our game, we're not going to use that, since we're looking for collision detection with the background. So, a little manual detection is in order.

...

Third Iteration: Polishing

The first thing I realized was that it was really hard to make out the player pixel in the sea of red. That's to be expected on a monochrome display at 8x8 resolution. The approach I came up with to make it a bit easier is to simply flicker the player pixel. Each time the game loop executes, I toggle the visibility of the ship PlayerMissile to give it a nice seizure-inducing flicker.

...

Final Steps

The final things to do are to create the manifest file and bitmap which will be used on the SD card. I'll need to check with Fabien to see what the exact format of the .bin file is, but I suspect it's just the 8 bytes of data formatted like all the other bitmap data in this application. I'm also not sure if he has a nice little app to write that data out, or convert from a bitmap, or something else. I ended up just using a hex editor to recreate the pattern from one of the images I created in the font editor.

...

What You Can Do

This came is completely free and open source. While I'd love credit for the initial work, it's not a requirement. Go ahead and do whatever you'd like with the source and have a blast

Here's a video of the game in action.

In short, if you have a hankering to get your soldering iron hot and build your own hand-held game console, one that you can also write your own games for, the PIX-6T4, and this guidance from Peter, has your name all over it...

[# KINECT] HowTo: Soften the detection of movements in the skeleton

Hi,

While we await the final SDK for developers with Kinect leave in a few days [GD: which by now is out], we still have to adjust quite a bit to make the SDK will allow us to make robust applications. One of these “debts” Kinect has with us is the ability to remove the “tembleque / tremor” have at each point of the skeleton when working with the same point to point or Joint to Joint. If you run the application that shows both skeletons in a Canvas of WPF, you’ll see that it works pretty well.

Now, if we modify it with a bit of the code base of this post, to add 2 worlds in each hand (I have ‘ s got the whole world in his hands!) in will see something similar to the following image. While I have not well adjusted the size of the form so that the worlds coincide 100% with each hand, when you run the application you can see that it is a flickering or tembleque a little weird when examines the detail of the skeleton.

...

Project Information URL: http://elbruno.com/2012/01/24/kinect-howto-soften-the-detection-of-movements-in-the-skeleton/

Project Source URL: https://skydrive.live.com/?cid=bef06dffdb192125&id=BEF06DFFDB192125%213798

Contact Information:

• Blog: http://elbruno.com
• Twitter: @elbruno

Page image, Lego advent calendar: Day 4, courtesy of Fimb

And that was all with beta software and a device meant for a gaming console.

With a fully supported, allowed for use in commercial products, dedicated device and updated SDK, today the world changes again.

Welcome to the Kinect for Windows SDK v1!

Kinect for Windows is now Available!

On January 9th, Steve Ballmer announced at CES that we would be shipping Kinect for Windows on February 1st. I am very pleased to report that today version 1.0 of our SDK and runtime were made available for download, and distribution partners in our twelve launch countries are starting to ship Kinect for Windows hardware, enabling companies to start to deploy their solutions. The suggested retail price is $249, and later this year, we will offer special academic pricing of $149 for Qualified Educational Users.

In the three months since we released Beta 2, we have made many improvements to our SDK and runtime, including:

• Support for up to four Kinect sensors plugged into the same computer
• Significantly improved skeletal tracking, including the ability for developers to control which user is being tracked by the sensor
• Near Mode for the new Kinect for Windows hardware, which enables the depth camera to see objects as close as 40 centimeters in front of the device
• Many API updates and enhancements in the managed and unmanaged runtimes
• The latest Microsoft Speech components (V11) are now included as part of the SDK and runtime installer
• Improved “far-talk” acoustic model that increases speech recognition accuracy
• New and updated samples, such as Kinect Explorer, which enables developers to explore the full capabilities of the sensor and SDK, including audio beam and sound source angles, color modes, depth modes, skeletal tracking, and motor controls
• A commercial-ready installer which can be included in an application’s set-up program, making it easy to install the Kinect for Windows runtime and driver components for end-user deployments.
• Robustness improvements including driver stability, runtime fixes, and audio fixes

More details can be found here.

If you're like me, you want to know more about what's new... So here's a snip from the Kinect for Windows SDK v1 Release Notes;

5. Changes since the Kinect for Windows SDK Beta 2 release

• Support for up to 4 Kinect sensors plugged into the same computer, assuming the computer is powerful enough and they are plugged in to different USB controllers so that there is enough bandwidth available. (As before, skeletal tracking can only be used on one Kinect per process. The developer can choose which Kinect sensor.)

· Skeletal Tracking

• The Kinect for Windows Skeletal Tracking system is now tracking subjects with results equivalent to the Skeletal Tracking library available in the November 2011 Xbox 360 Development Kit.

• The Near Mode feature is now available. It is only functional on Kinect for Windows Hardware; see the Kinect for Windows Blog post for more information.

• Robustness improvement including driver stability, runtime and audio fixes.

• API Updates and Enhancements
  • See a blog post detailing migration information from Beta 2 to v1.0 here: Migrating from Beta 2

• Many renaming changes to both the managed and native APIs for consistency and ease of development. Changes include:
  • Consolidation of managed and native runtime components into a minimal set of DLLs
  • Renaming of managed and native APIs to align with product team design guidelines
  • Renaming of headers, libs, and references assemblies

• Significant managed API improvements:
  • Consolidation of namespaces into Microsoft.Kinect
  • Improvements to DepthData object
  • Skeleton data is now serializable
  • Audio API improvements, including the ability to connect to a specific Kinect on a computer with multiple Kinects
  • Improved error handling

• Improved initialization APIs, including addition the Initializing state into the Status property and StatusChanged events

• Set Tracked Skeleton API support is now available in native and managed code. Developers can use this API to lock on to 1 or 2 skeletons, among the possible 6 proposed.

• Mapping APIs: The mapping APIs on KinectSensor that allow you to map depth pixels to color pixels have been updated for simplicity of usage, and are no longer restricted to 320x240 depth format.

• The high-res RGB color mode of 1280x1024 has been replaced by the similar 1280x960 mode, because that is the mode supported by the official Kinect for Windows hardware.

• Frame event improvements. Developers now receive frame events in the same order as Xbox 360, i.e. color then depth then skeleton, followed by an AllFramesReady event when all data frames are available.

• Managed API Updates

Correct FPS for High Res Mode

ColorImageFormat.RgbResolution1280x960Fps15 to ColorImageFormat.RgbResolution1280x960Fps12

Enum Polish

Added Undefined enum value to a few Enums: ColorImageFormat, DepthImageFormat, and KinectStatus

Depth Values

DepthImageStream now defaults IsTooFarRangeEnabled to true (and removed the property).

Beyond the depth values that are returnable (800-4000 for DepthRange.Default and 400-3000 for DepthRange.Near), we also will return the following values:

DepthImageStream.TooNearDepth (for things that we know are less than the DepthImageStream.MinDepth)

DepthImageStream.TooFarDepth (for things that we know are more than the DepthImageStream.MaxDepth)

DepthImageStream.UnknownDepth (for things that we don’t know.)

Serializable Fixes for Skeleton Data

We’ve added the SerializableAttribute on Skeleton, JointCollection, Joint and SkeletonPoint

Mapping APIs

Performance improvements to the existing per pixel API.

Added a new API for doing full-frame conversions:

public void MapDepthFrameToColorFrame(DepthImageFormat depthImageFormat, short[] depthPixelData, ColorImageFormat colorImageFormat, ColorImagePoint[] colorCoordinates);

Added KinectSensor.MapSkeletonPointToColor()

public ColorImagePoint MapSkeletonPointToColor(SkeletonPoint skeletonPoint, ColorImageFormat colorImageFormat);

Misc

Renamed Skeleton.Quality to Skeleton.ClippedEdges

Changed return type of SkeletonFrame.FloorClipPlane to Tuple<int, int, int, int>.

Removed SkeletonFrame.NormalToGravity property.

· Audio & Speech

• The Kinect SDK now includes the latest Microsoft Speech components (V11 QFE). Our runtime installer chain-installs the appropriate runtime components (32-bit speech runtime for 32-bit Windows, and both 32-bit and 64-bit speech runtimes for 64-bit Windows), plus an updated English Language pack (en-us locale) with improved recognition accuracy.

• Updated acoustic model that improves the accuracy in the confidence numbers returned by the speech APIs

• Kinect Speech Acoustic Model has now the same icon and similar description as the rest of the Kinect components

• Echo cancellation will now recognize the system default speaker and attempt to cancel the noise coming from it automatically, if enabled.

• Kinect Audio with AEC enabled now works even when no sound is coming from the speakers. Previously, this case caused problems.

• Audio initialization has changed:
  • C++ code must call NuiInitialize before using the audio stream
  • Managed code must call KinectSensor.Start() before KinectAudioSource.Start()
  • It takes about 4 seconds after initialize is called before audio data begins to be delivered
  • Audio/Speech samples now wait for 4 seconds for Kinect device to be ready before recording audio or recognizing speech.

· Samples

• A sample browser has been added, making it easier to find and view samples. A link to it is installed in the Start menu.

• ShapeGame and KinectAudioDemo (via a new KinectSensorChooser component) demonstrate how to handle Kinect Status as well as inform users about erroneously trying to use a Kinect for Xbox 360 sensor.

• The Managed Skeletal Viewer sample has been replaced by Kinect Explorer, which adds displays for audio beam angle and sound source angle/confidence, and provides additional control options for the color modes, depth modes, skeletal tracking options, and motor control. Click on “(click for settings)” at the bottom of the screen for all the bells and whistles.

• Kinect Explorer (via an improved SkeletonViewer component) displays bones and joints differently, to better illustrate which joints are tracked with high confidence and which are not.

• KinectAudioDemo no longer saves unrecognized utterances files in temp folder.

• An example of AEC and Beam Forming usage has been added to the KinectAudioDemo application.

• Redistributable Kinect for Windows Runtime package
  • There is a redist package, located in the redist subdirectory of the SDK install location. This redist is an installer exe that an application can include in its setup program, which installs the Kinect for Windows runtime and driver components.

Here's some more links and information

• Kinect For Windows
• Kinect for Windows Blog (Near Mode: What it is (and isn’t))
• Kinect for Windows SDK v1 Release Notes
• Download the Kinect for Windows SDK (Make sure you read the full release notes, there's instructions for those who are using earlier versions for the Kinect for Windows SDK)
• Additional Resources and Documentation

Last but not least, here's some of the resources and projects that have been with with us since day 0;

• Kinect for Windows Quickstart Series - http://channel9.msdn.com/Series/KinectQuickstart
  • Installing and Using the Kinect Sensor
  • Setting up your Development Environment
  • Camera Fundamentals
  • Working with Depth Data
  • Skeletal Tracking Fundamentals
  • Audio Fundamentals
• Kinect Service - This is a Windows Service so you can see Kinect data on your Windows Phone - http://kinectservice.codeplex.com/
• Kinect Paint – Draw with your hands - http://paint.codeplex.com/
• Kinect Mouse Cursor – Control Windows with your hands - http://kinectmouse.codeplex.com/
• Coding4Fun Kinect Toolkit – Developer library for easy programming – http://c4fkinect.codeplex.com
• Jellybean – Our driveable lounge chair – http://jellybean.codeplex.com

Today is an exciting day and I'm really looking forward to the explosion of cool and fun stuff that I'm sure will be coming to the Gallery soon!

Update 2/2/2012:

Since yesterday there's been a number announcements, posts and updates related to the v1 release. Here's a round for a number of them.

• Official Kinect for Windows SDK and Kinect Toolbox 1.1.1 are out! (David Catuhe)
• Kinect for Windows – Code Migration from Beta2 to v1.0 (C#/VB) (Rob Relyea)
• Kinect for Windows – Details of API Changes from Beta2 to v1.0 (C#/VB) (Rob Relyea)
• Kinect Service [also mentioned above, but this projects a few more details] (Brian Peek)
• Kinect for Windows now available! Information and resources for you. [This is another link round-up with even more information, links, etc.] (Eric Ligman)

In the coming days and weeks I'm sure we'll be hearing about more updates, refreshed, etc, so keep an eye on you favorite project or library...

This project is still in an Alpha state, but that's actually good, since it means that if you want to help them out on it, you can get in closer to the ground floor...

I said, "help out?" Yep, they are actively looking for your help...

We are seeking contributors in programming, art, sound, web design, taking YouTube videos and more.

These roles on the 0 A.D. development team are great if you want to brush up on your skills and update your portfolio, if you're seeking a project for school with real-life applications, or if you care about the cause of free culture and software and are willing to work pro bono with a group of dedicated volunteers from all over the world.

Interested? Please register on our forums and start a new topic introducing yourself in the applications and contributions forum following these instructions.

What kind of project are we talking about?

0 A.D.

• Free and Open Source Software
• Cross-platform
• Historically based
• 6 unique civilizations
• Provinces and territories
• Realistic maps/terrain
• Realistic naval warfare
• Comprehensive editor
• Several multiplayer modes

Overview

0 A.D. (pronounced "zero ey-dee") is a free, open-source, cross-platform real-time strategy (RTS) game of ancient warfare. In short, it is a historically-based war/economy game that allows players to relive or rewrite the history of Western civilizations, focusing on the years between 500 B.C. and 500 A.D. The project is highly ambitious, involving state-of-the-art 3D graphics, detailed artwork, sound, and a flexible and powerful custom-built game engine.

The game has been in development by Wildfire Games (WFG), a group of volunteer, hobbyist game developers, since 2001. The code and data are available under the GPL license, and the art, sound and documentation are available under CC-BY-SA. In short, we consider 0 A.D. an an educational celebration of game development and ancient history.

Top features - Technical

• The engine core is written in C++ for performance, but the scripting language, javascript, is what we try to write as much in as possible.
• Rendering: OpenGL with shaders
• Libraries used: OpenAL, OpenGL, Boost, Crypto++, CxxTest, DevIL, SDL, SpiderMonkey, Vorbis, wxWidgets, Xerces
• Operating Systems:
  • Windows 2000, XP, 2003, XP64, Vista
  • Linux
  • Mac OS X
• System Requirements: 1 GHz CPU, modern graphics card (GeForce 3 at minimum), 512 MB RAM
• Tools used: Visual Studio, g++, CppDoc, COLLADA, Debugging and Profiling tools included

Graphics

• OpenGL-based rendering engine with shaders
• Hierarchal skeletal animation and deformation system based on COLLADA
• Fancy animated water with refraction, reflection
• Realistic shadows
• Particle effects
• Environmental lighting effects (time of day, sunset)
• Flexible terrain renderer that uses alpha maps to seamlessly blend terrain

Gameplay

• Unique civilizations: In 0 A.D. each civilization will be unique in its appearance, units, structures, and technology trees.
• Citizen soldiers: There will be no standard villager unit. Instead, regular infantry and cavalry have not only military capabilities, but also economic, making them substantially more versatile than in typical RTS games.
• Unit auto-upgrading: Citizen Soldiers will gain experience and automatically gain promotions. With each rank, they become stronger, and don a unique appearance but also get gradually worse at civilian tasks.
• Units on structures and ships: Gone are the days of units disappearing into buildings and transport ships. Some garrisoned units will be visible on the battlements of structures or the decks of ships, and capable of firing on opponents at range.
• Realistic naval warfare: No more tiny ships sinking other ships with arrows. Ship gameplay will include a variety of new features in RTS games, like much larger ship sizes, ship capture, sea rams, and a modular design that allows catapults to be stationed on the decks, and units to fire from the bows.
• Choices, choices, and more choices: Technology trees branch out in a pair-based hierarchy. For example, when you are given the option of techs 1A and 1B and you choose 1A to research, 1B is no longer available. Some of the techs that are higher up on the tech ladder will require that tech 1A is done, while others will require tech 1B. This adds a level of strategy and 'randomness' to picking your techs, as availability of higher level techs will depend on your choices earlier in the game. Similar choices are available with unit formations and battle tactics.
• Provinces and territories: In some game types, the map is subdivided into provinces that must be captured and annexed into a player's territory in order to reap their valuable resources and construct forward bases in these areas. If the host wishes, a player's starting province can also be surrounded by attrition borders to reduce early rushes.
• Real world map realism: Random maps are based upon geographical regions where the civilizations of the ancient world lived. These will be generated with biome specific-to-location features that replicate the look and feel of the world as it existed 2,000 years ago: flora, fauna and terrain.

Sounds like something that would be hard to compile, doesn't it? All those third party libraries, etc? And I mentioned something about Visual Studio?

0 AD Build Instructions

This page describes how to get the very latest unstable version of the code. Unless you want to actively follow and contribute to development, you probably want the latest relatively-stable release instead.

The current release of the game is aimed at developers and not at 'normal' users. As such, the following instructions assume a reasonable level of technical proficiency. If you encounter difficulties, please post on the forum.

General prerequisites ¶

You'll need:

• An adequately high-spec computer - several gigabytes of free disk space, preferably at least 1GB of RAM for compiling, a fast CPU unless you want to spend ages waiting for the compiler, etc. Modern graphics hardware is also recommended, though the game can run (slowly) on fairly old devices (GeForce 4, Intel 945GM, etc).
• Up-to-date system software (Windows service packs, graphics driver updates, etc).
• Some technical proficiency. We try to make the build process as smooth and painless as possible, but it's designed to be followed by programmers - if you just want to play the game, wait for a pre-packaged installer instead.

Windows ¶

Windows 7, Vista and XP are the main supported versions; 2000 should work too but is rarely tested. Visual C++ 2010 and 2008 are supported. Visual C++ 2005 may also work given a sufficiently modern Platform SDK. Only 32-bit builds are supported (though they can be compiled and run on 64-bit Windows). We have noticed occasional trouble with the free Express Editions; if possible, please consider acquiring the full version (e.g. via university programs). In particular, failures of the built-in self-test test_wdbg_sym.h seem to occur with VC2008 EE but not VC2008 nor VC2010 (c.f. #884).

Acquiring the code ¶

The game's code, data and build environment are stored on a Subversion server. The recommended way to get an up-to-date copy is with TortoiseSVN:

• Download and install TortoiseSVN. (Make sure you reboot when it asks you to.)
• Use TortoiseSVN to check out http://svn.wildfiregames.com/public/ps/trunk/. This may take a while, and will use around 1.2GB of disk space. If there are errors during the checkout, use TortoiseSVN's "update" to resume downloading.

The TortoiseSVN manual has information on checking out, as well as updating and creating patches.

(This is the read-only public SVN URL. If you have commit access, you need to use http://svn.wildfiregames.com/svn/ps/trunk/ instead.)

Setting up the build environment ¶

The game must be compiled with Microsoft Visual C++. If you already have Visual C++ 2005 or 2008 installed, make sure you have SP1 and then continue. Otherwise, you can get the free Express edition:

• Visual C++ 2010 Express Edition is recommended.
• Or download and install Visual C++ 2008 Express Edition.
• If you have the old VC++ 2005 Express, you need to install the separate Platform SDK (steps 1-3).

The Visual Studio project/solution files are automatically generated from the source files:

• Run build/workspaces/update-workspaces.bat.
• Open build/workspaces/vc2010/pyrogenesis.sln. (Use the vc2005 directory for VC++ 2005 or the vc2008 directory for VC++ 2008.)
• ...

So get the source from the SVN repository, run one batch file and launch the solution. Yep, it's really that easy.

Now the repository/source is huge (the installable version you can also download is 275MB, so you can image the size of source and assets... which is 3.16GB, which includes the post compile/build binaries) so it will take a while to grab it. But once you do, you should be able to build and run it in the debugger. (Well, at least I was...

Here's a WinDirStat snap of my tree, which is in a post build/compile state;

So you get this pretty awesome RTS, you get the source and you get everything to build it too.

Here's a snap of the Solution;

The code is smartly commented (i.e. intent is commented and not just the code re-worded)

If you've always wished you could work on a big game, you love the idea of helping out in build an RTS or just wonder what the source of one would look like, this project is looking for you...

Getting started with Microsoft Kinect SDK - The Full Skeleton

Article Index

• Getting started with Microsoft Kinect SDK - The Full Skeleton
• Drawing the body
• Joining the Bones

So far in this series we've covered the visual and depth inputs and started to look at skeletonization. In this part we get down to the bare bones of the skeleton.

Other Articles in this Series

1. Getting started with Microsoft Kinect SDK
2. Depth
3. Player index
4. Depth and Video space
5. Skeletons
6. The Full Skeleton (this article)

While there is a very good example of how to draw a complete skeleton in the SDK it isn't explained in detail and, in common with most examples, it does things in clever and correct ways. This makes it a piece of code to admire but only if you can work out what it is doing and how. In this article the objective is not only to create a full skeleton graphic but to make it perfectly clear how it is done.

First a small digression into GDI graphics.

...

Getting started with the full Skeleton

As explained in the previous article, the Kinect doesn't return a skeleton, just a set of joints that it has detected. It is entirely up to us what to do with this set of joints. One of the problems with the example skeleton viewer is that at first look you might think that something clever was going on that relied on the way that the Kinect returns the data.

Let's try and draw a skeleton in a step-by-step way that shows how it all works. The instructions that follow just get you to the point where the SkeletonFrameReady methods is called as described in the previous article.

Start a new C# Windows Forms project.

...

Now to display the image we simply need to write the code for the FrameReady event handler. However we are going to want to modify the video returned from the camera by adding a small cross at the position of the players head. To do this we will store the video frame in a global variable and allow the SkeletonFrameReady event handler to actually do the displaying of the video frame.

So the FrameReady method is:

void FrameReady(object sender, 
            ImageFrameReadyEventArgs e)
{
 videoimage= e.ImageFrame.Image;
}

The videoimage variable is just a global PlanarImage:

PlanarImage videoimage;

Now we need to define the SkeletonFrameReady event handler to simply show the video. It has to check first to make sure that an image has been stored in the videoimage:

void SkeletonFrameReady(object sender,
        SkeletonFrameReadyEventArgs e)
{
 if (videoimage.Bits == null) return;

We can't display a PlanarImage in, say, a PictureBox unless we first convert it to an Image object. How to do this was covered in Part 1 of this series, so the method that does the job PImageToBitmap is simply quoted:

...

Drawing the Body

Now that we have the video frame as a bitmap we can start to draw the skeleton on it. First we need a Graphics object:

Graphics g = Graphics.FromImage(bmap);

Our next problem is to find the positions of each of the joints that makeup the "body" of the skeleton. If you look at the diagram that gives the names of the joints you can see that we need the positions of the Head, Shoulder Center, Spine and Hip Center.

....

Drawing a Bone

it should be obvious that what we have to do next is draw a line between ShoulderCenter and Spine. Clearly this is just a repeat of what we have already done so this suggests another helper function:

void DrawBone(JointID j1,
              JointID j2, 
              SkeletonData data, 
              Graphics g)
{
 Point p1=GetJoint(j1,data);
 Point p2 = GetJoint(j2, data);
 g.DrawLine(Pens.Red, p1, p2);
}

This will draw a line between the two specified Joints. So to draw the body all we need is:

...

Now if you run the program you will see a complete skeleton plot.

You can argue that there are better ways to organize the code but you have to have a list of the joints you want to draw lines between somewhere.

If you want to try taking it further why not change the drawing of the head for an ellipse and a rectangle for the body. It is all fairly easy.

...

Project Information URL: http://www.i-programmer.info/programming/hardware/3657-getting-started-with-microsoft-kinect-sdk-the-full-skeleton.html

Page image, America's Next Top Model, courtesy of Thunderchild7

Kinect Fundamentals #4: Implementing Skeletal Tracking

Hi and welcome to tutorial #4 in my Kinect Fundamentals tutorial. In this tutorial, I will show you how you can implement Skeletal Tracking using the Kinect SDK for Windows API, and how you can move a cursor by using your hand.

It’s very simple, and it is quite similar to the approaches we have used in the previous tutorials.

Project Information URL: https://digitalerr0r.wordpress.com/2011/12/13/kinect-fundamentals-4-implementing-skeletal-tracking/

Project Source URL: http://digitalerr0r.darkcodex.net/Tutorials/kinect4tutorial.zip

Contact Information:

• Blog: https://digitalerr0r.wordpress.com/
• Twitter: @petriw

Page image,a horse with no name, courtesy of guy schmidt

We've all seen depth "images" right? And we've all seen that they appear a little noisy/blotchy? Well Karl Sanford saw the same thing and decided to apply some smooth moves to the problem...

Smoothing Kinect Depth Frames in Real-Time

Removing noise from the Kinect Depth Frames in real-time using pixel filters and weighted moving average techniques.

I've been working with the Microsoft Kinect for Xbox 360 on my PC for a few months now, and overall I find it fantastic! However, one thing that has continued to bug me is the seemingly poor quality of rendered Depth Frame images. There is a lot of noise in a Depth Frame, with missing bits and a pretty serious flickering issue. The frame rate isn't bad from the Kinect, with a maximum of around 30 fps; however, due to the random noise present in the data, it draws your perception to the refresh. In this article I am going to show you my solution to this problem. I will be smoothing Depth Frames in real-time as they come from the Kinect, and are rendered to the screen. This is accomplished through two combined methods: pixel filtering, and weighted moving average.

...

The Problem of Depth Data

Before I dive into the solution, let me better express the problem. Below is a screen shot of raw depth data rendered to an image for reference. Objects that are closer to the Kinect are lighter in color and objects that are further away are darker.

What you're looking at is an image of me sitting at my desk. I'm sitting in the middle; there is a bookcase to the left and a fake Christmas tree to the right. As you can already tell, even without the flickering of a video feed, the quality is pretty low. The maximum resolution that you can get for depth data from the Kinect is 320x240, but even for this resolution the quality looks poor indeed. The noise in the data manifests itself as white spots continuously popping in and out of the picture. Some of the noise in the data comes from the IR light being scattered by the object it’s hitting, some comes from shadows of objects closer to the Kinect. I wear glasses and often have noise where my glasses should be due to the IR light scattering.

Another limitation to the depth data is that it has a limit to how far it can see. The current limit is about 8 meters. Do you see that giant white square behind me in the picture? That's not an object close to the Kinect; the room I'm in actually extends beyond that white square about another meter. This is how the Kinect handles objects that it can't see with depth sensing, returning a depth of Zero.

The Solution

As I had mentioned briefly, the solution I have developed uses two different methods of smoothing the depth data: pixel filtering, and weighted moving average. The two methods can either be used separately or in series to produce a smoothed output. While the solution doesn't completely remove all noise, it does make an appreciable difference. The solutions I have used do not degrade the frame rate and are capable of producing real-time results for output to a screen or recording.

...

As you can see, the demo application will do a side by side comparison of the Raw Depth Image and the Smoothed Depth Image. You can experiment with the smoothing settings in the application as well. The settings that you will find when you first run the application are what I recommend for general purpose use. It provides a good mix of smoothing for stationary objects, moving objects, and doesn't try to "fill in" too much from the filtering method.

For example: You can turn both band filters down to 1, and turn the weighted moving average up to 10, and you'll have the lowest flicker and noise for stationary blunt objects. However, once you move, you will have a very noticeable trail, and your fingers will all look like they are webbed if you don't have a wall close behind you.

Points of Interest

I have really enjoyed playing around with these smoothing techniques and learning that there is probably no 'one-size-fits-all' solution for it. Even with the same hardware, your physical environment and intentions will drive your choice for smoothing more than anything. I would like to encourage you to open the code and take a look for yourself, and share your ideas for improvement! At the very least, go borrow your neighbor kid’s Kinect for a day and give the demo application a whirl.

Another point of interest has been in seeing how reducing noise for rendering purposes can actually introduce noise for depth calculation purposes. The pixel filtering method of reducing noise works well on it's own to reduce noise in depth information prior to further calculations; removing 'white' noise and providing a best guess as to what that information should be. The weighted moving average method works well to reduce noise prior to rendering, but will actually introduce noise along the Z,Y perspective due to the effects of averaging depth information. I hope to continue learning about these effects and how to use them properly for different types of applications.

...

Project Information URL: http://www.codeproject.com/Articles/317974/KinectDepthSmoothing

Project Download URL: http://www.codeproject.com/KB/audio-video/317974/KinectDepthSmoothingBin3.zip

Project Source URL: http://www.codeproject.com/KB/audio-video/317974/KinectDepthSmoothingSrc3.zip

Contact Information:

• Twitter: @krsanford

Let's say you're writing a cool game and you need an explosion to cap it off. You'd don't want a cheesy one, but your not sure where else to go?

Go here...

Tranquility 3D Particle Engine

Tranquility is a compact, easy to use and highly extendible 3D particle system for Windows Phone 7 XNA projects.

For installation/integration, check out the Getting Started Guide. To learn how to use Tranquility check out Using Tranquility.

Using Tranquility

Using Tranquility is easy; most tasks can be achieved in a couple of lines of code. The demo project included with the source showcases more advanced scenarios including AppHub’s fire, smoke and explosion samples.

Particle Manager

All particle properties, behavior and drawing are managed by Tranquility's ParticleManager. ParticleManager is a DrawableGameComponent that can simply be added to your Game’s component collection.

....

Using Tranquility

Using Tranquility is easy; most tasks can be achieved in a couple of lines of code. The demo project included with the source showcases more advanced scenarios including AppHub’s fire, smoke and explosion samples.

Particle Manager

All particle properties, behavior and drawing are managed by Tranquility's ParticleManager. ParticleManager is a DrawableGameComponent that can simply be added to your Game’s component collection.

The ParticleManager needs to know how your world is being viewed. Use the SetMatrices method to set the view and projection matrices.

Particle Systems

A ParticleSystem defines a group of particles that share a texture representation. There are two base particle system types in Tranquility:

• StaticParticleSystem: All particles in this system have static properties. Once a particle is added to this system type, it cannot move, grow, change color, etc. Although particles can be added and removed to/from this system on the fly, it is ideal for static allocation of particles.
• DynamicParticleSystem:A dynamic particle system contains particles that can have a velocity, rotation, lifespan and can be affected by various affectors.

  Creating and registering a particle system

  To create a system, specify the maximum capacity and the texture to be used for this system in the LoadContent method. For example, create a dynamic particle system:

  • ..

  • Particles

    The overloaded AddParticle method can be used to add particles to any system. The RandomHelper class can be used to randomize the generation of particles. For example:

    particleSystem.AddParticle(           
    RandomHelper.Vector3Between(Vector3.Up, Vector3.Down),           
    RandomHelper.Color(),           
    RandomHelper.NormalizedVector3(),           
    RandomHelper.Float(),           
    TimeSpan.FromSeconds(RandomHelper.IntBetween(1, 3))      
    );

  Particle Emitters

  Emission of particles can be automated using a particle emitter. To create a custom particle emitter, implement the IParticleEmitter interface:

     1:  public class CustomParticleEmitter : IParticleEmitter 

  Implementing the Update method will allow the emitter to automatically emit particles in the particle system it is added to. The Emit method can be used to emit particles manually.

  ...

• Particle Affectors

  A particle affector can affect one or more properties of all particles in a system. There are three default affectors in Tranquillity that use the particle’s age as the time factor:

• Decelerate: Slows a particle down to a complete stop towards the end of its lifespan. This affectors affects only particles that have a velocity.
• Fadeout: Reduces the alpha of a particle until it becomes completely transparent towards the end of its lifespan.
• Shrink:Reduces the size of a particle until it disappears completely towards the end of its lifespan.
  • ...

Here's a snap of the Solution. As you can see, it's not crazy or insanely complicated (nor uses another other libraries).

Here's a snip from the Demo;

public FireParticleSystem(int maxCapacity, Texture2D texture)
     : base(maxCapacity, texture)
{

}

public override void Update(GameTime gameTime)
{
     EmitParticles(gameTime);

     foreach (DynamicParticle particle in liveParticles)
     {
         particle.Color = Color.Lerp(particle.InitialColor, new Color(1.0f, 1.0f, 1.0f, 0.0f), 1.0f - particle.Age.Value);
         particle.Scale += 0.001f;
     }

     base.Update(gameTime);
}

private void EmitParticles(GameTime gameTime)
{
     particlesEmitted += (float)gameTime.ElapsedGameTime.TotalSeconds * (float)EmissionRate;

     int emittedCount = (int)particlesEmitted;

     if (emittedCount > 0)
     {
         for (int i = 0; i < emittedCount; i++)
         {
             AddParticle(
                 RandomPointOnCircle(),
                 new Color(255, 255, 255, 100),
                 RandomHelper.Vector3Between(new Vector3(-0.25f, 0.0f, 0.0f), new Vector3(0.25f, 1.0f, 0.0f)),
                 RandomHelper.FloatBetween(-0.01f, 0.1f),
                 TimeSpan.FromSeconds(RandomHelper.IntBetween(1, 2)),
                 true,
                 RandomHelper.FloatBetween(0.0f, MathHelper.TwoPi),
                 RandomHelper.FloatBetween(0.05f, 0.075f));
         }

         particlesEmitted -= emittedCount;
     }
}

This is one of those projects that will help you add that final touch, help you apply a nice bit of polish to your app or game...

Mini-VREM Project

The main objective of this research project is the development of a low-cost training platform for quality cardiopulmonary resuscitation of lay and health care personnel.

In a previous work published on Resuscitation, Virtual reality enhanced mannequin (VREM) that is well received by resuscitation experts, We concluded that the prototype of a VREM was met with enthusiastic interest, unaffected by the need of utilizing interaction devices and deserves full technological development (for example movements, improvement of facial signs, and animation in different clinical scenarios) and validation in emergency care training.

The proposed training platform is composed of a traditional manikin for the physical interaction and Kinect Sensor, that will be automatically and reconstruct trainee’s hands position and posture while performing chest compressions.

...

Project Information URL: http://www.kapipal.com/mini-vrem

Home Automation with Netduino and Kinect

Home automation has been an interest of mine for a long time. There is a bunch of bad technology in the marketplace and the products are too expensive so I decided to build my own. I started out with the Arduino microcontroller which was really fun but the code quickly became hard to maintain because it was not object oriented. Additionally it could not do multithreading or real debugging with breakpoints and such. I refactored the code for C# and the .NET Micro Framework. I choose the netduino plus, http://www.netduino.com/netduinoplus/specs.htm, for the microcontroller which has a built in Ethernet adapter for network communication.

...

Netduino Controlled Squirt Gun

The first project that I built was a servo controlled squirt gun for the pool. The code that I wrote for the netduino controls the servos to spray the gun in different patterns in the pool. I then built a Windows Phone 7 interface to aim the servos to the position on the screen where you touch. I used IIS live smooth streaming to stream video to the phone so you could remotely nail the kids in the pool from anywhere. I had mixed results with the video piece and at some point I need to spend more time perfecting and reducing the buffering time to make it more real time.

...

Kinect

One of my colleagues in the office started doing projects with the Microsoft Kinect which has a rich SDK complete with drivers, APIs and plenty of good sample code. The Kinect has a bunch of sensors including a RGB camera, depth sensor and multi-array microphone. With a Kinect, you are the controller! I got the idea of using the Kinect for the controller of the squirt gun in the pool. You can now aim the gun by pointing to where you want it to shoot. The trigger is controlled by bending your other arm so that the hand is above the elbow joint. Plugging in the Kinect for the controller was really simple because of the rich Kinect API and because I had already written the back end tiers to communicate with the netduino microcontroller.

I don't know about you, but home automation is something I find very cool. Add that to the dream of an automated squirt gun (how fun does THAT look!) and all the other things Dan's showing off, there looks to be a number of cool things where his project can help us get started building. Now where did I put that breadboard...

Geomagic demonstrates Kinect-To-Print for 3D printers (video)

We're still waiting to check out 3D Systems Corporation's 3D printing service at CES. In the meantime, Geomagic, which powers the Kinect-To-Print app for the company, has released a video demonstrating the process by which a Kinect image gets turned into a printable template. Essentially, Geomagic uses the Kinect to capture a series of points, then turns them into a 3D model which can be sent to the printer or, presumably, uploaded to "create-and-make" environment Cubify.

...

Project Information URL: http://www.theverge.com/2012/1/10/2696115/geomagic-cubify-3d-printer-kinect-video

Board of Awesomeness

Members of the Chaotic Moon team are like little kids—you tell us we can’t do something, we’re sure going to go out and do it. And when it comes to technology, that rebellious side is magnified by a trillion. So, when the limitations of Kinect for Xbox 360 were revealed, our Chaotic Moon Labs geniuses put it under the microscope to show how we can make Kinect do everything it’s not supposed to do.

Using a motorized longboard custom rigged with a Microsoft Xbox 360 Kinect device, Samsung Windows 8 enabled tablet with full voice control (yep, the one that’s not yet released), a phidget interface module, and all terrain tires, we took Project Sk8 to the streets to show how we’ve revolutionized Kinect by re-engineering it to not only respond to movement but use that movement to operate something other than a gaming avatar.

Introducing Chaotic Moon Labs' Board of Awesomeness—a longboard powered by your movement … as well as our imaginative engineering and custom electronics, of course.

...

So how does it work? Video recognition, speech recognition, location data, accelerometer data, and other factors determine what the user wants to do and allow the board to follow the operator’s commands without other aid. Very similar to using Kinect for Xbox 360, the Kinect device on our Board of Awesomeness transmits the user’s gestures and movement to the Samsung Windows 8 tablet that serves as the board’s central brain by controlling the speed of the board’s electric motor, which is up to 32 miles per hour. Yeah, that’s fast. Just ask whurley.

...

Project Information URL: http://www.chaoticmoon.com/labs/board-of-awesomeness/

from Vimeo.

Contact Information:

• Blog: http://www.chaoticmoon.com/blog/
• Twitter: @ChaoticMoon

SpaceShoot - A multiplayer game in HTML5

The interest in using HTML5 to produce awesome cross-platform games has been increased lately. Technologies like WebSockets, Canvas and others are becoming more and more stable as well as safer to use for webdevelopers. The rule is still that products should be built with technologies that will be available when the product ships - not when the product is being built. So I assume that the need for advanced game development using HTML5 in combination with CSS3 and JavaScript will increase even more over the next couple of years.

Background

I always wanted to write an awesome looking multiplayer game - but I did never have the time to achieve my goal at all areas. Either I had a really solid and fast multiplayer code, or I had a good game idea, or I had the right graphics / graphic methods. With HTML5, a world with new possibilities has come up. First of all, there are plenty of possibilities to write games. There are many kind of games possible. Some browsers have even implemented the (certainly not part of the upcoming HTML5 standard) WebGL technology. Some browsers like Google's Chrome have even the so called native client available. All those technologies make (accelerated) 3D in the browser possible.

At the moment, the most games are kind of 2D social games. They follow a simple principle and contain nice 2D graphics with an interface to Facebook / Google+ / Twitter or other kind of social networks. You'll mostly end up playing a single player that is somehow (mostly over AJAX) connected to the databases of the big sites providing you with updates on how the others do or different kinds of feedback and information. However, there is one technology that will change it all.

With the emergence of the HTML5 standard, more and more popular technologies will be standardized. One of those technologies will be the WebSocket technology. There has already been quite a lot of talk about node.js. The software has been written an order to let everyone write his on (WebSocket-) server code in JavaScript. The code will be compiled to machine code (over Google's open source V8 engine) and will handle all requests in an event based form. This certainly has an advantage if you want to program the server's code in a language similar to the client's one although it must be said that node is a different kind of technology (and I suppose you'll find that out by using it only once!).

Since I do love C# I wanted to write the server code with C#. The basis for the server code was an open source code called Fleck. It does call the necessary .NET-Framework classes and methods and supports most of the current protocol specifications. On the client side, I wanted to use the <canvas> element. I do not want to present here a full game: the one I present here is playable (in multiplayer) and will certainly be quite a fun for a while. I build it to be extensible. It should be possible to include the features you want to. Everything that is in there was provided in order to make this also your game.

It should be noted that there are many problems arising when trying to program such a game with a multiplayer mode. What about latency? What kind of messages are sent and received? Is logic done on the client as well or only on the server? My approach is kind of simple for this example project. However, my goal is to present this approach and tell you about its advantages and disadvantages as well as how to get rid of those.

Every client will send keyboard input shortly before it gets evaluated to the server. The server then distributes the input to the other clients. So everyone will see the same actions. This has the advantage that the game remains nearly unchanged to the single player except that messages do have to be sent before logic is evaluated and except messages can be received which result in additional logic being done. However, there are several severe disadvantages - namely:

• If one client lags, he will receive the logic too late and not be able to see the actions of the opponents.
• Even worse, if messages from this client are not distributed in time n messages from one client will not be sent to the other clients. So the other clients will probably just see one message - the last one being sent. Instead of taking some turns and making some shots, only the last action will be seen resulting in a game that is out of sync.

In order to prevent the syncing problem, every spaceship is sending its current life status and its current position to the server. This data is then distributed to the other clients. This again has some disadvantages:

• One could cheat by altering the own spaceship's life and ammo properties.
• Particles that have been shot are not included, i.e., here the keyboard actions are really crucial.

Most of these disadvantages can be tackled with the following approach:

• The game's important logic is being executed on the server only in multiplayer.
• The game's not so important logic (like moving an asteroid) is also done on the client.
• The clients are only responsible for drawing and sending keyboard commands.
• The server collects one round of keyboard commands - it will not send the keyboard commands unless everyone has send the keyboard data.
• The clients loop is still send to 40 ms but does only send the keyboard information (in multiplayer).
• The rest is done if all the keyboard commands are received. So everyone will stay in sync for sure.

This approach has several advantages. First, if a new player joins, the server can give all required objects including coordinates to the client. This is possible since the server does execute logic by itself - knowing all the positions. Also the server just executes one logic step after it received all keyboard commands. So instead of relying on total time (which is sometimes good but mostly bad), it would rely on synchronized time.

...

Using the Code

In order to use the code, you do not have to do a lot of things. However, I need to distinguish between the singleplayer mode and the multiplayer mode. The singleplayer mode should run in your browser (if it is not too old!). I tested the game in the following browsers (singleplayer mode):

• Microsoft Internet Explorer 9+
• Opera 11.5+
• Google Chrome 16+
• Apple Safari 5+
• Mozilla Firefox 7+

Since the singleplayer mode is trivial to play around with - let's take a look at the multiplayer mode. First of all, you need to know that in order to run on your webserver, you probably need to set certain firewall settings. Even if you set them, you should take into consideration that the client side probably sits also behind a firewall (from the local router, your computer, ...). So in order to guarantee a connection, you need to choose your port as well as your testing methods carefully. Otherwise you can do the following:

1. Open the provided Visual Studio 2010 solution.
2. Change the line with new WebSocketServer("ws://localhost:8081"); the port you want to pick (instead of 8081).
3. Open the file sockets.js.
4. Alter the line with new WebSocket('ws://localhost:8081'); by replacing both, the port you want to use (instead of 8081) and the IP address or DNS name of the computer (e.g. replace localhost with 192.168.0.1 or example.com).
5. Host the HTML/CSS and JavaScript files either on a local server or on the internet.
6. If you execute the server program in a local network, then serving the HTML code over the internet does not make much sense - however, it should still work if you execute the page locally.

The last two points are quite non-trivial. Why do you still need to host the page on a server (e.g. localhost) instead of hosting the website in the filesystem? The problem is security. Most browsers do have a security setting preventing websites to execute things when being hosted on the local filesystem. Google Chrome does not WebSocket requests from locally hosted websites. The same is true for most XHR requests and other features (like WebWorkers). Some browsers offer options in order to adjust those settings. Since I don't know your browser, I just assume you have a browser that is capable of WebSockets and give you a set of instructions that should work for sure!

Here's a snap of the Server Solution;

If you're thinking about how you can use web sockets in your game or site, this is an interesting and easy to follow example...

Scientists Hack Kinect to Study Glaciers and Asteroids

SAN FRANCISCO — Last summer, Ken Mankoff shimmied through zero-degree water and mud into a small cavern underneath Rieperbreen Glacier in Svalbard, Norway, holding a Microsoft Kinect wrapped inside a waterproof bag.

Using the little toy, originally meant as a motion-sensing device for the Xbox 360 videogame console, Mankoff scanned the cave floor in 3-D. During the summer, water from lakes on the glacier’s surface had gushed through the channel he was sitting in. The Kinect was going to provide a better understanding of its size and roughness, which could help researchers predict how the ice above would flow toward the sea.

“I’ve always enjoyed repurposing cheap devices, doing things that you’re not supposed to do with them,” said Mankoff, a NASA-funded Ph.D. student at the University of California, Santa Cruz, studying ice and ocean interactions. “You know, the hacker ideals.”

He is currently a bit of an evangelist for the Kinect, trying to get scientist interested in using the device, which can record very accurate 3-D data in visible and infrared wavelengths. As part of this, he presented a poster of his work here Dec. 8 at the American Geophysical Union meeting in San Francisco. The poster drew strong crowds and piqued the interest of at least a dozen researchers.

...

We’ll put the Kinect through its paces in the lab to make sure it’s up to snuff,” he said.

The Kinect’s best asset may be that it inspires students, Tedesco said. Rather than a daunting black box with convoluted cables and arcane software, the Kinect is something that many students are already familiar with.

“This creates a different mindset in students,” he said. “They’re not so scared about using the Kinect, and they can really get involved in learning and basic research.”

Project Information URL: http://www.wired.com/wiredscience/2011/12/hacked-kinect-science/ [Found via How Scientists are Using Kinect]

We've all seen QR codes around, they are appearing on sites, in print, on TV and even tattoos. Four months ago we covered one way to consume them in a Windows Phone 7.1(5) app, Window Phone 7.5, ZXing and QR codes. Today we're going to highlight three other QR Code projects, one that will help you create them and two other ways to consume them in Windows Phone 7.1(5) apps.

QrCode.Net

Project Description
The goal of the project is provding an easy to use, fully managed .Net library for handling QR code according to ISO/IEC 18004. Following features are planned: encoding, rendering (to: screen, file & stream), decoding, detection & recognition, artistic QR code.

The Goal of the Project

The goal of the project is to provide an easy to use, managed .Net library for:

1. Crating QR code bit matrix from text – encoding.
2. Rendering of QR code bit matrix to screen, into an image file or stream.
3. Rendering of so called "artistic" QR codes (see below).
4. Decoding QR code given as bit matrix.
5. Detection and recognition of QR code captures.
6. The library should support Windows Phone 7 and Silverlight

 

Just launched another open source project QrCode.Net at qrcodenet.codeplex.com

Background

Recently I was looking for a .NET implementation of QR code generator. Most of components either use online services to generate and/or recognize QR code or the implementation was not “good enough” for my purposes. The most popular and very powerful Java implementation comes from google’s open source project code.google.com/p/zxing called ZXing (Zebra Crossing => Z=Zebra + X=Cross + ing).

There I found a one-to-one c# port of earlier version. The project is focusing on additional features and further development in Java so it seems that no one is taking care of c# branch.

Thus I have decided to set-up this project QRCode.Net – qrcodenet.codeplex.com.

As a start point I took a straight forward c# port of google’s QR code implementation from ZXing project.
I wrote a wrapper around and a demo application which is able to generate QR code from text as you type and save it to file.

In addition it contains a very naive and simple implementation of Artistic QR code generation. At the highest error correction level it is possible to create artistic QR codes that still scan correctly, but contain intentional errors to make them more readable or attractive to the human eye, as well as to incorporate colors, logos and other features into the QR code block.

Here's a snap of the app running;

And the Solution from the latest check-in (which ran for me the first time with no issues);

Now that we've generated a QR Code, let's look at reading it...

Creating a QR Code Reader App for Windows Phone 7

If you’ve updated Windows Phone 7.5, you might have noticed that it has some nice built-in functionality for reading QR Codes using Bing Vision search. After trying it out for a while, I pretty quickly started wondering how I could use this in an app, and equally quickly I was disappointed to find that there are no APIs available for 3rd party developers to access this feature.

After a short hunt online, I found an excellent library that can be used as an alternative, and I built a simple reader with it. Here are the basic steps to create one yourself:

• Create a new Windows Phone Project in Visual Studio
• Update the App Manifest
• Create the QR Reader Window and Output Area
• Directives and Variables
• Handle Navigation
• Add Camera Event Handlers
• Download the Barcode Library
• Add the Barcode Library to the Project
• Decode the QR Code Image
• Compile and Deploy

This project used a barcode library that I don't think I've seen before, messagingtoolkit-barcode

MessagingToolkit Barcode library is a C# barcode library that can be used in standalone Windows applications, ASP.NET web applications, and Windows Phone 7 applications.

The library current supports encoding and decoding of the following barcode types

Encoding

• QR Code
• Data Matrix
• PDF 417
• Bookland/ISBN
• Codabar
• Code 11
• Code 128
• Code 128-A
• Code 128-B
• Code 128-C
• Code 39
• Code 39 Extended
• Code 93
• EAN-13
• EAN-8
• FIM
• Interleaved 2 of 5
• ITF-14
• LOGMARS
• MSI 2 Mod 10
• MSI Mod 10
• MSI Mod 11
• PostNet
• Standard 2 of 5
• Telepen
• UPC 2 Digit Ext.
• UPC 5 Digit Ext.
• UPC-A
• UPC-E

Decoding

• UPC-A
• UPC-E
• EAN-8
• EAN-13
• Code 39
• Code 93
• Code 128
• QR Code
• ITF
• Codabar
• RSS-14
• Data Matrix
• PDF 417
• Aztec

This library is based on the zxing library, with some additional features not available in the original code. You can freely use it for non-commercial purpose. To use it commercially, please consider making a payment to support this project here

And last, but not least, our third project of the day, a simple and re-usable QR Code control that makes adding QR Code consumption to your Windows Phone 7.1(5) app drag-n-drop easy

A simple Windows Phone control for reading QR codes

There are great libraries out there written or ported to C# that let us developers rock by standing on the shoulders of giants. Here’s one such project.

A phone developer who’s also an enthusiast of foursquare suggested a feature that I should add in a future release, and provided some sample code based on the zxing barcode library and the Silverlight port of it. I’m working on adding the new feature soon.

In the process I realized it would be a good and quick opportunity to ship such a simple but useful control to the phone development community, so I’ve gone ahead and pushed that control refactoring and implementation to GitHub, check it out: https://github.com/jeffwilcox/wpqr-control

Special thanks to Michael Osthege (@theCake, blog) for providing the initial contact, sample, and encouragement.

The control is nice:

• Drop it on the design surface
• Wire up the ScanComplete event (and optionally the Error event)
• The control handles all the underlying image manipulation, scanning work, PhotoCamera initialization, etc.

Here’s what a simple sample app looks like in use. The control includes default border thickness and coloring properties that use the accent color and provide a nice visual separator:

• 
• ...

  Building the sample app

  All I did to build this app was drop the control into a new Windows Phone app project and wire it up. Here’s how.

  

Hopefully, with these three projects and the information and resources they provide, adding QR Code support to your apps should now be that much easier...

Anyway... Today's project is one that we mentioned a few months ago, Building your own hand-held game console with, Netduino, C# and the PIX-6T4 project, but until just recently wasn't one you could really start playing with yet. Well the wait is over and you can now get your own...

PIX-6T4

The goal of the PIX-6T4 kit and its companion book (coming soon) is to teach you how to use 'Electronic and Software Building Blocks' to become a Skilled Maker and, optionally, a Mad Scientist.

This little console can be programmed in C# and is a perfect learning tool for an initiation to both microelectronics and game programming. It is also a development board, with easily accessible pins.

The kit comprises the following parts:

• Netduino Mini: this is the heart of the system, a micro-controller running the .NET Micro Framework
• AS1100PL LED Driver: this little chip receives the data to display from the Netduino and uses it to turn the LEDs on and off.
• LED Matrix (8x8, red): this little and cost effective display may not have color or high definition, but the great thing about it is that you can actually understand exactly how it works.
• SD Card Socket: the PIX-6T4 console uses standard SD card as mass storage. SD cards are game cartridges, with each card containing many games. The SD card itself is not provided.
• 2 x Analog Joysticks with built-in switch: when we designed the console, we thought a lot about minimalism. This is why we did away with buttons entirely, replacing them with two clickable sticks.
• Speaker
• 2 x 24 PIN DIP Socket: each integrated circuit is mounted on sockets so that you can replace them should anything bad happen.
• Power LED (any color)
• Voltage Regulator (3.3v)
• Power Barrel Jack, Inline DC Power Plug & 9V Battery Connector
• Printed Circuit Board
• Acrylic Case Bottom
• 4 x Stand-Offs & 8 Screws
• Power Switch
• Break Away Header: gives easy access to all the Neduino pins for easy testing and extensibility. This makes it possible to use the PIX-6T4 as a development board.
• 2N4403 PNP Transistor
• 6 x 10K Resistors
• 1K resistor
• 2.1K resistor
• 54.9K resistor
• 100µF Electrolytic Capacitor
• 0.1µF Ceramic capacitor

http://www.pix6t4.com

• Build your own Video Game Console
• Join the Maker Revolution
• Use your console as a Turn-Key development board
• Discover the power of Netduino by 'Secret Labs'!
• Learn C# Programming
• Have fun building your own Games

The goal of the PIX-6T4 and its supporting companion book is to teach you how to use 'Electronic and Software Building Blocks' to become a Skilled Maker and, optionally, a Mad Scientist

To achieve this, we'll break down for you the process that we followed when we set out to build a simple video game console from readily available parts. Why a video game console? Because they're fun!... because a game console touches on many fundamental electronic concepts. In addition, a game console offers countless possibilities for learning how to write software: dream up a game and build it yourself by following our examples and techniques.

We chose the Netduino over other types of microcontrollers simply because the programming skills that you will learn on the .Net Micro Framework, as you discover the Netduino, will also be applicable to the full-featured .Net Framework used to build professional applications, large scale web services, mobile applications running on phones and web applications. Our hope is to empower you with life skills that can help you build a career or just build anything you can think of.

Last but not least, the Netduino community and the .Net Micro Framework embrace the open-source / open-hardware philosophy and whether you're a Mac or Linux user, the .Net Micro Framework is very relevant to you, thanks to the Mono Framework and its suite of development tools.

Where's the code in this Coding4Fun post?

The PIX-6T4 Source Code

The PIX-6T4 code is open source and is part of the netduino helpers repository on CodePlex.

The projects that you will need to build are located in the \Samples\PIX6T4 folder:

The Brain

• ConsoleBootLoader: is the program that runs when you turn on the console. Its job is to read the content of the SD card, looking for game modules for you to select in a main menu. When a game is selected, it is dynamically loaded from the SD card and starts. When the game ends, the player is brought back to the main menu.

The Games

• Paddles: is a two player game of Ping Pong. Each player controls a paddle with one of the analog joysticks of the console, trying to hit the ball back to the opponent. A player scores a point when the other misses the ball.
• MeteorsFromOuterSpace: is a game where the player controls the movement of a small ship with the left stick of the console, and fires at meteors coming from all directions with the right stick. To shoot a meteor, just point the right stick in its direction
• Tunes: is a simple application playing the Pacman theme song.

To get you started quickly with your console, you can just download these applications. Then, open up the .zip file, place the folders that are on it on an FAT32-formatted SD card. Finally, insert the SD card in your PIX-6T4 console and play.

Digging Deeper

If you want to explore how the 'layers of the cake' really work, you should dig into the pix6t4.netduino.helpers project:

• \Fun: abstracts the hardware away from the game code. It also provides a small framework to write your games simply and efficiently.
• \Hardware: contains all the drivers for the hardware components used to build the console.
• \Helpers: contains the resource loader used to read and execute games from the SD card
• \Imaging: provides an interface to build your game world, create and display sprites, test collisions between objects and display small and large fonts.
• \Math: a library of trigonometric functions, frequently needed when building games.
• \Sound: provides a simple method to play tunes using the standard Nokia RTTL ringtone format

Digging even deeper...

But wait, there's more! The pix6t4.netduino.helpers library is only a subset of the larger netduino.helpers library which contains drivers and sample applications for many more devices.

If you're looking to build something cool and fun and yet pretty cheap, you don't have to look much farther than the PIX-6T4...

Guide to Kinect and common problems (updated for beta 2)

I decided since people keep asking about the same questions over and over again i will make a guide. Note: some things work for different people and as this guide grows its depth will grow too to include the solution to your common problem.

Common checks to help solve problems:

1. Check where your kinect is plugged into and if all cables are hooked up. For instance, The usb ports on the back are all connected to the same hardware hub inside of the computer so sometimes any other device can conflict or draw power away from kinect if its plugged into the back. Also, the power cable which is sometimes a separate component needs to be hooked up to kinect for programming on the computer.

Project Information URL: http://social.msdn.microsoft.com/Forums/en-US/kinectsdk/thread/d0eeb269-2c3f-4a40-8b65-9d6b8dcae147