/// <summary>
/// Finds the distance to the next boundary and independent of hitting it
/// </summary>
/// <param name="photon"></param>
public virtual double GetDistanceToBoundary(Photon photon)
{
if (photon.DP.Direction.Uz == 0.0)
{
return(double.PositiveInfinity);
}
// going "up" in negative z-direction
bool goingUp = photon.DP.Direction.Uz < 0.0;
// get current and adjacent regions
int currentRegionIndex = photon.CurrentRegionIndex;
// check if in embedded tissue region ckh fix 8/10/11
LayerTissueRegion currentRegion = _layerRegions[1];
if (currentRegionIndex < _layerRegions.Count)
{
currentRegion = _layerRegions[currentRegionIndex];
}
// calculate distance to boundary based on z-projection of photon trajectory
double distanceToBoundary =
goingUp
? (currentRegion.ZRange.Start - photon.DP.Position.Z) / photon.DP.Direction.Uz
: (currentRegion.ZRange.Stop - photon.DP.Position.Z) / photon.DP.Direction.Uz;
return(distanceToBoundary);
}
/// <summary>
/// Finds the distance to the next boundary and independent of hitting it
/// </summary>
/// <param name="photon"></param>
public virtual double GetDistanceToBoundary(Photon photon)
{
// first check if closest boundary is layer
// going "up" in negative z-direction
bool goingUp = photon.DP.Direction.Uz < 0.0;
// get current and adjacent regions
int currentRegionIndex = photon.CurrentRegionIndex;
// check if not in embedded tissue region ckh fix 8/10/11
LayerTissueRegion currentRegion = _layerRegions[1];
if (currentRegionIndex < _layerRegions.Count)
{
currentRegion = _layerRegions[currentRegionIndex];
}
// calculate distance to boundary based on z-projection of photon trajectory
double distanceToLayer =
goingUp
? (currentRegion.ZRange.Start - photon.DP.Position.Z) / photon.DP.Direction.Uz
: (currentRegion.ZRange.Stop - photon.DP.Position.Z) / photon.DP.Direction.Uz;
// then check if infinite cylinder boundaries are closer
double smallestInfCylDistance = double.PositiveInfinity;
double distToInfiniteCylinder;
for (int i = 0; i < _infiniteCylinderRegions.Count; i++)
{
_infiniteCylinderRegions[i].RayIntersectBoundary(photon, out distToInfiniteCylinder);
// first check that photon isn't sitting on boundary of one of the cylinders
// note 1e-9 was found by trial and error using unit tests to verify selection
// if you change value, need to update InfiniteCylinderTissueRegion.ContainsPosition eps
if ((distToInfiniteCylinder > 1e-9) && (distToInfiniteCylinder < smallestInfCylDistance))
{
smallestInfCylDistance = distToInfiniteCylinder;
}
}
if (smallestInfCylDistance < distanceToLayer)
{
return(smallestInfCylDistance);
}
return(distanceToLayer);
}
/// <summary>
/// Finds the distance to the next boundary and independent of hitting it
/// </summary>
/// <param name="photon">photon</param>
public virtual double GetDistanceToBoundary(Photon photon)
{
// moved code that used to be here to LayerTissueRegion.RayIntersectBoundary
// where it should be
// get current region index, could be index of inclusion
int currentRegionIndex = photon.CurrentRegionIndex;
// check if in embedded tissue region ckh fix 8/10/11
LayerTissueRegion currentRegion = _layerRegions[1];
if (currentRegionIndex < _layerRegions.Count)
{
currentRegion = _layerRegions[currentRegionIndex];
}
double distanceToBoundary;
var intersect = currentRegion.RayIntersectBoundary(photon, out distanceToBoundary);
return(distanceToBoundary);
}
/// <summary>
/// Method to determine if photon ray (or track) will intersect boundary of cylinder
/// equations to determine intersection are derived by parameterizing ray from p1 to p2
/// as p2=p1+[dx dy dz]t t in [0,1] where dx=p2.x-p1.x dy=p2.y-p1.y dz=p2.z-p2.z
/// and substituting into ellipsoid equations and solving quadratic in t, i.e. t1, t2
/// t1,t2<0 or t1,t2>1 => no intersection
/// 0<t1<1 => one intersection
/// 0<t2<1 => one intersections, if above line true too => two intersections
/// Equations obtained from pdf at https://mrl.nyu.edu/~dzorin/rendering/lectures/lecture3/lecture3-6pp.pdf
/// and modified to assume cylinder finite along z-axis with caps in x-y planes.
/// Note: can't vouch for this code yet, especially if photon intersects sides AND cap
/// </summary>
/// <param name="photon">photon position, direction, etc.</param>
/// <param name="distanceToBoundary">distance to boundary</param>
/// <returns>boolean</returns>
public bool RayIntersectBoundary(Photon photon, out double distanceToBoundary)
{
distanceToBoundary = double.PositiveInfinity;
_onBoundary = false; // reset _onBoundary
double root = 0;
var dp = photon.DP;
var p1 = dp.Position;
var d1 = dp.Direction;
// determine location of end of ray
var p2 = new Position(p1.X + d1.Ux * photon.S,
p1.Y + d1.Uy * photon.S,
p1.Z + d1.Uz * photon.S);
bool oneIn = this.ContainsPosition(p1);
bool twoIn = this.ContainsPosition(p2);
// check if ray within cylinder
if ((oneIn || _onBoundary) && twoIn)
{
return(false);
}
_onBoundary = false; // reset flag
double distanceToSides = double.PositiveInfinity;
// first check if intersect with infinite cylinder
var intersectSides = (CylinderTissueRegionToolbox.RayIntersectInfiniteCylinder(p1, p2, oneIn,
CylinderTissueRegionAxisType.Z, Center, Radius,
out distanceToSides));
// then check if intersect caps, create three tissue layers 1) above cylinder, 2) cylinder, 3) below
double distanceToTopLayer = double.PositiveInfinity;
var topLayer = new LayerTissueRegion(
new DoubleRange(0, Center.Z - (Height / 2)),
new OpticalProperties()); // doesn't matter what OPs are
var intersectTopLayer = topLayer.RayIntersectBoundary(photon, out distanceToTopLayer);
double distanceToCapLayer = double.PositiveInfinity;
var enclosingLayer =
new LayerTissueRegion(
new DoubleRange(Center.Z - (Height / 2), Center.Z + (Height / 2)),
new OpticalProperties());
var intersectCapLayer = enclosingLayer.RayIntersectBoundary(photon, out distanceToCapLayer);
double distanceToBottomLayer = double.PositiveInfinity;
var bottomLayer = new LayerTissueRegion(
new DoubleRange(Center.Z + (Height / 2), double.PositiveInfinity),
new OpticalProperties()); // doesn't matter what OPs are
var intersectBottomLayer = bottomLayer.RayIntersectBoundary(photon, out distanceToBottomLayer);
var hitCaps = false;
double distanceToCap = double.PositiveInfinity;
if (intersectTopLayer || intersectCapLayer || intersectBottomLayer)
{
distanceToCap = Math.Min(distanceToTopLayer, Math.Min(distanceToCapLayer, distanceToBottomLayer));
double xto = p1.X + distanceToCap * d1.Ux;
double yto = p1.Y + distanceToCap * d1.Uy;
double zto = p1.Z + distanceToCap * d1.Uz;
if ((Math.Abs(zto - (Center.Z + (Height / 2))) < 1e-10 ||
Math.Abs(zto - (Center.Z - (Height / 2))) < 1e-10) &&
Math.Sqrt(xto * xto + yto * yto) < Radius)
{
hitCaps = true;
}
}
if (hitCaps && distanceToCap < distanceToSides)
{
distanceToBoundary = distanceToCap;
return(true);
}
if (intersectSides && distanceToSides < distanceToCapLayer)
{
distanceToBoundary = distanceToSides;
return(true);
}
distanceToBottomLayer = double.PositiveInfinity;
return(false);
}