My research into Guilloché did not begin with collecting antique machinery or studying the history of traditional watchmaking craftsmanship.
It began with a very engineer-like question:
How can I place a genuine Guilloché pattern into a 3D
model of a watch dial?
At first, I simply wanted to create a dial with a
Guilloché surface inside CAD, so that I could test how different patterns might
work with the design of the MARTINNY 2202.
However, after several attempts, I discovered that a
manufacturing technique which has existed for centuries can become an
unexpectedly difficult modeling problem when translated into modern parametric
CAD software.
When One Hundred Engraved Lines Meet
Parametric CAD
Creating a single Guilloché engraving in CAD is not
particularly difficult.
The process normally begins by drawing the engraving path
in a sketch. A small V-shaped profile is then created to represent the
cross-section of the engraving tool. Using the Sweep command, the V-shaped
profile can be moved along the path and subtracted from the solid surface of
the dial.
Once the first engraved line has been created, a Circular
Pattern can be applied around the Z-axis of the dial.
From a modeling perspective, this workflow appears
perfectly reasonable.
The problem is that real Guilloché is not normally made
from ten or twenty thick lines. A craftsman may repeatedly cut along a similar
path with extremely small positional offsets, producing dozens or even hundreds
of closely spaced engraved lines.
When each line is treated by the CAD system as an
individual sweep, surface intersection, cutting feature and topological
modification, the model quickly becomes extremely heavy.
On a flat dial, this method may still be technically
possible.
By “possible,” I only mean that the software may
eventually complete the calculation. In practice, every modification to the
original curve, engraving depth, line count or dial diameter can trigger a
complete recalculation of the feature history, causing the software to pause
for a considerable amount of time.
When I tried to apply the same method to a domed surface,
the problem became much more serious.
The engraving path must not only follow the curved
surface, but also change in height across the dial. Every sweep cut creates new
intersections, edges and boundaries. As the lines become increasingly dense,
the software becomes more likely to encounter extremely small overlaps,
tangencies or topological errors.
The result may be an extremely long calculation time, a
frozen application, or a failed modeling operation.
This does not mean that CAD is generally unsuitable for
repeated geometry. The issue is that a Guilloché surface, composed of a very
large number of fine cutting features, lies close to the limits of what
traditional parametric solid modeling handles efficiently.
CAD can define one engraved line with exceptional precision, but it is not always efficient at defining hundreds of them in the same way.
.jpeg)
What makes Guilloché especially interesting is that the
pattern itself is not random.
In a traditional rose engine, the workpiece rotates while
its position is controlled by a rosette or cam. This produces a controlled
oscillating motion between the workpiece and the cutting tool. The resulting
variation in relative position creates the repeated and continuous geometric
lines engraved into the metal surface.
Although the final pattern may appear visually complex,
it can often be controlled through a relatively small number of parameters.
For example, a simple radial wave can be described using a polar equation:
$r(\theta)=R+A\sin(n\theta+\phi)$
It can then be converted into Cartesian coordinates:
$x(\theta)=r(\theta)\cos\theta$
$y(\theta)=r(\theta)\sin\theta$
In this equation:
- $R$ defines the base radius of the pattern;
- $A$ defines the amplitude of the wave;
- $n$ controls the frequency or number of lobes;
- $\phi$ controls the phase and rotational position of the pattern.
Another family of curves commonly associated with
Spirograph-like geometry is created when one circle rolls around the inside or
outside of another circle. These curves include hypotrochoids and epitrochoids.
A hypotrochoid, for example, can be written as:
$x(\theta)=(R-a)\cos\theta+d\cos\left(\frac{R-a}{a}\theta\right)$
$y(\theta)=(R-a)\sin\theta-d\sin\left(\frac{R-a}{a}\theta\right)$
By changing the fixed-circle radius $R$ , rolling-circle
radius $a$, and tracing-point offset $d$, it is possible to generate
dramatically different interlaced, floral and looping geometries.
There is no single equation capable of describing every
Guilloché pattern. However, many Guilloché-like patterns can be constructed
from combinations of parametric curves, periodic functions and coordinate
transformations.
To turn a mathematical curve into a realistic engraving,
additional conditions must also be defined, including the number of engraved
lines, spacing between lines, groove width, groove depth, tool profile, phase
offset, and the inner and outer boundaries of the dial.
These conditions are especially suitable for
computational control.
The First Alternative: Simulating
Engraving with a Height Map
After discovering that direct solid modeling was not
practical, I initially explored the Appearance and material systems inside CAD
software.
In 3D rendering, grayscale images can be used as height
maps, bump maps or displacement maps. The light and dark values in the image
represent different surface heights, allowing an otherwise flat model to appear
textured under lighting.
Some systems only modify the apparent direction of the
surface normals, while true displacement physically changes the position of the
mesh surface.
In principle, this means that a grayscale image
containing Guilloché lines can be used to simulate engraved depth.
I experimented with open-source vector software such as
Inkscape to create repeated line patterns. It can generate large numbers of
repeated curves relatively easily and export them in formats such as SVG.
However, I soon encountered another problem.
Inkscape is capable of handling geometric patterns, but
it does not provide the same design relationships and parameter control that I
wanted from a parametric workflow.
When I needed to adjust the diameter, amplitude,
frequency, line count, phase and boundaries together, maintaining all of these
relationships became inconvenient.
After each modification, I still had to export the image
again, import it into the CAD software, and readjust its scale, position,
direction and displacement strength.
It could produce a usable result, but it was still not the design tool I was looking for.
B-Rep and Mesh: Two Different Ways of
Thinking About 3D Models
This experience forced me to reconsider how a computer
actually represents a 3D object.
In engineering CAD, geometry is commonly represented
using B-Rep, or Boundary Representation.
A cylinder is not simply something that visually
resembles a cylinder. It is defined through precise circles, lines, surfaces,
boundaries and topological relationships. Its diameter, length, position and
tangency conditions can all be measured and modified accurately.
Another common method of representing 3D geometry is the
polygon mesh.
A mesh does not necessarily store a curved surface as a
complete analytical equation. Instead, it uses a collection of vertices with X,
Y and Z coordinates, which are connected to form triangles or polygons.
The more faces a mesh contains, the smoother and more
detailed the surface can appear. However, it remains a discrete approximation
of the original form rather than a CAD surface containing the same level of
design intent.
This does not mean that mesh geometry is
“non-mathematical,” nor does it mean that repeated geometry has no
computational cost.
As the number of triangles increases, file size, memory
usage, display performance and rendering time also increase.
The important advantage, however, is that a mesh does not
need to preserve one hundred separate sweep operations, circular patterns and
Boolean cuts in a parametric feature timeline.
The program only needs to calculate where each vertex should exist in three-dimensional space and then connect those vertices into faces.
For a surface
such as Guilloché, which is highly repetitive, visually complex and often
intended primarily for rendering and design evaluation, this can be a much more
direct approach.
At this point, I
realised that the problem might not be the Guilloché pattern itself, but the
way I was asking the CAD software to represent it.
Instead of building hundreds
of engraving features inside a parametric timeline, perhaps I could calculate
the final geometry directly.
I was not experienced in
polygon modeling software such as Blender or Rhino. But I knew enough about
coding to ask a different question:
What if I built the Guilloché model with Python instead?
In Part II, I will explain
how this question led me to build my own parametric Guilloché Generator through
Python and AI-assisted coding.