Correct sharp edges in a mesh generated from an SDF

[Niels-IO]

Hi @elalish,

What an awesome library! I was playing around with the SDF generation capabilities and I noticed that on rotated geometry, the Marching Tetrahedra algorithm creates jagged edges.

I understand the reason and thought of a correction algorithm that may help correct this. I tried to visualize the algorithm in the following picture.

The algorithm would loop through all faces that have any edge that is smaller than the grid step size (which is a criterion that kind of encodes problematic regions) and calculates the normal vector of the SDF at the midpoint. The correction is then a projection of the triangle vertices to the plane created by the normal vector of the SDF and a chosen vertex of the current triangle, which acts as an anchor. This anchoring vertex could be the one that has a vertex normal that is most aligned with the SDF vector.

I would like to get your thoughts on this 🙂

[pca006132]

We have related discussions in #561, in short the problem is that a lot of useful SDFs are not really distance functions. The reliable thing is just the change of sign. So this seems not general enough.

[elalish]

Yeah, Marching Cubes will have similar issues. In general you have no idea how rapidly the SDF gradient changes - it could be much higher frequency than your grid sampling. Then things will tend to get weird. Basically, if you're making a cube function with your SDF, this approach might work, but there's also no point in using an SDF - Boolean ops are much faster and much more precise.

Still, if you have a general algorithmic improvement, feel free to open a PR with lots of complex test cases that show how it's better.

[Niels-IO]

Thanks for the reply and the valid critique. I just wanted to get the idea out there. When, as a human, looking at the output it is obvious how the shape could be corrected at the sharp edges, then there must be an algorithm to do this (more or less) reliably.

I am not at the level to contribute to a c++ code base, as I don't have any experience with that but maybe someday 🤞

[elalish]

Reliable is the key - you'd be surprised how hard this is when the function could be anything. For instance, your method could easily lead to self-intersections. There are a bunch of papers on super-resolution for Marching Cubes, but all the ones I've looked at have interesting gotchas. If you find a good paper or library, send it our way.