private static void closeIntersect(Curve innerBounderyCrv, PointCloud startPTsLeft, List <Parkingspace> finalParkingLinesLeft, Point3d crvEnd, out Curve lineOne, out CurveIntersections intersectionsOne) { int indexOne = startPTsLeft.ClosestPoint(crvEnd); lineOne = finalParkingLinesLeft[indexOne].Curves; Vector3d vectorone = lineOne.TangentAtEnd; vectorone.Rotate(RhinoMath.ToRadians(90), new Vector3d(0, 0, 1)); Point3d movedPTone = lineOne.PointAtStart + vectorone; vectorone.Rotate(RhinoMath.ToRadians(180), new Vector3d(0, 0, 1)); Point3d movedPTTwo = lineOne.PointAtStart + vectorone; PointCloud directionPT = new PointCloud(); directionPT.Add(movedPTone); directionPT.Add(movedPTTwo); int indexdir = directionPT.ClosestPoint(crvEnd); if (indexdir == 0) { vectorone.Rotate(RhinoMath.ToRadians(180), new Vector3d(0, 0, 1)); } vectorone = Vector3d.Multiply(vectorone, 10); intersectionsOne = Intersection.CurveCurve(innerBounderyCrv, new Line(lineOne.PointAtEnd, vectorone).ToNurbsCurve(), 0.01, 0.01); }
public GH_GetterResult LoadFromSelection(out PointCloud pc) { var go = new GetObject(); go.GeometryFilter = Rhino.DocObjects.ObjectType.Point | Rhino.DocObjects.ObjectType.PointSet; if (go.GetMultiple(1, 0) == Rhino.Input.GetResult.Cancel) { pc = null; return(GH_GetterResult.cancel); } pc = new PointCloud(); for (int i = 0; i < go.ObjectCount; i++) { var obj = go.Object(i); var rhObj = obj.Object(); if (rhObj.ObjectType == ObjectType.Point) { var pt = obj.Point().Location; var col = rhObj.Attributes.ObjectColor; pc.Add(pt, col); } else if (rhObj.ObjectType == ObjectType.PointSet) { using (PointCloud cloud = obj.PointCloud()) { foreach (var item in cloud.AsEnumerable()) { pc.Add(item.Location, item.Normal, item.Color); } } } } return(GH_GetterResult.success); }
/// <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) { List <Line> lines = new List <Line>(); DA.GetDataList(0, lines); PointCloud cloud = new PointCloud(); List <IElement> elements = new List <IElement>(); List <ITopologicVertex> vertices = new List <ITopologicVertex>(); foreach (Line ln in lines) { Point3d p1 = ln.From; Point3d p2 = ln.To; int idx1 = cloud.ClosestPoint(p1); if (idx1 == -1) { cloud.Add(p1); idx1 = 1; vertices.Add(new ITopologicVertex(p1.X, p1.Y, p1.Z, idx1)); } else { if (p1.DistanceTo(cloud[idx1].Location) > 0.01) { cloud.Add(p1); idx1 = cloud.Count; vertices.Add(new ITopologicVertex(p1.X, p1.Y, p1.Z, idx1)); } else { idx1++; } } int idx2 = cloud.ClosestPoint(p2); if (p2.DistanceTo(cloud[idx2].Location) > 0.01) { cloud.Add(p2); idx2 = cloud.Count; vertices.Add(new ITopologicVertex(p2.X, p2.Y, p2.Z, idx2)); } else { idx2++; } elements.Add(new IBarElement(idx1, idx2)); } IMesh mesh = new IMesh(); mesh.AddRangeVertices(vertices); mesh.AddRangeElements(elements); mesh.BuildTopology(); DA.SetData(0, mesh); }
protected override void SandwormSolveInstance(IGH_DataAccess DA) { SetupLogging(); DA.GetData(0, ref _showPixelColor); DA.GetData(1, ref _writeOutPoints); DA.GetData(2, ref _pixelSize); GetSandwormOptions(DA, 5, 3, 4); SetupKinect(); var depthFrameDataInt = new int[trimmedWidth * trimmedHeight]; var averagedDepthFrameData = new double[trimmedWidth * trimmedHeight]; // Initialize outputs if (keepFrames <= 1 || _outputPoints == null) { // Don't replace prior frames (by clearing array) if using keepFrames _outputPoints = new List <Point3d>(); } SetupRenderBuffer(depthFrameDataInt, null); Core.LogTiming(ref output, timer, "Initial setup"); // Debug Info AverageAndBlurPixels(depthFrameDataInt, ref averagedDepthFrameData); GeneratePointCloud(averagedDepthFrameData); // Assign colors and pixels to the point cloud _pointCloud = new PointCloud(); // TODO intelligently manipulate the point cloud // TODO: actually color pixels by their RGB values and/or using analytic methods if (allPoints.Length > 0) { for (int i = 0; i < allPoints.Length; i++) // allPoints.Length { if (_showPixelColor) { _pointCloud.Add(allPoints[i], Color.Aqua); } else { _pointCloud.Add(allPoints[i]); } } Core.LogTiming(ref output, timer, "Point cloud construction"); // Debug Info } //DA.SetDataList(0, ); // TODO: pointcloud output if (_writeOutPoints) { // Cast to GH_Point for performance reasons DA.SetDataList(0, allPoints.Select(x => new GH_Point(x))); } DA.SetDataList(1, output); // For logging/debugging ScheduleSolve(); }
protected override void SolveInstance(IGH_DataAccess DA) { var hasNotBeenInitialized = _receiveThread == null; if (hasNotBeenInitialized) { StartReceiver(); } if (_receivedData == null) { return; } while (!_receivedData.LidarPointCloud.IsEmpty) { if (_receivedData.LidarPointCloud.TryDequeue(out var item)) { _pc.Add(item.Item1, item.Item2); } } DA.SetData(0, _pc); DA.SetDataList(1, _receivedData.ReceivedPlanes.Values); DA.SetDataList(2, _receivedData.ReceivedBodies.Values); DA.SetDataList(3, _receivedData.ReceivedMeshes.Values); }
public static void ConvertFunc(out HImage image, string currFile) { if (string.IsNullOrEmpty(currFile)) { image = null; return; } PointCloud thePoints = new PointCloud(); FileInfo fileInfo = new FileInfo(currFile); long fileSize = fileInfo.Length; thePoints.SetCapacity((int)(fileSize / 26)); int Width, Height; using (StreamReader sr = new StreamReader(currFile)) { String line; while ((line = sr.ReadLine()) != null) { thePoints.Add(Point3d.ParseFromString(line)); } } HalExtention.ConverToCogRangeP(thePoints, 0.0057245f, 0.03f, thePoints.minZ - 0.1f, thePoints.maxZ - 0.1f, out image); image.GetImageSize(out Width, out Height); int _Height = (int)(Height * 0.03f / 0.0057245f); //int _Height = (int)(Height * 0.04f / 0.0055f); image = image.ZoomImageSize(Width, _Height, "constant"); }
public Line Direction(bool flip, double inflate, List <GH_Curve> curves, double rotateX, double rotateY) { _pointCloud = new PointCloud(); _polylines = new List <Polyline>(); foreach (var c in curves) { Polyline polyline; c.Value.TryGetPolyline(out polyline); _polylines.Add(polyline); _pointCloud.Add(c.Value.PointAt(0.0)); } //Get boudingbox and inflate it BoundingBox boundingBox = _pointCloud.GetBoundingBox(false); boundingBox.Inflate(inflate); //Get box center/top points and make line Line line = new Line(boundingBox.PointAt(0.5, 0.5, 0), boundingBox.PointAt(0.5, 0.5, 1)); if (!flip) { line.Flip(); } //Rotate line around center line.Transform(Rhino.Geometry.Transform.Rotation(Rhino.RhinoMath.ToRadians(rotateX), Vector3d.XAxis, line.PointAt(0.5))); line.Transform(Rhino.Geometry.Transform.Rotation(Rhino.RhinoMath.ToRadians(rotateY), Vector3d.ZAxis, line.PointAt(0.5))); return(line); }
private SimpleGraph <Point3d> BuildGraph(List <Polyline> Polylines) { List <Polyline> .Enumerator enumerator = new List <Polyline> .Enumerator(); SimpleGraph <Point3d> simpleGraph = new SimpleGraph <Point3d>(null); PointCloud pointCloud = new PointCloud(); pointCloud.Add(Polylines[0][0]); simpleGraph.AddVertex(Polylines[0][0]); int num = 0; try { enumerator = Polylines.GetEnumerator(); while (enumerator.MoveNext()) { Polyline current = enumerator.Current; GraphEdge count = new GraphEdge(); int num1 = pointCloud.ClosestPoint(current[0]); Point3d location = pointCloud[num1].Location; double num2 = location.DistanceTo(current[0]); count.From = num1; if (num2 > Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance) { pointCloud.Add(current[0]); simpleGraph.AddVertex(current[0]); count.From = checked (simpleGraph.Count - 1); } num1 = pointCloud.ClosestPoint(current[checked (current.Count - 1)]); count.To = num1; if (pointCloud[num1].Location.DistanceTo(current[checked (current.Count - 1)]) > Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance) { pointCloud.Add(current[checked (current.Count - 1)]); simpleGraph.AddVertex(current[checked (current.Count - 1)]); count.To = checked (simpleGraph.Count - 1); } count.Orient(); this.SrtThick[count] = this.Thickness[num]; this.SrtFaces[count] = this.FacesCounts[num]; simpleGraph.Edges.Add(count); num = checked (num + 1); } } finally { ((IDisposable)enumerator).Dispose(); } return(simpleGraph); }
/// <summary> /// Culls the PFVertex duplicates based on their position in 3d space /// MAKE SURE TO REMOVE also the corresponding edges /// </summary> /// <param name="pottentialDuplicates"></param> /// <param name="tollerance"></param> /// <returns></returns> public static IList <PFVertex> RemoveDuplicates(IList <PFVertex> pottentialDuplicates, double tollerance) { PointCloud pc = new PointCloud(); List <PFVertex> singulars = new List <PFVertex>(); pc.Add(pottentialDuplicates[0].Point); singulars.Add(pottentialDuplicates[0]); for (int p = 1; p < pottentialDuplicates.Count; p++) { int closeIndex = pc.ClosestPoint(pottentialDuplicates[p].Point); if (pottentialDuplicates[p].Point.DistanceTo(pc[closeIndex].Location) > tollerance) { pc.Add(pottentialDuplicates[p].Point); singulars.Add(pottentialDuplicates[p]); } } return(singulars); }
public void Run(int numPoints, float scale, float[] passes) { startTime = Time.realtimeSinceStartup; mesh = meshFilter.mesh; //generate a sphere of points for testing purposes cloud = new PointCloud <PointNormal>(mesh.vertexCount); //cloud = new PointCloud<PointNormal>(numPoints); var vertices = mesh.vertices; var normals = mesh.normals; for (int i = 0; i < mesh.vertexCount; i++) { Vector3 v = vertices[i]; Vector3 n = normals[i]; cloud.Add(new PointNormal(v.x, v.y, v.z, n.x, n.y, n.z)); } //for (int i = 0; i < numPoints; i++) { // var normal = new Vector3(UnityEngine.Random.value - 0.5f, UnityEngine.Random.value - 0.5f, UnityEngine.Random.value - 0.5f).normalized; // var point = normal * scale; // cloud.Add(new PointNormal(point.x, point.y, point.z, normal.x, normal.y, normal.z)); //} float initTime = (Time.realtimeSinceStartup - startTime); Debug.Log("Point Cloud loaded in: " + initTime + "s"); startTime = Time.realtimeSinceStartup; GetComponent <VoxelRenderer>().SetFromPointCloud(cloud); float voxTime = (Time.realtimeSinceStartup - startTime); Debug.Log("Renderer initialized in: " + voxTime + "s"); startTime = Time.realtimeSinceStartup; RunBallPivot(passes); float triangTime = (Time.realtimeSinceStartup - startTime); Debug.Log("Triangulation completed in: " + triangTime + "s"); Debug.Log("Total Searches: " + pivoter.totalSearches); startTime = Time.realtimeSinceStartup; MakeMesh(); float meshTime = Time.realtimeSinceStartup - startTime; Debug.Log("Mesh created in: " + meshTime + "s"); Debug.Log("Tris:" + preMesh.Count); text.text = "Point Cloud initialized in: " + initTime + "s\n" + "Triangulation completed in: " + triangTime + "s\n" + "Mesh created in: " + meshTime + "s"; }
PointCloud PopulatePointCloud(Mesh M) { PointCloud mP = new PointCloud(); for (int i = 0; i < M.Vertices.Count; i++) { mP.Add(M.Vertices[i], M.Normals[i]); } return(mP); }
/// <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(List <System.Object> P, List <System.Object> C, int W) { _cloud = new PointCloud(); _width = W; for (int i = 0; i < P.Count; i++) { _cloud.Add((Point3d)P[i], (Color)C[i]); } _clip = _cloud.GetBoundingBox(false); }
public Tuple <int, int> ClosestCoords(Point3d point) { PointCloud pointCloud = new PointCloud(); for (int y = 0; y < yLen; y++) { for (int x = 0; x < xLen; x++) { pointCloud.Add(Points[x, y]); } } int i = pointCloud.ClosestPoint(point); return(Tuple.Create(i % xLen, i / xLen)); }
protected override Result RunCommand(RhinoDoc doc, RunMode mode) { if (RFContext.Clip) { int N = RFContext.Cloud.Count; bool[] included = new bool[N]; for (int i = 0; i < N; ++i) { if (RFContext.ClippingBox.Contains(RFContext.Cloud[i].Location)) { included[i] = true; } } PointCloud pc = new PointCloud(); for (int i = 0; i < N; ++i) { if (included[i]) { pc.Add( RFContext.Cloud[i].Location, RFContext.Cloud[i].Normal, RFContext.Cloud[i].Color); } } doc.Objects.AddPointCloud(pc); } else { doc.Objects.AddPointCloud(RFContext.Cloud); } Polyline poly = new Polyline(new Point3d[] { new Point3d(0, 0, 0), new Point3d(120, 0, 0), new Point3d(0, 100, 0), new Point3d(0, 0, 0) }); poly.Transform(RFContext.Xform); doc.Objects.AddPolyline(poly); RFContext.ClearCloud(); return(Result.Success); }
protected override void SolveInstance(IGH_DataAccess DA) { DA.GetData("Enabled", ref m_display_enabled); if (m_display_enabled) { int N = 0; List <Mesh> m_input_meshes = new List <Mesh>(); DA.GetDataList("Mesh", m_input_meshes); Mesh m_mesh = new Mesh(); for (int i = 0; i < m_input_meshes.Count; ++i) { m_mesh.Append(m_input_meshes[i]); } DA.GetData("Samples", ref N); BoundingBox bb = m_mesh.GetBoundingBox(true); Plane m_plane = Plane.WorldXY; m_plane.Origin = new Point3d(bb.Min.X, bb.Min.Y, bb.Max.Z + 10.0); Rectangle3d rec = new Rectangle3d(m_plane, bb.Max.X - bb.Min.X, bb.Max.Y - bb.Min.Y); Random rnd = new Random(); double hrecW = rec.Width / 2; double hrecH = rec.Height / 2; double hit_dist = 0; m_cloud = new PointCloud(); for (int i = 0; i < N; ++i) { Ray3d ray = new Ray3d(new Point3d( rec.Center.X - hrecW + rnd.NextDouble() * rec.Width, rec.Center.Y - hrecH + rnd.NextDouble() * rec.Height, rec.Center.Z), -Vector3d.ZAxis); hit_dist = Rhino.Geometry.Intersect.Intersection.MeshRay(m_mesh, ray); if (hit_dist > 0) { m_cloud.Add(ray.Position + ray.Direction * hit_dist); } } } }
private PointCloud <PointXYZRGB> ReadData(byte[] byteArray) { PointCloud <PointXYZRGB> cloud = new PointCloud <PointXYZRGB> (); for (int i = 0; i < _width * _height; i++) { float x = System.BitConverter.ToSingle(_data, i * (int)_point_step + 0); float y = System.BitConverter.ToSingle(_data, i * (int)_point_step + 4); float z = System.BitConverter.ToSingle(_data, i * (int)_point_step + 8); float rgb = System.BitConverter.ToSingle(_data, i * (int)_point_step + 16); if (!float.IsNaN(x + y + z)) { PointXYZRGB p = new PointXYZRGB(x, y, z, rgb); cloud.Add(p); } } return(cloud); }
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(); for (int i = 0; i < nr; i++) { var d = (double)i; pc.Add( new Point3d(r.NextDouble() * edge, r.NextDouble() * edge, r.NextDouble() * edge), System.Drawing.Color.FromArgb(r.Next(0, 255), r.Next(0, 255), r.Next(0, 255)) ); } cnd.ThePc = pc; cnd.Enabled = true; } doc.Views.Redraw(); return(Result.Success); }
public static int[] CreateUnderlyingLinesFromCurve(Curve crv, double size, bool synchronize = false) { Polyline poly; crv.TryGetPolyline(out poly); List <int> ptsTags = new List <int>(); PointCloud ptsCloud = new PointCloud(); int tag; Point3d p; int[] tempTags = new int[poly.Count]; int idx; for (int i = 0; i < poly.Count; i++) { p = poly[i]; idx = EvaluatePoint(ptsCloud, p, 0.001); if (idx == -1) { tag = IBuilder.AddPoint(p.X, p.Y, p.Z, size); ptsTags.Add(tag); ptsCloud.Add(p); idx = ptsCloud.Count - 1; } tempTags[i] = idx; } int[] dimTags = new int[poly.SegmentCount]; for (int i = 0; i < poly.SegmentCount; i++) { dimTags[i] = IBuilder.AddLine(ptsTags[tempTags[i]], ptsTags[tempTags[i + 1]]); } if (synchronize) { IBuilder.Synchronize(); } return(dimTags); }
public List <Tuple <int, double, double, double, byte, byte, byte> > VoxelizeMesh(Mesh M, Color MC, int M_ID, Vector3d Vsize, int CO, ref PointCloud VPC) { //{ID,X,Y,Z,R,G,B} BoundingBox RBBox = M.GetBoundingBox(false); //bounding box in R3 (real numbers) BoundingBox ZBBox = RBBox_to_ZBBox(RBBox, Vsize); //boudning box in Z3 (integer numbers) (note that they are again embedded in R3 for visualization) List <Point3d> gridpoints = BBoxToVoxels(ZBBox, Vsize); List <Point3d> Mesh_NearPoints = NearPoints(gridpoints, M, Vsize.Length / 2); //A = Mesh_NearPoints List <Tuple <int, double, double, double, byte, byte, byte> > Voxels = new List <Tuple <int, double, double, double, byte, byte, byte> >(); //{ID,X,Y,Z,R,G,B} Line[] Intarget = null; //int[] Facets = null; // for each potential voxel check if it has to be included in the raster foreach (Point3d gp in Mesh_NearPoints) { if (CO == 26) { Intarget = MeshTarget26_Connected(gp, Vsize); } else if (CO == 6) { Intarget = MeshTarget06_Connected(gp, Vsize); } else { RhinoApp.WriteLine("connectivity target undefined!"); } //Line[] Intersections = Array.FindAll(Intarget, lambda => MeshLineIntersect(M, lambda)); if (Array.Exists(Intarget, lambda => MeshLineIntersect(M, lambda))) { Voxels.Add(Tuple.Create(M_ID, gp.X, gp.Y, gp.Z, MC.R, MC.G, MC.B)); VPC.Add(gp, MC); } } return(Voxels); }
/// <summary> /// Blend colors in a point cloud with a list of colors same amount as amount of points) or one color. /// </summary> /// <param name="cloud"></param> /// <param name="color"></param> /// <param name="pct"></param> /// <returns></returns> public static PointCloud BlendColors(PointCloud cloud, List <Color> color, Double pct) { PointCloud newCloud = new PointCloud(cloud); //Create Partitions for multithreading. var rangePartitioner = System.Collections.Concurrent.Partitioner.Create(0, newCloud.Count, (int)Math.Ceiling(newCloud.Count / (double)Environment.ProcessorCount)); List <PointCloud> subclouds = new List <PointCloud>(); //Run MultiThreaded Loop. System.Threading.Tasks.Parallel.ForEach(rangePartitioner, (rng, loopState) => { PointCloud subCloud = new PointCloud(); for (int j = rng.Item1; j < rng.Item2; j++) { Color Ptcolor = newCloud[j].Color; Color newColor = new Color(); if (color.Count == 1) { newColor = Blend(Ptcolor, color[0], pct); } else { newColor = Blend(Ptcolor, color[j], pct); } subCloud.Add(newCloud[j].Location, newColor); } subclouds.Add(subCloud); } ); PointCloud mergeCloud = new PointCloud(); for (int i = 0; i < subclouds.Count; i++) { mergeCloud.Merge(subclouds[i]); } return(mergeCloud); }
private PointCloud <PointXYZRGBAIntensity> ReadDataRGBAIntensity(byte[] byteArray) { PointCloud <PointXYZRGBAIntensity> cloud = new PointCloud <PointXYZRGBAIntensity> (); //int temp = byteArray.Length / (int)_point_step; for (int i = 0; i < _width * _height; i++) { float x = System.BitConverter.ToSingle(_data, i * (int)_point_step + 0); float y = System.BitConverter.ToSingle(_data, i * (int)_point_step + 4); float z = System.BitConverter.ToSingle(_data, i * (int)_point_step + 8); uint rgba = System.BitConverter.ToUInt32(_data, i * (int)_point_step + 12); float intensity = System.BitConverter.ToSingle(_data, i * (int)_point_step + 12); if (!(float.IsNaN(x) || float.IsNaN(y) || float.IsNaN(z))) { PointXYZRGBAIntensity p = new PointXYZRGBAIntensity(x, y, z, rgba, intensity); cloud.Add(p); } } return(cloud); }
public void RunInUpdate(bool fromShape, PointMeshType shape, int pivotsPerUpdate, int pivotAnimationSteps, int numPoints, float scale, float radius) { this.pivotsPerUpdate = pivotsPerUpdate; this.pivotAnimationSteps = pivotAnimationSteps; running = true; ballRadius = radius; mesh = meshFilter.mesh; ball.transform.localScale = new Vector3(radius * 2, radius * 2, radius * 2); //generate a sphere of points for testing purposes if (fromShape) { cloud = new PointCloud <PointNormal>(numPoints); if (shape == PointMeshType.Sphere) { for (int i = 0; i < numPoints; i++) { var normal = new Vector3(UnityEngine.Random.value - 0.5f, UnityEngine.Random.value - 0.5f, UnityEngine.Random.value - 0.5f).normalized; var point = normal * scale; cloud.Add(new PointNormal(point.x, point.y, point.z, normal.x, normal.y, normal.z)); } } } else { cloud = new PointCloud <PointNormal>(mesh.vertexCount); var vertices = mesh.vertices; var normals = mesh.normals; for (int i = 0; i < mesh.vertexCount; i++) { Vector3 v = vertices[i]; Vector3 n = normals[i]; cloud.Add(new PointNormal(v.x, v.y, v.z, n.x, n.y, n.z)); } } GetComponent <VoxelRenderer>().SetFromPointCloud(cloud); pivoter = new Pivoter(cloud, ballRadius); f = new Front(); }
void AddXYBPointToCloud(ref PointCloud pc, ref System.IO.BinaryReader reader) { double x, y, z; x = reader.ReadDouble() * this.scale; y = reader.ReadDouble() * this.scale; z = reader.ReadDouble() * this.scale; ushort i = reader.ReadUInt16(); pc.Add(new Point3d(x, y, z)); System.Drawing.Color col = System.Drawing.Color.FromArgb(UInt16toColor(i)); pc[pc.Count - 1].Color = col; for (int j = 0; j < resolution - 1; ++j) { x = reader.ReadDouble() * this.scale; y = reader.ReadDouble() * this.scale; z = reader.ReadDouble() * this.scale; i = reader.ReadUInt16(); } }
public static Polyline GetAxis(IEnumerable <Polyline> regions, Polyline boundary) { var lines = regions.SelectMany(e => e.GetSegments()); var pc = new PointCloud(boundary.GetSegments().Select(l => l.PointAt(0.5))); var edges = lines.Select(l => (Line: l, Center: l.PointAt(0.5))); var interiorEdges = edges.Where(e => !Exists(e.Center, pc)); var interiorLines = new List <Line>(); foreach (var edge in interiorEdges) { if (Exists(edge.Center, pc)) { continue; } pc.Add(edge.Center); interiorLines.Add(edge.Line); } return(GetAxis(interiorLines)); }
private PointCloud <PointXYZIntensity> ReadData(byte[] byteArray) { PointCloud <PointXYZIntensity> cloud = new PointCloud <PointXYZIntensity> (); int temp = byteArray.Length / (int)_point_step; for (int i = 0; i < _width * _height; i++) { float x = System.BitConverter.ToSingle(_data, i * (int)_point_step + 0); float y = System.BitConverter.ToSingle(_data, i * (int)_point_step + 4); float z = System.BitConverter.ToSingle(_data, i * (int)_point_step + 8); float intensity = System.BitConverter.ToSingle(_data, i * (int)_point_step + 12); if (!(float.IsNaN(x) || float.IsNaN(y) || float.IsNaN(z) || float.IsNaN(intensity))) { PointXYZIntensity p = new PointXYZIntensity(x, y, z, intensity); //Debug.Log(x + ", " + y + ", " + z); cloud.Add(p); } //Debug.Log(i + "/" + _width * _height + ", " + temp); } //Debug.Log("Done1"); return(cloud); }
public static int[] CreateUnderlyingLinesFromPolyline(Polyline poly, double size, ref List <int> ptsTags, ref PointCloud ptsCloud, double t = 0.001, bool synchronize = false) { Point3d p; int tag; int[] crvTags = new int[poly.SegmentCount]; int[] tempTags = new int[poly.Count]; int idx; for (int j = 0; j < poly.Count; j++) { p = poly[j]; idx = EvaluatePoint(ptsCloud, p, t); if (idx == -1) { tag = IBuilder.AddPoint(p.X, p.Y, p.Z, size); ptsTags.Add(tag); ptsCloud.Add(p); idx = ptsCloud.Count - 1; } tempTags[j] = idx; } for (int j = 0; j < poly.SegmentCount; j++) { crvTags[j] = IBuilder.AddLine(ptsTags[tempTags[j]], ptsTags[tempTags[j + 1]]); } if (synchronize) { IBuilder.Synchronize(); } return(crvTags); }
public static int[] CreateUnderlyingSplinesFromCurve(Curve crv, double size, bool synchronize = false) { // Covert curve into polycurve PolyCurve pc = crv.ToArcsAndLines(Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance, Rhino.RhinoDoc.ActiveDoc.ModelAngleToleranceRadians, 0, 1); // Divide points into 4 groups and create splines int remain = pc.SegmentCount % 4; int count = (pc.SegmentCount - remain) / 4; int[] dimTags = new int[4]; int sIdx = 0, pIdx, tag; PointCloud ptsCloud = new PointCloud(); List <int> allTags = new List <int>(); Point3d p; for (int i = 0; i < 4; i++) { if (i == 3) { count += remain; } int[] ptTags = new int[count + 1]; for (int j = 0; j < count; j++) { p = pc.SegmentCurve(sIdx).PointAtStart; pIdx = EvaluatePoint(ptsCloud, p, 0.0001); if (pIdx == -1) { tag = IBuilder.AddPoint(p.X, p.Y, p.Z, size); ptsCloud.Add(p); allTags.Add(tag); } else { tag = allTags[pIdx]; } ptTags[j] = tag; if (j == count - 1) { p = pc.SegmentCurve(sIdx).PointAtEnd; pIdx = EvaluatePoint(ptsCloud, p, 0.001); if (pIdx == -1) { tag = IBuilder.AddPoint(p.X, p.Y, p.Z, size); ptsCloud.Add(p); allTags.Add(tag); } else { tag = allTags[pIdx]; } ptTags[j + 1] = tag; } sIdx++; } dimTags[i] = IBuilder.AddSpline(ptTags); } if (synchronize) { IBuilder.Synchronize(); } return(dimTags); }
public static Polyline GetAxis(IEnumerable <Line> lines) { var allPoints = lines.SelectMany(l => new Point3d[] { l.From, l.To }); var pc = new PointCloud(); foreach (var point in allPoints) { if (Exists(point, pc)) { continue; } pc.Add(point); } var nodes = new List <List <Edge> >(Enumerable.Repeat(new List <Edge>(), pc.Count)); var edges = lines.Select(l => { var edge = new Edge() { Start = pc.ClosestPoint(l.From), End = pc.ClosestPoint(l.To), Line = l, Enabled = true }; nodes[edge.Start].Add(edge); nodes[edge.End].Add(edge); return(edge); }).ToList(); while (true) { var toDisable = new List <Edge>(); for (int i = 0; i < nodes.Count; i++) { var node = nodes[i]; int valence = node.Count(e => e.Enabled); if (valence == 1) { var edge = node.First(e => e.Enabled); var j = edge.Start == i ? edge.End : edge.Start; int otherValence = nodes[j].Count(e => e.Enabled); if (otherValence >= 3) { toDisable.Add(edge); } } } if (toDisable.Count == 0) { break; } foreach (var edge in toDisable) { edge.Enabled = false; } } var axes = edges .Where(e => e.Enabled) .Select(e => e.Line.ToNurbsCurve()); var curve = Curve.JoinCurves(axes); Polyline pl = new Polyline(); if (curve.Length > 0) { curve[0].TryGetPolyline(out pl); } else { Line maxLine = Line.Unset; double maxLength = 0; foreach (var line in lines) { double length = line.Direction.SquareLength; if (length > maxLength) { maxLength = length; maxLine = line; } } pl = new Polyline(new Point3d[] { maxLine.From, maxLine.To }); } return(pl); }
private static NGonsCore.Graphs.UndirectedGraph LinesToUndirectedGrap(List <Line> lines) { List <Point3d> pts = new List <Point3d>(); foreach (Line l in lines) { pts.Add(l.From); pts.Add(l.To); } //Sorting var edges = new List <int>(); var allPoints = new List <Point3d>(pts); //naked points int i = 0; while (allPoints.Count != 0) { Point3d pt = allPoints[0]; allPoints.RemoveAt(0); for (int d = 0; d < pts.Count; d++) { if (pt.Equals(pts[d])) { edges.Add(d); break; } } i++; } var uniqueVertices = new HashSet <int>(edges).ToList(); //Creating typological points var topologyPoints = new PointCloud(); foreach (int k in uniqueVertices) { topologyPoints.Add(pts[k]); } //var vertices = Enumerable.Range(0, uniqueVertices.Count); for (int k = 0; k < uniqueVertices.Count; k++) { if (uniqueVertices.ElementAt(k) != k) { for (int l = 0; l < edges.Count; l++) { if (edges[l] == uniqueVertices[k]) { edges[l] = k; } } } } //Create graph NGonsCore.Graphs.UndirectedGraph g = new NGonsCore.Graphs.UndirectedGraph(uniqueVertices.Count); for (int k = 0; k < uniqueVertices.Count; k++) { g.InsertVertex(k.ToString()); } for (int k = 0; k < edges.Count; k += 2) { g.InsertEdge(edges[k].ToString(), edges[k + 1].ToString()); } g.SetAttribute((object)topologyPoints); return(g); }
public static IMesh DualMesh(IMesh mesh) { IMesh nM = new IMesh(); // Face center points foreach (IElement e in mesh.Elements) { nM.AddVertex(e.Key, new ITopologicVertex(ISubdividor.ComputeAveragePosition(e.Vertices, mesh))); } int[] data1, data2; PointCloud cloud = new PointCloud(); List <int> global = new List <int>(); int vertexKey = nM.FindNextVertexKey(); foreach (ITopologicVertex v in mesh.Vertices) { data1 = mesh.Topology.GetVertexIncidentElementsSorted(v.Key); if (!mesh.Topology.IsNakedVertex(v.Key)) { nM.AddElement(new ISurfaceElement(data1)); } else { List <int> local = new List <int>(); data2 = mesh.Topology.GetVertexAdjacentVerticesSorted(v.Key); bool flag = false; foreach (int vv in data2) { if (mesh.Topology.IsNakedEdge(vv, v.Key)) { Point3d p = ISubdividor.ComputeAveragePoint(new[] { vv, v.Key }, mesh); int idx = cloud.ClosestPoint(p); if (idx == -1) { flag = true; } else { if (p.DistanceTo(cloud[idx].Location) > 0.01) { flag = true; } else { flag = false; } } if (flag) { cloud.Add(p); nM.AddVertex(vertexKey, new ITopologicVertex(p)); global.Add(vertexKey); local.Add(vertexKey); vertexKey++; } else { local.Add(global[idx]); } } } nM.AddVertex(vertexKey, new ITopologicVertex(v)); local.Insert(1, vertexKey); local.AddRange(data1.Reverse()); vertexKey++; nM.AddElement(new ISurfaceElement(local.ToArray())); } } nM.BuildTopology(true); return(nM); }