IMAP for migrating from OSX Mail to Thunderbird

There is a common online question about migrating from Apple’s Mail app (Using .emlx format mail files) to Thunderbird (or any other non-Mail app). I looked at a few options and have decided, as strange as it may seem, that installing an IMAP service was the best solution.

IMAP is normally known for it’s server-side mail storage with download/offline browsing on the client side as needed. If you want to travel lighter and have no trouble depending on Internet access for getting at some of your mail, then IMAP is for you. For you Gmail lovers, it has an IMAP option too so you don’t have to have multiple copies of your mail on PCs as well as their online services.

That said, installing IMAP (this time around) was really easy on my new sidux linux box. A couple of apt-get install later, generate an SSL certificate and I was away to the races!

Over on my Mac side, I connected to my IMAP service, created a new folder/mailbox and copied my messages over from my normal old POP account into the new IMAP one. Instantly I have a copy on my server in a flatfile that I can also access from Thunderbird.

In Thunderbird I can set up my normal POP accounts, but also set up the IMAP one. Now I can just drag the messages over from IMAP into the POP account.

Job done, carry on with life. One more nail in my Mac dependency coffin. 😉

Next time I have a long weekend I will configure my server to download my POP mail into my server IMAP folders, so I can run IMAP all the time and use VPN to get to my email securely.

Drop me a note if you’re interested (or already know how to already) too.

* This site helped me get the basics done, though I think it’s out of date. On Debian I could skip the SSL certificate part of this tutorial and also user accounts were automagically enabled already.

Datum transformation in Python

I’ll describe here a procedure for the evaluation of the tranforming parameters necessary to effect coordinates change among reference frames materialized on different Datum.

In order to have the changing of Datum it is used a
geometric transformation of correspond (conforme) type through the resolution of a last squares system based on a homologous points series, in order toobtain the direct changing from plane coordinates in one of the two Datum
to the corresponding in the other Datum.

The procedure realyzed in Python
environment, provides the possibilty to apply both a conforme transformation
(plane rotation with translation and isotropic scale variation) and of affine transformation (plane rotation with translation and anisotropic scale variation).

The
code has been implemented in a Python module sasha.py, in order to operate
geometric transformation on text files, trhough the use of special software libraries (numpy , scipy ) .

An example on how to use scipy-numpy to make a datum transformation :

>>from numpy import *
>>from scipy import *
>>L = io.readarray(str('locale'))
>>G = io.readarray(str('globale'))
>>L

array([[ 496.4 , -14853.55],
[ -405.58, -15197.24],
[ 602.12, -15273.71],
[ 643.14, -15141.68]])

>>G

array([[ 2561715.65, 4444638.81],
[ 2560815.52, 4444289.81],
[ 2561823.58, 4444219.83],
[ 2561863.75, 4444351.03]])

>>A = zeros((2*L.shape[0],4),float)
>>A

array([[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.]])

>>A[ ::2, 0] = 1.0
>>A[1::2, 1] = 1.0
>>A[ ::2, 2] = L[:,0]
>>A[1::2, 2] = L[:,1]
>>A[ ::2, 3] = L[:,1]
>>A[1::2, 3] = -L[:,0]
>>A

array([[ 1.00000000e+00, 0.00000000e+00, 4.96400000e+02,
-1.48535500e+04],
[ 0.00000000e+00, 1.00000000e+00, -1.48535500e+04,
-4.96400000e+02],
[ 1.00000000e+00, 0.00000000e+00, -4.05580000e+02,
-1.51972400e+04],
[ 0.00000000e+00, 1.00000000e+00, -1.51972400e+04,
4.05580000e+02],
[ 1.00000000e+00, 0.00000000e+00, 6.02120000e+02,
-1.52737100e+04],
[ 0.00000000e+00, 1.00000000e+00, -1.52737100e+04,
-6.02120000e+02],
[ 1.00000000e+00, 0.00000000e+00, 6.43140000e+02,
-1.51416800e+04],
[ 0.00000000e+00, 1.00000000e+00, -1.51416800e+04,
-6.43140000e+02]])

>>Y = zeros((2*G.shape[0],1),float)

array([[ 0.],
[ 0.],
[ 0.],
[ 0.],
[ 0.],
[ 0.],
[ 0.],
[ 0.]])

>>Y[ ::2, 0] = G[:,0]
>>Y[1::2, 0] = G[:,1]
>>Y

array([[ 2561715.65],
[ 4444638.81],
[ 2560815.52],
[ 4444289.81],
[ 2561823.58],
[ 4444219.83],
[ 2561863.75],
[ 4444351.03]])

>>N = dot(A.T.conj(), A)
>>T = dot(A.T.conj(), Y)
>>C = dot(linalg.inv(N), T)
>>C

array([[ 2.56113298e+06],
[ 4.45948730e+06],
[ 9.99856124e-01],
[ -5.80009571e-03]])

>>E0 = C[0]
>>N0 = C[1]
>>a = C[2]
>>b = C[3]
>>x = E0 + L[0,0] * a + L[0,1] * b
>>y = N0 + L[0,1] * a – L[0,0] * b
>>print x,y

[ 2561715.45624184] [ 4444638.76898143]

Examples on how to use sasha.py


>> #in python
>> from sasha import conforme
>> print conforme('GCP1.txt','GCP2.txt','x','out.txt')
Parametri di trasformazione :
Tx : -2587285.48816
Ty : -4445117.1582
Rotazione rigida : [ 0.33236506]
Fattore di scala: [ 1.]
Varianza dei parametri geometrici :
Sigma quadro rotazione rigida : 0.0244664334334
Sigma quadro varazione di scala : 0.000854147546627
Scarto quadratico medio : 0.343476930718
none

Guest blogger Massimo Di Stefano

Over the past few months I’ve been picking away on various hardware projects, particularly configuring my Arduino board as a USB joystick device and fusing in Python code, GPS signals, etc.

During this time I met Massimo Di Stefano (aka epifanio) who is also doing a bunch of neat controller work with ossimPlanet. You may know him from the #osgeo channel in IRC. We both feel we are just playing around in our spare time, but have some common goals. We are both interested in open source, hardware, ossimPlanet, Python, GPS and UAVs.

His work is encouraging for me and I think it is really cool. To help share some of his work, he’ll be blogging on here from time to time (he has his own feed).

Slashgeo – my source for news

As official Slashgeo day I wanted to make mention of this service for geospatial related news topics. When I’m too busy to browse through lists of blogs and websites, I can always depend on some interesting headlines from Satri and the gang. They are sure to point out much open source related news as well, which I always appreciate.

See: Slashgeo.org
—–
For open source focused blog entries, check out the OSGeo Planet Feed.

Safety Net for Cloud Computing?

A friend pointed out this Guardian article about Stallman’s (and others) perspective on the cloud computing direction. From an open source perspective I’ve felt similar concerns re: the shift to GMail, but I know that many users (like me) merely use it for mail mirroring, not a wholesale dependency.

As I got into FOSS, I prided myself on being “independent” of proprietary control – many of us started by running Linux on our home networks just to help maintain that sense of control and security. But with cloud computing, perhaps there’s a different story. What’s it worth to tap into that power? Are FOSS developers and service providers really going to move important services to these kinds of platforms? Intriguing, yes and exciting, no doubt – but how far will we go?

Like traditional proprietary strangleholds, I believe the FOSS universe will come through with their own alternatives. With all the Linux smarts sitting around, wouldn’t some sort of loosely coupled, FOSS-based peer-to-peer clustering network be enough for most of us? Or are FOSS developers and system integrators really ready to invest themselves in somebody else’s black boxes?

Did we learn nothing from Skynet or the first Cylon War? Those documentaries were accurate, right?

Disclaimer: Since my first introduction to “cloud computing” was through marketing hype, I’m trying to ignore that it exists until someone tells me it’s really useful. So, for now, my ignorance is intentional. 😉

A home server version of Linux – Amahi

What better way to spend a long weekend that experimenting with a new Linux-based file-sharing and networking platform? 😉 Amahi Linux Home Server aka the Home Digital Assistant is a set of pre-configured tools and services that are added on to the Fedora Core base. I just learned about it and thought I’d give it a try.
It’s currently in beta but is already looking like an interesting and “more easy” way of getting a home network up and running. Pretty much straight out of the box, you can map to a central set of Samba shares and access a web-based interface to various admin functions. Using ssh or samba, you can copy your docs, music and pictures over to it and use various built-in apps to access them. You can serve up your mp3 folder into a stream using the FireFly Media Server service, view your photos in a nice viewer and set up and monitor backup processes. I am especially interested in trying out the pre-configured VPN service!

For me, its primary purpose will be so I can have access to my docs and data while on the go, but my other interest is using this kind of system as a base for some geospatial tools. Similar to the FGS suite, or the OSGeo for Windows installed, I’d love to have my geospatial apps pre-configured and ready to use for interesting things like cataloguing data, browsing files and sharing maps.
There is still some progress to be made, especially to get it ready for Fedora 9, but take a tour – I’ll be interested to know what you think.

Handling sensors and smoothing input

I haven’t had time to put up more photos or instructions, but have made a little progress with adding sensors to my Arduino (aka Freeduino) board. I now have a range of code and devices working including:

  • my GPS receiver (Garmin eTrex Legend) – parsing coordinates and, for example, positioning the camera in ossimPlanet
  • a Wii Nunchuk game controller (no, I don’t own a Wii… who has time for games!? :). I can use the accelerometer readings to turn the camera in ossimPlanet using 2-3 axes.
  • more recently I’m now taking readings from this digital compass chip/module.

I haven’t combined these yet, but that is the plan. The next challenge, however is to try to smooth the inputs to manageable levels. Of course the 1 sec rate of the GPS isn’t too bad, but the jitter of the compass and the accelerometers is quite high. So now I’m investigating the various techniques for making these readings more usable.

I’ve looked so far at some basic methods, like weighted or running averages, but also at application specific ones – such as ones used in open source projects for navigation via Kalman filtering (Autopilot uses it and so does the Paparazzi platform), designed for reducing fuzzy input into more manageable vectors.

So without going cross-eyed and learning more about partial derivatives.. what do you think is the right way to go? A few moving averages might be enough, but in the end I basically want similar functionality to an IMU. Is that biting off too much?