The occluding contours of a smooth surface let you render 3D objects in many different artistic styles, such as this pen-and-ink hatching style:

Simple occluding contour renderings appear throughout many kinds of animations, TV shows and films throughout the past few decades, often consisting of basic black outlines.
Some recent examples include the game “Hi-Fi Rush”
and the Spider-Verse movies:

But there are entire classes of occluding contour stylizations we can’t do reliably or robustly—and we’re not seeing them in movies or games. Here are some examples of occluding contour stylizations from research papers over the years:

We can author all sorts of beautiful rendering styles. But the algorithms aren’t robust. All of the existing contour algorithms for smooth surfaces have unpredictable failure cases. And we’ve never really understood why.

This year, we finally cracked the case.

In a paper called ConTesse, we finally explain exactly what the problem really is, and describe when a solution works or doesn’t; moreover, we describe a method that produces correct results for subdivision surfaces. And, in a second paper, we show
how to generate exact smooth contours based on input meshes, allowing for very fast and accurate contours.

In this blog post, I explain exactly what the problem is, and, in the next post, what the breakthroughs are. In the third post, I recommend which of the existing methods to try for different types of problems, and point to where more research and development is needed to move these ideas from research to practical applications.

This post is intended for readers knowledgable about computer graphics algorithms. You can find a non-technical introduction to these topics here.

Here’s an example of occluding contours, drawn as black lines on a 3D model:

The occluding contours occur where a surface overlaps itself in image space:

For a triangle mesh, it’s easy to find the occluding contours: take all the edges that connect a front-face to a back-face, and then compute which of those edges are visible:

In this post, I am being very casual with definitions and terminology. You can see our tutorial paper for a detailed and precise definitions.

I’m also assuming that the surface is oriented: the faces have normal directions consistent with their neighbors, and the camera position is constrained, so that only front-facing surface will ever be visible. These assumptions are common in computer graphics applications.

For smooth surfaces, i.e.,