Relative depth between surfaces and lines

Support
1

I’m representing essentially the same data as lines and as tubes/spheres, as separate mappers and actors. I’m expecting the tubes to cover the lines (which mathematically would be inside the tubes) where they coincide. But it seems there is some accuracy issue and sometimes the lines are drawn “on top” of the tubes, depending on the zooming factor and orientation. For example, these screenshots differ only in slight orientation changes: the first one is what I expect, the second one is weird and wrong.

Screenshot_20250909_155808
Screenshot_20250909_155808292×215 38.6 KB

Screenshot_20250909_155839
Screenshot_20250909_155839292×215 46 KB

The tube diameter is 0.1, so not ridiculously small, and I still see the same when scaling everything up by 10. Is there some setting to increase the accuracy? Or is there something else I’m missing?

2

Hello,

That effect is likely caused by scene misconfiguration. For example, if the size of the view frustum is six-seven orders of magnitude greater than the separation between the lattice and the tubes, you can certainly expect Z-buffer accuracy issues. I think you could post the code that configures the graphics system. The six-seven orders of magnitude figure comes from a typical graphics card using 32-bit float depth buffers. Some may even have 24- or 16-bit z-buffers (check whether yours is no such case), which worsen the accuracy issue.

More on this: LearnOpenGL - Depth testing

best,

PC

3

Here’s a short sample:

#! /usr/bin/env python3

import vtk

graph = vtk.vtkMutableDirectedGraph()
v0 = graph.AddVertex()
v1a = graph.AddVertex()
v1b = graph.AddVertex()
v1c = graph.AddVertex()
graph.AddEdge(v0, v1a)
graph.AddEdge(v0, v1b)
graph.AddEdge(v0, v1c)
coord = vtk.vtkPoints()
coord.InsertNextPoint([0,0,0])
coord.InsertNextPoint([1,0,0])
coord.InsertNextPoint([0,1,0])
coord.InsertNextPoint([0,0,1])
graph.SetPoints(coord)
tree = vtk.vtkTree()
tree.CheckedShallowCopy(graph)

# Convert to PolyData
graphToPolyData = vtk.vtkGraphToPolyData()
graphToPolyData.SetInputData(graph)
graphToPolyData.Update()

# Scale transform for the grid lines
transform = vtk.vtkTransform()
transform.Scale(1, 1, 1)
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetTransform(transform)
transformFilter.SetInputConnection(graphToPolyData.GetOutputPort())

# Tubes filter for the edges
tubes = vtk.vtkTubeFilter()
tubes.SetInputConnection(graphToPolyData.GetOutputPort())
tubes.SetRadius(0.05)
tubes.SetNumberOfSides(6)

# Spheres filter for the vertices
ball = vtk.vtkSphereSource()
ball.SetRadius(0.1)
ball.SetThetaResolution(12)
ball.SetPhiResolution(12)
balls = vtk.vtkGlyph3D()
balls.SetSourceConnection(ball.GetOutputPort())
balls.SetInputConnection(graphToPolyData.GetOutputPort())

# Create mappers and actors
gridMapper = vtk.vtkPolyDataMapper()
gridMapper.SetInputConnection(transformFilter.GetOutputPort())
ballsMapper = vtk.vtkPolyDataMapper()
ballsMapper.SetInputConnection(balls.GetOutputPort())
tubesMapper = vtk.vtkPolyDataMapper()
tubesMapper.SetInputConnection(tubes.GetOutputPort())

gridActor = vtk.vtkActor()
gridActor.SetMapper(gridMapper)
gridActor.GetProperty().SetColor(1, 1, 1)
gridActor.GetProperty().SetLineWidth(2)
gridActor.GetProperty().EdgeVisibilityOn()
ballsActor = vtk.vtkActor()
ballsActor.SetMapper(ballsMapper)
ballsActor.GetProperty().SetColor(1.0, 0.5, 0.5)
tubesActor = vtk.vtkActor()
tubesActor.SetMapper(tubesMapper)
tubesActor.GetProperty().SetColor(0.5, 0.5, 1.0)

# Create a renderer, render window, and interactor
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderWindowInteractor.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())

# Add the actors to the scene
renderer.AddActor(gridActor)
renderer.AddActor(ballsActor)
renderer.AddActor(tubesActor)

renderer.ResetCamera()
camera = renderer.GetActiveCamera()
camera.SetFocalPoint(0.1, 0.1, 0)
camera.SetPosition(0.1, 0.1, 1.4)
renderWindowInteractor.GetInteractorStyle().OnMouseWheelBackward()
print(camera)

# Render and interact
renderWindow.SetWindowName('Graph')
renderWindow.Render()
renderWindowInteractor.Start()

This is the result for me, the white lines should not be there:

Screenshot_20250910_154711
Screenshot_20250910_154711300×300 9.58 KB

I don’t think there are six-seven orders of magnitude involved here, maybe one-two (or three, if you look at the clipping range).

4

How much is the clipping range in your case?

5

I get: ClippingRange: (0.00271491, 2.71491)

6

That’s probably the issue. I get the artifacts whenever the ratio of the clipping range is 1000 (0.02202210246807234, 22.02210246807234), and not if it’s smaller (0.05935975293667006, 21.495882829046867). Now, if you take 1000 squared, that’s indeed six orders of magnitude…

It seems VTK is automatically setting the clipping range ( How can I disable automatic reset of camera clipping range? - Development - 3D Slicer Community ). I see the problem even when I’m not “inside” or particularly close to any object, like here:

Screenshot_20250910_172632
Screenshot_20250910_172632791×590 140 KB

It also seems that VTK is limiting the ratio to exactly 1000 at most. So I wonder if I could limit it to something slightly smaller… Is there any way to affect the clipping range behavior?

Edit, it’s also happening for somewhat smaller ratios. But the ratio is changing a bit too much for very small camera movements. Consider this series:

(0.025773540601765444, 25.773540601765443)

Screenshot_20250910_173427
Screenshot_20250910_173427426×280 41.7 KB

(0.12001477318333542, 25.166034060297086)

Screenshot_20250910_173520
Screenshot_20250910_173520426×280 42.2 KB

(0.25125405776596654, 25.10985281790706)

Screenshot_20250910_173636
Screenshot_20250910_173636404×271 38 KB

I hardly changed the view with a small rotation, and the ratio goes from 1000 to ~100. And the artifact goes away from the spheres first and then from the tubes.

7

What do you get when you call renderWindow.GetDepthBufferSize()?

8

I get 24. It looks OK if I replace the lines with very thin tubes, but with ugly aliasing (even with FXAA enabled) and non-constant visible width.

9

It turns out I don’t need gridActor.GetProperty().EdgeVisibilityOn(). Without it, everything seems to look fine.

10

24-bit is a typical figure. An IEEE 24-bit floating point number has a mantissa of 15 bits. That means the depth test fails if the depth difference between two fragments is 4-5 orders of magnitude below the depth of the view frustum. Suppose you have a 10-kilometer clipping range. If your scene has objects less than 1 meter appart, you can expect occlusion artifacts like that.

11

IEEE doesn’t define a 24-bit float, as far as I’m aware. A 24-bit depth buffer gives an integer value in the range [0,16777215]. The mapping of depth to depth buffer Z for an integer depth buffer is:

Z = (1/depth - 1/near) / (1/far - 1/near) * (2**bits - 1)

Since the relation between depth and Z is nonlinear, the depth precision varies with depth.