コード例 #1
0
        /// <summary>
        /// This function creates curves between points
        /// </summary>
        /// <param name="pointer"></param>
        /// <param name="doc"></param>
        /// <param name="through"></param>
        public static void XCurveFromPoints(Point3dList pointer, RhinoDoc doc, bool through)
        {
            if (through)
            {
                //create a curve through points
                Curve curve = Curve.CreateInterpolatedCurve(pointer, 3);

                if (curve != null && curve.IsValid)
                {
                    doc.Objects.AddCurve(curve);
                    doc.Views.Redraw();
                }
            }

            else
            {
                //use points as control points
                NurbsCurve curve = NurbsCurve.Create(false, 3, pointer);

                if (curve != null && curve.IsValid)
                {
                    doc.Objects.AddCurve(curve);
                    doc.Views.Redraw();
                }
            }
        }
コード例 #2
0
        public GsaMember1d Duplicate()
        {
            GsaMember1d dup = new GsaMember1d
            {
                m_member = m_member //add clone or duplicate if available
            };

            if (m_crv != null)
            {
                dup.m_crv = m_crv.DuplicatePolyCurve();
            }

            Point3dList point3Ds = new Point3dList(m_topo);

            dup.Topology     = new List <Point3d>(point3Ds.Duplicate());
            dup.TopologyType = m_topoType.ToList();

            dup.ID = m_id;

            if (m_rel1 != null)
            {
                dup.ReleaseStart = m_rel1.Duplicate();
            }
            if (m_rel2 != null)
            {
                dup.ReleaseEnd = m_rel2.Duplicate();
            }
            if (m_section != null)
            {
                dup.Section = m_section.Duplicate();
            }

            return(dup);
        }
コード例 #3
0
        /// <summary>
        /// This function selects points
        /// </summary>
        /// <param name="message"></param>
        /// <param name="pointer"></param>
        public static void XSelectPoints(string message, out Point3dList pointer)
        {
            // variables are:
            // string message
            // out Point3dList points - the out won't be recognized unless you have Rhino.Collections and the 'out parameters
            // have to be filled in the function.
            // don't need a doc because we won't write anything to the document table, only reading.


            pointer = new Point3dList();

            var go = new GetObject();

            go.GeometryFilter = Rhino.DocObjects.ObjectType.Point;
            go.SetCommandPrompt(message);
            go.GetMultiple(1, 0);

            if (go.CommandResult() != Result.Success)
            {
                return;
            }

            for (var i = 0; i < go.ObjectCount; i++)
            {
                var point = go.Object(i).Point();
                if (null != point)
                {
                    pointer.Add(point.Location);
                }
            }
        }
コード例 #4
0
        public static void TestPolygonSelect()
        {
            Document doc = Application.DocumentManager.MdiActiveDocument;
            Editor   ed  = doc.Editor;
            //声明一个Point3d类列表对象,用于存储多段线的顶点
            Point3dList pts = new Point3dList();
            //提示用户选择多段线
            PromptEntityResult per = ed.GetEntity("请选择多段线");

            if (per.Status != PromptStatus.OK)
            {
                return;                               //选择错误,返回
            }
            using (Transaction trans = doc.TransactionManager.StartTransaction())
            {
                //转换为Polyline对象
                Polyline pline = trans.GetObject(per.ObjectId, OpenMode.ForRead) as Polyline;
                if (pline != null)
                {
                    //遍历所选多段线的顶点并添加到Point3d类列表
                    for (int i = 0; i < pline.NumberOfVertices; i++)
                    {
                        Point3d point = pline.GetPoint3dAt(i);
                        pts.Add(point);
                    }
                    //窗口选择,仅选择完全位于多边形区域中的对象
                    PromptSelectionResult psr = ed.SelectWindowPolygon(pts);
                    if (psr.Status == PromptStatus.OK)
                    {
                        Application.ShowAlertDialog("选择集中实体的数量:" + psr.Value.Count.ToString());
                    }
                }
                trans.Commit();
            }
        }
コード例 #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)
        {
            // 1. Declare placeholder variables
            var struts = new List<Curve>();
            double tol = 0.0;
            // 2. Attempt to retrieve input
            if (!DA.GetDataList(0, struts)) { return; }
            if (!DA.GetData(1, ref tol)) { return; }
            // 3. Validate input
            if (struts == null || struts.Count == 1) { return; }
            if (tol < 0) { return; }

            // 4. Call cleaning method
            var nodes = new Point3dList();
            var nodePairs = new List<IndexPair>();
            struts = FrameTools.CleanNetwork(struts, tol, out nodes, out nodePairs);

            // 5. Organize index lists
            var strutStart = new List<int>();
            var strutEnd = new List<int>();
            foreach (IndexPair nodePair in nodePairs)
            {
                strutStart.Add(nodePair.I);
                strutEnd.Add(nodePair.J);
            }

            // 6. Set output
            DA.SetDataList(0, struts);
            DA.SetDataList(1, nodes);
            DA.SetDataList(2, strutStart);
            DA.SetDataList(3, strutEnd);

        }
コード例 #6
0
ファイル: froGHRTree.cs プロジェクト: Co-de-iT/froGH
 public froGHRTree(Mesh mesh)
 {
     Point3d[] vertices = mesh.Vertices.ToPoint3dArray();
     Points = new Point3dList(vertices);
     Source = EnumRTreeType.Mesh;
     Tree   = RTree.CreateFromPointArray(vertices);
 }
コード例 #7
0
        /// <summary>
        /// Removes duplicate/invalid/tiny curves and outputs the cleaned list, and a list of unique nodes.
        /// </summary>
        public static List <Curve> CleanNetwork(List <Curve> inputStruts, double tol, out Point3dList nodes)
        {
            nodes = new Point3dList();
            var nodePairs = new List <IndexPair>();

            return(CleanNetwork(inputStruts, tol, out nodes, out nodePairs));
        }
コード例 #8
0
        public GsaElement2d Duplicate()
        {
            GsaElement2d dup = new GsaElement2d
            {
                m_elements = m_elements //add clone or duplicate if available
            };

            if (m_mesh != null)
            {
                dup.m_mesh = (Mesh)m_mesh.Duplicate();
                Point3dList point3Ds = new Point3dList(m_topo);
                dup.Topology  = new List <Point3d>(point3Ds.Duplicate());
                dup.m_topoInt = m_topoInt.ToList();
            }
            if (m_id != null)
            {
                int[] dupids = new int[m_id.Count];
                m_id.CopyTo(dupids);
                dup.ID = new List <int>(dupids);
            }
            if (m_props != null)
            {
                GsaProp2d[] dupprop = new GsaProp2d[m_props.Count];
                m_props.CopyTo(dupprop);
                dup.Properties = new List <GsaProp2d>(dupprop);
            }

            return(dup);
        }
コード例 #9
0
        public override IGH_GeometricGoo Transform(Transform xform)
        {
            if (Value == null)
            {
                return(null);
            }
            if (Value.PolyCurve == null)
            {
                return(null);
            }

            GsaMember1d mem = Value.Duplicate();

            List <Point3d> pts  = Value.Topology.ToList();
            Point3dList    xpts = new Point3dList(pts);

            xpts.Transform(xform);
            mem.Topology     = xpts.ToList();
            mem.TopologyType = Value.TopologyType.ToList();

            if (Value.PolyCurve != null)
            {
                PolyCurve crv = Value.PolyCurve.DuplicatePolyCurve();
                crv.Transform(xform);
                mem.PolyCurve = crv;
            }

            return(new GsaMember1dGoo(mem));
        }
コード例 #10
0
ファイル: FrameTools.cs プロジェクト: smor/intralattice
        /// <summary>
        /// Removes duplicate/invalid/tiny curves and outputs the cleaned list, and a list of unique nodes.
        /// </summary>
        public static List<Curve> CleanNetwork(List<Curve> inputStruts, double tol, out Point3dList nodes)
        {
            nodes = new Point3dList();
            var nodePairs = new List<IndexPair>();

            return CleanNetwork(inputStruts, tol, out nodes, out nodePairs);
        }
コード例 #11
0
ファイル: UnitCell.cs プロジェクト: smor/intralattice
        /// <summary>
        /// Instance constructor based on a list of lines.
        /// </summary>
        public UnitCell(List<Line> rawCell)
        {
            m_nodes = new Point3dList();
            m_nodePairs = new List<IndexPair>();
            m_nodePaths = new List<int[]>();

            ExtractTopology(rawCell);
            NormaliseTopology();
        }
コード例 #12
0
 public ErosionSim(Mesh M, List <Point3d> pts, double maxSpeed)
 {
     this.M = M;
     Morig  = new Mesh();
     Morig.CopyFrom(M);
     this.maxSpeed = maxSpeed;
     p1            = new Point3dList(M.Vertices.ToPoint3dArray());
     initParts(pts);
 }
コード例 #13
0
        public void SetCornerPts(Point3dList newcornerpts)
        {
            if (cornerpts != null)
            {
                cornerpts.Clear();
            }

            cornerpts = newcornerpts;
        }
コード例 #14
0
        /// <summary>
        /// Instance constructor based on a list of lines.
        /// </summary>
        public UnitCell(List <Line> rawCell)
        {
            m_nodes     = new Point3dList();
            m_nodePairs = new List <IndexPair>();
            m_nodePaths = new List <int[]>();

            ExtractTopology(rawCell);
            NormaliseTopology();
        }
コード例 #15
0
ファイル: froGHRTree.cs プロジェクト: Co-de-iT/froGH
 public froGHRTree(List <Point3d> points)
 {
     Points = new Point3dList();
     Source = EnumRTreeType.Points;
     Tree   = new RTree();
     for (int i = 0; i < points.Count; i++)
     {
         Points.Add(points[i]);
         Tree.Insert(points[i], i);
     }
 }
コード例 #16
0
 // constructor
 public ErosionSim(Mesh M, List <Point3d> P)
 {
     this.M = M;
     Morig  = new Mesh();
     Morig.CopyFrom(M);
     vertexList = new Point3dList(M.Vertices.ToPoint3dArray());
     parts      = new List <Particle>();
     foreach (Point3d p in P)
     {
         parts.Add(new Particle(this, p));
     }
 }
コード例 #17
0
        //weighted random populate point with attractors
        //reference Junichiro Horikawa on Github
        Point3dList Populate(Brep brep, double n, int ite, List <Point3d> attractors, double attractor_r, double attractor_strength)
        {
            var points = new Point3dList();
            int num    = Convert.ToInt32(n);

            if (brep != null)
            {
                var attracts = new Point3dList(attractors);
                var rnd      = new Random();
                var bbox     = brep.GetBoundingBox(true);
                attractor_strength = (-1) * attractor_strength;

                for (int i = 0; i < num; i++)
                {
                    if (points.Count == 0)
                    {
                        var rndpt = CreateRandomPoint(rnd, brep, bbox);
                        points.Add(rndpt);
                    }
                    else
                    {
                        double  fdist = -1;
                        Point3d fpt   = new Point3d();
                        for (int t = 0; t < Math.Max(Math.Min(ite, i), 10); t++)
                        {
                            var nrndpt = CreateRandomPoint(rnd, brep, bbox);
                            var nindex = points.ClosestIndex(nrndpt);
                            var npts   = points[nindex];

                            var ndist = npts.DistanceTo(nrndpt);

                            if (attractor_strength != 0)
                            {
                                var nattractid   = attracts.ClosestIndex(nrndpt);
                                var nattarctpts  = attracts[nattractid];
                                var mindist      = attractor_r;
                                var pow          = attractor_strength;
                                var nattractdist = Math.Pow(Remap(Math.Min(nattarctpts.DistanceTo(nrndpt), mindist), 0, mindist, 0, 1.0), pow);
                                ndist *= nattractdist;
                            }

                            if (fdist < ndist)
                            {
                                fdist = ndist;
                                fpt   = nrndpt;
                            }
                        }
                        points.Add(fpt);
                    }
                }
            }
            return(points);
        }
コード例 #18
0
        /// <summary>
        /// This function creates polyline from points
        /// </summary>
        /// <param name="pointer"></param>
        /// <param name="doc"></param>
        ///
        ///
        public static void XPolylineFromPoints(Point3dList pointer, RhinoDoc doc)
        {
            Polyline pline = new Polyline(pointer);

            pline.Add(pline[0]);   //this will close the polyline

            if (pline != null && pline.IsValid)
            {
                doc.Objects.AddPolyline(pline);
            }

            doc.Views.Redraw();
        }
コード例 #19
0
        /// <summary>
        /// This function creates lines from points
        /// </summary>
        /// <param name="pointer"></param>
        /// <param name="doc"></param>
        ///
        ///
        public static void XLinesFromPoints(Point3dList pointer, RhinoDoc doc)
        {
            for (var i = 0; i < pointer.Count - 1; i++)
            {
                Line line = new Line(pointer[i], pointer[i + 1]);

                if (line != null && line.IsValid)
                {
                    doc.Objects.AddLine(line);
                }
            }

            doc.Views.Redraw();
        }
コード例 #20
0
ファイル: CreateNetCommand.cs プロジェクト: jhaazpr/rocky
        protected Polyline generateFingerJoint(Line jointLine, double thickness)
        {
            Point3d     currPoint = new Point3d(jointLine.FromX, jointLine.FromY, 0);
            Point3dList points    = new Point3dList();

            points.Add(currPoint);

            double xIncr, yIncr;

            yIncr = thickness;
            xIncr = thickness / 2;

            // An even finger count means the finger will be drawn right of the
            // center line
            int fingerCount     = 0;
            int fingerDirection = -1;

            // Loop invariant: incrementing and placing current point will always
            // result in a point before the stoppingY
            while (currPoint.Y + yIncr <= jointLine.ToY)
            {
                // Multiplier for right finger on even, vice versa for odd
                fingerDirection = fingerCount % 2 == 0 ? 1 : -1;

                currPoint += new Vector3d(xIncr * fingerDirection, 0, 0);
                points.Add(currPoint);
                currPoint += new Vector3d(0, yIncr, 0);
                points.Add(currPoint);
                currPoint += new Vector3d(-xIncr * fingerDirection, 0, 0);
                points.Add(currPoint);

                fingerCount += 1;
            }

            // Finish the last truncated finger if necessary
            if (currPoint.Y < jointLine.ToY)
            {
                fingerDirection = fingerCount % 2 == 0 ? 1 : -1;

                currPoint += new Vector3d(xIncr * fingerDirection, 0, 0);
                points.Add(currPoint);
                currPoint += new Vector3d(0, jointLine.ToY - currPoint.Y, 0);
                points.Add(currPoint);
                currPoint += new Vector3d(-xIncr * fingerDirection, 0, 0);
                points.Add(currPoint);
            }

            return(new Polyline(points));
        }
コード例 #21
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)
        {
            // 1. Declare placeholder variables
            var    struts = new List <Curve>();
            double tol    = 0.0;

            // 2. Attempt to retrieve input
            if (!DA.GetDataList(0, struts))
            {
                return;
            }
            if (!DA.GetData(1, ref tol))
            {
                return;
            }
            // 3. Validate input
            if (struts == null || struts.Count == 1)
            {
                return;
            }
            if (tol < 0)
            {
                return;
            }

            // 4. Call cleaning method
            var nodes     = new Point3dList();
            var nodePairs = new List <IndexPair>();

            struts = FrameTools.CleanNetwork(struts, tol, out nodes, out nodePairs);

            // 5. Organize index lists
            var strutStart = new List <int>();
            var strutEnd   = new List <int>();

            foreach (IndexPair nodePair in nodePairs)
            {
                strutStart.Add(nodePair.I);
                strutEnd.Add(nodePair.J);
            }

            // 6. Set output
            DA.SetDataList(0, struts);
            DA.SetDataList(1, nodes);
            DA.SetDataList(2, strutStart);
            DA.SetDataList(3, strutEnd);
        }
コード例 #22
0
        /// <summary>
        /// Gets all Greville (Edit) points for this curve.
        /// </summary>
        public Point3dList GrevillePoints()
        {
            double[] gr_ab = GrevilleParameters();
            if (gr_ab == null)
            {
                return(null);
            }

            Point3dList gr_pts = new Point3dList(gr_ab.Length);

            foreach (double t in gr_ab)
            {
                gr_pts.Add(PointAt(t));
            }

            return(gr_pts);
        }
        protected override Result RunCommand(RhinoDoc doc, RunMode mode)
        {
            Random r     = new Random(13);
            var    plcnt = 1000000;
            var    edge  = 10;

            GetNumber gn = new GetNumber();

            gn.SetCommandPrompt("How many pointsies");
            gn.SetDefaultInteger(plcnt);
            gn.SetUpperLimit(500000001, true);
            gn.SetLowerLimit(1, true);
            gn.AcceptNothing(true);

            var gnrc = gn.Get();

            if (gnrc == GetResult.Nothing || gnrc == GetResult.Number)
            {
                var nr = (int)gn.Number();
                if (nr > 500000000)
                {
                    RhinoApp.WriteLine("More than 500.000.000 points");
                    return(Result.Cancel);
                }
                pc = new PointCloud();
                Point3dList p3dlist = new Point3dList(nr);
                List <System.Drawing.Color> collist = new List <System.Drawing.Color>(nr);
                for (int i = 0; i < nr; i++)
                {
                    var d = (double)i;
                    p3dlist.Add(new Point3d(r.NextDouble() * edge, r.NextDouble() * edge, r.NextDouble() * edge));
                    collist.Add(System.Drawing.Color.FromArgb(r.Next(0, 255), r.Next(0, 255), r.Next(0, 255)));
                }
                pc.AddRange(p3dlist, collist);
                cnd.ThePc   = pc;
                cnd.Enabled = true;
            }

            doc.Views.Redraw();


            return(Result.Success);
        }
コード例 #24
0
        public GsaNode Duplicate()
        {
            GsaNode dup = new GsaNode
            {
                Node = Node //add clone or duplicate if available
            };
            Point3dList pt    = new Point3dList(Point);
            Point3dList duppt = pt.Duplicate();

            dup.Point = duppt[0];
            if (m_id != 0)
            {
                dup.ID = m_id;
            }
            if (m_spring != null)
            {
                dup.Spring = m_spring.Duplicate();
            }
            dup.m_plane = LocalAxis.Clone();
            return(dup);
        }
コード例 #25
0
        /// <summary>
        /// Instace constructor based on a list of curves (i.e. a lattice).
        /// </summary>
        public ExoMesh(List <Curve> struts)
        {
            m_hulls   = new List <ExoHull>();
            m_sleeves = new List <ExoSleeve>();
            m_plates  = new List <ExoPlate>();
            m_mesh    = new Mesh();

            double tol = RhinoDoc.ActiveDoc.ModelAbsoluteTolerance;

            // First, we convert the struts to a list of unique nodes and node pairs
            // We use the following lists to extract valid data from the input list
            var nodeList     = new Point3dList();           // List of unique nodes
            var nodePairList = new List <IndexPair>();      // List of struts, as node index pairs

            struts = FrameTools.CleanNetwork(struts, tol, out nodeList, out nodePairList);

            // Set hull locations
            foreach (Point3d node in nodeList)
            {
                m_hulls.Add(new ExoHull(node));
            }


            // Create sleeves, plates and relational indices
            for (int i = 0; i < struts.Count; i++)
            {
                m_sleeves.Add(new ExoSleeve(struts[i], nodePairList[i]));
                // Construct plates
                m_plates.Add(new ExoPlate(nodePairList[i].I, struts[i].TangentAtStart));
                m_plates.Add(new ExoPlate(nodePairList[i].J, -struts[i].TangentAtEnd));
                // Set sleeve relational parameters
                IndexPair platePair = new IndexPair(m_plates.Count - 2, m_plates.Count - 1);
                m_sleeves[i].PlatePair = platePair;
                // Set hull relational parameters
                m_hulls[nodePairList[i].I].SleeveIndices.Add(i);
                m_hulls[nodePairList[i].J].SleeveIndices.Add(i);
                m_hulls[nodePairList[i].I].PlateIndices.Add(platePair.I);
                m_hulls[nodePairList[i].J].PlateIndices.Add(platePair.J);
            }
        }
コード例 #26
0
ファイル: ExoMesh.cs プロジェクト: smor/intralattice
        /// <summary>
        /// Instace constructor based on a list of curves (i.e. a lattice).
        /// </summary>
        public ExoMesh(List<Curve> struts)
        {
            m_hulls = new List<ExoHull>();
            m_sleeves = new List<ExoSleeve>();
            m_plates = new List<ExoPlate>();
            m_mesh = new Mesh();

            double tol = RhinoDoc.ActiveDoc.ModelAbsoluteTolerance;

            // First, we convert the struts to a list of unique nodes and node pairs
            // We use the following lists to extract valid data from the input list
            var nodeList = new Point3dList();               // List of unique nodes
            var nodePairList = new List<IndexPair>();       // List of struts, as node index pairs
            struts = FrameTools.CleanNetwork(struts, tol, out nodeList, out nodePairList);

            // Set hull locations
            foreach (Point3d node in nodeList)
            {
                m_hulls.Add(new ExoHull(node));
            }
               

            // Create sleeves, plates and relational indices
            for (int i = 0; i < struts.Count; i++)
            {
                m_sleeves.Add(new ExoSleeve(struts[i], nodePairList[i]));
                // Construct plates
                m_plates.Add(new ExoPlate(nodePairList[i].I, struts[i].TangentAtStart));
                m_plates.Add(new ExoPlate(nodePairList[i].J, -struts[i].TangentAtEnd));
                // Set sleeve relational parameters
                IndexPair platePair = new IndexPair(m_plates.Count - 2, m_plates.Count - 1);
                m_sleeves[i].PlatePair = platePair;
                // Set hull relational parameters
                m_hulls[nodePairList[i].I].SleeveIndices.Add(i);
                m_hulls[nodePairList[i].J].SleeveIndices.Add(i);
                m_hulls[nodePairList[i].I].PlateIndices.Add(platePair.I);
                m_hulls[nodePairList[i].J].PlateIndices.Add(platePair.J);
            }
        }
コード例 #27
0
        protected override Result RunCommand(RhinoDoc doc, RunMode mode)
        {
            ObjRef           obj_ref;
            const string     prompt      = "Select curve";
            const ObjectType object_type = ObjectType.Curve;
            Result           res         = RhinoGet.GetOneObject(prompt, false, object_type, out obj_ref);

            if (res != Result.Success)
            {
                return(res);
            }

            Curve crv = obj_ref.Curve();

            if (null == crv)
            {
                return(Result.Failure);
            }

            NurbsCurve nc = crv.ToNurbsCurve();

            if (null == nc)
            {
                return(Result.Failure);
            }

            Point3dList points = nc.GrevillePoints();

            foreach (Point3d point in points)
            {
                doc.Objects.AddPoint(point);
            }

            doc.Views.Redraw();

            return(Result.Success);
        }
コード例 #28
0
        public override IGH_GeometricGoo Transform(Transform xform)
        {
            if (Value == null)
            {
                return(null);
            }
            if (Value.NgonMesh == null)
            {
                return(null);
            }

            GsaElement3d elem = Value.Duplicate();

            Mesh xMs = elem.NgonMesh;

            xMs.Transform(xform);
            elem.NgonMesh = xMs;
            Point3dList pts = new Point3dList(Value.Topology);

            pts.Transform(xform);
            elem.Topology = pts.ToList();

            return(new GsaElement3dGoo(elem));
        }
コード例 #29
0
    /// <summary>
    /// This procedure contains the user code. Input parameters are provided as regular arguments,
    /// Output parameters as ref arguments. You don't have to assign output parameters,
    /// they will have a default value.
    /// </summary>
    private void RunScript(Point3d P0, int n, double evap, bool wrap, bool reset, bool go, bool MT, ref object P, ref object cPind, ref object nIndexes, ref object S)
    {
        // reset/initialize

        if (reset || diff == null || diff.ptsArray.Length != n * n)
        {
            diff             = new Diffusion(n, n, wrap);
            ptsList          = new Point3dList(diff.ptsArray); // create a Point3dList for faster closest point calculation
            cP               = ptsList.ClosestIndex(P0);       // find index of closest point to attractor
            diff.stigVal[cP] = 1;
            c = 0;                                             // reset counter
        }

        if (go)
        {
            diff.evap = evap;
            cP        = ptsList.ClosestIndex(P0); // find index of closest point to attractor

            if (MT)
            {
                diff.UpdateMT();
            }
            else
            {
                diff.Update();
            }
            diff.stigVal[cP] = 1;
            c++;
            Component.ExpireSolution(true);
        }

        P     = diff.ptsArray.Select(x => new GH_Point(x));
        S     = diff.stigVal.Select(x => new GH_Number(x));
        cPind = cP;
        // nIndexes = diff.GetNeighIndexes();
    }
コード例 #30
0
        public GsaMember2d Duplicate()
        {
            GsaMember2d dup = new GsaMember2d
            {
                m_member = m_member //add clone or duplicate if available
            };

            if (m_brep != null)
            {
                dup.m_brep = m_brep.DuplicateBrep();
            }
            if (m_crv != null)
            {
                dup.m_crv = m_crv.DuplicatePolyCurve();
            }

            Point3dList point3Ds = new Point3dList(m_topo);

            dup.Topology     = new List <Point3d>(point3Ds.Duplicate());
            dup.TopologyType = m_topoType.ToList();

            if (void_crvs != null)
            {
                dup.void_crvs     = new List <PolyCurve>();
                dup.void_topo     = new List <List <Point3d> >();
                dup.void_topoType = new List <List <string> >();
                for (int i = 0; i < void_crvs.Count; i++)
                {
                    dup.void_crvs.Add(void_crvs[i].DuplicatePolyCurve());
                    Point3dList voidpoint3Ds = new Point3dList(void_topo[i]);
                    dup.void_topo.Add(new List <Point3d>(voidpoint3Ds.Duplicate()));
                    dup.void_topoType.Add(void_topoType[i].ToList());
                }
            }

            if (incl_Lines != null)
            {
                dup.incl_Lines         = new List <PolyCurve>();
                dup.incLines_topo      = new List <List <Point3d> >();
                dup.inclLines_topoType = new List <List <string> >();
                for (int i = 0; i < incl_Lines.Count; i++)
                {
                    dup.incl_Lines.Add(incl_Lines[i].DuplicatePolyCurve());
                    Point3dList inclLinepoint3Ds = new Point3dList(incLines_topo[i]);
                    dup.incLines_topo.Add(new List <Point3d>(inclLinepoint3Ds.Duplicate()));
                    dup.inclLines_topoType.Add(inclLines_topoType[i].ToList());
                }
            }
            if (m_prop != null)
            {
                dup.Property = m_prop.Duplicate();
            }

            Point3dList inclpoint3Ds = new Point3dList(incl_pts);

            dup.incl_pts = new List <Point3d>(inclpoint3Ds.Duplicate());

            dup.ID = m_id;

            if (m_prop != null)
            {
                dup.Property = m_prop.Duplicate();
            }

            return(dup);
        }
コード例 #31
0
        public override IGH_GeometricGoo Transform(Transform xform)
        {
            if (Value == null)
            {
                return(null);
            }
            if (Value.Brep == null & Value.PolyCurve == null)
            {
                return(null);
            }

            GsaMember2d mem = new GsaMember2d
            {
                Member = Value.Member
            };

            List <Point3d> pts  = Value.Topology;
            Point3dList    xpts = new Point3dList(pts);

            xpts.Transform(xform);
            mem.Topology     = xpts.ToList();
            mem.TopologyType = Value.TopologyType;

            if (Value.VoidTopology != null)
            {
                for (int i = 0; i < Value.VoidTopology.Count; i++)
                {
                    xpts = new Point3dList(Value.VoidTopology[i]);
                    xpts.Transform(xform);
                    mem.VoidTopology.Add(xpts.ToList());
                }
                mem.VoidTopologyType = Value.VoidTopologyType;
            }

            if (Value.InclusionLines != null)
            {
                for (int i = 0; i < Value.InclusionLines.Count; i++)
                {
                    PolyCurve xLn = Value.InclusionLines[i];
                    xLn.Transform(xform);
                    mem.InclusionLines.Add(xLn);
                }
                for (int i = 0; i < Value.IncLinesTopology.Count; i++)
                {
                    xpts = new Point3dList(Value.IncLinesTopology[i]);
                    xpts.Transform(xform);
                    mem.IncLinesTopology.Add(xpts.ToList());
                }
                mem.IncLinesTopologyType = Value.IncLinesTopologyType;
            }
            if (Value.InclusionPoints != null)
            {
                xpts = new Point3dList(Value.InclusionPoints);
                xpts.Transform(xform);
                mem.InclusionPoints = xpts.ToList();
            }


            if (Value.Brep != null)
            {
                Brep brep = Value.Brep.DuplicateBrep();
                brep.Transform(xform);
                mem.Brep = brep;
            }
            if (Value.PolyCurve != null)
            {
                PolyCurve crv = Value.PolyCurve.DuplicatePolyCurve();
                crv.Transform(xform);
                mem.PolyCurve = crv;
            }


            return(new GsaMember2dGoo(mem));
        }
コード例 #32
0
        /// <summary>
        /// Solves the instance.
        /// </summary>
        /// <param name="DA">Da.</param>
        protected override void SolveInstance(IGH_DataAccess DA)
        {
            // Properties
            Mesh   mesh              = null;
            Curve  initialCurve      = null;
            double specifiedDistance = 0.0;
            int    maxCount          = 0;
            double threshold         = 0.0;
            double perpStepSize      = 0.0;
            bool   bothDir           = false;
            double minThreshold      = 0.0;

            // Set the input data
            if (!DA.GetData(0, ref mesh))
            {
                return;
            }
            if (!DA.GetData(1, ref initialCurve))
            {
                return;
            }
            if (!DA.GetData(2, ref bothDir))
            {
                return;
            }
            if (!DA.GetData(3, ref maxCount))
            {
                return;
            }
            if (!DA.GetData(4, ref threshold))
            {
                return;
            }
            if (!DA.GetData(5, ref specifiedDistance))
            {
                return;
            }
            if (!DA.GetData(6, ref perpStepSize))
            {
                return;
            }
            if (!DA.GetData(7, ref minThreshold))
            {
                return;
            }

            // Data validation
            if (maxCount == 0)
            {
                AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Count cannot be 0");
            }
            if (!mesh.IsValid)
            {
                AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Mesh is invalid");
            }

            // Placeholder properties
            DataTree <Curve> pattern       = new DataTree <Curve>();
            Curve            previousCurve = initialCurve;
            List <Curve>     perpGeods     = new List <Curve>();
            List <double>    perpParams    = new List <double>();

            // Start piecewise evolution process
            for (int i = 0; i < maxCount; i++)
            {
                Debug.WriteLine("Iter " + i);
                //  Create placeholder lists
                perpGeods  = new List <Curve>();
                perpParams = new List <double>();

                // Divide curve
                double[] geodParams = previousCurve.DivideByLength(perpStepSize, true);

                if (geodParams == null)
                {
                    AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, "No  points found on iter" + i);
                    break;
                }
                if (geodParams.Length <= 2)
                {
                    AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, "Not enough points found on iter" + i);
                    break;
                }

                // Generate perp geodesics for measurement
                foreach (double t in geodParams)
                {
                    // Get curve tangent vector and mesh normal
                    Point3d  point   = previousCurve.PointAt(t);
                    Vector3d tangent = previousCurve.TangentAt(t);
                    Vector3d normal  = mesh.NormalAt(mesh.ClosestMeshPoint(point, 0.0));

                    // Rotate vector against normals 90 degrees
                    tangent.Rotate(0.5 * Math.PI, normal);

                    // Generate perp geodesic
                    Curve perpGeodesic = MeshGeodesicMethods.getGeodesicCurveOnMesh(mesh, point, tangent, 100).ToNurbsCurve();

                    // Check for success
                    if (perpGeodesic != null && perpGeodesic.GetLength() > specifiedDistance)
                    {
                        // Divide by specified length
                        double perpT = 0.0;
                        perpGeodesic.LengthParameter(specifiedDistance, out perpT);

                        // Add data to lists
                        perpGeods.Add(perpGeodesic);
                        perpParams.Add(perpT);
                    }
                }
                // Clean perp geods of intersections ocurring BEFORE the specified distance
                var result = CleanPerpGeodesics(perpGeods, perpParams, specifiedDistance);
                // Assign clean lists
                perpGeods  = result.perpGeodesics;
                perpParams = result.perpParams;


                // Break if not enough perpGeods remain
                if (perpGeods.Count < 6)
                {
                    AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Not  enough perp geodesics where found for iter " + i);
                    break;
                }

                //Generate the next piecewise geodesic
                List <Curve> iterCurves = GeneratePiecewiseGeodesicCurve(mesh, perpParams, perpGeods, 1000, bothDir, 0, threshold, Vector3d.Unset);

                // Add it to the pattern
                pattern.AddRange(iterCurves, new GH_Path(i));

                // Assign as previous for the next round
                Curve[] joinedResult = Curve.JoinCurves(iterCurves);

                // Error check
                if (joinedResult.Length > 1)
                {
                    AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "More than 1 curve after Join in iter " + i);
                    break;
                }
                //Create points and bisectrix vectors for next round of perp geodesics
                Point3dList ptList = new Point3dList();
                foreach (Curve c in iterCurves)
                {
                    if (!ptList.Contains(c.PointAtStart))
                    {
                        ptList.Add(c.PointAtStart);
                    }
                    if (!ptList.Contains(c.PointAtEnd))
                    {
                        ptList.Add(c.PointAtEnd);
                    }
                }
                Debug.WriteLine("ptList Count: " + ptList.Count);
                // Assign new curve to previous curve
                Curve joinedCurve = joinedResult[0];
                previousCurve = joinedCurve;
            }

            // Assign data to output
            DA.SetDataTree(0, pattern);
            DA.SetDataList(2, perpGeods);
        }
コード例 #33
0
ファイル: penrose.cs プロジェクト: chirs/parametric_systems
    public static DataTree<Polyline> makeTiles(Mesh mesh)
    {
        DataTree < Polyline> Tree = new DataTree<Polyline>();
        for(int i = 0;i < mesh.Faces.Count;i++)
        {
          Vector3d ab = new Vector3d (mesh.Vertices[mesh.Faces[i].B] - mesh.Vertices[mesh.Faces[i].A]);
          Vector3d ac = new Vector3d (mesh.Vertices[mesh.Faces[i].C] - mesh.Vertices[mesh.Faces[i].A]);

          Point3dList pts = new Point3dList();
          pts.Add(mesh.Vertices[mesh.Faces[i].A]);
          pts.Add(mesh.Vertices[mesh.Faces[i].C]);
          pts.Add(mesh.Vertices[mesh.Faces[i].B]);
          Polyline edge = new Polyline(pts);
          Tree.Add(edge);
        }
        return Tree;
    }
コード例 #34
0
ファイル: xpointpicker.cs プロジェクト: danieldepoe/csharp
        protected override Result RunCommand(RhinoDoc doc, RunMode mode)
        {
            Point3dList points = new Point3dList();

            // Point3dList is from the Collections class, we add a new variable points then initialize it and add
            // empty array

            Result commandres;

            //calls class Point3dList and initializes a new empty array with the name 'points'

            while (true)

            //make an infinite loop.  every time we click on screen we will create a point which will
            // be added to the document and the screen will be refreshed.  it happens fast!!
            {
                var gp = new GetPoint();

                //prompt user
                string prompt;
                prompt = "set point(s) by click";

                gp.SetCommandPrompt(prompt);


                //set up what to do with the result
                var res = gp.Get();

                //get function returns a really cool type of enumeration
                //  https://developer.rhino3d.com/api/RhinoCommon/html/T_Rhino_Input_GetResult.htm

                if (res == GetResult.Point)

                //using Rhino.Input, double equal sign is necessary...

                {
                    doc.Objects.AddPoint(gp.Point());
                    //adds a point object to the document to object table

                    doc.Views.Redraw();
                    //refreshes the views

                    points.Add(gp.Point());
                    // add the point to our points array declared above

                    commandres = Result.Success;
                }

                else if (res == GetResult.Nothing)
                {
                    commandres = Result.Failure;
                    break;
                }
                else
                {
                    commandres = Result.Cancel;
                    break;
                }
            }

            RhinoApp.WriteLine("The user drew {0} point(s) successfully", points.Count.ToString());

            // access the points array and cast it to a string, outside the function so that it will only
            // show how many ponints you've drawn when the function is complete.

            return(Result.Success);
        }
コード例 #35
0
ファイル: FrameTools.cs プロジェクト: smor/intralattice
        /// <summary>
        /// Removes duplicate/invalid/tiny curves and outputs the cleaned list, a list of unique nodes and a list of node pairs.
        /// </summary>
        public static List<Curve> CleanNetwork(List<Curve> inputStruts, double tol, out Point3dList nodes, out List<IndexPair> nodePairs)
        {
            nodes = new Point3dList();
            nodePairs = new List<IndexPair>();

            var struts = new List<Curve>();

            // Loop over list of struts
            for (int i = 0; i < inputStruts.Count; i++)
            {
                Curve strut = inputStruts[i];
                // Unitize domain
                strut.Domain = new Interval(0, 1);
                // Minimum strut length (if user defined very small tolerance, use 100*rhinotolerance)
                double minLength = Math.Max(tol, 100*RhinoDoc.ActiveDoc.ModelAbsoluteTolerance);
                // If strut is invalid, ignore it
                if (strut == null || !strut.IsValid || strut.IsShort(minLength))
                {
                    continue;
                }

                Point3d[] pts = new Point3d[2] { strut.PointAtStart, strut.PointAtEnd };
                List<int> nodeIndices = new List<int>();
                // Loop over end points of strut
                // Check if node is already in nodes list, if so, we find its index instead of creating a new node
                for (int j = 0; j < 2; j++)
                {
                    Point3d pt = pts[j];
                    // Find closest node to current pt
                    int closestIndex = nodes.ClosestIndex(pt); 

                    // If node already exists (within tolerance), set the index
                    if (nodes.Count != 0 && pt.EpsilonEquals(nodes[closestIndex], tol))
                    {
                        nodeIndices.Add(closestIndex);
                    }
                    // If node doesn't exist
                    else
                    {
                        // Update lookup list
                        nodes.Add(pt);
                        nodeIndices.Add(nodes.Count - 1);
                    }
                }

                // We must ignore duplicate struts
                bool isDuplicate = false;
                IndexPair nodePair = new IndexPair(nodeIndices[0], nodeIndices[1]);

                int dupIndex = nodePairs.IndexOf(nodePair);
                // dupIndex equals -1 if nodePair not found, i.e. if it doesn't equal -1, a match was found
                if (nodePairs.Count != 0 && dupIndex != -1)
                {
                    // Check the curve midpoint to make sure it's a duplicate
                    Curve testStrut = struts[dupIndex];
                    Point3d ptA = strut.PointAt(0.5);
                    Point3d ptB = testStrut.PointAt(0.5);
                    if (ptA.EpsilonEquals(ptB, tol)) isDuplicate = true;
                }

                // So we only create the strut if it doesn't exist yet (check nodePairLookup list)
                if (!isDuplicate)
                {
                    // Update the lookup list
                    nodePairs.Add(nodePair);
                    strut.Domain = new Interval(0, 1);
                    struts.Add(strut);
                }
            }

            return struts;
        }
コード例 #36
0
ファイル: UnitCell.cs プロジェクト: smor/intralattice
 /// <summary>
 /// Default constructor.
 /// </summary>
 public UnitCell()
 {
     m_nodes = new Point3dList();
     m_nodePairs = new List<IndexPair>();
     m_nodePaths = new List<int[]>();
 }
コード例 #37
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)
        {
            int            iterations = 3;
            List <Point3d> iPoints    = new List <Point3d>();

            GridVectors = new List <Vector3d>();
            roadDensity = 0;
            double       blockWidth   = 0;
            List <Curve> outputCurves = new List <Curve>();

            DA.GetDataList(0, iPoints);
            DA.GetDataList(1, GridVectors);
            DA.GetData(2, ref GridFirstPoint);
            DA.GetData(3, ref GridLastPoint);
            DA.GetData(4, ref boundary);
            DA.GetData(5, ref roadDensity);
            DA.GetData(6, ref angle);
            DA.GetData(7, ref iterations);
            DA.GetData(8, ref step);

            // step = blockWidth;
            // roadDensity = step - 10;

            gridRes    = (int)Math.Sqrt(GridVectors.Count) - 1;
            pointCloud = new Point3dList();

            int            sign          = 1;
            Vector3d       prevTensor    = new Vector3d(0, 1, 0);
            Point3d        nextPt        = new Point3d();
            Vector3d       nextTensor    = new Vector3d();
            List <Point3d> currPointList = new List <Point3d>();
            List <Point3d> prevPointList = new List <Point3d>();

            for (int i = 0; i < iterations; i++)
            {
                List <Curve> currCurves = new List <Curve>();

                for (int j = 0; j < iPoints.Count; j++) // J ======= iPoints
                {
                    sign = 1;
                    currPointList.Clear();
                    prevPointList.Clear();

                    for (int k = 0; k < 2; k++)
                    {
                        prevPointList = new List <Point3d>(currPointList);
                        currPointList.Clear();
                        //  prevTensor = new Vector3d((i + 1) % 2, (i) % 2, 0);
                        prevTensor = new Vector3d(0, 0, 0);

                        if (GetTensor(iPoints[j], prevTensor) != Vector3d.Unset)
                        {
                            nextPt = iPoints[j] + sign * GetTensor(iPoints[j], prevTensor);

                            currPointList.Add(iPoints[j]);
                            prevTensor = GetTensor(iPoints[j], prevTensor);
                        }

                        int f = 0;
                        while (CheckPt(nextPt) && f < 100)
                        {
                            currPointList.Add(nextPt);
                            nextTensor = GetTensor(currPointList[currPointList.Count - 1], prevTensor);
                            nextPt     = currPointList[currPointList.Count - 1] + sign * nextTensor;
                            f++;
                            prevTensor = nextTensor;
                        }

                        double t = 0;
                        boundary.ClosestPoint((currPointList[currPointList.Count - 1]), out t, step + 5);

                        if (boundary.Contains(nextPt) == PointContainment.Outside && CheckPt(currPointList[currPointList.Count - 1]))
                        {
                            currPointList.Add(boundary.PointAt(t));
                        }
                        else
                        {
                            if (pointCloud.Count > 0)
                            {
                                Point3d pt = pointCloud[pointCloud.ClosestIndex(nextPt)];
                                // if ((pt.DistanceTo(nextPt) <= roadDensity) && f > 0)
                                currPointList.Add(pt);
                            }
                        }

                        outputCurves.Add(new PolylineCurve(currPointList));
                        currCurves.Add(new PolylineCurve(currPointList));
                        sign = -1;
                    }

                    pointCloud.AddRange(currPointList);
                    pointCloud.AddRange(prevPointList);
                }
                iPoints.Clear();

                foreach (PolylineCurve curve in currCurves)
                {
                    if (curve != null && curve.GetLength() > 0.1)
                    {
                        // if (curve.DivideEquidistant(blockWidth) != null)
                        //   iPoints.AddRange(new List<Point3d>(curve.DivideEquidistant(blockWidth)));
                        List <Point3d> points = new List <Point3d>();
                        for (int q = 0; q < curve.PointCount; q++)
                        {
                            points.Add(curve.Point(q));
                        }
                        iPoints.AddRange(points);
                    }
                }

                angle += 90;
            }

            DA.SetDataList(0, outputCurves);
        }
コード例 #38
0
ファイル: Beaver.Terrain.cs プロジェクト: parkjunseok/Beaver
        DataTree<Object> GetStepTree(Mesh terrainMesh, List<double> contourZList, DataTree<Curve> contourTree, List<Brep> brepList)
        {
            DataTree<Object> stepTree = new DataTree<Object>();
            Plane basePlane = Plane.WorldXY;
            basePlane.OriginZ = terrainMesh.GetBoundingBox(true).Min.Z;

            // For each contour-plane
            for (int i = 0; i < contourTree.BranchCount; i++)
            {

                // create higher-Z pt list
                Point3dList winPtList = new Point3dList();

                foreach (Curve contourCrv in contourTree.Branches[i])
                {

                    Plane frm;
                    double t;
                    contourCrv.NormalizedLengthParameter(0.5, out t);
                    contourCrv.FrameAt(t, out frm);
                    frm.Transform(Rhino.Geometry.Transform.PlanarProjection(basePlane));

                    Point3d samplePt0, samplePt1;
                    samplePt0 = frm.Origin;
                    samplePt1 = frm.Origin;
                    samplePt0 += doc.ModelAbsoluteTolerance * frm.YAxis;
                    samplePt1 -= doc.ModelAbsoluteTolerance * frm.YAxis;
                    Ray3d ray0 = new Ray3d(samplePt0, Vector3d.ZAxis);
                    Ray3d ray1 = new Ray3d(samplePt1, Vector3d.ZAxis);
                    double rayParam0 = Rhino.Geometry.Intersect.Intersection.MeshRay(terrainMesh, ray0);
                    double rayParam1 = Rhino.Geometry.Intersect.Intersection.MeshRay(terrainMesh, ray1);

                    winPtList.Add(((rayParam0 > rayParam1) ? samplePt0 : samplePt1));
                }

                // For each splitted region in contour-plane
                foreach (BrepFace brepFace in brepList[i].Faces)
                {
                    Brep testBrep = brepFace.DuplicateFace(false);

                    foreach (Point3d pt in winPtList)
                    {

                        LineCurve testRay = new LineCurve(new Line(pt, Vector3d.ZAxis, 1000));
                        Point3d[] outPts;
                        Curve[] outCrvs;

                        bool ix = Rhino.Geometry.Intersect.Intersection.CurveBrep(testRay, testBrep, doc.ModelAbsoluteTolerance, out outCrvs, out outPts);
                        if (outPts.Length != 0)
                        {
                            stepTree.Add(testBrep, new GH_Path(i));
                            break;
                        }
                    }
                }
            }

            return stepTree;
        }