subsequent pickPosition returns wrong value (depth?)

[anne-gropler]

Firstly, this issue is hard to reproduce, that's why I provide images below.

In my application, when the user clicks a point cloud point, we want to find the point closest to the camera within a certain screen environment (env currently set to 4). So this is not about hitting any point cloud point within that screen rect, but the closest one. This function we named pickPoint calls Cesium's viewer.scene.pickPosition().
However, sometimes*, pickPoint returns a position that is too close to the camera, where actually no point cloud is.

The sandcastle implements 2 kinds of picking:

1. "massive pick" (see toolbar) that invokes pickPoint all over the screen for every 20 pixel. Might take a minute or longer.
2. "diagonal pick" (double left click) that picks at the clicked position and then goes down-right for the next 100 pixel and invokes pickPoint there. Might take a few seconds.

In pickPoint, some point entites are created at the positions that were successfully picked. A yellow point means that this position was picked at the very first; a blue point means this position was picked subsequently in the loop to pick around the given screen environment env.

When the bug happens:

1. "massive pick": you will see that the yellow point is always at the correct position, and the blue points never are. The blue points are closer to the camera, it seems that all by the same amount. See the images below, it's like the point cloud would exist a second time.
2. "diagonal pick": The very first pick seems to be correct, and there are also some blue points at the correct position, but all other picks are wrong in the diagonal line, doesn't matter if yellow or blue, see the image and GIF below.

What I think could be wrong:

Since the first pick seems to be right and subsequent picks that are close to the first one aren't, I think this could be something about the picking cache, or maybe the depth buffer gets interpreted wrongly (logarithmic vs. linear). But this is just my intuition, I have no idea about the Cesium code. Since it's unreliable to reproduce, it might also be a race condition somewhere.

* sometimes: Happens very often on certain point clouds, sometimes on meshes, and almost never on certain other point clouds. We cannot find any difference in the point clouds that would make them special to this bug. The point cloud which has this bug quite often is also used in the sandcastle, and it also sometimes shows this error in the sandcastle, too. First I thought that attenuation might play a role, or the density of the point cloud, or that the point cloud is still loading, or that the globe is still loading, or just overall "busyness" of the browser. But nothing could reliably increase the chance of causing this bug.

Images: massive pick

It's as if the point cloud exists twice, but closer to the camera position. Easy to spot at the wall ("line") and the tree structures.

(the red and green circles on some images were picked using debugPickPosition on the point cloud when the inspector widget was initialized)

Initial position after massive pick:

Shown from above:

Even the globe gets picked wrongly:

From the ground:

Images: diagonal pick

Showing the same diagonal pick from different angles.

Inital Position:

Zooming in:

You can clearly see that the diagonal line is in shape as the vegetation in front of the wall, but only the first few picks are correctly on the wall.

Sandcastle example:

https://sandcastle.cesium.com/#c=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

Browser: Chrome, Firefox

Operating System: Windows 10, Ubuntu

[lilleyse]

Thanks for the detailed bug report @anne-gropler. For some reason though I can't reproduce the bug:

Maybe this is GPU specific? What system are you on?

[anne-gropler]

Thanks for trying it out!
It is indeed a really flaky issue. Even our team has troubles reproducing it, but it does happen regularly. The more we try, the more I think that it might happen more often when it's busy loading points or busy rendering. For example, when we open the Sandcastle while throttling the network speed (e.g. Chrome dev tools), we have more luck reproducing this while the points are still loading (some tiles are already shown, so there is something the picking could hit).
Could you give that a try and see if that makes it reproducible for you?

To answer your question, we use different GPUs across the team. Nvidia GPU, Intel chip, AMD GPU. The following picture was reproduced on Linux with Intel graphics using Firefox:

[UniquePanda]

I can confirm this for my machines (one notebook with an nvidia GPU and one desktop with an AMD GPU).
However, for me it became way more reliable (on both machines), when I removed the globe by initializing the viewer like so:
const viewer = new Cesium.Viewer("cesiumContainer", {globe: false});

I can then reliably reproduce the problem for certain angles (all of the picks in the screenshot were done on the wall but only one of them [bottom in the picture] really landed there):

Without the globe the "massive pick" also always looks like this for me (blue points at the wall in the center look wrong):

[UniquePanda]

I was also able to reproduce the problem with a simpler version of the original sandcastle.
I removed the "massive pick" option and replaced the spiral lookup with a simple "pick some pixels along the x axis".

https://sandcastle.cesium.com/#c=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

[UniquePanda]

The only other thing I was able to find is, that the depth which is used in Picking.js in this line:

cesium/packages/engine/Source/Scene/Picking.js

Line 423 in 27abb99

const depth = pickDepth.getDepth(

is different for the picks (in case the first pick is correct). E.g. the first pick at the correct position might have a depth of ~0.75 and all other picks might have a depth of ~0.71.
So from this little bit of research it looks like there might be a problem in the calculation of the depth/the values in the depth bufffer or something related to that.

Unfortunately I am not able to find out anymore here and any further help would be appreciated. :)

[anne-gropler]

Thanks @UniquePanda for sandcastle improvement and the debugging! 🌟

@lilleyse Can you reproduce it now?

[lilleyse]

@lilleyse Can you reproduce it now?

Yes

[UniquePanda]

A little update on this as I am currently investigating:
I am pretty sure that this bug was introduced for point clouds with the switch from the old Model class to new Model class (with "ModelExperimental" as an intermediate step). It only became reproducible with the PR that introduced the pnts loader for ModelExperimental.
This would make sense, given that the picking problems seem to be present for much much longer, but we didn't experience them in our work with point clouds before. They were probably only a problem of non point cloud models before.
I guess, as all types of 3D Models are now using the same core (the Model class), the thing that causes this bug has been transferred to point clouds at some point.
Does anyone have a clue what was different with point clouds regarding picking/depth buffer before they got "merged" into ModelExperimental/Model?

Maybe @ptrgags has an idea? You're might be the one who has spent the most time with the related code in the past months. 😄

I am willing to work further on this as it is becoming quite urgent for us, but any help is appreciated.

[UniquePanda]

As mentioned by @lilleyse this is related to #4368. It may even be the same problem. Maybe this issue should/could be closed.

Based on the discussion in #4368, I did some trail and error debugging and found out, that for us the problem goes away, if we call scene.pick() once before every scene.pickPosition().

We'll use that workaround for now, although it's not really nice and probably has an impact on performance. 😅
I might look into this further, but please don't assume I am working on this and feel free to fix it yourself (to whom it may concern 😄). Because of the workaround, the problem became less urgent for us and I can't justify putting too much effort in this right now.

[UniquePanda]

Just a last note to keep my debugging results somewhere:

I think, the following happens on a "double click" in the sandcastles:

1. scene.pick() is always called, because Cesium always registers a listener for "click" and "double click" in the viewer constructor here:

   cesium/packages/widgets/Source/Viewer/Viewer.js

   Line 925 in 84c9db6

   cesiumWidget.screenSpaceEventHandler.setInputAction(

   
   This is used to select/track entities in the viewer and those functions call scene.pick.
2. This somehow influences either the first call to scene.pickPosition() or all other calls to scene.pickPosition().
3. That's why the first call returns the correct result and all other ones don't.

If you let the browser render a frame after every single call to scene.pickPosition(), everything works fine. E.g. by putting the call into a requestAnimationFrame().

I suspected that the depth returned by this line is only correct for the first call to scene.pickPosition():

cesium/packages/engine/Source/Scene/Picking.js

Line 423 in 27abb99

const depth = pickDepth.getDepth(

Because in an example I got 0.76... for the first call and 0.72.... for all subsequent calls.
However, if you do the trick with requestAnimationFrame(), the later calls still get 0.72.... as depth but the resulting world position is correct.

So overall it looks like the values in the depth buffer change between frames/render passes (when scene.pick() was called?) but somehow this change is not correctly reflected when calculating the world position based on that depth afterwards(?).
It's all a bit confusing, but it really seems to be a strange side effect of scene.pick() or the following call of scene.pickPosition().

[ggetz]

Thanks for all the debugging here @UniquePanda. From my understanding, the root cause of this issue is likely #4368, however this only arose in point clouds once the Model reactor once point clouds and model implementations became a bit more unified.

If that's the case, I'll close this in favor of #4368, but cross link this report.

If I've misrepresented anything please let me know!

[anne-gropler]

@ggetz This issue was not fixed by #4368 / #11983 , so could we reopen this issue here, please?

I updated the sandcastle because the previous ones don't load the tileset anymore. This issue still persist, i.e., the subsequent picks are too close to the camera and don't properly hit the point cloud (they should be on the wall, or on the ground):

https://sandcastle.cesium.com/#c=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

[ggetz]

Got it, thanks for pointing this out @anne-gropler. Reopening.