Author Archives: Steve Haroz

Science and War – Visualizing U.S. Budget Priorities

Neil deGrass Tyson recently noted that the 2008 bank bailout was larger than the total 50 history of NASA’s budget. Inspired by that comparison, I decided to look at general science spending relative to the defense budget. How do we prioritize our tax dollars?

This information quest also gave me an opportunity to try using Tableau to visualize the results.

With science spending in green and military spending in red, the difference is enormous. In fact annual military spending is greater than the total cost of NASA’s entire history (adjusted for inflation).

NASA budget 2

Interactive version hosted by Tableau

Note: Tableau Public went down while I was trying to make this chart. During that time, I couldn’t save or open anything! The lesson here is to be cautious when using Tableau Public.

Response to Paper Critiques

A couple of people critiqued our paper, “How Capacity Limits of Attention Influence Information Visualization Effectiveness,” which won the best paper award at InfoVis 2012.

The criticism is largely centered on which colors we used, namely their luminance and contrast. The criticism is based on a misunderstanding or misreading of our paper.

We have two responses:

  1. Target and distractor colors were selected randomly for each trial and fully counterbalanced; every target color was also used as a distractor. Color and/or luminance pop-out, and discriminability differences between targets and distractors do not explain the results. Rather, grouping modulates search efficiency: Here is a demo.
  2. Color and luminance contrast explanations do not explain our results for motion. Here is a demo.

Seeing the Crowd: A Perception Demo in WebGL

I wrote a new demo for some recent research on the perception of biological motion. We found that the human visual system can very effectively perceive and encode a group of moving figures without having to serially inspect each one.

Check out the Ensemble Biological Motion Demo

On the implementation side, using VBOs instead of packing the points into textures resulted in massively redundant data (some values need two copies for each frame of motion). VTF would have significantly simplified the implementation. Luckily, the Angle Project has it implemented, and the canary build of Chromium/Chrome (version 13) has integrated the changes; Firefox should have it eventually as well. I give it 3-6 months before public release versions have it as well.

Testing the Waters with WebGL

Updated browser info as of May 1, 2010

  • Getting a WebGL browser
  • Firefox 4 and Safari partially work but do NOT have advanced vertex features
  • Chrome’s WebGL support is similar, but the features can be enabled:
    • Close all Chrome windows
    • Windows: [UserFolder]AppDataLocalGoogleChromeApplicationchrome.exe --use-gl=desktop
    • Mac: /Applications/Google Chrome.app/Contents/MacOS/Google Chrome --use-gl=desktop
  • Chrome’s and Firefox 4’s default vertex shader compiler has trouble with texture sampling in the vertex shader, so the demo skips that feature for those browsers. As Al mentioned in the comments, the plan to add the capability to the WebGL engine is in place.

After multiple people asked, I decided to give WebGL a try. I’m impressed but also annoyed.
Trying some features out
Check out my modified WebGL moon demo. Some credits are in the source.
screenshot moon
Overall thoughts on WebGL
Pros:

  • The graphics performance is an order of magnitude above any other web technology
  • Again, it’s really fast!
  • It stays fairly true to OpenGL (which is good if you’re familiar with OpenGL)

Cons:

  • The graphics performance is noticeably slower than a desktop app. And forget about using your CPU for anything else.
  • It says fairly true to OpenGL (is that antiquated, procedural, state-machine-based API the best that anyone can do?)
  • No released (non-beta) browser can run it by default.
  • It is OpenGL ES, rather than full OpenGL. Radom functions are just not implemented, but no documentation mentions what’s missing. In some cases whole features just don’t work (e.g. geometry shaders).
  • The crippled GLSL doesn’t have most built-in shader variables like texture coordinates and gl_normal, so you need to make your own “varying” pseudonyms.
  • HTML, javascript, and GLSL… ALL IN ONE FILE! Readability is lost.

Overall compatibility and tools (text completion and debugging those files) are going to be the primary determining factors in WebGL’s success. It’s early, so we’ll have to see what happens.

WPF OpenGL framework released

I’m open sourcing my WPF OpenGL framework. It’s still very rough and unpolished.

Some notes:

  • You need a decent graphics card and updated drivers (Nvidia or ATI).
  • It’s based on the OpenTK framework.
  • It still relies on WinForms. Eventually I’ll try to use purely WPF, but the hybrid works for now.
  • I definitely need to clean up the code and document it properly. Until that’s done, just email me if you have questions.
  • The structure from motion demo looks best with anti aliasing overridden at the hardware level. For Nvidia cards, go to the Nvidia control panel –> 3D settings –> Use the advanced 3D settings –> Take me there-> Antialiasing – mode = override, Antialiasing – setting >= 2x. You can hit “Restore” or reselect ‘”Let the 3D application decide” to undo this change.

 

WPFTK boxes    Shader UML

Refactoring in WPF

I’ve recently encountered a lot of frustrating DX (developer experience) problems while working on my WPF OpenGL project. For those curious, I’m disentangling my personal research from the OpenGL libraries and controls (hopefully, I’ll post by Monday). These gripes have no real order, so I’ll just mention a couple:

  • Renaming a Window class.
    1. Rename the class in the .xaml.cs file. VS will nicely refactor all references including dependency properties (I hate that specific class names are needed for these).
    2. Rename the class in .xaml file. That’s right; VS doesn’t refactor XAML code. It’s not even nice enough to give you a compiler error, you have to run the program to find the unintelligable, unlocalized error. WTF?!?
    3. To maintain sanity, rename the the .xaml file with the new class name. VS is at least nice enough to rename the .xaml.cs file automatically.
    4. If you renamed the file of the startup window, you’ll get another meaningless runtime error. Yay! The fix is to open App.xaml and change the StartupUri.
    5. Compile and hope you didn’t make a single typo anywhere. Then recall fond memories of the winform days when refactoring took care of everything.
  • Converting an application project into a library. It’s simple but unintuitive. Change the “Output type” in the project properties to “class library”. Now your application will completely break. The fix is to drop app.xaml and the .cs file from the class project. We shouldn’t have to do this!

A Nifty Video (WPF & OpenGL)

*Update: I released the framework.

I needed the ability to manipulate lots of geometry in WPF. Unfortunately, that’s just not feasible with the current framework, so I made this little demo to test out an OpenGL framework that I’ve been working on. It uses vertex shaders, pixel shaders, and framebuffers with some hacked together binding.

For those of you at MIX 09, this was the app that I was playing with.

[mediaplayer src=http://steveh.co/blog/wp-content/uploads/2009/03/wpftk2.wmv]