示例#1
0
        /// <summary>
        /// Read a .vol file into a VoxelImage.
        /// </summary>
        /// <param name="Path"></param>
        /// <returns name="Voxel"></returns>

        public static VoxelImage LoadVolFile(string Path)
        {
            VoxelImage vox = new VoxelImage(VoxelImageLayout.SHAPE_MATERIALRATIO);

            vox.LoadVolFile(Path);
            return(vox);// deLib.GeometricUtilities.GetVoxelPoint(Voxel, Point);
        }
示例#2
0
        public static Dictionary <string, object> CurveSinusoidalPointsWithVoxel(
            Autodesk.DesignScript.Geometry.Curve _Curve,
            VoxelImage Voxel,
            double WaveLength = 5.0,
            double Amplitude  = 1.0,
            double Resolution = 2.0)
        {
            VoxelChannel _VoxelChannel = Voxel.GetChannel(VoxelImageLayout.SHAPECHANNEL);

            double n     = (_Curve.Length / WaveLength) * 4 * Resolution;
            double _Span = _Curve.Length / n;
            List <Autodesk.DesignScript.Geometry.Point> points = new List <Autodesk.DesignScript.Geometry.Point>();
            List <double> ks = new List <double>();

            for (int i = 0; i < n; i++)
            {
                Autodesk.DesignScript.Geometry.Plane pl = _Curve.PlaneAtParameter(_Curve.ParameterAtSegmentLength(i * _Span));
                Autodesk.DesignScript.Geometry.Point p  = _Curve.PointAtSegmentLength(i * _Span);
                double FieldValue = V2GVoxel.GetVoxelFieldValue(_VoxelChannel, p.X, p.Y, p.Z);

                double k = FieldValue * Amplitude * Math.Sin(i * _Span * Math.PI * 2 / WaveLength + Math.PI * 2);

                points.Add((Autodesk.DesignScript.Geometry.Point)p.Translate(pl.YAxis, k));
                ks.Add(k);
            }

            return(new Dictionary <string, object>
            {
                { "Points", points },
                { "k", ks }
            });
        }
        /// <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();
            int        VectorType    = 0;
            double     SegmentLength = 0.0001;
            int        Iterations    = 25000;

            if (!DA.GetData(0, ref VoxelImage))
            {
                return;
            }
            DA.GetData(1, ref Point);
            DA.GetData(2, ref VectorType);
            DA.GetData(3, ref SegmentLength);
            DA.GetData(4, ref Iterations);

            List <V2GPoint> Points      = V2GVoxel.VoxelCurvePoints(VoxelImage, V2GH.V2GPoint(Point), SegmentLength, Iterations, VectorType);
            List <Point3d>  RhinoPoints = new List <Point3d>();

            foreach (V2GPoint p in Points)
            {
                RhinoPoints.Add(new Point3d(p.X, p.Y, p.Z));
            }
            Polyline Polyline = new Polyline(RhinoPoints);

            DA.SetData(0, Polyline);
        }
示例#4
0
        public static Dictionary <string, object> VoxelChannels(VoxelImage v)
        {
            VoxelChannel ShapeChannel         = v.GetChannel(VoxelImageLayout.SHAPECHANNEL);
            VoxelChannel MaterialRatioChannel = v.GetChannel(VoxelImageLayout.MATERIALRATIOCHANNEL);

            return(new Dictionary <string, object>
            {
                { "Shape", ShapeChannel },
                { "Material Ratio", MaterialRatioChannel }
            });
        }
示例#5
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));
        }
示例#6
0
        /// <summary>
        /// Calculate voxel point properties.
        /// </summary>
        /// <param name="_Voxel"></param>
        public void SetPropertiesWith(VoxelImage _Voxel)
        {
            double delta = 0.000001;

            VoxelImage   v  = _Voxel as VoxelImage;
            VoxelChannel vc = v.GetChannel(VoxelImageLayout.SHAPECHANNEL) as VoxelChannel;

            V2GPoint x0 = this.Position - V2GPoint.XAxis * delta;
            V2GPoint x1 = this.Position + V2GPoint.XAxis * delta;
            V2GPoint y0 = this.Position - V2GPoint.YAxis * delta;
            V2GPoint y1 = this.Position + V2GPoint.YAxis * delta;
            V2GPoint z0 = this.Position - V2GPoint.ZAxis * delta;
            V2GPoint z1 = this.Position + V2GPoint.ZAxis * delta;

            double x = V2GVoxel.GetVoxelFieldValue(vc, x1) - V2GVoxel.GetVoxelFieldValue(vc, x0);
            double y = V2GVoxel.GetVoxelFieldValue(vc, y1) - V2GVoxel.GetVoxelFieldValue(vc, y0);
            double z = V2GVoxel.GetVoxelFieldValue(vc, z1) - V2GVoxel.GetVoxelFieldValue(vc, z0);

            V2GPoint UnitVector = new V2GPoint(x, y, z);

            UnitVector.Normalize();

            double   fieldValue = V2GVoxel.GetVoxelFieldValue(vc, this.Position);
            V2GPoint RealVector = UnitVector * fieldValue;

            V2GPoint UnitVectorProjected = new V2GPoint(RealVector.X, RealVector.Y, 0);
            V2GPoint UnitVectorPerpendicularProjected = V2GPoint.CrossProduct(UnitVectorProjected, V2GPoint.ZAxis);

            UnitVectorProjected.Normalize();
            UnitVectorPerpendicularProjected.Normalize();

            this.ContourVector3d = UnitVector;
            this.ContourVector   = UnitVectorPerpendicularProjected;
            this.GradientVector  = UnitVectorProjected;
            this.FieldValue      = fieldValue;
        }
示例#7
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);
        }
示例#8
0
 /// <summary>
 /// Augment a point with voxel information.
 /// </summary>
 /// <param name="Voxel"></param>
 /// <param name="_Point"></param>
 /// <returns></returns>
 public static V2GVoxelPoint GetVoxelPoint(VoxelImage Voxel, V2GPoint _Point)
 {
     return(new V2GVoxelPoint(Voxel, _Point));
 }
示例#9
0
 /// <summary>
 /// A V2GPoint with voxel metadata.
 /// </summary>
 /// <param name="_Voxel"></param>
 /// <param name="_Point"></param>
 public V2GVoxelPoint(VoxelImage _Voxel, V2GPoint _Point)
 {
     this.Position = _Point;
     this.SetPropertiesWith(_Voxel);
 }