Geodesic source code for Silverlight 4.0

Geodesics

The shortest path between two points on an arbitrary surface is called a Geodesic, and on a sphere, it is a Great Circle. Modelling the surface of the earth as a perfect sphere, the shortest distance between any two locations on the surface is then described by a section of a Great Circle, ie an arc that lies on the plane that is described by the vectors between its start and end points and the Earth’s centre ( see figure 1 ).

With this information, one way ( and the way I have adopted ) to plot such a curve is as follows:

1. Generate the points of the curve in two dimensions using the parametric equation of a circle.
2. Transform the plane of the 2d curve into 3D space such that it intersects the end points on the sphere, and the sphere’s centre.
3. Project the transformed points back into 2D space using the Mercator projection equations.

A Parametric Representation of a Great Circle

The Mercator projection gives the 2D rectilinear coordinates (x,y) as a function of the latitude and longitude of a point on a sphere. However, it is easier to draw the point using a typical drawing API, if we have a representation that gives each point of the curve in terms of a single parameter. To derive such a function, we observe that the parametric equation for a circle is given by

Since a great circle is a rigid transformation of a circle in 3D space, it can also be represented as a function of a single parameter

where is a 2×3 matrix that transforms the plane circle to a location on a sphere. Using spherical coordinates, the Mercator projection of the curve specified above is then

Now that we have a suitable parametric equation, we can draw the geodesic with a series of connected line segments by varying the parameter, t.

Mathematical note – the parameterization given by this expression is highly non-uniform, meaning that there are many more points generated in some parts of the curve than in others. The mathematics of generating uniform ( or natural ) parameterizations belongs to the field of differential curve geometry and is beyond the scope of this article ( and my brain ).

Implementation notes

Inevitably, the mathematics alone is not sufficient to produce an implementation of a reuseable class for the Bing Silverlight control. There are two main issues to resolve; firstly, it is not immediately obvious how to derive from the provided MapShapeBase class to create new shape overlays and secondly, how to handle drawing the curves when they ‘wrap’ beyond the map’s viewable area ( this is easier to illustrate than to describe – see the figure opposite ).

Inheriting from MapShapeBase

I must confess that I cheated slightly in implementing the MapGeodesicPath class, in that I used Reflector to peer into the implementation of the base class. The existing derivations of this class simply defer to MapShapeBase for most of the work, which they can do since for a MapPolygon and MapPolyline there is a one-to-one relationship between Locations, latitude and longitude points on the map and Points, the actual 2D cartesian coordinates used to draw the shape. For the Geodesic, this is not the case, because we only want to specify the start and ending points of the curve, not every point in between. A solution is to delegate the point generation code to a secondary class, one that can be independently tested.

Splitting the curves at the map boundary

When the curves wrap around the map projection, they need to be split at the boundary. This is done by finding the parameter t for the longitude value of the boundary. Where the longitude value is +/- 180, this is straightforward as the equation above reduces to,

For the first time, the main Prime Ministerial candidates for the 2010 UK General Elections, will take part in three live debates. Since the BBC have kindly made the full transcripts available, I decided to have a go at analyzing the data and creating a visual representation in the form of word clouds. I am currently working on my own visualization software, but in the meantime these have been done using Wordle.

Preparing the data

Download the raw text of the first debate.

Having done that, a command line tool such as awk can be used to split the data by speaker. For example, the following command outputs Clegg’s comments into a separate file:

awk 'BEGIN {RS=""; FS="[@]"} $1=="NC" { print $2 }' debate.txt > clegg.txt

Parsing the data

Python’s Natural Language Toolkit provides all the functions needed to analyze the text data, such as tokenizing the text by word and even categorizing each word by type, such as proper nouns and prepositions. For example, having extracted Nick Clegg’s speech as above and read the file as a string using Python, the following commands parse the input for sentences, and then tokenize each word procucing a complete word list.

from __future__ import division
import nltk, re, pprint

sentences = nltk.sent_tokenize(text)
tokens=[]
for s = sentences:
 tokens.extend(nltk.word_tokenize(s))
words=[t.lower() for t in tokens]

We can then categorize each word with a POS tag and extract a list appropriately, for example, using the word tokens above the following extracts all the nouns

# this operation takes some time to execute
taggedwords=nltk.pos_tag(words)
nouns=[word for (word,tag) in words if t == 'NN']

Such a list is enough to use with Wordle, however it’s straightforward to create a word frequency list for use with other software.

# this operation takes some time to execute
nounfrequencies = nltk.FreqDist(nouns)

Going further

Word frequency analyses are fairly straightforward, however NLTK is a powerful library and allows for much more detailed and informative analysis based on grammar and sentence structure. It would be interesting to see the results of a more sophisticated approach.

Gallery of word clouds from the first debate

As 2010 is the 100th anniversary of the first published infra red photograph, I thought I’d try my hand using my own digital camera and some easily acquired accessories. If you want, you can skip the theory and go straight to the description of the method and a script for Photoshop.

A quick overview of IR photography

The CCD that is responsible for recording the images photographed by most digital cameras, is already sensitive to the near infra red part of the spectrum. That is, the part of the spectrum outside of the range visible to the human eye, but not so far as that used for, for example, thermal imaging. Since most photographers are not interested in light that they can’t see, this light is usually filtered out by an infra red cutoff filter placed inside the camera body, directly in front of the CCD. However, such filters are imperfect, so with some camera models by combining a long exposure with an infra red transmitting filter placed in front of the lens, some of that IR light can be recovered. The figure shows the basic principle, though I should add that the graphs are just a sketch to illustrate the principle and don’t represent an actual CCD response curve.

Pseudocolour

The LAB Colour Model

The most common method of representing a colour image is by a combination of Red, Green and Blue ‘colour primaries’. The reason for this is simply because it then becomes relatively trivial to display an image using a video display, which also constructs an image using a combination of red, green and blue LEDs or phosphors. This is why such a model is known as a ‘device dependent’ model. However, RGB is not the only colour model, and if you are at all familiar with Photoshop you may be aware of the LAB model.

LAB, or CIELAB to give it its full name, is a device independent model, which like RGB is composed of three components ( or channels ) but in this case only the ‘A’ and ‘B’ components contain colour information, whereas the ‘L’ component contains pure luminosity information. Thus, by separating an image into LAB components it becomes possible to manipulate the luminosity and colour components of an image independently.

Method and Implementation in Photoshop

Equipment

1. Canon G10 Digital Compact Camera
2. LA-DC58K lens adapter for same
3. Hoya R72 58mm Infra Red filter
4. Tripod
5. Photoshop ( or GIMP )

The images in this post have been created from two source images, one a long exposure taken using the IR filter and the other a conventional colour image. Both images are converted into the LAB colour space, and a single image is then produced, using the Luminosity channel from the IR image and the ‘A’ and ‘B’ channels from the colour image. The photoshop script below will automate the process when applied to two source images, you can then manipulate the final image using the adjustment tools. You can also do much the same thing in GIMP using the Decompose/Compose features from the Colour menu, but it does not include Photoshop’s image registration or LAB colour adjustment features.

Download ir_composite.jsx.zip

To use the script, open the IR and corresponding colour image, and ensure that the IR image is selected. Then apply the script.

Practicalities

There are a number of limitations to multiple exposure photography methods such as this, especially ones which require long exposures and changes of camera equipment. It is best suited to landscape photography in good conditions where the multiple exposures can be easily aligned. If either image contains rapidly moving subjects these can ( and will ) show up as artefacts in the resulting image.

Gallery

Disclaimer : this is an opinion piece. I trust that people are capable of using Google to research the facts, though if you’re planning on using Wikipedia I should mention that this article has nothing to do with the film starring Kevin Costner or any episodes of Star Trek.

The idea

Tax ’speculative banking transactions’ at 0.05% to raise money for public services, and to fight global poverty and climate change. I am not economist enough to object to this on financial grounds, so I want to look at it from a purely ideological perspective.

Is global poverty an economic, or political problem?

The underlying assumption behind the campaign is that global poverty is an economic problem, one that can be solved largely by throwing money at it. Is that really the case? It seems to me that the underlying causes of poverty include poor education, sanitation, the prevalence of superstition, oppressive and unstable political regimes and tribal warfare. Some of the richest nations on earth have tried their hand at tackling these issues over the past century, although perhaps not altruistically, and had little in the way of success.

As of 2009, government support for banking institutions cost the UK taxpayer some £850bn, so it seems that the treasury has few problems in finding the cash when it’s required. The Robin Hood Tax proposes putting even more under their control, can our government institutions really be relied upon to manage it efficiently? Even if more money is earmarked for aid, how can we be sure that it will reach its intended destination? The BBC recently reported that a portion of the aid sent to ease the Ethiopian famine in the 1980s only ended up in the hands of  unscrupulous arms dealers.

Avoidance of responsibility

Charities need money, and on those grounds it would seem that the Tax would be a good idea. However, more than money, charities need volunteers willing to give up their time and their skills. Is there not the worry that by collectively handing responsibility for charitable giving over to the treasury, we wash our hands of the issues and carry on oblivious to the problems around us?

The underlying causes of global poverty and suffering in all their complexities will only be resolved by accepting, and not absolving ourselves of our responsibilities. What is needed is not increased taxation, but participation. If you are interested in volunteering opportunities in your area, see http://www.do-it.org.uk/

Scapegoating the financial services industry

The banking industry needs to take its share of the responsibility for the financial crisis, but so do we all. Everyone rode on the crest of the credit wave over the past decade, taking >100% mortgages, interest-free overdrafts, living on credit and accepting a lifestyle beyond our means.

Recently the government proposed a tax on bankers bonuses but to do such a thing constitutes a massive abuse of power. If the government wish to reduce the bonuses of bankers then they should use their influence as majority shareholders of the institutions that they have bailed out, surely to achieve the same thing through tax legislation is a conflict of interest? These individuals would be taxed not on the basis of what they earn but on what they do for a living. Many individuals receive salaries that the general public perceive to be grossly inflated, but I have yet to hear if the Robin Hood Tax would be extended to box office or football tickets.

Celebrity endorsements

This may seem a trivial objection, but I found the decision to promote this tax with a video featuring actors Bill Nighy ( 2 O levels ) and Robert Hardy ( BA in English from Oxford, so some education, at least ) incredibly patronising. David Attenborough, when asked of his opinion on global warming, used to refrain from making comments about it on the basis that he was a journalist, not a climatologist. It was only after seeing the magnitude of the effects for himself that he began to speak out. I wish more celebrities would follow his example and understand that, for better or worse, their fame gives them influence that far outstrips their knowledge of the subject. I dread to think of the number of Americans currently taking vaccination advice from Jim Carrey ( high school graduate ) and his wife Jenny McCarthy ( abandoned nursing college to pose for Playboy ). It’s unfortunate that the promoters of the Robin Hood Tax have decided to perpetuate the idea that actors are an authority on anything other than acting.

Last week myself and a group of friends took a winter camping trip up to the Lake District. An odd decision, it could be argued, seen as the region has recently seen both some of its worst flooding and coldest winters in recent years.  Nonethless, equipped with ice axe, crampons and a generous supply of Kendal Mint Cake we set out to climb Scafell.

Some of the things I learned

1. Elephants, though clearly signposted, are not common in the lake district. I didn’t see a single one all weekend. Sheep, however, are plentiful.
2. It may be effective as a deterrent against the Ravenous Bugblatter Beast of Traal, but a towel is no replacement for an insulating mattress.
3. Pop up tents, though useful on the beach, are less effective in torrential rain and gale force winds.
4. Retracing your steps back through the snow sounds easy, and it probably is for other people.
5. The Wasdale Head Inn serves an excellent selection of whiskeys, of which Lagavulin is the best. I should know, I tried all of them.
6. Swimming in Wastwater in January is almost exactly as cold as you’d expect.

The Route

The map below, which requires Microsoft Silverlight, was exported from my GPS wristwatch and shows the route we took up Scafell before visibility made further progress a bit risky, and so we retraced our steps back through the snow. Or at least tried to before our steps mysteriously disappeared. There is also a Photosynth from part of our route available.

Swimming in Wastwater

Although as an amateur triathlete I’ve done many open water swims, I’ve never done one in winter and never without a wetsuit. So, in an attempt to kill both birds with one stone I decided to go for a swim in Wastwater in January. I lasted about two minutes. I’m no Lewis Gordon Pugh. It was cold, but it really wasn’t as bad as you might think.  The water was beautifully clear but unfortunately sharp rocks do not a beach make.

Gallery

Microsoft have recently released a beta of Silverlight 4, which has limited support for native interoperation using COM. Potentially, this example could be applied to any number of native interop scenarios, however for this example I have chosen to use Nvidia’s CUDA technology.

Disclaimer : This is an example of what can be done, not necessarily, and in all likelihood, an example of how it should be done.

About CUDA

Up until around 2001 PC graphics cards, though powerful, implemented a fixed function pipeline that limited use to whatever was exposed by the APIs, usually Direct3D or OpenGL. The addition of a programmable pixel pipeline led to the use of graphics cards for more general computation tasks; at first using shaders directly, followed by higher level GPU specific programming languages, such as Brook, SH, and later NVidia’s CUDA. Most of this work was, and is, documented by the GPGPU group. NVIDIA’s website shows CUDA being used in a wide variety of applications but in practice it is best employed in so called “embarassingly parallel” problems.

The demonstration application

The demo below shows a Silverlight 4 beta application, which implements a recursive gaussian filter. Note that this is not the same algorithm provided by the sample in the CUDA SDK, but a more efficient method, which is described in detail in [1] for those interested. The main advantage of a filter implemented in this way is that the computation time is independent of the width of the filter.
To enable CUDA interop, you’ll need a CUDA compatible graphics card. Then do the following,

1. Install the MFC COM application (link below). The installer should register the application with COM automatically.
2. Right click on the Silverlight App and install it for running outside of the browser. The CUDA option should now be available from the Combo box.

Source code : SilverlightCudaInteropDemo.zip
Install MFC COM Application (5.5 Mb)

The native component

The native component takes the form of a COM Automation server, implemented as a client side MFC application.

Note: Make sure you run Visual Studio with Administrator privileges, otherwise registering the automation server with COM will fail.

MFC and Automation are beyond the scope of this article, but the basic process I followed was thus

1. Create an MFC Dialog application using the Wizard. Make sure to enable Automation support
2. Add a method to the autmation interface using the add Method wizard from the Class View
3. Add a dual interface using this Technical Note from MSDN.
4. If you get link errors, make sure to include the output of MIDL in the application class ( the one that contains OnInitInstance). I couldn’t find any reference to this step, but it’s how the samples work.
5. Make sure that the run time library options passed to nvcc and msvc match, ie they should all use a DLL or Static linking, not a mixture of both
6. If you get stuck, take a look at the MFC Samples, particularly acdual.

when you pass a native array through COM Automation, it is converted to a SAFEARRAY on the native side. Note that I couldn’t find any documentation on this, I discovered it through experience. The code snippets below show sending and receiving array data between Silverlight and the MFC application.

Using MEF to implement the application

The Managed Extensibility Framework is an extensible plugin framework for .NET applications and Silverlight. I have used it to dynamically discover implementations of IProcessorProvider based on the permissions available to the Silverlight application. The figure below shows the component structure of the application.

Performance notes

Silverlight

Unlike the Reaction Diffusion simulation, for this application I have chosen to use Silverlight’s WriteableBitmap, introduced in Silverlight 3, rather than dynamic PNG encoding. This revealed an interesting performance issue when using a typical double loop to iterate over the pixels. Initial timings revealed that the vast majority of the time was spent in updating the WriteableBitmap rather than actually performing the image processing. The initial update loop used the PixelWidth and PixelHeight properties to bound the loop counters, taking about 200ms to iterate over the loop.

By caching the bitmap properties in local variables, the timing was reduced to ~5ms. Needless to say I was shocked by how much of a difference such a seemingly trivial change made.

OLE Automation

The guidelines for building performant automation code is much the same as that for other unmanaged interop scenarios in .NET : avoid chatty interfaces. Note that this is exactly what I have not done here. In fact, the time it takes CUDA to perform the image processing is dwarfed by the time it takes to marshal the data between Silverlight and COM. This can be mitigated somewhat by splitting the blur call into two operations, one to load the image, which is called only upon initialization, and one to perform the blur.

CUDA

CUDA operations are extremely sensitive to data alignment and the order in which threads access data. Kernels should be written in such a way that threads access adjacent data elements, meaning that the row major access pattern familiar to C and C# developers would produce suboptimal performance ( sometimes by as much as an order of magnitude ). Instead, array accesses should be performed in a manner more reminiscent of FORTRAN. In addition, 2D arrays should be padded out so that threads access data elements that are correctly aligned ( see the CUDA documentation for the correct alignment values ). A full exposition of performance optimization for CUDA is really beyond the scope of this article, there are many examples in the NVIDIA documentation although the terminology can be somewhat opaque. One of the clearest explanations I have found is this presentation from Mark Harris at Supercomputing 2007.

References

1. Young, I.T. & van Vliet,L.J, 1995. Recursive implementation of the Gaussian filter. Signal Processing, 44, pp.139-151.

This is the second in a series of attempts to do some piano recordings, a project which started out of a desire to conquer stagefright on the rare occasions that I perform in public. Increasingly I have been investigating the process in more depth, making use of Cubase and various recording techniques. The result of these investigations is this recording of Sergei Rachmaninoff’s Prelude in D Major, which I performed at a recital in June. This represents probably the best recording I can achieve given my upright piano and limited knowledge of recording techniques. The audio player requires Silverlight, I have also provided a link to an mp3 file.

Prelude in D Major, Op3 No 4 by Sergei Rachmaninoff

Setup

This article from Sound on Sound describes a number of piano recording methods, including several for upright piano. The simple fact is that an upright piano is not a suitable instrument for recording, however by following some of the advice in the article I think i have probably got the best I can from the instrument and the equipment available. The picture on the right shows the setup, which is as follows

• Kawai upright piano
• Alesis IO|2 stereo interface
• Pair AKG Perceptron 150 microphones in crossed stereo configuration
• Laptop computer running Cubase LE ( supplied with the Alesis hardware )

Most of the kit is quite portable, so at some point I hope to repeat the experiment with a grand piano and compare the results.

Silverlight toolkit themes do not support merged dictionaries

Unfortunately, merged dictionaries are not supported by the Silverlight Toolkit’s Themes feature – at least not as it stands. For example, the following XAML and accompanying class causes a XamlParseException if you try to use it.

All is not lost however, since full source code is provided for the Silverlight Toolkit, so it becomes a straightforward matter to track down the problem and supply a patch.

Writing a test to reproduce the problem

Since the toolkit comes with an accompanying test suite, we proceed in textbook TDD fashion by first writing a test that exercises the issue. We can reuse some of the existing code to do this, adding a resource dictionary containing a merged dictionary reference and adding the following test to the ImplicitStyleManagerTest class

The test fails as we would expect.

Fix the code to make the test pass

The Theme class works by transforming the ResourceDictionary xaml into a ContentControl. A quick glance at the xaml generated by this process in the Visual Studio debugger shows why an exception is being raised.

The ResourceDictionary.MergedDictionaries element is missing its parent ResourceDictionary element, so we add a couple of lines of code to ResourceParser.ParseElement to detect the element and wrap it in a ResourceDictionary, using LINQ to XML.

Having made the change, we rerun the test.

As we would hope, our custom theme now works as expected and we also have a unit test that ensures the bug does not reoccur. Note the Xaml code above, in that the Resource Dictionary is referenced using Pack Uri syntax. This is because Button.xaml is compiled as a Resource, rather than Content, since the latter doesn’t appear to work reliably and can result in obfuscated error messages such as XamlParseException: attribute “Button.xaml” value out of range.

I have submitted the patch for this fix to the toolkit site on Codeplex.

In December I had my first piano recital in nearly two years, and so I started to look into various methods that performers use to conquer performance anxiety, something which causes me a lot of grief. Lately I’ve been hanging around with a number of friends involved in Cambridge’s thriving local music scene, and so not willing to go the beta blockers route I started thinking about doing some recordings. This way not only do I get to hear what the audience hears but it also reproduces some of the pressure that comes with performing for an audience. The audiofile above is my first effort, a recording of Sergei Rachmaninoff’s Prelude in C♯ Minor.

Ok, nobody’s ever going to sign me up for any recording contracts and there were a number of dodgy chords in that last section but I thought it was pretty good for a first effort. It was recorded in one take and I haven’t added anything else since the whole point of this exercise is as practice for a live performance.

Kit

I spent a little under £200 ( excluding the piano and the laptop ) on the recording kit, from Digital Village in Cambridge. I used an Alesis IO|2 stereo mixer attached to a laptop running a cutdown version of Cubase that came with the mixer, and a couple of cheap microphones stuffed down the piano cabinet and secured with parcel tape. The piano is a fairly largish Kawai upright.