Esempio n. 1
0
        /// <summary>
        /// This is the method that actually does the work.
        /// </summary>
        /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param>
        protected override void SolveInstance(IGH_DataAccess DA)
        {
            VoxelImage VoxelImage = null;
            Point3d    Point      = new Point3d();

            DA.GetData(0, ref VoxelImage);
            DA.GetData(1, ref Point);

            V2GVoxelPoint VoxelPoint = new V2GVoxelPoint(VoxelImage, V2GH.V2GPoint(Point));

            DA.SetData(0, VoxelPoint);
            DA.SetData(1, V2GH.Point3d(VoxelPoint.Position));
            DA.SetData(2, VoxelPoint.FieldValue);
            DA.SetData(3, V2GH.Vector3d(VoxelPoint.ContourVector));
            DA.SetData(4, V2GH.Vector3d(VoxelPoint.GradientVector));
            DA.SetData(5, V2GH.Vector3d(VoxelPoint.ContourVector3d));
        }
Esempio n. 2
0
        /// <summary>
        /// Walk through the contour and gradient curves of a voxel field.
        /// </summary>
        /// <param name="VoxelImage">A voxel.</param>
        /// <param name="Point">A Point3d.</param>
        /// <param name="SegmentLength"></param>
        /// <param name="MaxIterations"></param>
        /// <param name="VectorType"></param>
        /// <returns></returns>

        public static List <V2GPoint> VoxelCurvePoints(VoxelImage VoxelImage, V2GPoint Point, double SegmentLength = 0.0001, int MaxIterations = 10000, int VectorType = 0)
        {
            List <V2GPoint> Points = new List <V2GPoint>();
            List <V2GLine>  lines  = new List <V2GLine>();

            V2GPoint lastPoint    = Point;
            bool     ContourEnded = false;

            int i = 0;

            Points.Add(Point);
            while (ContourEnded == false)
            {
                if (i > MaxIterations)
                {
                    ContourEnded = true;
                }
                V2GPoint      pathVector = new V2GPoint();
                V2GVoxelPoint voxelPoint = V2GVoxel.GetVoxelPoint(VoxelImage as VoxelImage, lastPoint);
                if (voxelPoint.FieldValue > 0.995)
                {
                    ContourEnded = true;
                }
                if (voxelPoint.FieldValue < 0.005)
                {
                    ContourEnded = true;
                }

                if (Points.Count > 500 && lastPoint.DistanceTo(Points[Points.Count - 20]) < 0.001)
                {
                    ContourEnded = true;
                }

                switch (VectorType)
                {
                case 0:
                    pathVector = voxelPoint.ContourVector;
                    break;

                case 1:
                    pathVector = voxelPoint.GradientVector;
                    break;

                case 2:
                    pathVector = voxelPoint.ContourVector3d;
                    break;

                default:
                    pathVector = voxelPoint.ContourVector;
                    break;
                }

                V2GPoint newPoint = lastPoint + pathVector * SegmentLength;

                lines.Add(new V2GLine(newPoint, Point));
                Points.Add(newPoint);
                lastPoint = newPoint;
                if (i > 50 && newPoint.DistanceTo(Point) < 0.001)
                {
                    ContourEnded = true;
                    Points.Add(Point);
                }
                ++i;
            }
            return(Points);
        }