For my first years at Pace GmbH, I was Product Manager for the Pacelab Suite API. My responsabilities covered product definition and documentation, establishment of API standards and change processes, as well as staff and customers trainings.

The focus of my software development experience was on the .NET framework, though over the years I have worked with a wide variety of programming languages and tools. My tasks ranged from kernel module programming to user interface design for applications targeting aircraft predesign (Pacelab Suite), route and aircraft economic analysis (Pacelab Mission Suite), aircraft cabin configuration (Cabin) and web-based aircraft documentation authoring.
My expertise in geometry led me to a position as IT Project Manager Visualization with the responsibility to evaluate and integrate CAD and high-end 3D visualisation technologies, as well as to define, specify, implement and maintain whole visualization modules.

My work experience allowed me to gain deep insight into Agile development processes as well as development methodologies and tools such as TDD and test automation (NUnit, SpecFlow, ...), refactoring and profiling, continuous integration (Cruise Control, TeamCity), versioning tools (git, SourceGear),...

During my work at the Schaerer Mayfield Techologies GmbH, a company which proposed real-time imaging solutions for the operating room (Neurosurgery, ENT, Orthopedics), I was involved in the development of the company's main product GuideLine, an integrated, image-guided navigation system that allowed to navigate intra-operative fluoroscopy and pre-operative MRI and CT images.
I participated in the whole software development process (including design, refactoring, testing, internal documentation, and preparation for the ISO cerification) and was responsible for the core and GUI library modules.

• Design and development of core library components, such as a module for serialization and automatic instantiation of C++ objects, a framework for the communication and synchronisation between widgets, and basic components for system management (patient database, user management, archiving, ... ).
• Design and development of a GUI module for workflow management (customizable GUI layouts and workspace scenarios optimized for muti-screen systems and dedicated surgical tasks), as well as custom widgets based on the Model-View-Controller pattern.

All algorithms were implemented in C++ and based on the Qt and the STL libraries. Scripts were written in Python.

During my work at the Tools & Toys GmbH, I was responsible for the development of components for mesh simplification and mesh healing. Moreover, I participated in the design of an interactive rendering system and developed a tool for the out-of-core preprocessing of giga-sized datasets.

• Mesh simplification module for high-quality static level of detail (LOD) generation. The program handles meshes with vertex attributes and allows mesh reparation and topological simplification.
• Module for out-of-core construction of hierarchical level of detail (HLOD) representations for huge CAD models.

The algorithms are implemented in C++ and LUA Script and make intensive use of librairies such as STL and BOOST.
Besides Tools & Toys proprietary format, VRML and XML were used to interface with other programs.

Subject: Geometric constructions with finite precision
Supervisor: Olivier Devillers, Geometrica Project
See below for more details

Subject: Geometric constructions with finite precision
Supervisor: Olivier Devillers, Geometrica Project

Geometric algorithms are usually described in the conceptual model of the real numbers, with unit-cost exact arithmetic operations. However, floating-point arithmetic often substitutes for real arithmetic which leads to the well-known problem of numerical robustness.

If the adoption of the exact computation paradigm [Yap/Dube95] gives a satisfactory solution to the robustness problem for algorithms that are purely combinatorial, this approach does not allow in practice to solve the case of algorithms that reuse or cascade the construction of new geometric objects. In application such as CAD systems, for example, constructed objects need to undergo further geometric processing. In principle, the further processing can also be done by exact algorithms. However, the numerical precision required to represent exactly a feature of a new constructed object grows exponentially with the height of its construction tree. Consequently, the running time of these algorithms becomes quickly prohibitive.

A solution to remedy these problem is geometric rounding. Geometric rounding converts algorithms and objects from the continuous domain to a uniform and discrete domain with finite resolution which simulates fixed precision representation and manipulation of real numbers. The goal is to represent derived geometric structures in fixed precision, so that the key combinatorial/topological properties of the structures are preserved. It is often problem-specific which constraints are critical to be kept.

Yet, despite the great practical interest of such solutions, there exist few published work in this direction, except for the particular problem of rounding line segment arrangements (Snap Rounding, Shortest Path Rounding, ...). Moreover, although the proposed techniques allow to preserve somehow the topology of the arrangement, they do not offer any inclusion or convexity guarantees if they are applied on faces (and not only on edges) of the arrangement.

In this context, I proposed in collaboration with Olivier Devillers (see Publication SoCG04) different rounding modes to round the result of boolean operations of two planar polygonal regions onto the integer lattice, which respond to the demand of such guarantees The inner/outer rounding of set operations on two polygonal regions allows to introduce the geometric analogue of interval arithmetic provided by the certified rounding modes of the IEEE 654 norm of floating point arithmetic operations. The computation of such geometric intervals with respect to the inclusion relation permits in particular to cascade various geometric constructions such as set operations, convex hulls or rotations with a control on their bit complexity.

I implemented a program based on CGAL (Computational Geometric Algorithms Library) for rounding the results of exact set operations of planar polygonal regions onto the integer grid with inclusion properties (see SOCG04 paper).
The algorithm is based on a plane sweep scheme and uses floating point filtering techniques for all basic geometric computations in order to ensure the exactness of all decisions and constructions. The rounding onto the integer grid is achieved thanks to the implementation of the continued fractions expansion technique from number theory.
(The code is property of INRIA.)

Most collision detection algorithms, such as OBBTree, sphere hierarchies and BV-trees, minimize the number of primitive-primitive intersection tests that have to be computed. Still, a fast and reliable method for computing these primitive-primitive overlap tests is desired. Since rendering hardware is often targeted for triangles, the primitives in collision detection algorithms are often triangles as well.

In this context, I proposed with Olivier Devillers a triangle-triangle overlap test (see Publications jgt03) that relies exclusively on the sign of 4 x 4 determinants and does not need any intermediate explicit constructions which are the source of numerical errors. Besides the fact that the resulting code is more reliable than existing methods, it is also more efficient.

I extended this approach to test the intersection of others pairs of geometric objects such as rays, lines, segments, and polygons. The algorithms are part of CGAL (Computational Geometry Algorithms Library).

Subject: Randomized analysis of on-line algorithms
Supervisor: Olivier Devillers, Prisme Project

Randomization techniques have encountered a large success in computational geometry since they often lead to conceptually simpler algorithms than their deterministic counterparts. One possibility to introduce randomness in an algorithm is to use an incremental algorithm whose complexity depends on the insertion order and to provide the data in a random order to the algorithm. However, to guarantee this hypothesis, the data have to be known in advance in order to be mixed which contradicts the on-line nature of the algorithm.

For my diploma thesis, I investigated in collaboration with Olivier Devillers (see Publications ijcga01) a technique consisting in a shuffling buffer of small size plugged between the incoming data and the algorithm. This introduces enough randomness to guarantee some improvement on the worst case complexity without modifying the underlying algorithm.

I applied and prooved this technique with binary search trees, Delaunay triangulations and Trapezoidal diagrams for line segments intersection detection. The latter problem arises naturally from the manipulation of display and related entities through, for instance, windowing, clipping, and hidden surface removal.