示例#1
0
        private BinaryMask GetInterpolatedMask(double z)
        {
            if (sliceDictionary.ContainsKey(z))
            {
                return(sliceDictionary[z].BinaryMask);
            }

            RegionOfInterestSlice slice1 = GetClosestSlicePrevious(z);
            RegionOfInterestSlice slice2 = GetClosestSliceNext(z);
            double     z1 = slice1?.ZCoord ?? 0, z2 = slice2?.ZCoord ?? 0;
            BinaryMask mask1 = slice1?.BinaryMask;
            BinaryMask mask2 = slice2?.BinaryMask;

            if (mask1 == null)
            {
                mask1 = new BinaryMask(XRange, YRange);
                z1    = slice2 != null ? slice2.ZCoord - 2 : z - 2;
            }
            if (mask2 == null)
            {
                mask2 = new BinaryMask(XRange, YRange);
                z2    = slice2 != null ? slice2.ZCoord + 2 : z + 2;
            }
            double     frac     = (z - z1) / (z2 - z1);
            BinaryMask interped = mask1.InterpolateWith(mask2, frac);

            return(interped);
        }
示例#2
0
 public void ComputeBinaryMask()
 {
     if (Polygons.Count > 1)
     {
     }
     for (int i = 0; i < Polygons.Count; i++)
     {
         BinaryMask.AddPolygon(Polygons[i]);
     }
 }
示例#3
0
        /// <summary>
        /// Finds whether a point is inside the ROI, by interpolating between ROI slices
        /// Only use this if you are checking a SINGLE point, otheriwse use ContainsXYCoordsInterpolated
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="z"></param>
        /// <returns></returns>
        public bool ContainsPointInterpolated(double x, double y, double z)
        {
            if (!ZRange.Contains(z))
            {
                return(false);
            }

            BinaryMask mask = GetInterpolatedMask(z);

            return(mask.ContainsPoint(x, y));
        }
示例#4
0
        /// <summary>
        /// Bulk processes whether an array of x and y coords are inside the roi, with interpolation
        /// </summary>
        /// <param name="xy">Vertices accessed by (row,col) </param>
        /// <param name="z"></param>
        /// <returns></returns>
        public bool[,] ContainsXYCoordsInterpolated(double[, ][] xy, double z)
        {
            BinaryMask mask = GetInterpolatedMask(z);
            int        cols = xy.GetLength(1);
            int        rows = xy.GetLength(0);

            bool[,] pointsInside = new bool[rows, cols];
            for (int col = 0; col < cols; col++)
            {
                for (int row = 0; row < rows; row++)
                {
                    pointsInside[row, col] = mask.ContainsPoint(xy[row, col][0], xy[row, col][1]);
                }
            }
            return(pointsInside);
        }
示例#5
0
        /// <summary>
        /// Interpolates between two binary masks.
        /// See Schenk et. al Efficient Semiautomatic Segmentation of 3D objects in Medical Images
        /// Note this DOES NOT CURRENTLY WORK. Needs tweaking
        /// </summary>
        /// <param name="mask2"></param>
        /// <param name="frac">0 is all this mask, 1 is all mask 2</param>
        /// <returns></returns>
        public BinaryMask InterpolateWith(BinaryMask mask2, double frac)
        {
            BinaryMask newMask = new BinaryMask(XRange, YRange);

            float[] m1distance = BinaryMath.DistanceTransform(InsideBinaryData);
            float[] m2distance = BinaryMath.DistanceTransform(mask2.InsideBinaryData);
            newMask.InsideBinaryData = new bool[InsideBinaryData.Length];

            for (int i = 0; i < m1distance.Length; i++)
            {
                var dist = m1distance[i] * (1 - frac) + m2distance[i] * (frac);
                if (dist <= 0)
                {
                    newMask.InsideBinaryData[i] = true;
                }
            }
            return(newMask);
        }
示例#6
0
 public bool ContainsPoint(double x, double y)
 {
     return(BinaryMask.ContainsPoint(x, y));
 }
示例#7
0
 public RegionOfInterestSlice()
 {
     Polygons   = new List <PlanarPolygon>();
     BinaryMask = new BinaryMask();
 }