Andrej Tozon's blog

In my previous post I briefly described the process of creating a large Deep Zoom image with Microsoft Image Composite Editor. This post is going to present the steps I took with ICE in a little bit more detail, just to show its power.

As I mentioned in that post, I shot the scene with 24 (6x4) - kind of - detailed photos, which gave me the following set (arranged with the Deep Zoom Composer):

It doesn’t take a very detailed examination to notice how partial set photos are not distributed evenly, bear different lighting and some of them even being way out of focus. Now let’s see how ICE works it’s magic…

The ICE UI is simple as it is with Deep Zoom Composer. One thing I don’t get though is that I have to start it twice before the app actually appears on my desktop. Anyway, here’s how it looks when started:

The instructions couldn’t be simpler – I just had to drop all part photos onto editor’s main space and let it process them. After a minute or so, I got this:

Notice the perspective corrections? Camera motion setting was set to Rotating motion, which obviously hinted the processor that the scene was set from one single spot (like panorama). There is an option to adjust perspective and projection, which I simply didn’t need to do in this case.

Next were the crop settings – Automatic crop selects the optimal rectangle to exclude empty spaces:
 

The Export sections offers a couple of options: your creation is exportable in a number formats, which selection varies depending on a scale setting. With the largest scale (100%), available formats are: TIFF Image, HD View Tileset and Deep Zoom Tileset. Smaller thumbnail creation is optional. Deep Zoom Tileset was the one I wanted, but before hitting the Export button, I took some more time to adjust the selection rectangle on the left to exclude an unimportant part of the scene:
 

After clicking the Export Button, I was asked for a target directory and the project name. After that, the processor took over for a few minutes to render the output, which resulted in a ready-to-publish Deep Zoom folder.

Talking about publishing Deep Zoom/Silverlight content, here’s a little trick: if your hosting provider doesn’t have MIME types for Silverlight apps set up correctly, you can rename your XAP file to ZIP (including any references to it in accompanying files) and your app should still work.

The final result can be seen in the original post.

Setting up the nativity scene for the Christmas holidays has been my family tradition going back way before I was born. Most figures are dated back to my grandparents era, while the others (mostly sheep) were gathered over the years.

Each year, the scene setup is determined by a couple of factors, like the current inspiration/mood, the place to set it up and starting this this year – accessibility; we really don’t want our little munchkin do some redecoration on her own :) So this year I set it up on the less accessible place and made it a little bit smaller than usual.

At the same time, I wanted to try out the Microsoft ICE (Image Composite Editor), an amazing (free) piece of software, coming from Microsoft Research, which is doing a brilliant job at stitching your partial photos of the same subject into one really big photo, preserving the original resolution. The latest version has an option to export the final scene as a Silverlight Deep Zoom image, and this was the one that I was interested in trying out.

First, I tried to shoot a large number of really small and detailed photos (like 20 photos in one row by 10 rows), but soon realized that the place wasn’t getting enough light and/or my lenses were not up for the job. Also, this was an experiment rather than a professional job, so instead of bringing in more light, I decided to go smaller (6x4 photos only). Much less time consuming, I tell you… Anyway, I was very doubtful about the final result, because the exposure settings were not consistent throughout all photos and I left the autofocus on. I did try to keep the aperture small and constant for a decent DoF, but the shutter speed value kept going through the roof :)

Now, given the fact that I wasn’t really trying that hard, the final result looks very good for convincing me to give some more time and effort into my next panoramic photo projects.

And here it is – our Deep Zoom-ed Christmas Nativity Scene 2008:

Side note 1: with SeaDragon technology (the one behind Deep Zoom) coming to iPhone [Seadragon Mobile], I can now carry this image with me in my pocket :)

Side note 2: and how’s that for an original nativity scene? :)

I was thinking about switching this blog’s engine for some time now, mainly because I was stuck with Community Server 2007 (.NET 1.1!), not playing along with any further upgrades. Too much custom actions and customization, I guess. Meanwhile, Community Server went mainstream and developed into a really big and complete community solution (blogs, forums, wikis, galleries, …), while I only needed a simple blog engine.

I became more alert about the BlogEngine.NET after our local MS DPE’s set up their blogging site. Loving its simplicity and responsiveness, the idea of migrating to a new engine was becoming stronger by the day, until I gave in and gave it a try. Note: the root of all evil lied in the fact that my blog is hosted on my hosting provider servers with limited access and other options. 

The setup couldn’t be easier – copy the files. The tricky part was migrating the data. Hopefully, others have been on the same path before me (here and here), so I just had to adapt those sql scripts a little and get rid of all the spam, which found its way into my database through all these years. The new database is currently 20x smaller than the old one, which sure sounds good too.

I’m not completely saying goodbye to Community Server though. SLODUG, SLOWUG and Spletomanija communities will continue to run on Community Server, which fits perfectly for the job.

Also of interest: BlogEngine.NET is a part of Sueetie.

And yes, I’ll do some work on this site’s visuals…

If you followed me on Twitter you’d know about my latest little “problem”. I decided not to wait another month for my New Year’s resolutions, but start losing that extra weight right away. To help me keep my score, I created a little Silverlight app, showing my progress visually, through a line chart. Since charts were introduced in recently released Silverlight Toolkit, this was a very simple task.

All I had to do was:

1. Create a SQL 2008 database to keep my weight history in. The key idea here ware daily updates…
2. Expose data as a service (WCF, what else)
3. Build a Silverlight front end, which would consume this data service and present the data using the Chart bits from Silverlight Toolkit.

After browsing through some of the enclosed samples, it all boiled down to just these few lines of Xaml:

<UserControl 
    x:Class="WeightWatch.Page"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:local="clr-namespace:WeightWatch"
    xmlns:charting="clr-namespace:Microsoft.Windows.Controls.DataVisualization.Charting;
                    assembly=Microsoft.Windows.Controls.DataVisualization"
    Width="600" Height="300">
    <UserControl.DataContext>
        <local:ViewModel />
    </UserControl.DataContext>
    <Grid x:Name="LayoutRoot">
        <charting:Chart Title="Andrej's Weight Watch" LegendTitle="Legend">
            <charting:Chart.Series>
                <charting:LineSeries
                        Title="Running Weight"
                        ItemsSource="{Binding RunningWeight}"
                        IndependentValueBinding="{Binding Date}"
                        DependentValueBinding="{Binding Weight}" />
                <charting:LineSeries
                        Title="Target Weight"
                        ItemsSource="{Binding TargetWeight}"
                        IndependentValueBinding="{Binding Date}"
                        DependentValueBinding="{Binding Weight}" />
            </charting:Chart.Series>
        </charting:Chart>
    </Grid>
</UserControl>

With the exception of the ViewModel, which is responsible of fetching the data from the service, there was absolutely no additional code required for this to work. Simplicity at its best. There’s of course much more to this than just displaying static data lines in a box; I have a long way to lose those 10+ kilos, which will give me plenty of time to update this sample with some new features.

And here's my progress: