MVVM and SOA for scientific visualization

I've been working on an architecture that combines the simplicity of MVVM for UI interactions with the scalability, pluggability, and distributedness of SOA for processing data for visualization.  The first prototype I've implemented is in the form of the PheonixRt.Mvvm application (on github at https://github.com/dg1an3/PheonixRt.Mvvm)

PheonixRt.Mvvm is split in to two exe's:

• Front-end
• UI containing the MVVM
• Interaction with back-end services is via service helpers (using standard .NET events)
• Back-end
• hosts the services responsible for pre-processing data
• hosts services that visualize the data, such as calculating an MPR, a mesh intersection, or an isosurface

The important interface is between what processing should be done by services, versus what processing can be done by the View (which is WPF in this case).  The line I've drawn is that anything that has been reduced to a:

• Bitmap (including alpha values)
• 2D vector geometry, such as a line, polyline, or polygon
• 2D transformation

can be exposed as bindable properties on the ViewModel, and then any additional rendering can be done by the View (for instance to add adornments, or other rendering styles).  So the services are necessary to turn the data in to these kinds of primitives, and WPF will take it from there.

This prototype also looks at the use of the standy pool as a means of caching large amounts of data to be ready for loading.  This is similar to what the Windows SuperFetch feature does for DLLs, but in this case it is large volumetric data being pre-cached.

Crowd Sourcing and Anonymous Science

Maybe the future of science will be in the form of crowd-sourced anonymous discussions, which will be used to formulate testable hypotheses and experimental design.  Then publicly funded labs would pick up the work, perform the experiments, and publish the results.  The results would then be discussed by the anonymous crowds.

The anonymity is crucial, because it would act as an objectivity filter.  The mechanism of anonymity would specifically act to prevent the formation of visible "personas", because comments would not be traceable to a known identity.  So over time the discussions would assume the form of a "collective mind" debating with itself.

word2vec

I've been able to analyze some notes using word2vec, and the extracted "meaning" has some interesting properties.  Maybe next I'll run some archived comments from the Mosaiq Users listserv and see how often users talk about

• slow loading of images
• import problems due to inconsistent SRO semantics
• issues with imported structure sets
• re-registering the ImageReview3DForm COM control

[which all point to a need for a better image review capability for Mosaiq users.]

pheonixrt has a new home!

I just recently completed the GitHub migration, due to Google Code shutting down.

https://github.com/dg1an3/pheonixrt

Three projects are represented:

• pheonixrt is the original inverse planning algorithm based on the convolutional input layer
• WarpTPS is the interactive morphing using TPSs
• ALGT is the predicate verification tools

Also, see the references at the end of http://en.wikipedia.org/wiki/Thin_plate_spline for some videos showing WarpTPS.

d3

I've been starting to look at d3, and what kinds of cool things can be done with it.  The examples are pretty nifty, especially as a starting point for more complex things.

To get a feel for the code under src\, I made a code tree map:





Basically I followed the same formula; on a local PC I placed the d3 javascript and then ran:

for /S %n in (*.js) find /C ";" %n >> output.txt

which produces a list of line counts with at least one semicolon.  Then I imported the result in to a Google spreadsheet, sorted and removed unnecessary files, and then created the treemap.

playing with Cytoscape

and I transferred part of the SonicSpace (my old test space for theWheel) in to cytoscape and used a force-directed layout to get the following (with some manual tweaks):

I also manually changed the size of the nodes, though ideally I would like to implement a cytoscape plugin that would propagate activation changes for me.

Would also like to experiment with cytoscape web, whenever I have the time.

Reading about Rudy Rucker's Lifebox

Lifebox Immortality & How We Got There

I like the fact that he talks about the lifebox as being a sort of digital-immortality lite, because it sidesteps the question of embodying a full human being (with all concomitant rights and responsibilities) in a digital form.  I think it cuts to the heart of the issue, which is that a human being, in life, has a lot of baggage that may not be desirable to transcribe to a different form.  Rather, the transcription may want to 'filter out' parts that won't translate well across time...

Plus it reminds me of what I was aiming for with theWeel and now fatline, which is an interactive presentation of the things that have interested me in my life.  Ted Nelson's Xanadu concept seems to fit with this idea.

Fatline Events

Have been arranging timelines on TimeGlider, because they let me expand / contract events based on relative importance (which of course seems to change over time anyway) which is I think one of key features of fatline. In TimeGlider I can arrange to have work / school related events on top of the timeline, and personal events on the bottom, like this:

I started contemplating the various categories of things I included on the fatline, and a set of tags that capture them.  I think the main ones are:

Using these as axes, I can define a set of coordinates for each event in this 7-dimensional space, and then perform an SOM for the events.  The SOM could be 2-D, and include time / place for each events, or it could be 1-D and use the timeline itself as one of the dimensions.

New Eevorg screen shot

After mucking around for some time, I've managed to dust off my old Eevorg code and incorporate it (with minimal bells and whistles) in to a basic MFC application.  We are rendering with interpolation, to support multiple zoom scales across the child hierarchy.

We also have a simple mechanism to back up (showing the parent to the left of the current eevorg).

Still to be done, is to implement:

• a persistence mechanism 
• some properties (state count, entropy, maybe lookup table, maybe favorite button)
• filtering of later generations, to eliminate the aliases in the bottom of some of the eevorg
• implement as an OpenGL rendering (would take care of filtering using texture mipmaps)

Of course, we would like to implement as a web service so that people can use a browser to browse the eevorg.  And eventually maybe an iPhone/iPad app would be pretty nifty too...

DarwinTunes.org and Crowdsourcing

DarwinTunes.org reminds me of my idea for evolving ragtime MIDIs from this blog post Ragtime Music and Crowdsourcing.  But I think both ideas are really just recapping what happens musically around the world, which is that particular musical "memes" are heard by different musicians and thus spread.  So the most successful memes become most prevalent, and less successful ones slowly fade away.

What makes a musical meme successful?  Maybe its ability to be used to invoke particular emotions.  Or maybe it is that it can flexibly invoke different emotions given different contexts (maybe this is where my interest in the  Eastern European modalities comes from)

Dynamic call graph treemaps

I'm trying to come up with new visualization techniques for analyzing code.  The static structure diagrams / UML diagrams are all well and fine, but I kind of want something that shows the relationship among objects resulting from the actual code execution.

So I'm looking at whether you can create a tree map, where the tree reflects the call hierarchy of the code with each method as a node, but then the size of each node in the tree map is proportional to the amount of time spent executing that method.  And maybe a very Tufte-esque graph inside each node could reflect consumption of resources (like memory) that were allocated / released during the execution.

Quitwiki

What if there was a wiki, a kind of DIY site that specifically concentrated on quitting services, products, etc. while preserving the value obtained from those services, products, etc.   I guess the basic idea is to pool collective knowledge to lower switching costs for products and services.

For instance, if I want to stop using Quicken to manage my money (maybe to switch to Mint.com, or to just use spreadsheets), then I could go to this "Quitwiki" to find out about how to ensure the highest level of data portability, potential compatibility issues, etc.  I think one of the main things it would need to provide is tools for conversion and access to file formats, APIs, and other tools like that.

LINQ to Fields

I've been looking in to the lambda expression capability in LINQ / C# 3.0, and it occurred to me that it provides the perfect mechanism for implementing a field abstraction that I have been thinking about for a while.  The idea is that an image / volume / region / transform is represented at its most basic level as a lambda which takes a vector is input and produces a scalar, vector, or bool as its output.

The most interesting part is the use of the Expression<> to create expressions trees.  This allows lambdas to be combined in to algebraic expressions to form new lambdas, but the result is an expression tree that can be examined via reflection.  So, one could assemble the lambda that represents some image processing operation, and then an inference could be made to construct a pipeline (for instance, with ITK) that implements the expression.

Then LINQ could be used to construct these expressions, given a set of data objects and possible transformations that could be applied.  Each field entity would have the necessary attributes to describe how it could be combined with other entities, and then the LINQ query would do the combining.

Writer's strike solution

The networks need to create a new Reality TV show with a group of unemployed writers living together in a house in the Hollywood Hills. Each episode involves them getting in to a zany situation, and then they have to write themselves out of it...

Rubberneck TV

I sat in a traffic jam on I-280 this morning that stretched for ~5 miles, apparently caused by a motorcycle accident. I realized that there is a very cool and useful feature that should be available for current model cars, what with their LCD panels and communication systems built in to the navigation dashboard: RubberneckTV!

The basic idea is that when a traffic backup occurs due to a crash, there could be a single reporter with a camera (or maybe even a passing motorist vlogger) that is on the scene right away. They would have access to a special mobile transmitter, able to transmit footage and a live report to the cars waiting in traffic due to the crash.

So people could tune in, find out about the crash, find out if anyone was hurt, etc. They could get their entire fix of the most immediately relevent news item in their life at the moment. After 30 minutes of waiting in traffic, when they finally reach the crash scene, there will be no slowing down to take a look, because it will already be stale news...

Ragtime Music and "Crowdsourcing"

I have been searching on Ragtime music, and found this great web page with MIDI files for some of the big ragtime pieces from the turn of the century.

Ragtime is unique because it was first original contribution from American culture to the world of music, and in many ways represented the beginning of consumer pop culture. The advent of inexpensive parlor pianos at the turn of the century created a market for sheet music, and somewhat later the player piano created a market for piano rolls.

Ragtime served the needs of both markets well -- by incorporating rapidly shifting chromatic accompaniments, the need for a perfectly tuned piano was lessened (one of the big problems with the less-expensive mass-produced pianos of the day). At the same time, a musical genre whose primary complexity was in voicing, chord sequences, and interacting melodies (as opposed to the obligatory performance nuances of classical piano pieces) made a perfect candidate for encoding on the "digital" player piano roll.

Furthermore, ragtime as a fusion of classical European melodic invention with the heavy backbeat of African rhythm was the first real representation of black culture in the parlors of white America (and white Europe for that matter), paving the way for the advent of Jazz as the definitive original American musical genre.

The availability of free MIDI files of ragtime classics, with MIDI being the modern technology equivalent of player piano rolls, brings ragtime full-circle -- an inexpensive, populist form of entertainment.

The final link will be the advent of a ragtime generator -- a piece of software that, given a starting motif or chord sequence, can generate a full ragtime piece. The ragtime generator could also start with a piece and then modify it in particular ways. Then the social phenomenon of ragtime "trees" can really take hold -- I generate a piece that I e-mail to you, then you use your generator to modify the piece and forward it on to another in the musicological equivalent of a game of operator.