Slashdot Mirror
Upscaling Retro 8-Bit Pixel Art To Vector Graphics
An anonymous reader writes "Two researchers — Johannes Kopf from Microsoft, and Dani Lischinski from The Hebrew University — have successfully created an algorithm that depixelizes and upscales low-resolution 8-bit 'pixel art' into lush vector graphics. The algorithm identifies pixel-level details (original paper — PDF) to accurately shade the new image — but more importantly, the algorithm can create smooth, curved contour lines from only-connected-on-the-diagonal single pixels. At long last, we might be able to play Super Mario Bros. on a big screen without stretching our beloved plumber's pixels to breaking point. You really must look at the sample images." Scroll down in the paper to see how their technique stacks up against some others, including Adobe's Live Trace.
I've always thought that this would be possible. Now we just need to create a translator that will let us play our retro games with vector graphics.
Sig: I stole this sig.
PDF got slashdotted immediately, but the dolphin image shown in the first article is quite stunning.
Its a pretty common practice to take drawings and scale them down, and repaint for sprites
Because we haven't strip-mined the past enough. I'm impressed by the results but weary of its implications.
Being able to convert low resolution pixel art into nice vectors like that is kick ass. I wish they had released a utility to try it out on other materials. (like my own..)
I do some of my best work in a work envelope around 100x100 pixels.
EvilHom3r over on Reddit seems to have mirrored the paper (as images) here.
My verdict: Yeah, it looks all nice and smooth, but with all upscaling, it's basically interpolating data. The original just didn't have that much detail, so you can only get so much out of it. Sometimes it works, sometimes it doesn't.
(Oh, and it makes all text look pretty bad. Kinda Comic Sans-y, if I can say that without invoking instant hate.)
Pr0n industry would be able to save a fortune in bandwidth!
http://webcache.googleusercontent.com/search?q=cache:15iKIgSAkDwJ:johanneskopf.de/publications/pixelart/paper/pixel.pdf+http://johanneskopf.de/publications/pixelart/paper/pixel.pdf&cd=1&hl=en&ct=clnk&gl=us&client=iceweasel-a&source=www.google.com
Minecraft's about to get a whole lot better.
Could this improve the look of minecraft, or should we assume the overhead is to great?
Now we need realtime implementation in ZSNES....
Are you implying that VectorMagic does the same thing just as well or better (making this research irrelevant), or that VectorMagic is the first bitmap vectorisation algorithm?
(hint: both are wrong)
They mention that form of approach in the introduction and reference Hqx specifically in Section 2: Previous work.
As mentioned two posts up there's an image of the paper (so text search blows) here: http://imgur.com/a/gRXPJ
...such as 2001's HQ3X (http://www.hiend3d.com/hq3x.html) which both awesome and as common as dirt ten years later.
Article author Sebastian Anthony looks like a tech nitwit with the "at long last, we might be able to play Super Mario Bros. on a big screen without stretching our beloved plumber's pixels to breaking point" comment.
No, not really. From the paper:
Various commercial tools, such as Adobe Live Trace [Adobe, Inc.2010] and Vector Magic [Vector Magic, Inc. 2010], perform automatic vectorization of raster images. The exact nature of the underlying algorithms is not disclosed, however, they generally do not perform well on pixel art images, as is evidenced by the comparisons in this paper and in our supplementary material.
EvilHom3r over on Reddit seems to have mirrored the paper (as images) here.
My verdict: Yeah, it looks all nice and smooth, but with all upscaling, it's basically interpolating data. The original just didn't have that much detail, so you can only get so much out of it. Sometimes it works, sometimes it doesn't.
(Oh, and it makes all text look pretty bad. Kinda Comic Sans-y, if I can say that without invoking instant hate.)
I know what you mean but it's pretty impressive nonetheless. The flaw I found interesting was in the keyboard image. I'm sure the intention here is square keys, but their algorithm made all the keys round. Some things in a pixelated image should not be smoothed but without human context that's a very hard call to make.
These posts express my own personal views, not those of my employer
RTFP - they list the various existing upscaling algorithms, and why they're not perfect:
Several later algorithms are based on the same idea, but use more sophisticated logic to determine the colors of the 2x2 block. The best known ones are Eagle [Unknown 1997], 2xSaI [Ohannessian 1999], and Scale2x [Mazzoleni 2001], which use larger causal neighborhoods and blend colors. Several slightly different implementations exist under different names, such as SuperEagle and Super2xSaI. An inherent limitation of all these algorithms is that they only allow upscaling by a factor of two. Larger magnication canbe achieved by applying the algorithm multiple times, each time doubling the resolution. This strategy, however, signicantly reduces quality at larger upscaling factors, because the methods assume non-antialiased input, while producing antialiased output.
The latest and most sophisticated evolution of this type of algorithms is the hqx family [Stepin 2003]. This algorithm examines 3x3 pixel blocks at a time and compares the center pixel to its 8 neighbors. Each neighbor is classied as being either similar or dissimilar in color, which leads to 256 possible combinations. The algorithm uses a lookup table to apply a custom interpolation scheme for each combination. This enables it to produce various shapes, such as sharp corners, etc. The quality of the results is high. However, due to its strictly local nature, the algorithm cannot resolve certain ambiguous patterns and is still prone to produce staircasing artifacts. Lookup tables exist only for 2, 3, and 4 magnication factors.
whereas what they did here is:
Our goal in this work is to convert pixel art images to a resolution-independent vector representation, where regions with smoothly
varying shading are crisply separated by piecewise-smooth contour curves.
Seriously, just look at the whale image linked from TFS.
I'm going to steal it. Next time I see something I'm both apprehensive, and tired of, I shall be /we?ary/ of it.
PDF mirror is here
Please someone do a plugin for ZSNES for this...
If you read the paper (which is presently slashdotted) you'll see that they compare their results to existing pixel-smoothers, and theirs definitely look better in pretty much every case.
So it's not "Hey, we invented this new thing no one ever thought of!" so much as it's "Hey, we invented this better way of doing something that already exists."
I, for one, look forward to having better graphics in emulators.
Can get very similar results by simply using better sampling/interpolation techniques.
ENHANCE! http://www.youtube.com/watch?v=Vxq9yj2pVWk
The authors of the article are aware of other scaling algorhythms, and discuss and compare their work to them. RTFA.
Last time I checked, these filters you speak of in Zsnes and other emulators simply extrapolate the pixels without paying any special attention to shapes and colors. TFA picture looks quite a bit more advanced.
I, for one, look forward to having better graphics in emulators.
Don't kid yourself. This is from a Microsofter so it will probably disappear into Intellectual Ventures where the next time you see it, it will be because somebody is getting sued for using pixel scaling that might kind of sort of almost look a little bit like this. You can almost certainly forget Zsnes, SNES9x, and the like getting their mitts on it. A sad day is when MS gets in the mix of an interesting new technology.
Yes, this is news. Most scientific and technological advancement is iterative improvement. This paper describes an improvement in the state-of-the-art for vectorizing pixel art (which is not the same as pixel-smoothing, though a vectorized image is usually re-rasterized for display).
Seriously, read the paper. The algorithm described will require some basic understanding of splines and graph algorithms, but it's surprisingly accessible for a graphics/vision paper. Also, shiny pictures.
Those are all post-processing up-scaling effects. But they do have limitations in that even the pixels themselves can still be made out. Obfuscating them only goes so far. But with this new technique, they're pure vectors. They will scale infinitely with splines to match your screen resolution, much like fonts.
Life is not for the lazy.
I'm pretty sure that's a dolphin, actually... OK, so maybe their algorithm isn't perfect yet ^_^
Yes, but what lines are you smoothing? That's what this algorithm's about - generating the lines.
I've seen something similar done in PhotoShop years ago using multiple cycles of blurring, "erode", "encroach" (opposite of erode), palette-ing, etc.
However, it doesn't work well on angles intended to be sharp. The dolphin is not a good example to test such a potential flaw.
Table-ized A.I.
It seems to me that they've optimized their algorithm for recreating cartoony line-art style graphics. This works great if it was the initial intent (ala the Super Mario World graphics they used in most of their examples), but it falls down on many other art styles. Something like an old Sierra game (mid-series Kings Quest, Space Quest, etc...) are likely to be a hot mess. I bet most of Doom is a disaster too. So it's a cool tool, but the applications are limited by the original art design.
I read the internet for the articles.
The network affiliate I work at still ingests all content (other than the network feed) in SD, and of course upsamples it to 1080i. Ive noticed certain spots that are mostly line art, they upsample very convincingly with almost no artifacts. It is the photorealistic stuff that doesn't upsample very well.
I play in Znes with the Hq3x filter. It might be good, but it's nowhere near the quality of what these people have accomplished. Znes having this technique implemented would be amazing,
Grammar nazis are to this community what excrements are to gold.
It looked like it was on the verge of a Slashdotting, so I CORALized it.
http://johanneskopf.de.nyud.net/publications/pixelart/paper/pixel.pdf
Very interesting, and quite effective.
Willie...
I've posted the CORAL link to the PDF under the original article.
Willie...
You can't understand the difference between SCALING and VECTORIZING? Really? Scaling algorithms increase the number of pixels, but you're fundamentally still dealing with a raster image. A vectorized drawing is a whole different beast.
That said, I would like to compare the final results against a best of breed scalar like hq4x for the same final output resolution.
This looks a lot like what you might end up with if you use the image tracing function in Flash to convert bitmaps into...vectors.
Spoke too soon, the paper has an hq4x comparison. The results are really, really good -- it actually manages to do a better job than hq4x on Super Mario World.
I redraw bitmaps as vector art as a little side business, and I have to say this is the best "livetrace" automated program I've come across. Shameless plug: Vectify.com. Still no substitute for hand drawn (rounded corners that should be sharp; variable, wobbly line widths; but very good for an automated process). I've scanned through the PDF paper, and it looks like it's too CPU intensive to be used in retro games in realtime: from page 6, "There are many avenues for future work. Obviously, it would be nice to optimize the performance of the algorithm so that it can be applied in real-time in an emulator." As someone who used to play old games via dosbox and SNES9x, having something like this as a selectable filter option one day would be welcome. Now that I think about it, this kind of thing would be useful for app developers who want to scale up low-res artwork to work on higher res displays (like going from the original iPhone to the iPad). At least, it could be used as a starting point to further manual refinement.
For every Richard Feynman, you have a Jerry Springer. It is just that Jews are overly represented by the Entertainment, Legal, and Banking professions. There is a great deal of hatred toward the latter professions. Needless to say, this is why some people 'hate Jews'. Sure Jews are also overly represented by the respected science and medicine professions, but nobody knows who the surgeon general is, and everyone knows who Jerry Springer is.
Jerry Springer has done more for anti-Jewish sentiment Adolf Hitler ever could have.
*clickityclackity* "enhance." *clickityclackity* "enhance!"
Corel PhotoTRACE was out in 1993, and produced results comparable to the Live Trace examples in the PDF. Such results are far inferior to this algorithm in most of the provided examples.
You do not have a moral or legal right to do absolutely anything you want.
That's why I like Jerry Springer, you, uh, insensitive clod!
The real test for the Kopf-Lischinski algorithm will be how it can handle Nethack.
I can see the fnords!
The paper actually mentions them, compares how they work and describes what was improved.
This is news? Anyone else run a NES on those dozen or so emulators that already has pixel-smoothing options?
One suspects that if /. posted an article about a new engineering method that will allow us to finally build a cheap, working space elevator, you'd post, "This is news? Haven't we had ways of making cables for centuries?"
"Convictions are more dangerous enemies of truth than lies."
http://en.wikipedia.org/wiki/Pixel_art_scaling_algorithms
After the vectors are rasterized, I see no difference between the results of this method and those used by scaling algorithms like: 2xSAI, Super2xSAI, SuperEagle, HQ2x, HQ3x, etc.
The novelty might be that it generates vectors, but the algorithm must be quite similar.
The hq2x and hq4x filter are all specially made to handle pixel art shapes. Even the generic filters are selected for their ability to upscale pixel art well.
Yeah, they are dolphins wearing swimming masks, from Super Mario World: http://www.youtube.com/watch?v=W94OrZU4-aw&t=428
Have a look at the paper, if you haven't yet. Their algorithm is impressive, but even in the samples they chose, some things get better results (IMO) with hq4x (Fig. 10, Mario Bros. scene, perhaps?) or Photo Zoom 4 (Fig.9, That warrior with the sword).
This looks good because it is specialized for 8-bit manually created graphics. 8-bit graphics with a broad palette has little shading, so it's usually unambiguous which pixel attaches to which adjacent pixel. Vectorizing 24-bit color images, or 8-bit images from photographs, requires more guesses about how wide things are and where the edges are supposed to be.
Nice if you really want to play 80's games in higher resolution.
I just lost the game.
That we like the way pixel art looks in the first place!
This project is technically interesting but as art it completely misses the point. Not every piece of human creation needs to be updated, upscaled, "improved" and redone.
I know the originals make more sense to me.
Imagine what this could do for minecraft!
old news. This has been in emulators for a long time y'know, so I'd assume it's been a used method in other applications before that too.. The hq3x filter is fantastic
http://www.megaupload.com/?d=VSGR0S30
Open in Firefox; ZOOM (Ctrl-+)
It's not about pretending that Avant Vector on the Atari ST and a pile of things before and after didn't exist, it's about a better technique to get vectors out of bitmaps than the existing ones.
The result's are very interesting.
Guys, create converter, sell something!
Zoom in on Mario a bit... Enhance...
Looks like somebody just watched Zeitgeist~
NVIDIA and AMD should implement this and related algorithms for their LCD upscaling!
The algorithm looks like it could be parallelized onto the GPU easily enough, and doing it transparently at the video card driver level would enable PC gamers to play classic games on large LCDs without the thumbnail sized pixels.
Just imagine what this scaling algorithm could do for classic low-res games like Diablo.
This is why closed-source sucks... I'd have done it myself by now if I had access to the AMD GPU Windows driver source code!
http://bitmob.com/articles/bringing-your-sprites-into-the-21st-century
(Includes animated sprites)
yeah, they're close to the best scaling out there - but the feature is that the output is a vector image,
the benefit is better upscaling at more than 4x and most importantly the possibility to edit the result (imagine how that would help speed up/reduce cost of the current rereleasing of old arcade under the hd moniker on xbox live)
also, I like how they also disclosed the worst case scenario, with an analysis of the algorithm failure.
Can someone link to the MAME build that supports this? ....
What do you mean they're not coding this directly into MAME source?!?!?!
Commodore 64 Porn arrives in high-res
The image of the dolphin comes from Super Mario World, which was for the Super Nintendo. That was a 16bit game on a 16bit system. Anyone who played the 8bit Super Mario Bros games can tell you there were no dolphins in those games.
Damn_registrars has no butt-hole. Damn_registrars has no use for a butt-hole.
I cannot say that I like Mario's eyes.
Also, the pins of the chip was a failure, becoming sawtooths instead of parallel pins.
The problem with this algorithm, like many others, is that it's subject to an extension of the Pareto principle. In 80% of cases, it may be an improvement, but that doesn't help if it makes the result worse in 20%. Cause it's the failures we notice, and judge quality by.
Algorithms like this also don't work well for animated sprites. Our imagination can fill in the gap between Mario holding the hammer above his head and the hammer hitting a barrel, precisely because of the technical limitations. But the same abrupt transition with high res splines would be jarring. (And a morph would be even worse)
Speaking of failures, I must say the greatest result was Adobe's version of the fish. They were the only one that managed to make the fish more scary!
It looks like their vectorized version has 1 less colour than the original.
Sure the vector version is nicer, but if every pixel is important, why would the algorithm decide to drop the light blue?
Too late, you already did.
-dZ.
Carol vs. Ghost
Unfortunately it seems the output is a collection of splines which are then recombined with the original image data to produce a shaded image at arbitary resoloution. Which is a nice result don't get me wrong but it looks like it would still be some further effort to turn the result into a standard vector format.
Also they don't seem to have released the code so to actually use this one would have to try and reimplement the technique from the info in the paper.
note: i'm known as plugwash most places but i screwd up registering that here somehow in the past and now can't register
Some algorithms find better balance than others. Hq4x, used as one of the examples in the paper, does that for me - maybe not as "smooth", but generally nice enough. Plus it rarely gives something weird, IMHO maintains decent consistency in the look of the games.
Or maybe I'm just used to it... (with it and similar around for a decade+, in various emulators)
One that hath name thou can not otter
The real drawback with hqx is that they are fixed-multiplier upscalers. I can take an old game with a 320x200 resolution and scale it up to 960x600, and it looks great, but if I want to play it full screen then I need to do more traditional interpolation to get it up to my screen resolution. It still looks nice, but not as good. Being able to scale up to an arbitrary resolution in one step is much better.
That said, when I was at the University of Utah around 2006, I saw some very similar results to the pretty pictures in the paper (I've not read the words yet), using a similar approach. I don't know where their results were published, so I can't compare the results in detail, but the idea of creating topology maps from image data and then using this to generate rasters at arbitrary resolutions is not new - they were mainly looking at it as a compression scheme, since the topology maps can be tiny; smaller than a low-resolution bitmap, but able to be scaled up to high resolutions without artefacts.
I am TheRaven on Soylent News
The edge lines, and then the color fills in. Doesn't it make sense that the spline would eliminate jagged edges?
Just needs
If (IsPictureOfKeyboard() ){
drawStraightEdges = True;
}
so it looks like the fighters hit each other with soft nerf bats instead of swords
A baseball bat has a smooth contour, but as Ness shows in Super Smash Bros. series, it's still a formidable weapon.
Think of what would become M.A.M.E. with depixeling, all retro games would become much alive!
I had a PlayStation emulator that would play PS1 CDs on a PC, and remember how much better Gran Turismo looked in a higher resolution. WipeOut's art by the Designers Republic was out of this world. Street Fighter EX Plus had some problems with the ground texture tiling, but was otherwise great. And all this was over ten years ago, at a resolution that we deem to be HD with TVs.
I also design t-shirts as a hobby. My chosen medium is still pen and pencil, but with software like GIMP and Inkscape, I'm able to scan in my drawings. Color them. Add effects. And then convert the image to vector paths for submission. One of the t-shirt sites, TeeFury, has a Mario-inspired piece of artwork that would have been rendered in high definition. Being able to play games like this too: that's exciting stuff to an old geezer like myself.
I can't say you got him there.
oh..
Anyone know the difference between a pixel scaler and a vectorizer?
Give me Classic Slashdot or give me death!
This algorithm should be applied to lower resolution textures in 3d games. World of Warcraft would look incredible with this in place.
You can't understand the difference between SCALING and VECTORIZING? Really? Scaling algorithms increase the number of pixels, but you're fundamentally still dealing with a raster image. A vectorized drawing is a whole different beast.
Your words are all true, but the reality of the situation is that the images are going to be displayed on a pixel-based device. The input is just pixels, and the eventual output is also just pixels. This approach, that internally uses vector graphics, appears to work incredibly well - but they're final results aren't better simply because they use vectors.
You're special forces then? That's great! I just love your olympics!
I mean, if you can program a GPU to do it, great. Otherwise, you're probably better sticking with hq2/4x and using a texture map onto a flat surface to get arbitrary scaling.
Good pixel-art filtering algorithms like 2xSaI, hq3x and hq4x have been around and been supported by all of the major emulators for at least ten years now.
Trust me on this: Vector graphics don't actually add anything to the experience of playing Yoshi's Island or Super Metroid in 1080p.
I'd have to see a comparison between TFA's picture and zsnes to be certain, but I agree with the AC. At least going by memory, it doesn't look any different from what I recall zsnes looking like.
If someone has a comparison image handy, it'd certainly be welcome. Otherwise I'll just check it out myself when I get home.
"I'm not sure I like the fugnutish tone you used in your post!" -RogL (608926)-
What's so much better about this than HQ4X? Even the images in the PDF don't look much better, and HQ4X has been around for years.
A pixel scaler is an algorithm that makes a different resolution output image, for example upscaling 320x240 to 640x480. Most existing pixel scalers look at neighboring pixels (2x2 or 3x3 area) to decide how to replace one input pixel with NxN output pixels.
A vectorizer is an algorithm that creates a vector representation of an image input as pixels. You can then use that vector representation to render at a higher resolution (any zoom factor, not just integer values), but you could do other things such as rendering at the same resolution but with anti-aliasing or even scaling down.
Yes, but these low-detail originals were enough to fool the brain, in our minds we "knew" what these would look like if they were well drawn. I'm sure an algorithm could be developed to guess at these details the way our brains do.
Twinstiq, game news
I wonder if this could be adapted into a Go playing AI of some sort. If nothing else, it'd be able to store several thousand kifu variations as vector patterns that it could later crunch through using machine learning. You'd just have to convert the kifu data into a QR code-like icon to feed it into the program.
Ah, so this is how they can get people's faces shown clearly on low rez video captures!
Enhance!
The Super NES drew things in layers, so emulators are able to up-res each layer separately. The TV would try and up-res the entire screen all in one shot, so some of the details of the characters and backgrounds might get mixed up together. If part of the outline of the character is black and part of the background is black, then the TV upscaler might think the two are joined together. If a previous-frame(s) algorithm were implemented it might help to mitigate some of these issues, but that wouldn't stop problems with static screens.
Twinstiq, game news
Can I get the *reverse* of that, i.e. downscaling big-ass vector graphics to 8-bit?
I agree on the importance of the development of this new method. However I cannot help but think that there is no perceptible difference between the hq4x result and their algorithm in Figure 9 (SNES mario picture). Myabe the difference (of these two methods) will be more evident with big screens.
Ubuntu is an African word meaning 'I can't configure Debian'
Potrace is a command line utility that does something like this, though only for black and white images. I believe Inkscape (which somebody else mentioned already) has a multi-color version of the potrace algorithm.
Though the article seemed to lament that this new algorithm is processor-intensive and thus can't be used, there's no reason not to use it as a load-time algorithm, or as an automatically-seeded algorithm. Even on an NES emulator, it's reasonable to pull apart the individual 8x8 tiles in the sprite tables and generate the large versions. For example, playing a game for a little while can automatically generate information about which tile combinations are generally displayed next to each other to form a full image. The emulator could then automatically upload these discovered pairings to a server, which can tell other emulators playing the same game how to pre-cache the upsampled sprites. Palette information could either be included or left to runtime. Somebody should definitely put that feature into an emulator.
Yes, I was a NES developer and am still a game developer.
Actually, the keyboard ends up looking a bit like a typewriter. It's a little weird to modern sensibilities, but there were whole decades when most typewriter keys were round, or at least all the old-style non-electric ones I've seen had round keys.
The Quirkz Handbook of Self-Improvement for People Who Are Already Pretty Okay
[blockquote]Speaking of failures, I must say the greatest result was Adobe's version of the fish. They were the only one that managed to make the fish more scary![/blockquote]
In Super Mario World, the dolphins appear in the level 'Vanilla Secret 3' and help Mario complete the level and avoid the otherwise unkillable puffer fish by serving as flying platforms. They are not intended to look scary. :)
Algorithms like this also don't work well for animated sprites. Our imagination can fill in the gap between Mario holding the hammer above his head and the hammer hitting a barrel, precisely because of the technical limitations. But the same abrupt transition with high res splines would be jarring. (And a morph would be even worse)
Anime fans are just fine with characters that are detailed yet jerkily animated.
I'm still feeling bad for being a human. /.
Humanity is not a great thing on
Don't be a twat. The difference is that once you have a vector, it scales to an arbitrary size much better.
'nuff said.
Zoom in a little, and the differences are extremely obvious. hq4x is much blockier in every instance.
Yes, it is very impressive. If I remember correctly hq2x and hq4x are not even real algorithms, they are hand-written tables designed to work well. Even if the new algorithm was not a visual improvement (it is), it would still be impressive.
So what? At the time of scaling, which for video games has to be the time of playing in realtime, the output resolution is known. Sure, we can all come up with fairy-tale scenarios of 8-bit video games that will be recorded and re-displayed on big screens and watches, but in real life that just doesn't happen enough to be statistically significant.
You're special forces then? That's great! I just love your olympics!
A bunch of official picture comparisons here: http://research.microsoft.com/en-us/um/people/kopf/pixelart/supplementary/multi_comparison.html
Their algorithm is compared to various others. All images look awesome and superior at 4x. Some even higher but 4x is super-nice (and probably the size these characters would be in modern games)
It looks like potrace output. Does anybody care to explain the technical breakthrough here?
Lazy minds, might, possibly, perhaps, sort of want to know. A bit.
20 years around computers, and all you are is a tech? You're a joke Robert. You must be a retrograde idiot, because even young kids in collegiate academia accomplish more than that Robert, and they do it in less time put in. The "M" in your name must stand for moron. Enlighten us as to why you are only a techie after all that time, won't you? You don't have to, because it's obvious you're a limited moronic dolt, RobertM.
20 years around computers, and all you are is a tech? You're a joke Robert. You must be a retrograde idiot, because even young kids in collegiate academia accomplish more than that Robert, and they do it in less time put in. The "M" in your name must stand for moron. Enlighten us as to why you are only a techie after all that time, won't you? You don't have to, because it's obvious you're a limited moronic dolt RobertM.
http://research.microsoft.com/en-us/um/people/kopf/pixelart/paper/pixel.pdf