示例#1
0
        /// <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);
        }
示例#2
0
        /// <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);
        }
示例#3
0
        /// <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);
        }