Simon Marache-Francisco

I have always been fascinated by gravity simulations, and I have vivid memories of small simulators where you would create celestial bodies and watch them in motion. As I wanted to see what the fuss was about TypeScript, I decided to make a simple gravity simulator featuring planets. My goal was to simulate trajectories of around a dozen bodies in real-time, in the browser. Everything is based on Newton’s second law:

While hosting my website all by myself is actually quite fun, it is however very time-consuming. Doing things right means taking care of security updates, features updates, backups, crashes, etc. And problems always arise when you are not ready to deal with them, like that time when my co-hoster decided to install a new kernel module that crashed completely our VPS instance. I was obviously with my parents this weekend and waiting for an important email.

The SSE and AVX2 extensions of the x86 instruction set can dramatically improve the speed of a program if you can optimize ot for SIMD instructions. I made a small test with a fractal generator, which lends itself very well to this kind of optimization. I was impressed by the results: In very little time, thanks to the intel intrisics guide, I have been able to reduce the rendering time by a factor of 6.

Let’s say you have a picture with an awkward ratio. You can’t print it anywhere without either cropping or rescaling. The technique described in the paper from S. Avidan and A. Shamir, Seam Carving for Content-Aware Image Resizing is a very nice and elegant solution to resize the picture without changing the pixel aspect ratio. Original image (picture by Beverley Goodwin) Horizontal Shrink using naive resize on the left and Seam Carving on the right The picture on the right has all the features of the originalimage, with little distortion, but the aspect ratio is completely different.

A few days ago I took a picture of the night sky using my camera, right in the middle of nowhere. I expected a nice clear picture but no matter where I looked, there was always some background light, and the sensor noise was quite strong: Thumbnail of the original image: notice the haze I wanted to play with the python version of OpenCV for a long time, so this was a great opportunity to try to improve the result!

I just discovered that coursera had several courses about Scala, made by the creator of the language Martin Odersky. Functional programming: https://www.coursera.org/course/progfun Reactive programming: https://www.coursera.org/course/reactive I always wanted to try functional programming, and they seem to be a good place to start. I probably won’t have enough time to follow them through, but I started a small fractal generator in scala, using what I learned in the first few videos, and I really enjoy the language so far.

With my friend Clement we have been working on an exciting new project lately: Augmented reality on the smartphone. The goal is to show on the screen the landmarks you are looking at through the camera. Using your location (GPS), your direction (compass), and the location of the landmark (database), the program will show where the landmark should be on the screen. Unfortunately, for now, I am stuck with a problem: Even when correcting for the magnetic inclination, the compass measurement is off by a small angle….

I was having an argument with a coworker about the fastest method to branch in a code: lots of if/Else or a switch/case. I figured that the switch case would be faster, because the compiler would be less constrained than with the if/else, and could therefore use a better algorithm to select the right execution path. To check this, I made a new entry in my microprojects repo, the aptly named switchVsIfElse.

It is well known that accessing the memory in a non-sequential way is slower because it leads to a lot of cache miss. This micro-project was made to evaluate the difference in performance. An array of 10 000 000 elements (size_t) is created. It represents a typical data structure that you will access in your program. A random list of 1 000 000 offsets is generated. I compare the time used to fetch this million offset in a random order with the time used to fetch the same offsets, but in ascending (or descending) order.

Edit: there is a more recent post on this project. The new version has more feature and is finally able to render any STL. This is the follow-up on a project I started on November 2010. The goal was to code a very simple rasterizer in c++. I used the framebuffer provided by the SDL library to perform the rendering. In other word, SDL only provide a canvas on which I “paint” the model, pixel by pixel.