Ben's Log

PiSeg Arduino Project

Ben Snider — Mon, 06 Feb 2012 22:31:00 -0500

View the sketch for this project itself, along with the Fritzing file, in my GitHub repository.

This simple sketch displays the first 8 thousand or so digits of PI on a 7 segment LED from Radioshack. The LED display is done nicely with a byte encoded segment value, where each bit turns a segment on or off. Below is a labeled diagram of the segments themselves:

Using the above diagram it is easy to see how we derive the values. The following illustrates computing the value for the digit 6:

A: 0 B: 0 C: 1 D: 1 E: 1 F: 1 G: 1

Compounding the above in order from segment A through G we get 0011111, which in base 10 we can write as 95. A simple way to do this conversion is using the Python interpreter to convert a string representation of the binary value to a base 10 integer using int('0011111', 2) and noting the return value is 95.

In the sketch, I create an array of bytes to hold the values for the digits 0-9, so looking up a digit is as easy as looking up the value at the digit's index into the array. So for digit 3 we would look up index 3. We can then use the handy readByte function to read a byte at a time, and turn the segment of the LED on or off depending on the bit value. Strangely, Arduino appears to reverse the order of the bits as you read them from the byte. So our above digit 6 would be read in order 1111100. To fix this, instead of reversing the byte and then reading bits from it, I reverse the order in which I apply the bit values to the segments, starting at the end and working backward to the beginning.

The digits of PI are stored in an included header file that defines the actual values into read-only PROGMEM. The sketch then reads the current digit of PI out of the PROGMEM array. I think using PROGMEM for this is a nice example of the kinds of data one would store into read-only memory.

Below is a Fritzing diagram of the prototype (might have obsessed a little on this one):

Code Camp Columbus 2011

Ben Snider — Sat, 29 Oct 2011 16:14:00 -0400

Last weekend I had the opportunity to attend Code Camp Columbus for the first time. This is the second year that the event has been held, and it was pretty great this year. As a busy, working developer, I greatly appreciate their core principles:

by and for the developer community
always free
community-developed material
no fluff - only code
never occurs during working hours

The venue was Tech Columbus, which is quite a nice place. The main presentation room was large with a very large screen. There were two additional rooms, one of which was probably a little too small for the group, but it made the talks more interactive in that space. Breakfast, drinks, snacks, and lunch were all generously provided by the event sponsors, as were the many many raffle prizes. I went away with a neat Beginning Scala book (which I'm currently working through) and a $25 Best Buy gift card. All in all, quite worth the cost of attendance, which was free.

Overall the talks were great, and I highly recommend going to this conference the next time it is presented. I greatly enjoyed the Perl, Behavior Driven Development, and the Verilog talks. I'll outline a few of the talks below.

HTML5 Apps with PhoneGap

The first talk that I attended, and the talk that was likely most persuaded my attendance, was a talk about PhoneGap and HTML5. In the near future I hope to develop several HTML5 mobile apps and will probably use PhoneGap to wrap them for deployment on the various app stores. My particular problems revolve around video and complexity management, which weren't specifically addressed, but the talk was indeed generally useful.

The main narrative here was an app that the presenter had made in HTML5 and was planning on releasing it to the various mobile app stores, as well as to the chrome app store. The app was a simple two screen deal that queried the Heavens Above ISS orbit data, asked the user where he/she is (or uses GPS data when available) and presents the user with the times and locations of the next few ISS viewings. Admittedly a rather simple app, but a good showcase of the integration between HTML5, web services, and PhoneGap.

This particular talk was hosted in the smallest of the three venues, and it was quite a tight fit for all the people that wanted to attend talks in this room. Otherwise the venue was nice. No real technical difficulties or anything.

Unlock the Power of Arduino with Libraries

This talk was a more specific Arduino talk than the others I have previously attended at other conferences. It assumed at least a basic understanding of Arduino, which I thought was quite helpful. Most people interested in Arduino already know a significant amount about the platform, but just don't have the time to devote to actually doing anything with it. This talk introduced more advanced topics that I hadn't previously known. An interesting quote from the presentation speaks to the paradigm shift when switching from primarily software development to a more hardware integrated approach with Arduino: Ardiuno interacts more directly with the world, as opposed to mediated through a user or another library.

The main topic of this particular talk is about how to use libraries in Arduino. Libraries in Arduino are more or less identical to libraries in other contexts, and the use is the same as well. Simply #including a header file adds callable code to the current program. The header files expose some public members or methods, and the including program can use them as usual. As a sort of throwback to the days when one had to be conscious of memory, including library code can easily overflow the amount of program memory available on the Arduino. Other than that, libraries are just header files that you can use to easily add additional functionally to your Arduino programs. The community is apparently fairly active, and many libraries are available for common add-on hardware, as well as libraries for controlling servos and enabling communication, and the like.

The talk ended with a demonstration of some cool Arduino hardware. The speaker had quite a cool collection of Arduino shields, displays, servos, a digital analog clock, a TV out shield, and other stuff. I was particularly interested in the Danger Shield which is a shield that just gets stuck onto the top of the Arduino board (a "shield") and adds a bunch of additional hardware like a temperature sensor, a bunch of LEDs, a speaker, three potentiometer sliders, and some other cool tech.

Perl - laziness, impatience, hubris, and one liners

I've always been a fan of Perl because of its expressive syntax, but it's just not terribly practical anymore. This talk centered around some of the new cool features in the latest versions of Perl, as well as introducing some of the syntax standardization that has been formalized in the past few years. This lets Perl developers adhere to a standard set of best practices and a single coding standard, so that the programs are more readable and more maintainable.

To this end, the speaker showed an example of some of the core regex library code, and the file's header literally said "VOODOO MAGIC, LINE NOISE FOLLOWS." It was the sort of Perl that one thinks of when one thinks of overly complicated Perl code. The speaker then showed how to use some new tools available through CPAN that mostly de-obfuscated the line noise into a quite readable program.

The speaker also went through the use of the Mechanize framework, that has been quite improved since the last time I used it. The framework makes it easy to login to website, carry over the login cookies, and generally request and scrape content from websites in a concise manner. The speaker is using the Mechanize library to automate the transfer of projects from the closing BerliOS repository and import them into GitHub.

Intro to Verilog for C programmers

I went into this talk without even a little bit of understanding about Verilog but went away with a desire to learn more. Coincidentally the next local Python meetup I went to was about VHDL, a competitor to Verilog. The talk was a basic overview of Verilog, and I probably knew about as much about Verilog as everyone else in the room (e.g. nothing) and the talk was still fairly well above all our heads lol. It's good to experience things outside of our expertise, however, and I appreciated the challenge in understanding Verilog, which is very difference from most procedural languages that compile into code that runs on micro-controllers.

In a nutshell, Verilog is a hardware description language that, when compiled, can be loaded onto an FPGA and run. This is a major difference from compiling code that runs on a normal CPU. For one thing, most operations in a Verilog program can happen at the same time, in parallel. This entails that a line at the top of the program can run after a line at the end of the program. This all depends on the ending structure of gates that get programmed into the FPGA, but the designer must still be aware of such thins. Another difference is the fact that all operations are essentially a set of logic operations that runs through gates on a positive or negative clock edge. This means most of the operations a Verilog program describes are things like XORing or NORing two integers, for example. A major shift from traditional programming languages.

The speaker is apparently using a Verilog designed FPGA to detect gamma ray bursts from an x-ray machine used in a health care environment. This is for his day job at Batelle, in Columbus. Apparently, using a micro-controller wouldn't work for this particular problem because the gamma ray bursts are on the order of a single nano-second, and even the fastest micro-controllers aren't fast enough to process all the incoming data. So his team turned to an FPGA that can, in parallel, process the input, perform a FFT on it, and dump it out over a serial interface to a PC based program. Overall, very cool stuff.

Verilog is something I would like to learn more about, because it does indeed seem fascinating, and I greatly appreciated this talk because it helped open my eyes to yet another subset of computer science and engineering.

In Summary

Code Camp Columbus was a huge success this year, in my opinion, and I look forward to the next year of new and cool presentations. Perhaps next year I'll get my act together and present something. I fancy myself quite an experienced iOS developer, and perhaps I will have more to share with my experience of HTML5 and PhoneGap. Winning some goodies in the raffle was icing on the cake, and I enjoyed the venue and the presentations very much.

COhPUG Monthly Meetup and FreeGeek

Ben Snider — Tue, 27 Sep 2011 22:07:00 -0400

This week I think I've met my geek quota a little early, so hopefully I can just cruise the rest of the week. I'm always pleasantly surprised by the amount of geekery that goes on in Columbus on a random week.

Tuesday was the monthly meetup for the Central Ohio Python User Group (COhPUG I think...). The main topic this week was Greg Malcom's talk on Unix streaming, piping, and forking, and how we can write very Unix looking Python scripts using the same concepts. This talk was apparently originally given at a Ruby conference, but thankfully, all but one Ruby reference was converted to Python.

The bit on forks, for me, was a bit of a refresher course, having taken a Unix class in college. Thankfully, I had forgotten everything so I was able to learn it all over again. With forks I feel like there's always an "Aha!" moment where the concept just sort of clicks into place in your brain, but until then you're all "what the crap is this?" So, that was a good talk. I was reminded how odd Python's Popen classes are with respect to piping. I think I usually avoided using those in favor of the commands module, but apparently that's deprecated these days.

Eric Floehr gave a talk on using PyGame to compete in the semi-annual PyWeek game development contest (in which he attempted to participate). PyGame, as far as I can tell, is a simple Python layer over OpenGL with some sound, font image, and sprite support baked into a Python module. Writing a PyGame...game involves the developer implementing a main runloop, much like other frameworks, and apparenly includes a sort of hybrid event queue mechanism that looks pretty handy. I don't know how well any physics libraries and such plug into PyGame, but judging from the sophistication of the entries, it doesn't look too amazing. There seems to be some activity on a Box2D Python port that looks like it's heading in the right direction.

The remainder of the meetup was spent listening to a fellow who created a nifty video visualization of all the Columbus Underground forum posts. He apparently used Amazon EC2 to setup a render farm of 60 instances that rendered frames independently. This sped up the render from all night on his laptop to 10 seconds in the cloud. When the job was finished it allegedly cost about $8. Quite impressive.

I also spent this evening at FreeGeek. This week I attempted to build a computer, but the gods would not have it. I kept getting a random freeze. Normally I would chalk this up to memory but we test all the memory we get at FreeGeek so I assume it would either have to be a bad CPU or a PSU with damaged voltage regulators (but the voltage seemed to be fine in the BIOS). So I was stumped. Initially I found that the sound card was faulty and I replaced that, but that didn't stop the freezes. I also replaced the video card to be safe, no dice. So I gave up and just tagged it with my findings. The next thing I did was mostly a success, in that I was able to get through all quality control checks for a computer that was waiting to be tested. I ran out of time before I could test the disc drive, but a success I will take!

FreeGeek Columbus Volunteering

Ben Snider — Tue, 13 Sep 2011 21:46:00 -0400

I volunteered today for the first time at FreeGeek Columbus. I got a tour from the staff, which included a runaround of all the stacks of hardware that they have in stock. I don't think I've ever seen so many video cards, memory sticks, hard drives, and various parts in a single place before. My mind was a little blown at the sheer volume.

They then explained the process that hardware goes through when it comes in the door. First we basically tear everything out of the computer and test its components separately. Then, once the parts have passed some basic tests, they get put in bins based on what type of component they are. If a part doesn't pass the hardware tests, it gets tore down a little more and dumped into its own recycling bin.

Tonight I was able to work on testing hard drives and memory. Basically the process here involves using a set of 8 computers that are setup with a PXE boot loader that loads either memtest for testing memory, or a disk recovery image that checks for bad blocks and then does a dban style wipe on the contents. Once memory passes I just label it and bin it. Once a hard drive passes and is wiped, I move it over to the imaging machines where a copy of Ubuntu is cloned onto it, and I bin it so it can be built into a computer.

Overall, the process was quite cool. I totally geeked out a little bit at the sheer volume of tech and gadgetry just laying about. Mostly I just feel good about putting my wasted youth spent in tinkering with computers to good use. If you want to get started volutneering here, just walk in and the staff is more than willing to give you a task (or several).

s3cmd, Pelican, and You

Ben Snider — Sun, 11 Sep 2011 21:55:00 -0400

Turns out uploading this blog to Amazon S3 using s3cmd is ridiculously simple. All I have to do to sync the Pelican generated directory to my S3 bucket is the follwing:

s3cmd sync --acl-public --delete-removed output/ s3://www.bensnider.com/

The sync command basically works like rsync; it uses the hashing and diffing features in S3 to upload only the contents that have changed. I also specify the --acl-public option to have the files uploaded be HTTP readable by everyone.

If you don't feel like jumping in with both feet yet, you can use the rsync-alike --dry-run option until you are satisfied with the operations.

Handy!

Keynote Speech at OLF 2011

Ben Snider — Sun, 11 Sep 2011 21:23:00 -0400

This talk was given by Cathy Malmrose of ZaReason and mostly consisted of her relating how awesome it is to have an operating system that "just works", to steal a phrase from the Steve. This enables her to focus on the hardware, making it as robust, powerful, and cost effective as possible, without needing to focus too much on the operating system.

She related several support conversations she has had with her customers, and how they either love how well Linux works on the desktop (I believe they use Ubuntu) or how they need a computer that won't get viruses or won't come bloated with software, and that won't waste their time. She lamented the fact that developers often aren't in direct contact with the users of our products, and that disconnect means we are never really directly appreciated. She, however, has a dedicated client support line for her hardware business, so she gets to interact with the client. She remarked how great it is that Linux has matured to the point that she is getting calls like "how do I turn it on" rather than "my network card isn't supported."

She also apparently is somewhat anti-corporation, which could be the proximity of UC-Berkley rubbing off on her. She mentioned the documentary The Corporation. However, I think she genuinely wants to provide an excellent service to people, and the mindset of Linux fits very well within that particular ideology.

During the talk she tangentially mentioned technology in education, and how we are moving from rigid computer instructional software to more real-world types of problem solving, navigational, and practical learning software. She gave the example of Minecraft and how her son learned to navigate Paris from playing a racing game. I don't really see how this relates to Linux, but whatever, it was interesting.

Overall it was a very broad talk encompassing several topics, but it was a keynote, and it was a good overview of all the ways Linux is used, and how much the developer community is appreciated. So, a good opener for the day.

Ohio LinuxFest 2011 Series

Ben Snider — Sun, 11 Sep 2011 21:01:00 -0400

In this series of posts I will be review my experience at the 2011 Ohio LinuxFest. I will be giving my opinions and what I learned at the talks. Overall it was a very good day of talks, and I'm always impressed at how well organized this free convention is every year.

I will update this post with links to specific articles, and they will all be tagged with OLF2011.

Simple Pelican Blog Post Template Generator

Ben Snider — Sun, 11 Sep 2011 20:55:00 -0400

I just finished a simple script that helps generate Pelican blog posts by printing out some reStructuredText, in the format Pelican expects, based on the given input parameters. You can use it simple as in the following listing:

./tools/pelican-template-generator.py "My New Post"

And it will generate the reStructuredText header file that Pelican expects and dump it to stdout, where you are free to copy+paste into your desired editor. It includes options for writing to an output file, attempting to get the current author's name from the environment, generating dates, and support for categories and tags. The command I used to generate this post's template was:

./pelican-template-generator.py "Simple Pelican Blog Post Template Generator" --category Development --tags "python, pelican" -f simple-pelican-blog-post-template-generator.rst

Get the script on my GitHub.

It's Alive!

Ben Snider — Thu, 08 Sep 2011 02:08:00 -0400

Finally got the new blog up and running. But I feel like I've learned a lot about modern python development (github, pip, virtualenv, etc.), which was the main impetus behind doing this conversion.

This blog is now a static site that's generated using Pelican, stored on my GitHub repository and served up through my Amazon S3 bucket that I just point my domain at. Ideally I will automate this to the point that a git commit will trigger a Pelican build and then a s3cmd.rb script that syncs up the generated files. Not sure if I want to make that one or two steps though.

But, expect more to come of this!

NSZombie to the Freaking Rescue

Ben Snider — Wed, 05 May 2010 11:21:00 -0400

So I've been beating my head against a wall the past few days trying to cram as much Objective-C knowledge as possible and I think it's all starting to click.

Today I stumbled over the NSZombieEnabled argument and HOLY CRAP WHY ISN'T THIS DEFAULT BEHAVIOR. After enabling the argument I found where my app crashed in about 1 minute. Turns out you should not do:

- (void)viewDidUnload {
    self.foo = nil;
    [super viewDidUnload];
}

but rather

- (void)viewDidUnload {
    foo = nil;
    [super viewDidUnload];
}

A fairly subtle difference I'll grant myself but, apparently, an important one. In this particular case I am using the self.foo property as a typed copy of the UIViewController's view property. In the wrong case setting self.foo to nil releases the property where the framework assumes it still exists, resulting in an app crash. Simply setting the foo instance variable to null, however, works great.

Exile Issue 1 Released

Ben Snider — Tue, 27 Apr 2010 22:22:00 -0400

The game I've been working on at my day job has been released. The first issue of Exile is available today, and if you order now for $8 you get the remaining 3 issues delivered digitally when they are released.

Exile is unlike most games and most graphic novels, in that it offers first rate art and story with a compelling interface including interactivity, a soundtrack, and sound effects. We've also put a lot of effort into making the game as immersive as possible by providing unlockable elements within the game that give players a look at concept art, character sketches, and even minigames set in the Exile universe. The end result is a unique experience and the game succeeds in blurring the line between graphic novels and video games.

I've been lucky to work with a great team of artists and writers on this game, and I couldn't be happier with the way this has turned out.

Don't Get Shot Released

Ben Snider — Tue, 27 Apr 2010 22:20:00 -0400

The minigame I've been working on at my day job has been released, play "Don't Get Shot" free at Kongregate. This minigame is released in support of the release of the first issue of Exile.

The game is a reversal on the popular top down shmup genre, in that you are the one getting shot at. It is your goal to not get shot, or exploded, and progress through the levels. The level names I find entertaining and they typically give you a hint as to what to expect in the level.

The game was made with the excellent Flixel and Box2D libraries. It is a successful hybrid between the two, leveraging the Flixel framework for its great sprite animation, state management, and quick rendering, while using the accurate physics and collision features of the Box2D project. The integration was actually a great deal simpler than I thought it was going to be, which is like icing on the cake given all the features now available. These features coupled with a simple editor and an xml level format made it easy to turn out lots of great levels, which you can look forward to in future issue releases.

The game's artwork was done by Dave Will, the original concept was created by Ran Flasterstein, and the levels were done by Jay Treuhaft and Fred Dinovo.

Lice Helper Launched

Ben Snider — Mon, 01 Mar 2010 21:23:00 -0500

Recently finished and launched a new website for a client. The website advertises a lice removal service and provides means for potential customers to learn about the service and get in touch with the business quickly and easily. Lice Helper The site is built on a CakePHP application and actually uses Wordpress for the blog section of the site. It doesn't use Wordpress for any of the front end, but in the back end the standard Wordpress Dashboard is used to manage, edit, and write blog posts that are then displayed in the front end blog section. The site also utilizes my meta description and title components, that allow the application to manage those parts of the page independently of the page content. Basically it just ties a URL to a title or a description, matches them up when pages are requested, and if it finds a matching record it outputs it in the proper place. Otherwise it will output a sensible default text. I did enjoy working with CakePHP again as it's been some time. But all the things I liked about it still apply. It's still lightening fast from prototype to finished site, and design modifications couldn't be any simpler. All in all, good project, and I think the end result looks and works very well.

ImageMagick Split and Join a Sprite Sheet

Ben Snider — Tue, 09 Feb 2010 18:03:00 -0500

Continuing the Flixel theme that seems to be brewing here, I found a good way to transform images from full dimension art to sprite sheets. This is useful when converting an image into a sheet compatible with the Flixel tile and map system. In my case I am using it to split up background images so I can use them in Flan, the Flixel map editor. I'm just using the standard ImageMagick tools `convert`_ and `montage`_ to split and join the images, as well as some bash-fu to sort files properly. I am using Cygwin to get bash tools on my Windows machine. The first command is used to split up the main image. The only constraints here are that the resulting tiles must be square, and that they don't exceed the width limit for Flash BitmapData objects. So here we simply are cropping the image into square tiles.

convert full.png -crop 32x32 tiles.png

This will spit out a bunch of images in the current folder named tiles-%d.png where %d is the 0 based index of the tile. This also assumes that the width and height of the full.png image are divisible by 32 without remainder. The next command we need is to stitch the images back together. For this we will use the handy montage tool to tile the images into one big sheet. We just pass it a sorted list of names and tell it to make 1 row with as many columns as it needs (the x1 parameter). Sorting is not entirely necessary but using the default bash globbed format will result in tiles that should be at the end of the image randomly at the beginning (try it before this step by noting the output of `ls tiles*.png`).

files=$(ls tiles*.png | sort -t '-' -n -k 2 | tr '\n' ' ')
montage $files -tile x1 -geometry 32x32+0+0 sheet.png

If all went well we should see, inside the current directory, an image with all of our separate tile sprites in a single row in order from the original image from left to right and top to bottom. This technique is also useful for converting "liberated" sprite sheets that have more than one row, into single row sprite sheets that flixel can handle out of the box.

Flixel Pixel Perfect Collisions

Ben Snider — Sun, 31 Jan 2010 23:13:00 -0500

I haven't found a decent source of information about this on the interwebs so I thought I'd share my findings. Flixel doesn't have any built in pixel perfect collision support, it just assumes that you are using square (or at least rectangle) sprites and don't use any rotation. Well, that's not entirely a real world assumption so some of us will have to dig around and implement something ourselves. Hence, the below class. The class I developed is a simple override of the base FlxSprite class with some modifications to its collision detection system. It takes advantage of the fact that each sprite has its own set of BitmapData in its own coordinate space, which the framework uses to blit to the main screen BitmapData. BitmapData objects in Flash provide us with a native implementation (in the Player AFAIK) of per pixel collision detection, using the hitTest method. The hitTest method takes 5 parameters, but we only really care about the first 4. The first parameter we pass it defines where the calling BitmapData object is in screen space, i.e. the sprite's (x,y) coordinates. We then pass it a threshold alpha value, 0 being transparent and 255 being opaque. If you want semi-transparent regions of your sprite to collide then set this to something lower than 255 (0xFF is the hexadecimal representation of decimal 255). The third parameter is the colliding sprite's BitmapData object. And the fourth is the colliding sprite's (x,y) coordinates in screen space. I have abstracted this into the class's structure, so the overridden functions handle everything. You can use another alpha threshold by setting the sprite's alphaThreshold value to something valid, as explained above. You can also disable this pixel perfect collision detection method per technique by either setting doPerfectCollide or doPerfectOverlap to false. Because there are two methods Flixel uses to detect collisions, the class implements enhanced versions of both, and allows you to disable either independently. Note that, in order for the collision detection to be pixel perfect, either a) both colliding objects must subclass PPlxSprite or b) the sprite calling overlaps or collide must sublcass PPlxSprite and the colliding sprite must have a single frame. This is due to fact that the original FlxSprite class does not expose the _framePixels BitmapData object which is needed to collide the objects with the frame that is currently displayed. When a FlxSprite is collided with a PPlxSprite and the perfect collision is enabled, the exposed _pixels BitmapData is used, which contains the entire sprite sheet, so collisions are detected against all frames, not just the frame displayed. However, changing existing sprite's to use this class is easy enough so as not to cause problems. Note also that we only call the hitTest method when we know there is already a bounding box collision, so as not to waste CPU cycles. The native hitTest method is fast but probably not fast enough to call every frame, which would be wasteful in any case. Below is the PPlxSprite class which override the collision methods to provide pixel perfect collisions.

import flash.display.BitmapData;
import flash.geom.Point;

import org.flixel.FlxCore;
import org.flixel.FlxSprite;

public class PPlxSprite extends FlxSprite {

    public var alphaThreshold:uint = 0xFF;
    public var doPerfectOverlap:Boolean = true;
    public var doPerfectCollide:Boolean = true;

    protected var _corePos:Point = new Point();
    protected var _thisPos:Point = new Point();

    public function PPlxSprite(X:int=0, Y:int=0, SimpleGraphic:Class=null) {
        super(X, Y, SimpleGraphic);
    }

    public function get framePixels():BitmapData { return this._framePixels; }

    override public function overlaps(Core:FlxCore):Boolean {
        var doesOverlap:Boolean = super.overlaps(Core);
        if (doesOverlap && this.doPerfectOverlap && Core is FlxSprite) {
            doesOverlap = this.perfectCollision(FlxSprite(Core));
        }
        return doesOverlap;
    }

    public function perfectCollision(Sprite:FlxSprite):Boolean {
        this._corePos = Sprite.getScreenXY(this._corePos);
        this._thisPos = this.getScreenXY(this._thisPos);

        var corePixels:BitmapData;
        if (Sprite is PPlxSprite) {
            corePixels = PPlxSprite(Sprite).framePixels;
        } else {
            // i guess other standard FlxSprites are boned if they are animted
            corePixels = Sprite.pixels;
        }

        return this._framePixels.hitTest(this._thisPos, this.alphaThreshold, corePixels, this._corePos);
    }

    override public function hitWall(Contact:FlxCore=null):Boolean { return this.hitSomething(Contact); }
    override public function hitFloor(Contact:FlxCore=null):Boolean { return this.hitSomething(Contact); }
    override public function hitCeiling(Contact:FlxCore=null):Boolean { return this.hitSomething(Contact); }

    public function hitSomething(Contact:FlxCore):Boolean {
        var didHit:Boolean = true;
        if (this.doPerfectCollide && Contact is FlxSprite) {
            didHit = this.perfectCollision(FlxSprite(Contact));
        }

        return didHit;
    }
}

Here I have overriden the core FlxSprite methods that are responsible for collision detection, those methods being overlaps and the hit family of methods. Overlaps gets called when you explicitly issue a sprite.overlaps(otherSprite); This is a simple override that adds functionality to the super overlaps method, namely, calling the pixel perfect detection method and returning its results. The hit family of methods are called after calling the collide family of methods, including collideArray and the like. The collide methods, when they have detecting a bounding box collision, call the hit family of methods, depending on the location of the collision, which return a boolean. If the called hit method implemented by the sprite returns false, the collide method aborts and reports that it didn't collide after all. This is the behavior on which the above hit methods rely, and return false when it detects that while a bounding box collision may have occurred, the pixels in either sprite have not collided. A short usage class follows.

public class SomeSprite extends PPlxSprite {

    // Embed sprite image.

    public function SomeSprite(X:Number, Y:Number):void {
        super(X, Y);
        // Load sprite image, and other sprite stuff
    }

    override public function hitWall(Contact:FlxCore):Boolean {
        if (super.hitWall(Contact)) {
            this.hurt(1);
            return true;
        }
        return false;
    }
}

Here, all we do is simply extend the PPlxSprite class from above, and do what we normally do for sprites. We also decide to do something special when a character hits a wall, namely, get hut. To do this we override the hitWall method, call the super hitWall (which would be the PPlxSprite hitWall) method, and depending on its return value, we either get hurt or do nothing. We don't need to do anything special for calling the overlaps method, as this will simply call PPlxSprite overlaps method. So, hopefully this is helpful for someone looking to do this, or at least someone can find the ideas listed here useful. Let me know if you used it and if you find any bugs, improvements, or have any other suggestions.

Flixel Puddles and Oil Slicks

Ben Snider — Mon, 18 Jan 2010 17:46:00 -0500

I've been using the super cool Flixel framework to make a game and it's quite handy for most things. The game I'm working on is basically a top down...ehh, well let's just say it's top down. :) I can post more details when the game is actually released. As a category, top down and platformer games in general usually have some type of movement modification obstacles. These obstacles allow the player to pass through them, so they don't stop the player from moving, but they somehow alter the player's course by speeding up, slowing down, or sending the player in a different direction. In my case, these obstacles are oil slicks and water puddles, which speed up and slow down the player in whatever direction they are traveling. Here I will cover how I solved speeding up and slowing down the player when he crosses over such an obstacle. Below is a skeleton of my main player class:

 package sprites {
    import org.flixel.FlxG;
    import org.flixel.FlxSprite;

    public class Player extends FlxSprite {

        [Embed(source="player.png")] private var Img:Class;

        protected var _runSpeed:Number = 100;

        public var velocityFactor:Number = 1;

        public function Girl(X:int=0, Y:int=0) {
            super(Img, X, Y, true, false, 58, 58);

            drag.x = this._runSpeed * 8;
            drag.y = this._runSpeed * 8;

            maxVelocity.x = this._runSpeed;
            maxVelocity.y = this._runSpeed;

            ...
        }

        override public function update():void {
            // MOVEMENT
            acceleration.x = acceleration.y = 0;
            this.maxVelocity.x = this._runSpeed * this.velocityFactor;
            this.maxVelocity.y = this._runSpeed * this.velocityFactor;
            if (FlxG.keys.UP) {
                acceleration.y -= drag.y;
            }
            // And similarly for all 4 key directions
            ...

            super.update();
        }
    }
}

Using this player class, we can see that by modifying the velocityFactor instance variable, we can effectively control how fast the player can move around the screen. By setting velocityFactor equal to a value less than one, we decrease the player speed, and by setting it equal to a value greater than one we increase the player speed. So what we need now is a way to modify this value externally in response to player interaction with the world, namely, the player stepping onto a puddle or an oil slick. We also need sprites that define how they should change the player movement when they are stepped over. Below is a skeleton of one of my obstacle classes:

package sprites.obstacles {
    import org.flixel.FlxG;
    import org.flixel.FlxSprite;

    public class SpawnerObstacle extends FlxSprite {

        public function get playerVelocityFactor():Number { return 2; }

        [Embed(source="spawner.png")] private var SpawnerImg:Class;

        public function SpawnerObstacle(X:int=0, Y:int=0) {
            super(SpawnerImg, X, Y, true, false, 24, 24);

            this.fixed = true;
        }

    }
}

Here is just a simple implementation of a FlxSprite class where we define that this sprite, when stepped over, speeds up the player by a factor of 2. Below are the relevant parts of the update() method in my main PlayState class.

this._player.velocityFactor = 1;
for each (sprite in this._obstacles) {
    if (this._player.overlaps(sprite)) {
        trace('modifying player velocity');
        this._player.velocityFactor = obstacle.playerVelocityFactor;
        break;
    }
}

Here we loop over the obstacle sprites in the _obstacles array. This array would be created whenever you initialize the obstacles for the game. The obstacles themselves, in this case, are instances like the above SpawnerObstacle class, which have a playerVelocityFactor getter attached. In the beginning, we make sure that we set the player's velocityFactor to 1 so that the player moves at the default speed in the case that they are not on top of an obstacle sprite. We also break out of the loop when we collide with a single obstacle sprite to avoid any extra complexity. We could make it so that we average the velocity factors when multiple obstacle sprites are encountered, but I don't have this use case so it would be unnecessary. When all these parts are in place and working in conjunction, we have a game that satisfies our original goal. When the player collides with one of our obstacles sprites, he is either sped up or slowed down, depending on the velocity factor defined by the colliding sprite. If I get any less lazy (highly unlikely) I'll post an example swf with source code.

Computer Engineer Barbie

Ben Snider — Wed, 13 Jan 2010 17:10:00 -0500

A coworker writes me saying:

Please take a moment to vote for Barbie to become a Computer Engineer. Future generations of computer engineers would really appreciate it if we could influence some girls to take up the profession.

So indeed, I did vote, and so should you....or else! From the Barbie site:

Computer engineers have lots of different specialties. They can do anything from building computers to making video games!

It's true folks. Why would any young girl not want a computer engineer Barbie? It's fun for the whole family! I certainly wish my toys could program an analog synthesizer. Vote!

Flash Draw Transparent BitmapData

Ben Snider — Tue, 12 Jan 2010 11:17:00 -0500

Recently ran into an issue where I thought I should have been drawing a transparent BitmapData object, but the resulting object had a white background. The original incorrect code was the following:

var bd:BitmapData = new BitmapData(w, h, true);

The third boolean argument to the function is a transparency flag, and here it is set to true. However, when creating a Bitmap object from this BitmapData object and adding it to the display list, it clearly has a white background instead of being transparent. To remedy this, the solution is to pass along to the function a 32bit color value where the alpha value is zero. The following code illustrates this solution:

var bd:BitmapData = new BitmapData(w, h, true, 0x00000000);

This will create a totally transparent BitmapData object on which you can draw whatever you desire. In practice I use this to determine the alpha values of a given pixel in a given display object. The following function implements this technique:

public static function getAlphaAt(d:DisplayObject, x:Number, y:Number):Number {
    // Even though we set transparent to true, we still need to use a transparent color.
    // This is easily done by setting alpha to 0; the RGB octects after that don't matter.
    var bd:BitmapData = new BitmapData(d.width, d.height, true, 0x00000000);
    bd.draw(d);
    return (bd.getPixel32(x, y) >> 24 & 0xFF)/255;
}

Flex Scale Image to Max Dimension

Ben Snider — Mon, 11 Jan 2010 18:21:00 -0500

Recently had a problem where I needed to display images as large as possible within given bounds. So I made a handy little function that computes the scaling needed so that the image, if it is larger than any of the bounds, is scaled so that its largest dimension becomes equal to the given maximum. This function scales the image proportionally so it won't skew it.

public function scaleImageToMaxDimension(img:Image, maxWidth:Number, maxHeight:Number):void {
    var scaleH:Number=1, scaleV:Number=1;
    if (img.content.height > maxHeight) {
        scaleV = maxHeight / img.content.height;
    }
    if (img.content.width > maxWidth) {
        scaleH = maxWidth / img.width;
    }
    img.scaleX = img.scaleY = Math.min(scaleH, scaleV);
}

Flex doesn't do a terribly good job of resizing images, however, but it works for images that just need to be tweaked to fit. If you have control over your images and your display size, it is always best to resize them as needed to save space/bandwidth and preserve quality. This approach works best when you have little or no control over either. In application this code would be used after the image has finished loading. So for example I might do something like the following:

import flash.events.Event;
import mx.controls.Image;

public class Test {
    public var image:Image;

    // pretend scale function is here

    public function Test {
        image = new Image();
        image.addEventListener(Event.COMPLETE, imageComplete, false, 0, true);
        image.load('http://www.google.com/intl/en_ALL/images/logo.gif')
    }

    private function imageComplete(event:Event):void {
        scaleImageToMaxDimension(image, 100, 100);
    }
}

This Is Not a |

Ben Snider — Mon, 28 Sep 2009 14:09:00 -0400

Saw this joke at this year's Ohio Linux Fest during the closing talk, A Surfeit of Sophistication which was quite a good talk.

Flash 10 Valid Vector Elements

Ben Snider — Wed, 19 Aug 2009 20:29:00 -0400

Finally got around to learning about the new collection class available in Flash 10. To be honest, I'm not terribly excited about many things in Flash 10, hence my slowness to adapt. But, the vector class does interest me somewhat. It promises faster iteration over a strongly typed collection. Doesn't seem to add any other handy features however, like Flex's robust ArrayCollection methods including removeItem. But alas. As for it being faster, I have heard talk around the internets of the vector class only being significantly faster with simple types, but I'm way too lazy to any informal benchmarks of my own, so I'll just read someone else's results. One specific question I had that I didn't see answered anywhere, however, was the type of objects you could stick in a vector once the template class had been set. It was my suspicion that you could put any subclass of the template class in the vector, just like C++ templated vetors, but I hadn't read it confirmed anywhere, so I fired up my shiny new Flash CS4 and gave it a try. And indeed, my suspicion was correct. The following simple code below validates my hypothesis.

var test:Vector.<Sprite> = new Vector.<Sprite>();
test.push(new Sprite(), new MovieClip());

// should output something like "[object Sprite],[object MovieClip]"
trace(test);

Copying a Flash MovieClip, or The Flash Holy Grail

Ben Snider — Fri, 15 May 2009 19:41:00 -0400

Ran into a nice solution for copying arbitrary MovieClips at runtime today. I am designing a spot the difference game akin to 6 Differences with the requirement that, upon finding a difference, the scene should go to the "correct" state depending on which difference was defined as master, among a few other criterion. This required that I somehow duplicate, as much as is possible, the state of the "master" difference, when appropriate. At any rate, the solution comes from Danny Burbol's blog, which apparently came from a Experts Exchange thread (damn people charging for information). I modified the solution a bit to fit my needs, but not by a whole lot. Sometimes I only need to copy the instance and I can reconstitute the MovieClip from there but other times I will need to get the whole shebang. It's pretty handy in general. So my version follows (as a bonus I include my handy-dandy clearAllChildren function):

package com.bmm.utils {
  import flash.display.DisplayObject;
  import flash.display.DisplayObjectContainer;
  import flash.geom.Rectangle;

  /**
   * ...
   * @author BenS
   */
  public class UIUtils {

    public static function clearAllChildren(c:DisplayObjectContainer):void {
      if (c == null || c.numChildren == 0) return;

      var i:int = 0, n:int = c.numChildren;
      for (i = 0; i < n; i++) {
        c.removeChildAt(0);
      }
    }

    public static function simpleDisplayObjectClone(source:DisplayObject):DisplayObject {
      var cc:Class = Object(source).constructor;
      return new cc();
    }

    public static function displayObjectClone(source:DisplayObject):DisplayObject {
      var copy:DisplayObject = UIUtils.simpleDisplayObjectClone(source);

      copy.transform = source.transform;
      copy.filters = source.filters;
      copy.cacheAsBitmap = source.cacheAsBitmap;
      copy.opaqueBackground = source.opaqueBackground;
      if (source.scale9Grid) {
        var r:Rectangle = source.scale9Grid;
        copy.scale9Grid = r;
      }

      return copy;
    }
  }
}

Flexunit Asyncrhonous Setups

Ben Snider — Thu, 12 Feb 2009 20:56:00 -0500

If you ever need to load some external data before running a test, or need to wait for a component's creation complete event, then you know the inadequacies of the Flexunit framework when it comes to asynchronous operations. One approach you might think of is to load the XML data, for example, in the setUp() method and attach a handler to the loader to wait for the complete event which would then call runMiddle() so the actual test body runs. You would need to override the runMiddle() method in your test case, and call super.runMiddle() in your complete handler. However, while this will cause the tests to run properly after the data has become available, Flexunit will not hang around long enough to catch the passed/failed asserts in your test body. You will instead get a runtime error box telling you which asserts failed, and a green bar from the Flexunit UI. This is not desirable. What we need then is to somehow write a test case that begins loading the data, and somehow specifies which method to run that contains the actual asserts for the test method. Essentially if you wanted to do really simply you would just load the data with a Loader object, attach a complete handler to the loader wrapped with the addAsync method of the TestCase to delay test execution, and write the complete handler so that it accepts the complete event and does what it will with the event.currentTarget. I would rather have a general asynchronous setup method that takes as parameters the URL of the data to load, the test handler with all the asserts, and the class of the data that should be loaded. Instead of a jumble of words explaining this it would probably help more to just paste the code at this point.

package {
    import flash.events.Event;
    import flash.net.URLLoader;
    import flash.net.URLRequest;

    import flexunit.framework.TestCase;

    public class AsyncSetupTestCase extends TestCase {

        public var data:*;
        public var returnType:Class;

        public function setupAsync(target:String, test:Function, returnType:Class):void {
            this.returnType = returnType;
            var helper:Function = this.addAsync(this.completeHandler, 1000, test);
            var loader:URLLoader = new URLLoader();
            loader.addEventListener(Event.COMPLETE, helper);
            loader.load(new URLRequest(target));
        }

        private function completeHandler(event:Event, test:Function):void {
            trace('async load complete');
            this.data = event.currentTarget.data as this.returnType;
            test.call(this);
        }

    }
}

As the previous code demonstrates, I have simply extended Flexunit's TestCase class and added a few methods to help with asynchronous setups. Essentially all a test case that needs to load external data must do then is to call the setupAsync method with the desired information, and AsyncSetupTestCase will handle running the test once the load is complete. All the designated handler in the test needs to do differently from other tests is to a) not be prefixed with test and b) use the data property to access the loaded data from the setup. An example test case demonstrating this follows:

public function testMethod():void {
    this.setupAsync('something.xml', this.doTestMethod, XML);
}
public function doTestMethod():void {
    // do what we will with this.data, it shall be an XML instance
    assertTrue(this.data is XML);
}

FlashDevelop Setter and Getter Snippets

Ben Snider — Mon, 09 Feb 2009 19:02:00 -0500

FlashDevelop, the Flash IDE I am using at the moment, has support for saving snippets of code that is general and reusable, like setters and getters. The default setter and getter snippets simply add the skeleton code and require the developer to actually type in variable names, and types. I found this amount of extra typing to be not worth using the snippets for setters and getters at all. So I made my own snippets for these two operations. Mine require that you simply name the method, because the method name can't be the same as the variable name, and because the snippet system cannot do string processing. The cursor is placed where the function name belongs after the snippet is completed. All that is required for this to work as intended is for the cursor to be on the same line(anywhere on the line) of a variable definition. You can then use the same Control-B combo to get the snippet box, and select the appropriate snippet. The actual snippets follow. set:

$(Boundary)$(CSLB)public function set $(EntryPoint)(value:$(MbrTypName)):void { $(MbrName) = value; }$(Boundary)

get:

$(Boundary)$(CSLB)public function get $(EntryPoint)():$(MbrTypName) { return $(MbrName); }$(Boundary)

With these snippets you can make setters and getters quickly and accurately. The actual code they generate will end up looking something like the following:

private var _points:uint = 0;
public function get points():uint { return _points; }
public function set points(value:uint):void { _points = value; }

Flex MenuItem Actions

Ben Snider — Fri, 30 Jan 2009 15:08:00 -0500

So, gonna write this here because I will forget how to do it. Essentially, this approach eliminates the need to conditionally branch on menu item properties. Before we would do something like:

private function menuHandler(event:MouseEvent):void {
    if (event.item.@label == 'Save') {
        f = File.destopDirectory;
        f.browseForSave('Save');
        f.addEventListener(Event.SELECT, this.selectSaveFolderHandler);
    } else if (event.item.@label == 'Open') {
        // etc
    }
}

As you can see, this is an awfully coupled solution. Whenever we want to change the name of a menu item, we also need to change the logic in the handler. This can be somewhat alleviated by using an @id property instead of the display text, but its still coupled. The better solution is to allow the menu item itself designate what action it should trigger when clicked. This is the method that Buttons use, but for menu items it's a little different because the menu is simply XML data. What we need then is a way to store a method name in the menu item XML definition, have that parameter read by the menu handler method, and the appropriate method called. For simplicity we limit the specified method to whichever class contains the actual menu, and that the method has no required arguments. The magic here is the use of the flash.utils.getDefinitionByName() function to return a Function definition rather than a Class, and using the Function.call() method to actually call the returned Function. So our revised menu item XML would look something like:

<!-- menu items -->
<mx:XMLList>
    <menuitem label="Save" action="saveMenuHandler"/>
    <menuitem label="Open" action="openMenuHandler"/>
</mx:XMLList>

And our handler would look like:

// AS handler
private function menuHandler(event:MouseEvent):void {
    var method:String = String(event.item.@action);
    try {
        var methodRef:Function = Function(flash.utils.getDefinitionByName(method));
        methodRef.call(this);
    } catch (e:ReferenceError) {
        trace(e.message);
    }
}

I haven't tested this idea so no idea if it works or not, so YMMV. But it should work, and if I ever get around to refactoring some old code I will certainly be including this.

HP Laptop Linux Boot Parameters

Ben Snider — Mon, 03 Nov 2008 13:32:00 -0500

Instead of me wracking my braing trying to remember the exact boot parameters to make my HP laptop not break when I update the kernel, I am posting it here. Hopefully someone else may find it useful as well. My specific laptop is the HP dv9000 series special edition I bought at Best Buy about a year ago and I am currently running Ubuntu 8.10 with the 2.27 kernel. The "magic" boot parameter seems to be pnpbios=off, so I end up with a grub entry something like:

root (hd0,0)
kernel /vmlinuz root=UUID=<some giant UUID> ro quiet splash pnpbios=off
initrd /initrd.img
boot

Fixes most things including sleep, hibernate, USB hotplugging, and most noticeably my wireless card.

World of Goo

Ben Snider — Wed, 29 Oct 2008 17:18:00 -0400

Not often do I write personally here outside of programming, but I must make an exception for World of Goo. It's a game unlike anything else really, maybe a little like the Fantastic Contraption flash game in that they are both logic puzzles. Otherwise it's a great unique game in which you can lose yourself. Try the demo or get more information.

Google Chrome and Firefox 3 Benchmark Comparisons

Ben Snider — Tue, 02 Sep 2008 16:40:00 -0400

Google released the beta for their new browser called Google Chrome and one of the features they talked about was the new Javascript virtual machine. So to test their claims of speed I ran Sun's SunSpider Javascript benchmark on both. The results of the tests follow:

Firefox 3

Google Chrome

As you can see, Google chrome is much faster than FF3 by nearly a factor of 6. To see the comparison, load the Chrome score then copy the Firefox link into the second box, push enter, and be amazed. While Chrome falters on some of the tests, namely regex, it blows FF3 out of the water for the most part, especially in the bitopts section. But with Firefox 3.1 coming out in the near future sporting a new Javascript tracing engine, which will be faster?

OpenMP Examples

Ben Snider — Thu, 07 Aug 2008 20:31:00 -0400

Here are some usage examples for the C++ library available in the GNU C++ compiler versions 4.2 and up, and probably others. This first example shows how to use the parallel for construct to iterate over a set of neurons. Each thread here gets an equal share of the current layer's neurons. How big of a portion each thread gets is determined by how many threads OpenMP has been configured to create. Each thread then iterates over all the parent layer's neurons. This is made possible by declaring a private loop index variable. This shows how to construct an OpenMP work sharing for loop with a nested for loop where each thread iterates over its own copy of the parent layer's neurons. If j was not explicitly declared private, it would implicitly be shared among all the threads OpenMP creates, which would cause the inner loop to behave erratically as each thread completes iterations over the parent layer. Likewise with the neuronValue variable. It also shows how to conditionally fork multiple threads. In this example we only create multiple threads if the current layer has more than 500 neurons. If the current layer has only 500 neurons, then the for loop will execute in a single threaded environment, otherwise it will execute in parallel. This is useful, for example, if the current layer 200 neurons, then the overhead associated with creating more threads might actually degrade performance.

int j(0); double neuronValue(0);
#pragma omp parallel for private(j, neuronValue) if(layer.numNeurons > 500)
for (int i=0; i<layer.numNeurons; ++i) {
    neuronValue = 0;
    for (j=0; j<layer.parentlayer->numNeurons; ++j) {
        neuronValue += layer.parentLayer->neurons.at(j).value * layer.parentLayer->weights.at(j).at(i);
    }
}

Likewise we can use these two declarations independently as in the following two examples with expected results.

#pragma parallel for if(x > 100)
for (int i=0; i<1000; ++i) {
    // something
}

int j(0);
#pragma parallel for private(j)
for (int i=0; i<1000; ++i) {
    for (j=0; j<1000; ++j) {
        // something
    }
}

These are the fundamentals to creating OpenMP threads. Maybe sometime in the future I will add some more examples.

CakePHP Getting Tree Path

Ben Snider — Fri, 25 Jul 2008 12:06:00 -0400

In a reversal of yesterday's post is today's, getting a path to a node, or nodes. Basically we just use the core getpath() function of the Tree behavior and traverse that path.

function setTreePath(&$data, $path='tree_path', $label='name') {
    if (!is_array($data) || !in_array('Tree', $this->actsAs)) {
        return $data;
    }
    if (is_array($data) && is_int(array_shift(array_keys($data)))) {
        foreach ($data as $i=>$item) {
            $this->_setTreePath($data[$i], $path, $label);
        }
    } else {
        $this->_setTreePath($data, $path, $label);
    }
}

function _setTreePath(&$data, $pathField, $label) {
    $cats = $this->getpath($data[$this->name][$this->primaryKey]);
    $path = array();
    foreach ($cats as $cat) {
        array_push($path, $cat[$this->name][$label]);
    }
    $data[$this->name][$pathField] = implode('/', $path);
}

And we can use it simply like in the following test:

function testSetTreePath() {
    $result = $this->Category->findById(3);
    $this->Category->setTreePath($result, 'tree_id');
    $this->assertEqual($result['Category']['tree_id'], 'My Categories/Fun/Sport');
}

It's mostly useful when working with related models, so the whole path is displayed instead of just the nodes, which may or may not be unique.

CakePHP Tree Find By Path

Ben Snider — Thu, 24 Jul 2008 13:11:00 -0400

Wrote these little functions to help with finding tree nodes by specifying a path of values. For example if we had a tree of categories with similar names like TVs->Color and Movies->Color, we can't find by the category name since its not unique, but we can search by pathing like tvs/color or movies/color. So to this end is this model code:

function findPath($paths, $fieldName) {
    $root = $this->find('threaded');
    return $this->findPathHelper($root, $paths, $fieldName);
}

function findPathHelper($node, $paths, $fieldName) {
    // search for paths from the beginning of the list
    $path = array_shift($paths);
    $newNode = false;
    // looking for the current path in the specified field
    foreach ($node as $nodeNode) {
        if ($nodeNode[$this->name][$fieldName] == $path) {
            $newNode = $nodeNode;
            break;
        }
    }
    if (empty($paths) || $newNode === false) {
        // done processing the paths, or cannot find a matching node
        return $newNode;
    } else {
        // not done, find based on the found node's children
        return $this->findPathHelper($newNode['children'], $paths, $fieldName);
    }
}

And we can use it from our controller like:

$category = $this->Category->findPath(array('tv', 'color'), 'name');

Probably not the most efficient code, but it sure is elegant. It also will probably break if you have two rows on the same level with the same name, but that would be pointless anyway.

CakePHP Lightbox Helper

Ben Snider — Tue, 22 Jul 2008 13:24:00 -0400

Made a helper to output lightbox compatible links, since the core HTML helper was not working. Stick the following code in app/view/helpers/lightbox.php:

class LightboxHelper extends AppHelper {

    var $helpers = array('Html');

    function img($thumb, $full, $imgAttributes = array(), $linkAttributes = array()) {
        $defaultLinkAttributes = array('rel'=>'lightbox');
        $linkAttributes = array_merge($defaultLinkAttributes, $linkAttributes);

        $thumb = $this->Html->image($thumb, $imgAttributes);
        if (strpos($full, '://') === false) {
            $full = $this->Html->webroot(IMAGES_URL . $full);
        }
        return $this->Html->output(sprintf($this->Html->tags['link'], $full, $this->Html->_parseAttributes($linkAttributes), $thumb));
    }
}

Then you can use it from your views, after including it in your controller's $helpers array, like the following:

echo $lightbox->img('somethumb.jpg', 'somefullimage.jpg');

Using Radio Buttons with CakePHP

Ben Snider — Tue, 17 Jun 2008 20:40:00 -0400

There's sparse documentation on this topic so here I give some example usages. Say we have a Posts model like in most of the cake documents. Basically what we do is make an options array available to the template that contains the keys and values for the radio button. In the $options array, the keys are the values sent back to the controller, and the values are the text displayed on the page. Building the controller to output a list of radio buttons looks like this:

...
function radioPosts() {
    if (empty($this->data)) {
        $posts = $this->Post->findAll();
        $options = array();
        foreach($posts as $post) {
            $options[$post['Post']['id']] = $post['Post']['title'];
        }
        $this->set(compact('posts', 'options'));
    } else {
        $this->Session->setFlash('You chose a post with id='.$this->data['Post']['id']);
        $this->redirect(array('action'=>'radioPosts'));
    }
}

Then the view for this controller would look something like:

echo $form->create('Post', array('action'=>'radioPosts'));
echo $form->radio('id', $options);
echo $form->end('Submit!');

Dynamically Import and Instantiate Python Classes

Ben Snider — Wed, 27 Feb 2008 16:18:00 -0500

Ran into this bit of genius code in the python mailing list. Here's the code for now and I'll explain it later:

def forname(modname, classname):
    ''' Returns a class of "classname" from module "modname". '''
    module = __import__(modname)
    classobj = getattr(module, classname)
    return classobj

Basically it returns a class object from modname matching classname. Sound decptively simple, and it is. If it doesn't find classname in modname, or it doesn't find modname, it will simply throw an import error. What's left to do is just instantiate an object of that class and shazam, its magic. Here's an example to create a new Popen instance:

p_class = forname("subprocess", "Popen")
p_inst = p_class(["ls", "-l"])

It's useful for getting input from a file or user and creating classes based on that input. Of course, be certain to properly validate that input, or it can get really nasty really quickly.

Getting the Owner of a File in Linux

Ben Snider — Mon, 25 Feb 2008 17:40:00 -0500

Ran across this problem where I needed root to execute a script as whoever owns it. The solution is simple and should work most everywhere. Basically it just uses the standard "stat" program and uses the print formatting option to only output the name of the owner. Here I use bash to get the owner:

#!/bin/bash
username=`stat ${1} --printf %U`
echo "The owner of ${1} is ${username}";
exit 0;

And a sample run looks like:

$ ./whoOwnsIt.sh testfile.txt
The owner of testfile.txt is ben.

Making root run it as the user's owner is then trivially done with:

su ${username} ${cmd}

C++ Pointers and Incomplete Types

Ben Snider — Sun, 24 Feb 2008 20:57:00 -0500

Learned some new things about C++ and pointers today. Namely that you can declare a pointer member variable of the class A in class A. Pretty neat. Take for example the following simple illustration.

#include <iostream>
class A {
    public:
        void setMember(A& m) { this->member = &m; }
        A* member;
        int x;
};

int main(int argc, char** argv) {
    A a,b;
    a.x = 2;
    b.x = 3;
    a.setMember(b);
    b.setMember(a);

    std::cout << "a.member->x = " << a.member->x << "n";
    std::cout << "b.member->x = " << b.member->x << "n";
}

It's output is as follows:

a.member->x = '3'
b.member->x = '2'

So instead of doing this same thing in other more complicated ways we can do it in one class with simple pointers. Also note that we don't need to destruct the member variable since it will be destructed automagically. I find this technique useful in cases where it makes sense for classes to be linked together. In my case the different layers of a neural network.

Python Lies

Ben Snider — Sun, 17 Feb 2008 19:13:00 -0500

This is probably a documented issue, but I think it deserves another mention. Python lies, its the truth. Well, as much as an interpreter can lie. Say we want to do some math in Python. Say we want to raise large numbers to large numbers. Say those numbers are 324 and 324. Then we would do something like:

<<< 324**324

and see all the pretty numbers spew out from the interpreter. How do we know if this is right or wrong though? Say we use long doubles in C++ to determine the results of this same operation. Then we would do something like:

long double k = 324;
for (int i=0; i<324; ++i) {
    k *= k
}
std::cout << "324^324 = " << k << "n";

But alas, the output is "inf", so we check the largest long double our compiler and machine can represent and find that it is roughly equal to 1.2e+4932. We then check in python if this number is greater than 324^324 by doing something like:

>>>> (12**4932) > (324**324)
True

However, this contradicts the fact that C++ could not represent 324^324, so Python must be lying. Indeed we check the largest power of 324 we can represent in C++ long doubles, and it turns out to be 11. Thus Python lies. What does this mean. Don't rely on Python for numeric accuracy without checking its results. Update: This post is probably wrong, but I don't like deleting things. So refer to Tyler's comment below.

Flixya Firefox Extension

Ben Snider — Thu, 28 Jun 2007 23:12:00 -0400

I just recently finished up a Firefox Extension for the social video site Flixya. Extensions are all written in JavaScript and a sort of XML called XUL. Most of the framework was already written for me though, so I just hacked together the bits that worked with my code and nixed some of the old stuff. Basically the extension grabs some relevant data like tags, the title, etc., from a video hosted on a number of online video sites like Veoh or YouTube. It then fills that text into the extension's interface so user's can edit or add to the provided information. Finally it posts all of the information to the user's Flixya account where other users can view and comment on each other's videos. The idea of using an extension like this is to streamline the video submitting process, and it works quite well. Grabbing the text from all the various sites took a while and was the most difficult part of the process. Some sites like Veoh are coded in XHTML so they use CSS for presentation and a minimal amount of actual markup. This makes parsing a page much easier with either XPath or grabbing elements with the JavaScript getElementById() function. Other sites like LiveVideo use tables almost exclusively which makes finding a unique part of the HTML rather difficult and sometimes near impossible since the code around the desired text is so similar to other undesired text. But the resulting extension works very well with a number of online video sites and allows easy posting to Flixya.

Flixya Firefox Video Publisher 2.0

LocalWineEvents.com Google Gadget

Ben Snider — Thu, 21 Jun 2007 19:49:00 -0400

Just finished a Google Gadget for the LocalWineEvents website. It uses the Google Gadget API, of course, which is in JavaScript, XML, a little HTML, CSS, and the obligatory IE CSS hacks. Basically it asks the user where he or she lives when it's run for the first time, then it grabs the corresponding RSS feed from LocalWineEvents.com, parses that, and produces the output as shown in the screenshot below. Clicking on the + reveals the event's details and changes the + to a -, which can then be hidden again using the - button. I used a new tool to make this gadget, since it's primarily coded in JavaScript, called Aptana. It's essentially a plugin for Eclipse, but the authors also provide a stand-alone client preloaded with the plugin. I liked it except that it didn't detect JavaScript inside an XML document, which is the format for Google Gadgets. So I just coded the JavaScript in an HTML file and pasted the JavaScript into the XML as needed. I was once again reminded how bad I am at using the GIMP or any other graphics editor. Must be missing that visual creativity gene... Add to your Google Homepage.