Curve intersection and closest point on spline precision

[MangoSister]

Hello. I am new to embree, and I am using embree for ray-round curve intersection (RTC_GEOMETRY_TYPE_CONE_LINEAR_CURVE or RTC_GEOMETRY_TYPE_ROUND_LINEAR_CURVE). For each intersection I would like to get the closest point on the spline to the intersection point. This seems to be as simple as performing an interpolation:

RTCRayHit rayhit; // filled by rtcIntersect
float P[4];
rtcInterpolate1(rtcGetGeometry(scene, rayhit.hit.geomID), rayhit.hit.primID, rayhit.hit.u, rayhit.hit.v,
    RTC_BUFFER_TYPE_VERTEX, 0, P, nullptr, nullptr, 4);

To verify this, when I calculate the distance between the intersection point and (P[0], P[1], P[2]), I should get something close to P[3]. However, in my test I observed quite non-negligible deviation when the curve radius is small. Each curve in my test has a constant radius of 0.00375 (so actually cylinders) and length of around 1.0. I trace rays from several units away. The actual results I got varies from 0.0036 to 0.0038. The error can be close to 5%.

Am I doing anything wrong, or is this kind of numerical precision normal (seems much larger than I expect), or is it because my curves are too thin? Thanks.

[cbenthin]

Depending on the shape and radius of the curve and angle the ray hits it there could be quite a bit of numerical difference. Could you share the curve and ray data so that we could double-check that the result is as expected?

[MangoSister]

@cbenthin I have created a minimal reproducible example: https://github.com/MangoSister/embree_curve_test
The curve data is in curve_data.h/cpp. There are 1000 cylinders inside the unit sphere. In main.cpp I generate rays with random directions and random offset to intersect the scene. Each run usually generates some outliers similar to what I mentioned above. I am using the latest 3.13.1 release compiled by Visual Studio 2019.

[freibold]

@MangoSister I've looked at your code and everything looks good to me.

However, I think that your error computation is a bit wrong. As far as I understand it, you compare the distance of the hit point H on the curve surface to the interpolated point P on the spline (or line in the cylinder case) with the radius. This difference is indeed almost 5% (of the radius) but this dramatically depends on the curve radius. If you increase the curve radius in your example, the error drops significantly.

I went ahead and computed a more appropriate error in your code by taking the distance of the hitpoint projected on the spline (simple to compute only in the cylinder case) and the interpolated point P on the spline. This error is sqrt(dist^2 - radius^2), where dist is the distance from H to P. Relative to the length of the cylinder (assumed to be ~1 unit), this error is about 0.1% and almost constant when scaling the radius of the curve.

As a side note, computing the intersection point with ray.o + ray.d * tfar can be quite inaccurate if the ray origin is far away and the curve radius is small. In this case, it might be better to compute it using P + radius * N where N is the curve normal computed as the cross product of the curve derivatives (check out the curve tutorial for the normal computation).

Long story short, you are doing everything right and I don't think there is an accuracy problem here (at least none, that we could easily fix).

[MangoSister]

@freibold Thank you for the clarification. Using P + radius * N to calculate the hit point does sound like a better idea, though I think in the cylinder case you could only get normal from rayhit.hit.Ng_x/y/z since per readme 7.29 "For the linear basis and in round mode the v-coordinate is set to zero"?