コード例 #1
0
ファイル: RegionOfInterest.cs プロジェクト: yt876/rt-dtools
        /// <summary>
        /// Returns the closest slice with a z value less than z
        /// </summary>
        /// <param name="z"></param>
        /// <returns></returns>
        public RegionOfInterestSlice GetClosestSlicePrevious(double z)
        {
            if (!ZRange.Contains(z))
            {
                return(null);
            }

            if (sliceDictionary.ContainsKey(z))
            {
                return(sliceDictionary[z]);
            }

            int index = BinaryMath.BinarySearchClosest(z, roiZCoordinates);

            if (!(index - 1 > RegionOfInterestSlices.Count - 1) && !(index - 1 < 0))
            {
                return(RegionOfInterestSlices[index - 1]);
            }

            if (Math.Abs(RegionOfInterestSlices[0].ZCoord - z) <= 1)
            {
                return(RegionOfInterestSlices[0]);
            }
            if (Math.Abs(RegionOfInterestSlices[RegionOfInterestSlices.Count - 1].ZCoord - z) <= 1)
            {
                return(RegionOfInterestSlices[RegionOfInterestSlices.Count - 1]);
            }

            return(null);
        }
コード例 #2
0
 internal void AddFeature(uint id, Envelope geometry, Interval?zRange, Interval?mRange)
 {
     NumRecords++;
     XRange = XRange.ExpandedByInterval(Interval.Create(geometry.MinX, geometry.MaxX));
     YRange = YRange.ExpandedByInterval(Interval.Create(geometry.MinY, geometry.MaxY));
     ZRange = ZRange.ExpandedByInterval(zRange ?? Interval.Create());
     MRange = MRange.ExpandedByInterval(mRange ?? Interval.Create());
 }
コード例 #3
0
        public Range3Single Intersect(Range3Single other)
        {
            var xrange = XRange.Intersect(other.XRange);
            var yrange = YRange.Intersect(other.YRange);
            var zrange = ZRange.Intersect(other.ZRange);

            return(new Range3Single
                       (new Vector3(xrange.Min, yrange.Min, zrange.Min),
                       new Vector3(xrange.Max, yrange.Max, zrange.Max)));
        }
コード例 #4
0
ファイル: RegionOfInterest.cs プロジェクト: yt876/rt-dtools
        /// <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));
        }
コード例 #5
0
        public long GetLength()
        {
            long size = 0;

            size += XYRange.GetLength();
            size += sizeof(int);
            size += Util.GetArraySize(Points);
            size += ZRange.GetLength();
            size += Util.GetArraySize(ZValues);
            size += MRange.GetLength();
            size += Util.GetArraySize(MValues);
            return(size);
        }
コード例 #6
0
        void RenderXYFunc(double[,] data, bool booleanMode, Color trueColor)
        {
            if (HeatColors == null)
            {
                HeatColors = new Color[(ColorBands.Length - 1) * 16];
                for (int band = 0; band < ColorBands.Length - 1; band++)
                {
                    Color lo = ColorBands[band], hi = ColorBands[band + 1];
                    for (int hii = 0; hii < 16; hii++)
                    {
                        int loi = 16 - hii;
                        HeatColors[band * 16 + hii] = Color.FromArgb((lo.R * loi + hi.R * hii) >> 4,
                                                                     (lo.G * loi + hi.G * hii) >> 4,
                                                                     (lo.B * loi + hi.B * hii) >> 4);
                    }
                }
            }
            Color nanColor = Color.FromArgb(trueColor.R / 2 + 64, trueColor.G / 2 + 64, trueColor.B / 2 + 64);

            for (int y = 0; y < data.GetLength(0); y++)
            {
                for (int x = 0; x < data.GetLength(1); x++)
                {
                    double d = data[y, x];
                    if (!booleanMode)
                    {
                        ZRange.PxCount = HeatColors.Length;
                        double z = ZRange.ValueToPx(data[y, x]);
                        Color  c;
                        if (double.IsNaN(z))
                        {
                            c = Color.DarkGray; // which is lighter than "Gray"
                        }
                        else if (double.IsInfinity(z))
                        {
                            c = Color.Purple;
                        }
                        else
                        {
                            int z2 = (int)G.PutInRange(ZRange.ValueToPx(data[y, x]), 0, HeatColors.Length - 1);
                            c = HeatColors[z2];
                        }
                        Bitmap.SetPixel(x, Bitmap.Height - 1 - y, c);
                    }
                    else if (!(d == 0))
                    {
                        Bitmap.SetPixel(x, Bitmap.Height - 1 - y, double.IsNaN(d) ? nanColor : trueColor);
                    }
                }
            }
        }
コード例 #7
0
ファイル: RegionOfInterest.cs プロジェクト: yt876/rt-dtools
        /// <summary>
        /// Returns the closest slice with
        /// </summary>
        /// <param name="z"></param>
        /// <returns></returns>
        public RegionOfInterestSlice GetClosestSlice(double z)
        {
            if (!ZRange.Contains(z))
            {
                return(null);
            }

            if (sliceDictionary.ContainsKey(z))
            {
                return(sliceDictionary[z]);
            }

            int index = BinaryMath.BinarySearchClosest(z, roiZCoordinates);
            RegionOfInterestSlice slice1 = null;
            RegionOfInterestSlice slice2 = null;

            if (!(index - 1 > RegionOfInterestSlices.Count - 1) && !(index - 1 < 0))
            {
                slice1 = RegionOfInterestSlices[index - 1];
            }
            if (!(index > RegionOfInterestSlices.Count - 1) && !(index < 0))
            {
                slice2 = RegionOfInterestSlices[index];
            }

            if (slice2 == null)
            {
                return(slice1);
            }
            if (slice1 == null)
            {
                return(slice2);
            }

            if (Math.Abs((slice1.ZCoord - z)) <= Math.Abs((slice2.ZCoord - z)))
            {
                return(slice1);
            }
            else
            {
                return(slice2);
            }
        }
コード例 #8
0
ファイル: RegionOfInterest.cs プロジェクト: yt876/rt-dtools
        /// <summary>
        /// Returns the closest slice with a z value greater than z
        /// </summary>
        /// <param name="z"></param>
        /// <returns></returns>
        public RegionOfInterestSlice GetClosestSliceNext(double z)
        {
            if (!ZRange.Contains(z))
            {
                return(null);
            }

            if (sliceDictionary.ContainsKey(z))
            {
                return(sliceDictionary[z]);
            }

            int index = BinaryMath.BinarySearchClosest(z, roiZCoordinates);

            if (!(index > RegionOfInterestSlices.Count - 1) && !(index < 0))
            {
                return(RegionOfInterestSlices[index]);
            }

            return(null);
        }
コード例 #9
0
        /// <summary>
        /// Converts the component z-order to the Adorner z-order. The adorner z-order
        /// is shifted by the minimal value for this level. Also there is a restriction
        /// about the maximal possible value for this level too
        /// </summary>
        /// <param name="zOrder">component z-order</param>
        /// <param name="level">component z-level</param>
        /// <returns></returns>
        private static int ComponentToAdorner(int zOrder, int level)
        {
            int    res   = zOrder;
            ZRange range = (ZRange)_ZRanges[level];

            if (range != null)
            {
                //adjust the Z-order (shift it with the minimal value for this range)
                //that way the component does need to know the range for its type that is
                // set by the application. It always sets the z-order as it starts from 0
                res += range.Min;
                if (res < range.Min)
                {
                    res = range.Min;
                }
                if (res > range.Max)
                {
                    res = range.Max;
                }
            }
            return(res);
        }
コード例 #10
0
 public bool ContainsPoint(double x, double y, double z)
 {
     return(XRange.Contains(x) && YRange.Contains(y) && ZRange.Contains(z));
 }
コード例 #11
0
        public override void Interpolate(Point3d position, Voxel voxel)
        {
            voxel.Position.X = position.X;
            voxel.Position.Y = position.Y;
            voxel.Position.Z = position.Z;

            if (!XRange.Contains(position.X) || !YRange.Contains(position.Y) || !ZRange.Contains(position.Z))
            {
                voxel.Value = DefaultPhysicalValue;
            }
            else
            {
                try
                {
                    //float x0 = 0, x1 = 0, y0 = 0, y1 = 0, z0 = 0, z1 = 0;
                    //int ix0 = 0, ix1 = 0, iy0 = 0, iy1 = 0, iz0 = 0, iz1 = 0;

                    if (ConstantGridSpacing)
                    {
                        ix0 = (int)((position.X - XCoords[0]) / GridSpacing.X);
                        if (ix0 >= XCoords.Length - 1)
                        {
                            ix1 = ix0 = XCoords.Length - 1;
                        }
                        else
                        {
                            ix1 = ix0 + 1;
                        }
                        x0 = XCoords[ix0];
                        x1 = XCoords[ix1];

                        iy0 = (int)((position.Y - YCoords[0]) / GridSpacing.Y);
                        if (iy0 >= YCoords.Length - 1)
                        {
                            iy1 = iy0 = YCoords.Length - 1;
                        }
                        else
                        {
                            iy1 = iy0 + 1;
                        }

                        y0 = YCoords[iy0];
                        y1 = YCoords[iy1];
                        if (GridSpacing.Z != 0)
                        {
                            iz0 = (int)((position.Z - ZCoords[0]) / GridSpacing.Z);
                            iz1 = iz0 + 1;

                            if (iz0 >= ZCoords.Length - 1)
                            {
                                iz1 = iz0 = ZCoords.Length - 1;
                            }
                            else
                            {
                                iz1 = iz0 + 1;
                            }

                            z0 = ZCoords[iz0];
                            z1 = ZCoords[iz1];
                        }
                        else
                        {
                            iz0 = 0; iz1 = 0;
                            z0  = ZCoords[iz0];
                            z1  = ZCoords[iz1];
                        }
                    }
                    else
                    {
                        var xt = binarySearchForSurroundingCoords(position.X, XCoords);
                        x0  = (float)xt.Item1;
                        x1  = (float)xt.Item2;
                        ix0 = xt.Item3;
                        ix1 = xt.Item4;
                        var yt = binarySearchForSurroundingCoords(position.Y, YCoords);
                        y0  = (float)yt.Item1;
                        y1  = (float)yt.Item2;
                        iy0 = yt.Item3;
                        iy1 = yt.Item4;
                        var zt = binarySearchForSurroundingCoords(position.Z, ZCoords);
                        z0  = (float)zt.Item1;
                        z1  = (float)zt.Item2;
                        iz0 = zt.Item3;
                        iz1 = zt.Item4;
                    }

                    voxel.Value = Interpolation.TrilinearInterpolate(
                        (float)position.X, (float)position.Y, (float)position.Z,
                        x0, y0, z0,
                        x1, y1, z1,
                        Data[getIndex(ix0, iy0, iz0)],
                        Data[getIndex(ix1, iy0, iz0)],
                        Data[getIndex(ix0, iy0, iz1)],
                        Data[getIndex(ix1, iy0, iz1)],
                        Data[getIndex(ix0, iy1, iz0)],
                        Data[getIndex(ix1, iy1, iz0)],
                        Data[getIndex(ix0, iy1, iz1)],
                        Data[getIndex(ix1, iy1, iz1)]);
                }
#pragma warning disable CS0168 // The variable 'e' is declared but never used
                catch (Exception e)
#pragma warning restore CS0168 // The variable 'e' is declared but never used
                {
                    voxel.Value = DefaultPhysicalValue;
                }
            }
        }
コード例 #12
0
        // ----------------------------------------------------------------------------------------
        #region WireframeDimensions

        public void UpdateDimensions(Single3 origin)
        {
            XRange = XRange.Add(origin.X);
            YRange = YRange.Add(origin.Y);
            ZRange = ZRange.Add(origin.Z);
        }
コード例 #13
0
 public double Distance2(Vector3 point)
 {
     return(_basePolygon.Distance2(point.XY) + ZRange.Distance2(point.Z));
 }
コード例 #14
0
 public bool Contains(Vector3 point)
 {
     return(_basePolygon.Contains(point.XY) && ZRange.Contains(point.Z));
 }
コード例 #15
0
        public override void Interpolate(Point3d position, Voxel voxel)
        {
            voxel.Position.X = position.X;
            voxel.Position.Y = position.Y;
            voxel.Position.Z = position.Z;

            if (!XRange.Contains(position.X) || !YRange.Contains(position.Y) || !ZRange.Contains(position.Z))
            {
                voxel.Value = 0;
            }
            else
            {
                float x0 = 0, x1 = 0, y0 = 0, y1 = 0, z0 = 0, z1 = 0;
                int   ix0 = 0, ix1 = 0, iy0 = 0, iy1 = 0, iz0 = 0, iz1 = 0;

                if (ConstantGridSpacing)
                {
                    ix0 = (int)((position.X - XCoords[0]) / GridSpacing.X);
                    ix1 = ix0 == XCoords.Length - 1 ? ix0 : ix0 + 1;
                    x0  = (float)XCoords[ix0];
                    x1  = (float)XCoords[ix1];
                    iy0 = (int)((position.Y - YCoords[0]) / GridSpacing.Y);
                    iy1 = iy0 == YCoords.Length - 1 ? iy0 : iy0 + 1;
                    y0  = (float)YCoords[iy0];
                    y1  = (float)YCoords[iy1];
                    if (GridSpacing.Z != 0)
                    {
                        iz0 = (int)((position.Z - ZCoords[0]) / GridSpacing.Z);
                        iz1 = iz0 == ZCoords.Length - 1 ? iz0 : iz0 + 1;
                        z0  = (float)ZCoords[iz0];
                        z1  = (float)ZCoords[iz1];
                    }
                    else
                    {
                        iz0 = 0; iz1 = 0;
                        z0  = (float)ZCoords[iz0];
                        z1  = (float)ZCoords[iz1];
                    }
                }
                else
                {
                    var xt = binarySearchForSurroundingCoords(position.X, XCoords);
                    x0  = (float)xt.Item1;
                    x1  = (float)xt.Item2;
                    ix0 = xt.Item3;
                    ix1 = xt.Item4;
                    var yt = binarySearchForSurroundingCoords(position.Y, YCoords);
                    y0  = (float)yt.Item1;
                    y1  = (float)yt.Item2;
                    iy0 = yt.Item3;
                    iy1 = yt.Item4;
                    var zt = binarySearchForSurroundingCoords(position.Z, ZCoords);
                    z0  = (float)zt.Item1;
                    z1  = (float)zt.Item2;
                    iz0 = zt.Item3;
                    iz1 = zt.Item4;
                }
                float xd;
                if (x1 == x0)
                {
                    xd = 0;
                }
                else
                {
                    xd = (float)(position.X - x0) / (x1 - x0);
                }
                double yd;
                if (y1 == y0)
                {
                    yd = 0;
                }
                else
                {
                    yd = (position.Y - y0) / (y1 - y0);
                }
                double zd;
                if (z1 == z0)
                {
                    zd = 0;
                }
                else
                {
                    zd = (position.Z - z0) / (z1 - z0);
                }
                float c00 = Data[ix0, iy0, iz0] * (1 - xd) + Data[ix1, iy0, iz0] * xd;
                float c01 = Data[ix0, iy0, iz1] * (1 - xd) + Data[ix1, iy0, iz1] * xd;
                float c10 = Data[ix0, iy1, iz0] * (1 - xd) + Data[ix1, iy1, iz0] * xd;
                float c11 = Data[ix0, iy1, iz1] * (1 - xd) + Data[ix1, iy1, iz1] * xd;
                float c0  = (float)(c00 * (1 - yd) + c10 * yd);
                float c1  = (float)(c01 * (1 - yd) + c11 * yd);
                float c   = (float)(c0 * (1 - zd) + c1 * zd);

                voxel.Value = c;
            }
        }