To sum it up… I have been working my rocks off. Incase you haven’t read my LinkedIn profile, I’m working as a serious game software developer at a research company that primarily focuses on US Army dismounted infantry simulators. We have a demo coming up in September so we’re all pretty strapped for time while trying to make this demo as clean and bug-free as possible.

One of the more interesting aspects of my work lately has been using motion capture equipment to retrieve realtime data about the anatomical positions of bones and joins throughout the body in order to get a computer (NPC, non-player character) to recognize what the user is actually doing with their body. In essence this is gesture recognition. Much like speech recognition, it is the process of looking for patterns inside of a set of input data. This input data however is not a sound-wave. It is a huge sequence of 3D vectors and Quaternions (for the bone positions and orientations) and a long sequence of values between 0 and 1 for the fingers.

The finger data is captured using a glove that has potentiometers (variable resistors for the layperson) that react to the closing and opening of each finger along with the abduction between each digit on the hand (thats the webbing between your fingers). The rest of the body is measured using accelerometers, g-force sensors, and compasses placed in key locations on the human body. As the body moves it creates various changes in this data which is translated into 3-dimensional vectors for position and 4-dimensional vectors (Quaternions) for orientation.

This data is then sent through a processor (the software I’m working on) which looks for patterns in the data and attempts to match these patterns with pre-recorded “template” gestures. The match with the highest confidence level wins out and ultimately becomes what is deemed recognized by the NPC.

This recognition is then tied to key events in the training software such as directing your squad of NPCs to clear a building, freeze, follow (in various formations), or commence firing among many others. The other purpose for recognizing when a gesture has been made by the user is for locomotion through the virtual world. This means the user of the system can walk around in the virtual world, fully immersed in the equipment, and not move outside of a 6ftx6ft square on the floor. Its pretty remarkable what we’ve been able to accomplish with this.

It still has some distance to go before it is production ready, but these early tests look very promising. It has been quite a task to figure out this problem. In the process we have all learned how complex the human body really is and what we as humans take for granted in terms of how we move and act. The human body and brain is a very remarkable feat of biological engineering.

The above code will add the ‘findObject’ method to your Array objects. Then you can use that instead of indexOf() and be guaranteed that it will work regardless if the browser supports indexOf or not.

The second one (deep copying) can be circumvented by creating a helper method which will perform the copy for you:

Just thought I’d share those with everyone. Credit for the majority of the deep copy code goes to http://blog.pramatiservices.com/deep-copy-in-javascript/ and credit for the findObject code goes to someone other than me, but I didn’t bookmark the link so I can’t find it again. Sorry

I just thought I re-post this incase anybody stumbled upon my blog before they landed on the Microsoft page that had the fix for IDE crashes. I experienced this only one time when I was moving/undocking windows.

Enjoy.

Basically it takes a set of input data, containing multiple entities (rows), each with multiple properties (columns), formatted from some type of delimited text file. Then it takes in a master template file and spits out multiple “data-injected” versions of that template.

View the full page here.

CTask-Lite is an easy to install, configure, theme, and use task management system. It is aimed at tiny teams working on ‘open’ projects. What I mean by open is that they don’t care who sees what (because there is no user/role management capability in it).

The Wiki for CTask-Lite is here:  http://wiki.github.com/cdunlap/ctask-lite

Spread the word! Download it, use it, mangle it, hack it, fork it, etc.

I checked out Google code, where I have placed several projects of mine. I successfully created a project, but when I’d try to check in the code, the SVN server wasn’t available. At the same time, I’d try to click the “Source” tab on the project that I just created and I’d get an HTTP 500 from Google (which is incredibly rare). So I marked that project for deletion from Google Code.

Then I went over to Source Forge. Source Forge is having issues. I couldn’t get their site to load at the time that I tried, again, HTTP 500 errors. Though I did get an email from them a few days ago saying they were going to be pushing a new UI to their site soon. The email said the service interruptions were only going to be for a few minutes at the most. Lets just say it was more than a few minutes, so I scrapped that idea.

Then I remembered a guy at work recommended GitHub. I’m really new to Git and so far I don’t like it. I find it more difficult to use than SVN–though it is faster by far. So I get the code put up on GitHub just fine, but now I can’t edit the repository details in the admin area. Every time I try to change the project website or description it responds with “Name is already taken”. Ok, minor annoyance. Ignoring that, I went over to the downloads area to upload my ZIP containing the final v1.0 build of the project. It gets 100% done and then I get a HTTP 500 from GitHub. I try to go back to the project page but now I’m getting a HTTP 500 error anytime I try to do anything with my project. Not all of GitHub… my project page. I seem to be the only one affected by this.

So, I’m a bit frustrated at the moment. I guess I’ll start working on one of my closed-source projects and call it a night.

Lately I’ve been in “endian-ness” hell on a project I’m working on. Well, not really a “hell”, more of a hurdle that can easily be overcome. A friend of mine recently asked me the difference between the two binary encoding strategies and when I went to explain it to him (via cell phone txt messaging) I quickly realized that I will run up both our bills pretty quickly by doing so. So here’s the quick rundown, and an example as it applies to the project I am working on.

Big Endian means that value is stored “from left to right”. The most significant values (bytes) are stored in memory with the lowest address first. This is probably what many people are familiar with, especially those in the networking field.  Here’s an example of data stored as Big Endian:

Take for instance the 2-byte value 1325, equivalent to a short or unsigned short. Stored in Big Endian encoding, the value would look like this in binary: 00000101 00101101. Makes sense right?

Now here is the same 2-byte value, 1325, in Little Endian encoding: 00101101 00000101. The bytes are flipped and thus to make any sense of it, you must read the last set of bits first.

So for simplicity’s sake, Big Endian values are stored like so:

<byte1> <byte2> <byte3> <byte4> ... <byten>

Little Endian values are stored like so:

<byten> ... <byte4> <byte3> <byte2> <byte1>

Network devices use Big Endian, it is considered the network standard, or “network encoding”. Endian-ness varies from CPU to CPU depending on its architecture. Power Macs use Big Endian, network devices use Big Endian. Intel PC’s (and Intel Macs) use Little Endian. What does that mean? Well, it means that if a program running on a Power Mac sends data to a PC, the PC may not understand it correctly without some type of encoding change taking place.

In my situation, I’m reading a series of values off of the network, all coming in via a byte stream. So the client will send the following packet for example:

4 bytes, 2 bytes, 1 byte, … and some others but I won’t get into them

So when I read the first four bytes off the network (which uses Big Endian encoding, remember?) I must flip the entire set of 4 bytes before my Little Endian PC can understand it.  Same goes for the next 2 bytes. The single byte obviously doesn’t need to be flipped with anything, it stands alone. So an incoming set of data may look like:

0x1A 0x2B 0x3C 0x4D 0x2A 0x2B 0xAD

Now I must flip each set of values byte by byte (but not invert the entire thing; this is a packet, containing multiple values).

In Little Endian, the same set of data reads:

0x4D 0x3C 0x2B 0x1A 0x2B 0x2A 0xAD

Confused yet? You’ll figure it out. Here’s some reading that should help: http://en.wikipedia.org/wiki/Endianness. It even gets into the origins of the word, which is pretty interesting. Here’s a little tool that may help you understand the pattern: http://dlnova.com/reverseendian.htm

Check out the Screenshots.

KnowIT works with Windows ONLY. There is currently not a Linux/UNIX scanner available for KnowIT, and the database back-end is a Microsoft product (MSSQL 2005). However, I did add ODBC support this time around, so it may work on other database types as well. If anybody gets it to work on MySQL or Oracle, let me know.

I’m looking for any pointers, contributors, or experts to make improvements or recommendations to the code. So please check it out. If you’re interested in contributing, please send me an email at cale@caledunlap.com so I can add your Google account to the members list.

And if you haven’t already, check out http://www.venomgamelabs.com!

Now for your entertainment for the evening:

www.youtube.com/watch?v=FRgYtp3HfvY

So in my years being trained on data architecture and database design, I learned to "normalize, normalize, normalize". Unfortunately, normalization doesn’t lend itself to very simple statistical calculations–such as those used to generate graphs or a statistical scorecard.

In the case of Angel, I’ve normalized the hell out of the data. Now it comes down to needing to report on that data. At first, my reporting attempts were terrible–tons of nested loops, many queries, etc. Well, when I spoke to a colleague of mine at work, he said that if I was running on an SAS Mainframe, the work would already be done for me using a function called "PROC TABULATE". He sort of dated himself by saying that.

Then I broke the news to him: I’m not using SAS, or any other mainframe technology. He replied by suggesting I look into some sort of MySQL equivalent to that function. So I started hunting. I came across this very nice article: http://dev.mysql.com/tech-resources/articles/wizard/print_version.html

That article shows, very effectively, how to create a nice "statistical" report using cross-tabulation techniques with normalized source data. The queries are sort of monstrous if you have a large number of fields to report on, but at that point, you’d be using code to generate the parameters for the SELECT statement.

Here’s my example:

My source data looks like the following–please note that some results are truncated because the result set would be WAY too large for a blog:

mysql> select uid, Email from players;
+-----+--------------------------+
| uid | Email                    |
+-----+--------------------------+
|  10 | brian@venomgamelabs.com  |
|   4 | cale@caledunlap.com      |
|   1 | cale@venomgamelabs.com   |
|   9 | daniel@venomgamelabs.com |
|  11 | dave@venomgamelabs.com   |
|   5 | jane@venomgamelabs.com   |
|   8 | janes@venomgamelabs.com  |
|  12 | jill@venomgamelabs.com   |
|   6 | john@venomgamelabs.com   |
|   7 | johns@venomgamelabs.com  |
+-----+--------------------------+
mysql> select * from gamedata LIMIT 10;
+----------+---------+------+
| playerid | fieldid | data |
+----------+---------+------+
|        1 |       3 | 60   |
|        1 |       4 | 1    |
|        1 |       5 | 1    |
|        1 |       6 | 286  |
|        1 |       7 | 1    |
|        1 |       8 | 13   |
|        1 |       9 | 1    |
|        1 |      10 | 1    |
|        1 |      11 | 261  |
|        1 |      12 | 13   |
+----------+---------+------+

mysql> select FieldID, FriendlyName, GameID, FieldTypeID FROM gamefields;
+---------+---------------------------------+--------+-------------+
| FieldID | FriendlyName                    | GameID | FieldTypeID |
+---------+---------------------------------+--------+-------------+
|       1 | Play Time                       |      1 |           2 |
|       2 | Last Character                  |      1 |           1 |
|       3 | Total Eggs                      |      4 |           2 |
|       4 | Total Playtime                  |      4 |           2 |
|       5 | Total King Of The Hill Captures |      4 |           2 |
|       6 | Total Kills                     |      4 |           2 |
|       7 | Total Deaths                    |      4 |           2 |
|       8 | Engineer Playtime               |      4 |           2 |
|      10 | Mongo Playtime                  |      4 |           2 |
|      11 | Grunt Playtime                  |      4 |           2 |
|      12 | Gladiator Playtime              |      4 |           2 |
|      13 | Total Powerup Uses              |      4 |           2 |
|      14 | Total Powerups Received         |      4 |           2 |
+---------+---------------------------------+--------+-------------+
mysql> select typeid, typename from field_types;
+--------+------------------+
| typeid | typename         |
+--------+------------------+
|      1 | Text             |
|      2 | Numeric          |
|      3 | Game Coordinates |
|      4 | Boolean          |
|      5 | Physical Address |
|      6 | IP Address       |
+--------+------------------+

What I want to know from that data is how many players have field values within specific ranges–to generate some input data for a chart output. The code I’m using does the following math (from a separate query):

1. Find the minimum value out of all of the player data for each field (SQL Query)
2. Find the maximum value out of all of the player data for each field (Same SQL query)
3. Get a "standard deviation" between the number $StandardDeviation = floor( ($High - $Low)/NUM_DEVIATION_RANGES );
4. Begins a SQL query and assembles a list of parameters to select (based on the deviation ranges)

   for $i = 0 to NUM_DEVIATION_RANGES
   $Min = $Low + ($StandardDeviation * $i)
   $Max = ($Min + $StandardDeviation) – 1;
   $Query .= “SUM( IF( CAST(gamedata.Data AS UNSIGNED) >= $Min AND CAST(gamedata.Data AS UNSIGNED) <= $Max, 1, 0) ) AS ‘$Min-$Max’,”;
   end for

5. Runs the query, obtains a single result per field and feeds it to the chart to render a per-field graphical analysis chart.

The output of the query from step 4 is as follows:

Now that query runs once per number of fields requested. The above query was just a single query for a single field. Note how the code generated the SELECT statement parameters (min and max) and set them as the column header in the result?

The result of that query looks like this:

+-------+--------+---------+---------+---------+---------+---------+---------+---------+---------+
| 60-87 | 88-115 | 116-143 | 144-171 | 172-199 | 200-227 | 228-255 | 256-283 | 284-311 | 312-339 |
+-------+--------+---------+---------+---------+---------+---------+---------+---------+---------+
|     2	|      0 |	 2 |	   0 |	     1 |      0	 |	2  |	   0 |	     1 |       0 |
+-------+--------+---------+---------+---------+---------+---------+---------+---------+---------+

So the output is exactly what I need for my chart. The result fields represent the X axis of the chart, and the result values represent the Y axis of the chart, all from a single query against normalized data using cross-tabulation.

I urge you to click on the link I mentioned near the top of the article if you want to learn how to do this. My example is fairly specific to my situation. That article showed me exactly what I needed to do, but I needed to apply it to my data and my reports.  You’ll notice that I’ve used CAST’s in my query. The reason being that in order to accept any type of data, I’ve used the ‘TEXT’ type on my game data fields–that’s why I also have a type table and a type ID in the field types. I then query what types of fields is numeric, and only perform my calculations against them.

Doing cross-tabluation/pivot tables isn’t too bad once you know what you’re doing. I had a tough time wrapping my head around it, but after a few hours of tinkering, I finally got what I was looking for. Another thing to note is that I’m summing up 1′s and 0′s, basically a tally. If you want to sum up your real data, don’t use 1′s and 0′s; use your actual data field.