INTelegance

I’ve finished the first draft of my 3d film (currently untitled). I plan on re cutting a lot of it, but feel like this is a good first draft and proof of concept.

There are two versions, one is just the single channel 2d film, the other is the anaglyph 3D version that you can watch if you have Red/blue glasses!

The end of the film also uses a time blurring effect that I have been experimenting with that I wrote in Objective-C using the Core Image libraries

Untitled in 2D HD
H.264 720p30 28.1MB

Untitled in 2D small
H.264 480p30 19.7MB

Untitled in 3D HD
H.264 720p30 28.4MB

Untitled in 3D small
H.264 480p30 21.4MB

For the DXARTS course on stereoscopic video I have been doing research into efficient editing work flows.  Today I’ve created a handy little script that can take a single camera After Effects composition and turn it into a side-by-side left/right composition that is compatible with our 3d projection system running the DepthQ software.

The script is custom for HDV footage (1440×1080 pixel aspect of 1.33). This is great for the Canon XH A1 and XH G1 footage. For those of you running the Panasonic AG-HVX200 on your stereo rigs, I am sure this could be easily modified to work with that footage.

By the way, After Effects scripting is super intuitive and easy. I created this script in about two hour without having any previous AE scripting experience.

Download the Script

Instructions

Footage Requirements:

• You need all your footage to be named with the convention MyVideoClipLEFT.mov and MyVideoClipRIGHT.mov and for them to be in the same folder
• Your files should be captured with synced time code so they’re in/out points are the same and they are the same duration
• Make sure the word LEFT and RIGHT doesn’t show up anywhere else in the file names too

To Use the script:

• Create a composition that is 1440×1080 with Pixel aspect of HDV 1080 (1.33) (this is a default setting in after effects for HDV 29.97 and is correct for the footage we shot with the XH G1)
• Edit your movie using only the left camera’s footage. You can do whatever you want here except resize the footage… so masks, effects, time stretching, opacity…is all fair game
• When you are done with the cut you want, select your composition and then select File > Scripts > Run Script File… and select the above Create3dComp.jsx
• Blamo! you now have a new comp that is named YourComp_3dified and it will have widened the composition and placed the right camera’s footage next to the left, flipped and ready to go.
• You can export as you would normally. Note: This script creates compositions that are 2880×1080 with wide pixels, when you export out of after effects you will need to select a custom aspect ratio to get the full 3840×1080 with square pixels.

Hope somebody finds it useful. Feel free to contact me with any questions or bugs

I am currently taking a course in Stereoscopic (3D) video production in the department of Digital Arts and Experimental Media here at UW. DXArts is the only arts program in the nation that has High Definition Stereoscopic cinema production capabilities, so we’re all pretty lucky to get a chance to dabble in this medium.

my project

Tonight I did the first test shots for my 3d experimental film. For these shots I filmed monocular to get an idea of what lighting, composition, camera settings work before busting out the huge 3d rig.

For my film, I have constructed a half tube of infinite depth. Here is a sample video:

Spheres & Mirrors sample (11.4mB)

The photos explain the set up

I have always been enthralled with the idea of particle accelerators. Something about the experimental nature of placing simple physical elements into a system and seeing what happens appeals to my algorithmic aesthetics. I wanted to create a similar set of constraints for myself when creating this film. Imposing strong constrained system where the depth and physics are stripped down to their elemental levels.

The film will be a set of experiments conducted in the system. Each experiment testing an abstract hypothesis. A series of vignettes in the this no place. I hope the results are conclusive.

After 3 years in the department I finally got around to submitting some T-Shirt designs for the University of Washington Department of Computer Science & Engineering’s yearly t-shirt contest.
Below are the designs:

post-rationalization

I wanted to build design that actually represented the students in the department visually. I chose two aspects to concentrate on when representing students in a visualization. The first was whether a student was computer science or computer engineering (here at UW, there is a lot of overlap … the distinction is minor, but fun to associate with oneself). The second was how long the student had been in the department. I pulled the data from the department’s class list and parsed it down to just these two bits of information.

In the trees on the shirt, each node represents one student. The color of the node represents CS/CE (which can be decoded from the color of the letter in the logo). The size of the node is representative of how long the student has been in the department. The longer enrolled the larger the node. The amount of time in the department decreases as the tree is traversed, putting the veterans near the root and the newbies on the leaves. Each sub-tree contains only CE or CS students, yet in line with the t shirt slogan, they all share the common singular root: University of Washington CSE.

process(ing.org)

I built this visualization using processing, an open source graphic prototyping environment built on Java. I borrowed heavily from Traer Physics and Traer Animation examples to create the simulation. The code is available here (warning, it is really rough):

processing source code

student data file

I hope they end on somebody’s body.

Out of the blue, I got a recruiting phone call from a member of the Yahoo! Internet Application team. Not being in a position to accept a job in California, I politely explained my situation and thanked them for the call. We did, however, spend a quite a while discussing the state of web application development, present and future. Particularly, what enterprise employers such as Yahoo are doing to make robust and maintainable applications in the face of horrendous browser compatibility problems. The conversation affirmed a lot of what I believe, but also provided some interesting context from an enterprise perspective.

Here is the story: As web applications have begun to move critical and complex functionality to the browser client, there have emerged a number of problems born out of inconsistent and incomplete JavaScript implementations. No matter how much we complain, browser problems (yes, IE6 is a disaster), incomplete programming languages (yes, inheritance in JavaScript is hard), and poorly interpreted standards (box model, anyone?), are facts of life. Accept this. Move on. What can be done to to make the web a feasible platform for these rich user experience applications? Yahoo and I both agree, the basic idea is simple:

good abstraction.

Yahoo supports this with their YUI toolkit. But it’s also what Dojo, Prototype, jQuery, Google Web Toolkit and a number of other emerging libraries attempt to create.  The model is:


+------------+
|  UI/Ajax   | < --- where I like to live
+------------+
| JS Library | < --- the *hopefully*
+------------+       impenetrable barrier
|Browser Hell| < --- maintained by only
+------------+       the bravest programmers


In this model, all JavaScript implementation such as User Interface components, AJAX connections, form validation, and DHTML manipulation, happens only through the support of the JavaScript Library calls provided by a library. It is up to the developers of the library to ensure these calls work as per the API specification (which certainly is no enviable task).  Writing this way buys you three major advantages

1. You only write your functionality once and it works for all browsers.
2. You gain a lot of high level language concepts, such as inheritance
3. You don’t have to re-write anything when new browsers are released

These are mouthwatering concepts for any seasoned web application developer who has tried write a web application without a 3rd party framework underneath them. That experience teaches you that you have to write your application 3 times (once for FireFox, half a time for Safari, and a time and a half for Internet Explorer). Then when a new browser comes out, you have to write your application yet again to support it. But when you are using something like the YUI toolkit, you can rely on statements like the following (taken from their browser support page):

…it’s important to be aware of forthcoming releases, especially from established brands that enjoy rapid adoption once generally available (GA). We are currently watching the development progress of Firefox 3 and Internet Explorer 8.

I personally would much rather let the crack-shot browser support team at Yahoo fix my web application for Internet Explorer 8 than do it myself. Once all the specified API in YUI works in IE8, it’s as simple as upgrading the library and my web application will work on that browser.

So what’s the catch? I believe the biggest inhibitor for companies and entrepreneurs in adopting this model is a brain scarcity issue. Supporting these libraries means that web applications need to be written by engineers. JavaScript can be simple by just defining global functions and copy-and pasting other people’s solutions from Google. But using these frameworks above requires the ability to apply concepts of software engineering. Object Oriented structure, proper use of design patterns, modularity, encapsulation. All the things that have lived in the hearts and minds of software engineers since the mainframes of the 60’s are now being applied to web applications. Historically, JavaScript has received the stereotype of being an easy language for non-programmers. Due to the “we know what you probably mean” attitude that browsers take towards poor JavaScript and markup, the average web contributors do not need to be engineers. They are writers, designers, kids, get-rich-quick schemers, and opinionated bloggers. This makes for a lot of diverse content, but not necessarily robust web sites. What is emerging now is the distinction between what technologies are used and how a technology is being used. It came to me straight from the horse’s mouth: enterprise employers are looking for web application developers who are well versed in good engineering and software design. It’s time to pony up and learn some design patterns.

So what’s my advice if you are an aspiring web application developer? Stop reading how to create a ActiveXObject(”Microsoft.XMLHTTP”) in IE6 and instead learn how to implement a Singleton pattern using Prototype. Unless you want to be on that bottom layer of abstraction, overrun when IE8 drops, it’s in your best interest to become familiar with writing code on top of a these new libraries. As I enumerated above, it is also much more convenient and practical to do so. The expiration date on your application will be a lot longer then “June 2008″ if you hitch your wagon to the strong minds behind these abstraction layers. If you are worried about becoming becoming dependent on someone else’s support team, rest assured there are a lot industrial quality web applications built on top of these technologies. It is a safe bet they will stand the test of time.

I have hesitated for a long time about starting a blog. The reason being simple: I had nothing to say. Or at least, that is how I felt. It is true that INTelegance Labs has been my expressive platform for the last 3 years (that is, I have been “saying” things through it), but the content I deem worthy of releasing under the INTelegance name has been sparse. A blog as a context for communicating the Lab’s output has never been necessary or appropriate. Within the last few months, however, thoughts that I deem valuable have occurred with increased frequency. Enough so to finally justify a central repository for ideas; this.

What goes Here?

There exists only one qualifying criterion for what is posted here: relevance. It is of the greatest importance to me that the information contained within is useful to somebody, hopefully that somebody is you. To be less abstract, the content will be things such as algorithmic design experiments, project updates and ideas, updates to my dashboard widgets, a few helpful web design tricks, some software development industry commentary, and perhaps a few whimsical thought experiments.

I hope you enjoy.