Never mind this programmer-like title. Last week I didn’t even program all that much, having spent most of my time doing weird schoolwork for courses like Accounting, not to mention English compositions and whatnot. This weekend, however, things got better as I finally managed to solve the matrix inversion problem of my horribly ill-conditioned spherical MLS algorithm.

Uh, I guess for you guys to understand what I mean I must explain about that scientific project I’m working on. The project’s whole purpose is developing a tool for interaction and visualization of medical images taken from exams such as CT. As it turns out, these images can be considered 2D slices and one may convert them to 3D by integrating them into a volume. This integration can be achieved using various volume rendering techniques like raycasting, the one we are using in our project. However, raycasting as it is normally used (with linear interpolation between points detected by rays) doesn’t provide information about any points in the volume other than the ones present on the images being integrated. The problem is that the points on these images are only samples (after all, the pixels at an image are a discreet representation of a continuous space, namely the organ being examined). So rendering stuff with raycasting can cause imprecisions or misrepresentations to occur: if a volume region is under-sampled some holes may appear, or the linear interpolation between the point samples can simply fail. My mission is to implement an algorithm that, by using spherical interpolation, may increase this rendering precision and allow the calculation of extra information such as curvature at each sample point, which is impossible when linear interpolation is used. The curvature part is fundamental to the interaction side of the project, which I’ll explain on another occasion because …well, because I should be going to sleep now

The problem is ill-conditioned because I must invert a matrix at a moment of the algorithm and this matrix has both incredibly large and quite small values. This causes lack of stability and, if common algorithms like Gauss-Jordan/Gauss with Backsubstitution or LU are used (all of which I tried along the way) then overflow or underflow can easily occur. So the solution, as I found out with some effort, is using another algorithm named SVD. Well, I implemented it and to my surprise the damn result was finally reasonable. So yeah, SVD all the way!

Other than that, I am still doing my Computer Animation project. I hope I finish it soon, as it’s very time-consuming, although very pleasurable. Or else I’ll be in real trouble during November, with all the final exams. Here is a picture of another animation scene.