/// <inheritdoc />
public float RayIntersect(Ray ray)
{
Vector3 rayStart = ray.StartPosition;
Vector3 rayDirection = ray.Direction;
// Since we raytrace only using a cylindrical surface that is horizontal and at the origin, we
// first shift and rotate the ray such that we get the right orientation:
Vector3 start = CenterCurve.GetStartPosition();
Vector3 end = CenterCurve.GetEndPosition();
Vector3 tangent = Vector3.Normalize(CenterCurve.GetTangentAt(0.0f));
Vector3 normal = Vector3.Normalize(CenterCurve.GetNormalAt(0.0f));
Vector3 binormal = Vector3.Normalize(CenterCurve.GetBinormalAt(0.0f));
float length = Vector3.Distance(start, end);
// CenterCurve is guaranteed to be a LineSegment, since the base property CenterCurve is masked by this
// class' CenterCurve property that only accepts a LineSegment, and similarly this class' constructor only
// accepts a LineSegment. The following mathematics, which assumes that the central axis is a line segment,
// is therefore valid.
Matrix4x4 rotationMatrix = new Matrix4x4(normal.X, binormal.X, tangent.X / length, 0.0f,
normal.Y, binormal.Y, tangent.Y / length, 0.0f,
normal.Z, binormal.Z, tangent.Z / length, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f);
Vector3 rescaledRay = Vector3.Transform(rayStart - start, rotationMatrix);
Vector3 newDirection = Vector3.TransformNormal(Vector3.Normalize(rayDirection), rotationMatrix);
float x0 = rescaledRay.X;
float y0 = rescaledRay.Y;
float z0 = rescaledRay.Z;
float a = newDirection.X;
float b = newDirection.Y;
float c = newDirection.Z;
// Raytrace using a cylindrical surface equation x^2 + y^2. The parameters in the following line
// represent the coefficients of the expanded cylindrical surface equation, after the substitution
// x = x_0 + a t and y = y_0 + b t:
QuarticFunction surfaceFunction = new QuarticFunction(x0 * x0 + y0 * y0, 2.0f * (x0 * a + y0 * b), a * a + b * b, 0.0f, 0.0f);
IEnumerable <float> intersections = Radius.SolveRaytrace(surfaceFunction, z0, c);
// The previous function returns a list of intersection distances. The value closest to 0.0f represents the
// closest intersection point.
float minimum = Single.PositiveInfinity;
foreach (float i in intersections)
{
// Calculate the 3d point at which the ray intersects the cylinder:
Vector3 intersectionPoint = rayStart + i * rayDirection;
// Find the closest point to the intersectionPoint on the centerLine.
// Get the vector v from the start of the cylinder to the intersection point:
Vector3 v = intersectionPoint - start;
// ...And project this vector onto the center line:
float t = -Vector3.Dot(intersectionPoint, tangent * length) / (length * length);
// Now we have the parameter t on the surface of the SymmetricCylinder at which the ray intersects.
// Find the angle to the normal of the centerLine, so that we can determine whether the
// angle is within the bound of the pie-slice at position t:
Vector3 centerLineNormal = CenterCurve.GetNormalAt(t);
Vector3 centerLineBinormal = CenterCurve.GetBinormalAt(t);
Vector3 d = intersectionPoint - CenterCurve.GetPositionAt(t);
float correctionShift = (float)Math.Sign(Vector3.Dot(d, centerLineBinormal));
float phi = (correctionShift * (float)Math.Acos(Vector3.Dot(d, centerLineNormal))) % (2.0f * (float)Math.PI);
// Determine if the ray is inside the pie-slice of the cylinder that is being displayed,
// otherwise discard:
if (phi > StartAngle.GetValueAt(t) && phi < EndAngle.GetValueAt(t) && i >= 0.0f)
{
minimum = Math.Sign(i) * (float)Math.Min(Math.Abs(minimum), Math.Abs(i));
}
}
return(minimum);
}
/// <inheritdoc />
public double RayIntersect(Ray ray)
{
dvec3 rayStart = ray.StartPosition;
dvec3 rayDirection = ray.Direction;
DebugUtil.AssertAllFinite(rayStart, nameof(rayStart));
DebugUtil.AssertAllFinite(rayDirection, nameof(rayDirection));
// Since we raytrace only using a cylindrical surface that is horizontal and at the origin, we
// first shift and rotate the ray such that we get the right orientation:
dvec3 start = CenterCurve.GetStartPosition();
dvec3 end = CenterCurve.GetEndPosition();
DebugUtil.AssertAllFinite(start, nameof(start));
DebugUtil.AssertAllFinite(end, nameof(end));
dvec3 tangent = CenterCurve.GetTangentAt(0.0).Normalized;
dvec3 normal = CenterCurve.GetNormalAt(0.0).Normalized;
dvec3 binormal = CenterCurve.GetBinormalAt(0.0).Normalized;
DebugUtil.AssertAllFinite(tangent, nameof(tangent));
DebugUtil.AssertAllFinite(normal, nameof(normal));
DebugUtil.AssertAllFinite(binormal, nameof(binormal));
double length = dvec3.Distance(start, end);
DebugUtil.AssertFinite(length, nameof(length));
// CenterCurve is guaranteed to be a LineSegment, since the base property CenterCurve is masked by this
// class' CenterCurve property that only accepts a LineSegment, and similarly this class' constructor only
// accepts a LineSegment. The following mathematics, which assumes that the central axis is a line segment,
// is therefore valid.
dmat3 rotationMatrix = new dmat3(normal, binormal, tangent / length).Transposed;
dvec3 rescaledRay = rotationMatrix * (rayStart - start);
dvec3 newDirection = rotationMatrix * rayDirection.Normalized;
double x0 = rescaledRay.x;
double y0 = rescaledRay.y;
double z0 = rescaledRay.z;
double a = newDirection.x;
double b = newDirection.y;
double c = newDirection.z;
// Raytrace using a cylindrical surface equation x^2 + y^2. The parameters in the following line
// represent the coefficients of the expanded cylindrical surface equation, after the substitution
// x = x_0 + a t and y = y_0 + b t:
QuarticFunction surfaceFunction = new QuarticFunction(x0 * x0 + y0 * y0, 2.0 * (x0 * a + y0 * b), a * a + b * b, 0.0, 0.0);
IEnumerable <double> intersections = Radius.SolveRaytrace(surfaceFunction, z0, c);
// The previous function returns a list of intersection distances. The value closest to 0.0f represents the
// closest intersection point.
double minimum = Single.PositiveInfinity;
foreach (double i in intersections)
{
// Calculate the 3d point at which the ray intersects the cylinder:
dvec3 intersectionPoint = rayStart + i * rayDirection;
// Find the closest point to the intersectionPoint on the centerLine.
// Get the vector v from the start of the cylinder to the intersection point:
dvec3 v = intersectionPoint - start;
// ...And project this vector onto the center line:
double t = -dvec3.Dot(intersectionPoint, tangent * length) / (length * length);
// Now we have the parameter t on the surface of the SymmetricCylinder at which the ray intersects.
// Find the angle to the normal of the centerLine, so that we can determine whether the
// angle is within the bound of the pie-slice at position t:
dvec3 centerLineNormal = CenterCurve.GetNormalAt(t);
dvec3 centerLineBinormal = CenterCurve.GetBinormalAt(t);
dvec3 d = intersectionPoint - CenterCurve.GetPositionAt(t);
double correctionShift = Math.Sign(dvec3.Dot(d, centerLineBinormal));
double phi = (correctionShift * Math.Acos(dvec3.Dot(d, centerLineNormal))) % (2.0 * Math.PI);
// Determine if the ray is inside the pie-slice of the cylinder that is being displayed,
// otherwise discard:
if (phi > StartAngle.GetValueAt(t) && phi < EndAngle.GetValueAt(t) && i >= 0.0)
{
minimum = Math.Sign(i) * Math.Min(Math.Abs(minimum), Math.Abs(i));
}
}
return(minimum);
}