It’s easier to ask forgiveness than it is to get ACL permissions

Access control lists are complicated. Granting permissions to certain people for specific objects can become a jumbled mess. And what if you need object level permissions? This session will help you sort out the basics and give you tools to extend your permissions to fit your application.

Covered:
Basic ACL structure
Strategies for handling complex scenarios
Customizing beyond ACL

Thank you to all who attended. I have posted my code on github.

http://github.com/electricpineapple/CakeFestAclDemo

Thanks to everyone who attended RIApalooza 3 in Chicago, IL and to everyone with great questions.

www.youtube.com/watch?v=IGZf0Vgp-sY

The time came to renew our cable subscription (promotional period was ending) and we decided our usage did not justify keeping the television portion of our cable bill. We also receive our broadband through the cable company and so we debated other broadband offerings but as in most places, the options are limited to cable or telephone providers. Cable was going to give us the speed we wanted to stream all of our video online, so we just downgraded our cable service.

A few months before, my wife upgraded here laptop and we had a spare lying around that I moved straight to the entertainment center. The specs are not that impressive but it was a spare:

• Acer Aspire 5630
• Processor: 1.6GHz Core 2 Duo T5200
• Memory: 1GB DDR2
• HD: 120GB hard drive
• Optical: Double-layer DVD±RW
• Graphics: Integrated Intel GMA 950
• OS: Windows 7 Home Premium (upgraded)
• 1 Tb attached USB external HD

Around the same time we also upgraded our display (television) to an internet connected model (Vizio Via SV472XVT). I wanted to see first hand the capabilities of the integrated widgets which I had previously talked about here.

I first experimented with Windows Media Center. I “looked” on every dvd I owned for a “digital copy,” and if there was one, I put in on the computer so I could access it through WMC. I also installed the Media Browser plugin, which gave me the ability to obsess over all the meta data associated with my movies. I also grabbed the Hulu desktop plugin which gave me some amount of streaming capability. The Hulu selection paired with antennae reachable stations (network, PBS) was not quite enough coming from our 57+ channels and nothings on. I decided to give Boxee another shot, having tried it prior and found that the pre-beta versions choking on most feeds. The new beta did not have the same stuttering issues that I found prior but did have some staggering that may be related to the video card or the cpu load. Boxee also offered a greater selection of television shows as well as easily usable apps. I was disappointed that Boxee did not offer any way to manually identify movies and other video data stored on my computer. I looks to be a greatly requested feature from the Boxee community and my OCD concerning extra meta data will hopefully be satisfied soon.

Toting a full keyboard and mouse around was not option for control so we looked to our mobile device to control, a Motorola Droid for both my wife and myself. Since I had decided on Boxee, we went for the Boxee Wifi Remote from Sunil Sadasivan (qr code below).

I am still interested in the upnp server concept that would act as the media server which Boxee mangled in its current form from the XMBC code base. I would also like to upgrade the hardware of the system to get a smoother video playback and I question adding a Bluray drive at this stage because streaming/online HD content is still too rare. I do think that the disc model will go the way of the PC software CD-ROM. Looking at content, there are very few live streams of any cable or network content and bandwidth is still too much of an issue to try to ease compression on the online streams. I’m sure I will have more to say about dropping cable in the future but for now, I love tinkering with my system and do not miss cable even with the occasional video stutter.

Boxee remote qr

First Rovio needs to know where home is. To do this we use the beacon on the base station and optional extender beacons. On the topic of the extender beacons, the single home beacon has more strength than reported in the web interface. Using the api you can see the signal strength (ss) using the http://xxx.xxx.xxx.xxx/rev.cgi?Cmd=nav&action=1 command. The higher the better we found a number above 5000 seemed adequate to get Rovio home. This beacon also projects its beam onto the ceiling and in doing so projects an oval shape with the two dots being the ends of the oval. In our situation we also needed multiple docks which turns out to cause trouble because all dock ids are set to number 0 and are not changeable. The extender beacons allow multiple id but the docks do not respond to anything but 0 as home. The solution is to only use one 0 beacon and place the docks at least 2 feet apart. Rovio only uses the beam on the ceiling to get right in front of his own home. With home positions set independently on each rover they will navigate to right in front of their home and then use the small dot on the top arm to get into the dock. We ended up using photography lens caps to cover the other beacons.

The documented battery status in the api is 0-79 is not charging, while 80 indicates a charging state. After some discussion with Wowwee, we got a few more statuses:
80: charging
72: is in the dock fully charged (not charging)
64: status when the Rovio docks but is not charging yet, usually right as it hits the dock
0: not charging
It’s not a ton of new information but does help when dealing with some automated docking.

The experience that was designed did not involve 5 year olds needing to navigate the Rovio back to the dock but relied on the application knowing how to get him back and move to another rover when ready. It was quite a twisted web of calls to the rover but it gave the rover the best chance at getting home to charge.

1. Poll the rover to check its battery level with the api call
2. If the battery level was below the specified level then continue with the checks
3. Switch the video stream to the next rover to prep streaming for the user
4. Tell Rovio to go home
5. Loop over the api call to see if the charging status is one of the acceptable numbers indicated above (80,72,64), if it doesn’t reach a number send the home request again
6. When one of the numbers is achieved switch the api call to the next rover
7. Check the next docked rover for its battery level
8. If that rover is too low, move to the next until a adequate charge is reached
9. Set timers in actionscript to allow for unreachable rovers to be passed over (this speeds up the process, rather than using error catching)

Shape and size: Using these characteristics and constructing custom object (similar to facial) recognition using opencv and haartraining the different objects could be “seen” by the rover. This ended up being a balance of accuracy and speed, of which neither was good enough to use in the application.

Position: Using the rover’s position, both location and orientation, the specific object could be determined from its coordinates. The numbers coming back from the rover, through the beacon, ended up being too cryptic and not reliable enough to give specific positioning information, especially for moving a precise onscreen target. There was also no way to get vertical movement information.

Color: Pairing a unique color with the object to be identified could allow color detection to run the brain of the rover. This ended up being the most streamlined and accurate approach to identifying object in the interactive. Using a vibrant red, green and blue gave enough differentiation between the objects to bring up specific prompts for each target. Running the color detection on the video stream and then creating a box around the identified color gave a specific position in the video frame. The target could then be positioned in the center of the box, and exceptions could be made for outlying false positives. Color scraps could be disregarded and focus could be on heavy concentrations of the specific colors. Below you can see the blue box (hidden when not in debug mode) surrounding the green colored image.

Lighting greatly impacted the color detection on the objects. Above is a picture of two of the colored boxes blacked out by the background window light. The objects needed to be lit from a reliable, consistent source of light. This light would have to be pointed on the object or what was done in this case from within the object. The targets were lit with colored light to attempt to nullify lighting differences due to sunny or cloudy days (the interactive being in a heavily windowed area). Below are images against the window areas. First, the transparent gels of the three different colors (the red needed some help and has a light behind it). Second is a stronger light competing with the self lit color cone.

Update (prior to posting):

After using the previous version of color detection where one color was identified, it was determined that this was a fickle method given external lighting conditions. The color detection was updated with the following:

For aesthetic reasons, the object was to be internally lit. When in the final space, the bulb was not colorful enough and was whitewashed in the rover’s view. We tried to use the colored gels and other manipulations but due to the fact that the rover was looking for one specific color we were not able to tune it in enough to be accurate. Take two.

Now we were looking for two objects. First a strong white light source, which is what we had and were trying to fight the first time, and then look below the light for a color. The first method was based on the blob detection outlined here by Tomek Augustyn (Og2t). This takes the video object, draws it to a bitmap object and then creates another bitmap object using the threshold method finding the brightest spots in the video. After singling out the brightest spots, we take some measurements of the individual rectangles found with getColorBoundsRect(). If they meet the minimum and maximum requirements for size, of which in this case the minimum height is a ratio of the width, then we look for the next piece of information.

Below the bright spot is a colored ring that can be averaged out and determined to be in a specific range. Using the technique outlined here by Justin Windle we have averaged out the ring color and can ask if the RGB values are in the range that we are looking for:

if((colorin >> 16 & 0xFF) < 0x5f && (colorin >> 8 & 0xFF) > 0x84 && (colorin & 0xFF) < 0xc6){do something}

If the color is in the correct range then we are displaying the found target icon over the bright area. This gives a bit more flexibility and accuracy in finding the correct targets.

Update (3/29/10):

You are witnessing the evolution of the color detection idea as it plays out in the physical space. The previous method, which relied on a strong light source, did not play out in a brightly-lit, white-walled space because the light source was buried in the sea of bright white wall behind it. I was able to scavenge the threshold method that was used previously and base the next method around that.

For each of the three colors we were looking for (red, green, blue), I ran the video through a couple of thresholds to filter out the precise color we were looking for. Red for instance uses these lines to filter out the red color from the background images:

aBitmapDataObject.draw(theVideoObject);
var pt:Point = new Point(0,0);
var rect:Rectangle = new Rectangle(0,0,aBitmapDataObject.width,aBitmapDataObject.height);
var threshold1:uint = 0x00004040; //green and blue values
private var color1:uint = 0xff000000; //turn this black for next threshold because it is greater than >
private var maskColor1:uint = 0x0000ffff; //mask on green and blue
private var threshold2:uint = 0x00600000; //red value
private var color2:uint = 0xffff0000; //change this to a indicating color (bright red) to mark
private var maskColor2:uint = 0x00ff0000; //mask on red value
//turn anything with green and blue pixel values greater than threshold1 black to filter out strong blue/green color
aSecondBitmapDataObject.threshold(aBitmapDataObject, rect, pt, ">", threshold1, color1, maskColor1, true);
//turn anything with red pixel values greater than threshold2 indicator color2 to find strong red
aSecondBitMapDataObject.threshold(aSecondBitMapDataObject, rect, pt, ">", threshold2, color2, maskColor2, true);
boundRectangle = aSecondBitMapDataObject.getColorBoundsRect(0xffffff, 0xff0000,true);

Here is the blue:

aBitmapDataObject.draw(theVideoObject);
var pt:Point = new Point(0,0);
var rect:Rectangle = new Rectangle(0,0,aBitmapDataObject.width,aBitmapDataObject.height);
var threshold1:uint = 0x00000099; //blue values
private var color1:uint = 0xffffffff; //turn this white for next threshold because it is less than <
private var maskColor1:uint = 0x000000ff; //mask on blue
private var threshold2:uint = 0x00440000; //red value
private var color2:uint = 0xff0000ff; //change this to a indicating color (bright blue) to mark
private var maskColor2:uint = 0x00ff0000; //mask on red value
//turn anything with blue pixel values less than threshold1 white to filter out weak blue
aSecondBitmapDataObject.threshold(aBitmapDataObject, rect, pt, "<", threshold1, color1, maskColor1, true);
//turn anything with red pixel values less than threshold2 indicator color2 because the blue does not contain red
aSecondBitMapDataObject.threshold(aSecondBitMapDataObject, rect, pt, "<", threshold2, color2, maskColor2, true);
boundRectangle = aSecondBitMapDataObject.getColorBoundsRect(0xffffff, 0xff0000,true);

After we have the boundRectangle we can use the technique previously mentioned from Tomek Augustyn (Og2t), to check for height and width sizes or ratios. And the color averaging method to weed out false positives by Justin Windle.

Download Flex Builder 4 Project – Simple color detection

Download Flex Builder 4 Project – Complex color detection

Not only did the robot need eyes, he also needed to be able to recognize what he was looking at. The objective of the interactive was to have young children track down specific objects on a surface. To give them a prompt and to make the video of the surface a bit more interesting, a target was to be overlayed on the video pointing to where the object was. This meant that the Rovio would need to distinguish between the unique objects on the driving surface. So what set the objects apart from each other? More in the next post.

Recipe for robot eyes:

Wowwee Rovio
Red 5 video server
Flash netstream/video objects

Download Flash Builder 4 Project – Using consecutive jpg images, choppy

Download Flash Builder 4 Project – Using red 5 connection

A year ago I published a post about widgets coming to the television. A year later I have widgets on my TV. Now that I have experienced the widgets first hand, there is not much change to my feelings about the basics of the previous post.

There is still no bridge between the cable content coming over the wire and the widgets on screen. Widget content cannot be populated by on-screen cable content. This leaves out advertising tie-ins and related content that would be automatically populated.

There are however widgets for pulling video content from online. This enables the content to interact with additional features. The main downside to the online content is the timeliness of the content in comparison to traditional counterparts. There is very little to no live television content being delivered through the widget interface, or anywhere online. Any online movie rentals or purchases are delayed by at least a month compared to in-store movies.

HD is another problem area for online content. There are allot of bits to move for HD content and until broadband infrastructure is in place to handle the content, a coaxial cable is the only option.

Online content delivery still needs time to develop and find a viable business model. Timely content will not be allowed to move to an online market unless it promises not to threaten the more profitable traditional models, and until timely content is delivered people will still want cable/satellite and physical dvd rental.

1. The interactive needed a custom interface so the built-in web interface (and keyboard controls) would not work.
2. The interactive needed to be accessible to children as young as 3 years old.

The custom interface was built with ActionScript3 and so to move the rover, the api was used. With the api, the rover could be sent movements via http requests. These api requests needed to be mapped back to user input and so the web interface was recreated in with as3. The ASDW keys were mapped back to specific movement requests via the api. This is a specific piece of code initiated by a keypress that gets sent to the rover:

switch(e.keyCode){
//forward
case 87: //W key
drive = 1; //1 maps to forward
speed = 1;
request.data = "Cmd=nav&action=18&drive=" + drive + "&speed="+speed; //action 18 is manual drive mode
loader.load(request);
break;
}

The drive variable signals the command/direction for the rover (forward, backward, rotate right) and the speed variable is how fast the command should be executed by the rover. Sending one of these http requests would move the rover a fraction of an inch. Mapping each key to a specific movement and sending multiple commands successively reproduces the motion of the built-in interface. This does not remedy our problem of simplifying the interface for 3 year olds. This is where the custom hardware comes in.

Our custom hardware consists primarily of a joystick but also includes some auxiliary buttons for game functionality which I will describe in a following post. The hardware came from Suzo Happ and also included a UGCI board for USB interface. The UGCI board had an included key-mapping utility which was used to map the joystick and button contacts to key presses. A constant connection with the joystick in any direction sent a repeating key press rather than a key up and down.

With key presses mapped to the joystick control and to the rover’s api through actionscript, the rover could now be driven with custom joystick controls. Now if only our rover could see…

Download Flash Builder 4 Project

Over the past months at work I have been taking a consumer mobile webcam (robot) and converting it to custom interactive experience. Over the next couple of weeks I will be talking about some of the finer point of taking an off-the-shelf WowWee Rovio (which comes with some fine built-in features) and transforming it into something much more. I will be talking about the following modifications in the coming weeks:

• Custom hardware controls
• Processing the video stream in Flash
• Object detection
• Docks and Beacons

This is on the side of the Rovio box:

I will be proving this incorrect.