internal IfcRationalBSplineCurveWithKnots(DatabaseIfc db, NurbsCurve nc, bool twoD) : base(db, nc, twoD) { mWeightsData = new List<double>(nc.Points.Count); for (int icounter = 0; icounter < nc.Points.Count; icounter++) mWeightsData.Add(nc.Points[icounter].Weight); }
public void init(NurbsCurve C, double scaleT) { Point3d P; P=C.PointAt(t); x = P.X; y = P.Y; z = 0; }
/// <summary> /// Elevate the degree of a Bezier curve (represented in NURBS form) to a given degree /// without changing the shape /// </summary> /// <param name="crv">The curve</param> /// <param name="finalDegree">The requested degree</param> /// <returns></returns> public static NurbsCurve ElevateBezierDegree(NurbsCurve crv, int finalDegree) { if (crv.ControlPoints().Count() != crv.Degree + 1 || crv.IsRational) { throw new Exception("The supplied curve for degree elevation must be a bezier curve"); } if (crv.Degree > finalDegree) { throw new Exception("The supplied curve for degree elevation must have a " + "lesser degree than that required"); } while (crv.Degree < finalDegree) { crv = ElevateBezierDegreeBy1(crv); } return crv; }
private static NurbsCurve ElevateBezierDegreeBy1(NurbsCurve crv) { var cpts = crv.ControlPoints(); var n = crv.Degree + 1; var cptsFinal = new List<Point>(); cptsFinal.Add(cpts.First()); for (var i = 1; i < cpts.Length; i++) { cptsFinal.Add(Interp(cpts[i - 1], cpts[i], (double)i / n)); } cptsFinal.Add(cpts.Last()); var oldKnots = crv.Knots(); var knots = HermiteToNurbs.Clamp(new[] { oldKnots.First(), oldKnots.Last() }, n); var weights = Enumerable.Repeat(1.0, cptsFinal.Count).ToArray(); return NurbsCurve.ByControlPointsWeightsKnots(cptsFinal, weights, knots, n); }
public static NurbsCurve Extend(this NurbsCurve curve, double start = 0.0, double end = 0.0, bool tangentExtensions = false, double tolerance = Tolerance.Distance) { throw new NotImplementedException(); }
public static Point Centroid(this NurbsCurve nurbsCurve, double tolerance = Tolerance.Distance) { throw new NotImplementedException(); }
internal IfcBSplineCurveWithKnots(DatabaseIfc m, NurbsCurve nc, bool twoD) : base(m, nc, twoD) { if (mDatabase.mModelView != ModelView.Ifc4NotAssigned) throw new Exception("Invalid Model View for IfcRationalBSplineCurveWithKnots : " + mDatabase.ModelView.ToString()); ClosedCurve = nc.IsClosed ? IfcLogicalEnum.TRUE : IfcLogicalEnum.FALSE; adoptKnotsAndMultiplicities(nc); }
public BezierPatchForeignEdge(ForeignShell parent, ControlPoint[] points, int index) : base(parent) { Debug.Assert(points != null); NurbsData data = new NurbsData(4, false, false, new Knot[] { new Knot(0, 4), new Knot(1, 4) }); nurbsCurve = NurbsCurve.CreateFromControlPoints(data, points); this.index = index; }
internal static GeometryBase CreateGeometryHelper(IntPtr pGeometry, object parent, int subobjectIndex) { if (IntPtr.Zero == pGeometry) { return(null); } var type = UnsafeNativeMethods.ON_Geometry_GetGeometryType(pGeometry); if (type < 0) { return(null); } GeometryBase rc = null; switch (type) { case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Curve: //1 rc = new Curve(pGeometry, parent, subobjectIndex); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_NurbsCurve: //2 rc = new NurbsCurve(pGeometry, parent, subobjectIndex); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_PolyCurve: // 3 rc = new PolyCurve(pGeometry, parent, subobjectIndex); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_PolylineCurve: //4 rc = new PolylineCurve(pGeometry, parent, subobjectIndex); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_ArcCurve: //5 rc = new ArcCurve(pGeometry, parent, subobjectIndex); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_LineCurve: //6 rc = new LineCurve(pGeometry, parent, subobjectIndex); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Mesh: //7 rc = new Mesh(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Point: //8 rc = new Point(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_TextDot: //9 rc = new TextDot(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Surface: //10 rc = new Surface(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Brep: //11 rc = new Brep(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_NurbsSurface: //12 rc = new NurbsSurface(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_RevSurface: //13 rc = new RevSurface(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_PlaneSurface: //14 rc = new PlaneSurface(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_ClippingPlaneSurface: //15 rc = new ClippingPlaneSurface(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Hatch: // 17 rc = new Hatch(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_SumSurface: //19 rc = new SumSurface(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_BrepFace: //20 { int faceindex = -1; IntPtr ptr_brep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref faceindex); if (ptr_brep != IntPtr.Zero && faceindex >= 0) { Brep b = new Brep(ptr_brep, parent); rc = b.Faces[faceindex]; } } break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_BrepEdge: // 21 { int edgeindex = -1; IntPtr ptr_brep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref edgeindex); if (ptr_brep != IntPtr.Zero && edgeindex >= 0) { Brep b = new Brep(ptr_brep, parent); rc = b.Edges[edgeindex]; } } break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_InstanceReference: // 23 rc = new InstanceReferenceGeometry(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Extrusion: //24 rc = new Extrusion(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_PointCloud: // 26 rc = new PointCloud(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_DetailView: // 27 rc = new DetailView(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Light: //32 rc = new Light(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_PointGrid: //33 rc = new Point3dGrid(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_MorphControl: //34 rc = new MorphControl(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_BrepLoop: //35 { int loopindex = -1; IntPtr ptr_brep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref loopindex); if (ptr_brep != IntPtr.Zero && loopindex >= 0) { Brep b = new Brep(ptr_brep, parent); rc = b.Loops[loopindex]; } } break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_BrepTrim: // 36 { int trimindex = -1; IntPtr ptr_brep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref trimindex); if (ptr_brep != IntPtr.Zero && trimindex >= 0) { Brep b = new Brep(ptr_brep, parent); rc = b.Trims[trimindex]; } } break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Leader: // 38 rc = new Leader(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_SubD: // 39 rc = new SubD(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_DimLinear: //40 rc = new LinearDimension(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_DimAngular: //41 rc = new AngularDimension(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_DimRadial: //42 rc = new RadialDimension(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_DimOrdinate: //43 rc = new OrdinateDimension(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Centermark: //44 rc = new Centermark(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Text: //45 rc = new TextEntity(pGeometry, parent); break; default: rc = new UnknownGeometry(pGeometry, parent, subobjectIndex); break; } return(rc); }
/***************************************************/ /**** Public Methods ****/ /***************************************************/ public static int Degree(this NurbsCurve curve) { return(curve.Knots.Count - curve.ControlPoints.Count + 1); }
/// <summary> /// Remove zig-zags from curve /// WARNING: could have problems in Singularity /// </summary> /// <param name="crv"></param> /// <param name="srf"></param> /// <param name="tol"></param> /// <returns></returns> public static bool _ZigZagDeformations_TryRemove_old(this Curve crv, Surface srf, double tol, out NurbsCurve newCrvNurb) { newCrvNurb = null; NurbsCurve crvNurb = crv._ToNurbsCurve(); // Linear crv's can't have deformations - so return original curve if (crvNurb.Degree == 1) { return(false); } var zigzagIndexes = crvNurb._ZigZagDeformationsFind(); if (zigzagIndexes == null) { return(false); } // // Project all points on surface // List <SurfacePoint2d3dSrf> srfPoints; if (!crvNurb._TryProjectOnSrf(srf, tol, out srfPoints)) { return(false); } var savesrfPointsCount = srfPoints.Count; // // Remove wrong Control Points // // remove from left to right RemoveZigZagIndexes(ref srfPoints, 5); // remove from right to left srfPoints.Reverse(); RemoveZigZagIndexes(ref srfPoints, 5); // back to original order srfPoints.Reverse(); // // Apply fix // if (srfPoints.Count == savesrfPointsCount) { // } // deformation present - recreate curve base on new control points (without deformed ones) var newPoints = srfPoints.Select(o => o.LocationSrf); var res = srf.InterpolatedCurveOnSurface(newPoints, tol); newCrvNurb = res; return(true); }
public static void ToMaya(Curve CurveToSend, string name) { NurbsCurve ctsAsNurb = null; if (CurveToSend is Rectangle) { Rectangle rec = (Rectangle)CurveToSend; ctsAsNurb = NurbsCurve.ByControlPoints(rec.Points, 1, true); } else if (CurveToSend is Polygon) { Polygon rec = (Polygon)CurveToSend; ctsAsNurb = NurbsCurve.ByControlPoints(rec.Points, 1, true); } else { ctsAsNurb = CurveToSend.ToNurbsCurve(); } var ncd = new MFnNurbsCurveData(); MFnNurbsCurveForm mfnform; if (ctsAsNurb.IsClosed) { mfnform = MFnNurbsCurveForm.kClosed; } else { mfnform = MFnNurbsCurveForm.kOpen; } var mayaCurve = new MFnNurbsCurve(); var vtxs = new MPointArray(); var cvs = ctsAsNurb.ControlPoints(); var yUp = MGlobal.isYAxisUp; if (yUp) { foreach (var cv in cvs) { var pt = new MPoint(cv.X, cv.Z, -cv.Y); vtxs.Add(pt); //pt.Dispose(); } } else { foreach (var cv in cvs) { var pt = new MPoint(cv.X, cv.Y, cv.Z); vtxs.Add(pt); //pt.Dispose(); } } var knots = ctsAsNurb.Knots(); var crvKnots = new MDoubleArray(knots); crvKnots.RemoveAt(0); crvKnots.RemoveAt(crvKnots.Count - 1); MDagPath node = null; var nodeExists = false; Task checkNode = null; Task deleteNode = null; try { node = DMInterop.getDagNode(name); nodeExists = true; } catch (Exception) { nodeExists = false; } MObject obj; if (nodeExists) { MDagPath nodeShape = node; nodeShape.extendToShape(); var modifyCrv = new MDGModifier(); mayaCurve = new MFnNurbsCurve(nodeShape); try { MFnNurbsCurveData dataCreator = new MFnNurbsCurveData(); MObject outCurveData = dataCreator.create(); var span = (vtxs.Count - ctsAsNurb.Degree); string rblCmd = $"rebuildCurve -rt 0 -s {span} -d {ctsAsNurb.Degree} {name}"; if (mayaCurve.numCVs != vtxs.Count || mayaCurve.degree != ctsAsNurb.Degree) { MGlobal.executeCommand(rblCmd); } mayaCurve.setCVs(vtxs); mayaCurve.setKnots(crvKnots, 0, crvKnots.length - 1); mayaCurve.updateCurve(); modifyCrv.doIt(); if (CurveToSend.GetType() == typeof(Circle)) { span = 8; rblCmd = $"rebuildCurve -rt 0 -s {span} {name}"; MGlobal.executeCommand(rblCmd); } } catch (Exception e) { MGlobal.displayWarning(e.Message); } } else { obj = mayaCurve.create(vtxs, crvKnots, (uint)ctsAsNurb.Degree, (MFnNurbsCurve.Form)mfnform, false, ctsAsNurb.IsRational); MFnDependencyNode nodeFn = new MFnDagNode(obj); nodeFn.setName(name); } }
private void adoptKnotsAndMultiplicities(NurbsCurve nc) { double tol = (nc.Knots[nc.Knots.Count - 1] - nc.Knots[0]) / Math.Max(1000, nc.Knots.Count) / 1000; if (nc.IsPeriodic) { int kc = 1; if (nc.Knots[1] - nc.Knots[0] < tol) { kc = 2; } else { mKnots.Add(nc.Knots[0] - (nc.Knots[1] - nc.Knots[0])); mKnotMultiplicities.Add(1); } double knot = nc.Knots[0]; for (int icounter = 1; icounter < nc.Knots.Count; icounter++) { double t = nc.Knots[icounter]; if ((t - knot) > tol) { mKnots.Add(knot); mKnotMultiplicities.Add(kc); knot = t; kc = 1; } else { kc++; } } mKnots.Add(knot); if (kc > 1) { mKnotMultiplicities.Add(kc + 1); } else { mKnotMultiplicities.Add(1); mKnots.Add(knot + (knot - nc.Knots[nc.Knots.Count - 2])); mKnotMultiplicities.Add(1); } } else { int kc = 2; double knot = nc.Knots[0]; for (int icounter = 1; icounter < nc.Knots.Count; icounter++) { double t = nc.Knots[icounter]; if ((t - knot) > tol) { mKnots.Add(knot); mKnotMultiplicities.Add(kc); knot = t; kc = 1; } else { kc++; } } mKnots.Add(knot); mKnotMultiplicities.Add(kc + 1); } }
private static NurbsCurve _ZigZagDeformations_TryRemove__by_removing_diapasons(NurbsCurve crv, Surface srf, int[] zigzagIndexes, List <ZigZagDiapason> diapasons) { // // Split curve on segments // Point3d[] allCrvPoints; //Try1 var divby = crv._GetDivBy(srf); var ts = crv._DivideByCount_ThreadSafe(divby, true, out allCrvPoints); if (allCrvPoints == null) { //Try2 ts = crv._DivideByCount_ThreadSafe(100, true, out allCrvPoints); if (allCrvPoints == null) { //Try3 var length = crv._Get3dLength(srf); if (length < 0.001) { allCrvPoints = new[] { crv.PointAtStart, crv.PointAtEnd }; ts = new[] { crv.Domain.T0, crv.Domain.T1 }; } else { return(null); } } } // // Fix curve by extending diapasons until we get fixed curve // NurbsCurve res = null; var diapasonExtensionMax = crv.Domain.Length * 0.05; // 5% double diapasonExtension = 0; while (diapasonExtension <= diapasonExtensionMax) { //Layers.Debug.AddPoint(crvNurb._PX3d(diapasons[0].StartIgnoreAtT - diapasonExtension, srf), Color.Red); //Layers.Debug.AddPoint(crvNurb._PX3d(diapasons[0].EndIgnoreAtT + diapasonExtension, srf), Color.Red); var crvFixed = _ZigZagDeformations_Remove(crv, srf, ts, diapasons, diapasonExtension); if (crvFixed == null) { break; //break tries - return what we found till now :( } // if no more zigzags - set result if (!crvFixed._ZigZagDeformationExists(srf)) { res = crvFixed; break; } // if we here - zigzags still exists after fix - so lets increaese cut length and lets try once again diapasonExtension += crv.Domain.Length * 0.01; // 1% } return(res); }
public static NurbsCurve Scale(this NurbsCurve curve, Point origin, Vector scaleVector) { throw new NotImplementedException(); }
public static Vector TangentAtLength(this NurbsCurve curve, double length, double tolerance = Tolerance.Distance) { throw new NotImplementedException(); }
/***************************************************/ public static ICurve SetGeometry(this NurbsCurve curve, ICurve newCurve) { return(newCurve.IClone()); }
public static Vector StartDir(this NurbsCurve curve) { throw new NotImplementedException(); }
public static NurbsCurve Mirror(this NurbsCurve curve, Plane p) { throw new NotImplementedException(); }
public NurbsCurve ToNurbsCurve(int degree, int cvCount) { return(NurbsCurve.CreateFromCircle(this, degree, cvCount)); }
public static Point Centroid(this NurbsCurve nurbsCurve) { return(nurbsCurve.Centroid(Tolerance.Distance)); }
private static NurbsCurve _ZigZagDeformations_Remove(this NurbsCurve crvNurb, Surface srf, double[] ts, List <ZigZagDiapason> diapasons, double diapasonExtension) { // // Filter segmens - remove those segments what is close to zigzag control points // var filteredCrvPoints = new List <Point3d>(); filteredCrvPoints.Add(crvNurb.PointAt(ts[0])); // add 1-st point (PointAtStart) for (int i = 1; i < ts.Length - 1; i++) { var t = ts[i]; var isCloseToZigzag = false; foreach (var d in diapasons) { var minT = d.StartIgnoreAtT - diapasonExtension; var maxT = d.EndIgnoreAtT + diapasonExtension; if (minT <= t && t <= maxT) { isCloseToZigzag = true; break; } } if (!isCloseToZigzag) { filteredCrvPoints.Add(crvNurb.PointAt(t)); //Layers.Debug.AddPoint(crvNurb._PX3d(t, srf), Color.Green); } else { //Layers.Debug.AddPoint(crvNurb._PX3d(t, srf), Color.Red); } //DEBUG //var p3d = crvNurb.PointAt(t); //if (crvNurb.Dimension == 2) //{ // p3d = srf.PointAt(crvNurb.PointAt(t).X, crvNurb.PointAt(t).Y); //} //Layers.Debug.AddPoint(p3d, isCloseToZigzag ? Color.Red : Color.Blue); //ENDDEBUG } filteredCrvPoints.Add(crvNurb.PointAt(ts[ts.Length - 1]));// add last point (PointAtEnd) //DEBUG //log.temp("Adding debig point for ZigZag"); //Viewport.Redraw(RhinoDoc.ActiveDoc, "Layers.Debug.AddPoints(filteredCrvPoints)"); //foreach (var p in filteredCrvPoints) //{ // var p3d = p; // if (crvNurb.Dimension == 2) // { // p3d = srf.PointAt(p.X, p.Y); // } // Layers.Debug.AddPoint(p3d, Color.Blue); //} //ENDDEBUG // // Approximate and simplfy new crv // var res = Curve.CreateControlPointCurve(filteredCrvPoints, 3); //var res = Curve.CreateInterpolatedCurve(filteredCrvPoints, 3); - works bad - creates zigzags if (res != null) { if (crvNurb.Dimension == 2) { res = res._SetDimension(2); } // it is incorrect to fix control point here! //////////if (crvNurb.Dimension == 2 && srf != null) //////////{ ////////// res = res._Fix2dContorlPoints(srf); // - shall we do fix 2d control points ??? - NO!!! //////////} res = res._Simplify(srf, true); } return(res == null ? null : res._ToNurbsCurve()); }
public NurbsExtrudedSurface(NurbsCurve profile, NurbsCurve rail) { this.ProfileCurve = profile; this.ExtrusionRail = rail; }
protected override void SolveInstance(IGH_DataAccess DA) { try { //Input Surface S = s; //if (!DA.GetData(0, ref S)) { return; } DA.GetData(0, ref S); Point3d P = Point3d.Unset; if (!DA.GetData(1, ref P)) { P = S.PointAt(S.Domain(0).Mid, S.Domain(1).Mid); } double R = Rhino.RhinoMath.UnsetValue; if (!DA.GetData(2, ref R)) { return; } double A = Rhino.RhinoMath.UnsetValue; if (!DA.GetData(3, ref A)) { return; } int max = 0; if (!DA.GetData(4, ref max)) { return; } Boolean extend = false; if (!DA.GetData(5, ref extend)) { return; } if (R <= 0) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Mesh edge length must be a positive, non-zero number."); return; } Mesh cutter = new Mesh(); //DA.GetData(8, ref cutter); Surface Sold = S; Sold.SetDomain(0, new Interval(0, 1)); Sold.SetDomain(1, new Interval(0, 1)); PointCloud cornerPoints = new PointCloud(new Point3d[] { Sold.PointAt(0, 0), Sold.PointAt(0, 1), Sold.PointAt(1, 0), Sold.PointAt(1, 1) }); if (extend) //Extend more and trim edges? { S = S.Extend(IsoStatus.North, R * 2, true); S = S.Extend(IsoStatus.East, R * 2, true); S = S.Extend(IsoStatus.South, R * 2, true); S = S.Extend(IsoStatus.West, R * 2, true); } //int L = 0; //int W = 0; //DA.GetData(6, ref L); //DA.GetData(7, ref W); //----------------------------------------------------------------------------------------------------------// //Solution // starting point double u0, v0; S.ClosestPoint(P, out u0, out v0); //Create plane on surface by point and surface normal, plane x,y axis are directions for the net Plane plane = new Plane(S.PointAt(u0, v0), S.NormalAt(u0, v0)); plane.Rotate(Rhino.RhinoMath.ToRadians(A), S.NormalAt(u0, v0)); Vector3d[] dir = new Vector3d[] { plane.XAxis *R, plane.YAxis *R, plane.XAxis * -R, plane.YAxis * -R }; //Surface Curve[] MyNakedEdges = Sold.ToBrep().DuplicateNakedEdgeCurves(true, false); Curve SurfaceNakedEdge = Curve.JoinCurves(MyNakedEdges)[0]; Mesh[] meshes = new Mesh[] { new Mesh(), new Mesh(), new Mesh(), new Mesh() }; //----------------------------------------------------------------------------------------------------------// //Create axis // for each direction, walk out (and store list of points) double u, v; List <Point3d>[] axis = new List <Point3d> [4]; List <Arc>[] arcs = new List <Arc> [4]; polylines = new List <Polyline>(); for (int i = 0; i < 4; i++) { // set u and v to starting point u = u0; v = v0; List <Point3d> pts = new List <Point3d>(); List <Arc> arcCurrent = new List <Arc>(); for (int j = 0; j < max + 1; j++) { Point3d pt = S.PointAt(u, v); // get point and normal for uv pts.Add(pt); Vector3d srfNormal = S.NormalAt(u, v) * R; Arc arc = new Arc(pt + srfNormal, pt + dir[i], pt - srfNormal); // create forward facing arc and find intersection point with surface (as uv) arcCurrent.Add(arc); CurveIntersections isct = Intersection.CurveSurface(arc.ToNurbsCurve(), S, 0.01, 0.01); if (isct.Count > 0) { isct[0].SurfacePointParameter(out u, out v); } else { break; } // adjust direction vector (new position - old position) dir[i] = S.PointAt(u, v) - pt; } axis[i] = pts; arcs[i] = arcCurrent; } //----------------------------------------------------------------------------------------------------------// //Build up the mesh quads in between Rhino.RhinoApp.ClearCommandHistoryWindow(); GH_PreviewUtil preview = new GH_PreviewUtil(GetValue("Animate", false)); Mesh mesh = new Mesh(); // target mesh Mesh[] fourMeshes = new Mesh[4]; List <int>[] faceID = new List <int>[] { new List <int>(), new List <int>(), new List <int>(), new List <int>() }; //columns lengths List <List <Polyline> >[] strips = new List <List <Polyline> >[] { new List <List <Polyline> >(), new List <List <Polyline> >(), new List <List <Polyline> >(), new List <List <Polyline> >() }; //columns lengths //List<Polyline> cuts = new List<Polyline>(); for (int k = 0; k < 4; k++) //Loop through each axis { Mesh qmesh = new Mesh(); // local mesh for quadrant Point3d[,] quad = new Point3d[axis[k].Count + 10, axis[(k + 1) % 4].Count + 10]; // 2d array of points int[,] qindex = new int[axis[k].Count + 10, axis[(k + 1) % 4].Count + 10]; // 2d array of points' indices in local mesh int count = 0; //Add 2nd axis particles for (int i = 0; i < axis[(k + 1) % 4].Count; i++) { quad[0, i] = axis[(k + 1) % 4][i]; //store 2nd axis points in point array qmesh.Vertices.Add(axis[(k + 1) % 4][i]); //also add 2nd axis points to mesh qindex[0, i] = count++; //store indicies } for (int i = 1; i < quad.GetLength(0); i++) { if (i < axis[k].Count) // add axis vertex { quad[i, 0] = axis[k][i]; //store 1st axis points in point array qmesh.Vertices.Add(axis[k][i]); //also add 1st axis points to mesh qindex[i, 0] = count++; //store indicies } int counter = 0; List <Polyline> currentStrip = new List <Polyline>(); // for each column attempt to locate a new vertex in the grid for (int j = 1; j < quad.GetLength(1); j++) { // if quad[i - 1, j] doesn't exist, try to add it and continue (or else break the current row) if (quad[i - 1, j] == new Point3d()) { if (j < 2) { break; } CurveIntersections isct = this.ArcIntersect(S, quad[i - 1, j - 1], quad[i - 1, j - 2], R); if (isct.Count > 0) { quad[i - 1, j] = isct[0].PointB; qmesh.Vertices.Add(quad[i - 1, j]); qindex[i - 1, j] = count++; } else { break; } } // if quad[i, j - 1] doesn't exist, try to create quad[i, j] by projection and skip mesh face creation if (quad[i, j - 1] == new Point3d()) { if (i < 2) { break; } CurveIntersections isct = this.ArcIntersect(S, quad[i - 1, j], quad[i - 2, j], R); if (isct.Count > 0) { quad[i, j] = isct[0].PointB; qmesh.Vertices.Add(quad[i, j]); qindex[i, j] = count++; continue; } } // construct a sphere at each neighbouring vertex ([i,j-1] and [i-1,j]) and intersect Sphere sph1 = new Sphere(quad[i, j - 1], R); Sphere sph2 = new Sphere(quad[i - 1, j], R); Circle cir; if (Intersection.SphereSphere(sph1, sph2, out cir) == SphereSphereIntersection.Circle) { CurveIntersections cin = Intersection.CurveSurface(NurbsCurve.CreateFromCircle(cir), S, 0.01, 0.01);// intersect circle with surface // attempt to find the new vertex (i.e not [i-1,j-1]) foreach (IntersectionEvent ie in cin) { if ((ie.PointA - quad[i - 1, j - 1]).Length > 0.2 * R) // compare with a tolerance, rather than exact comparison { quad[i, j] = ie.PointA; qmesh.Vertices.Add(quad[i, j]); qindex[i, j] = count++; Point3d[] facePt = new Point3d[] { quad[i, j], quad[i - 1, j], quad[i - 1, j - 1], quad[i, j - 1] }; Sold.ClosestPoint(quad[i, j], out double u1, out double v1); Sold.ClosestPoint(quad[i - 1, j], out double u2, out double v2); Sold.ClosestPoint(quad[i - 1, j - 1], out double u3, out double v3); Sold.ClosestPoint(quad[i, j - 1], out double u4, out double v4); double tolerance = Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance * 10; bool[] flag = new bool[] { Sold.PointAt(u1, v1).DistanceTo(quad[i, j]) < tolerance, Sold.PointAt(u2, v2).DistanceTo(quad[i - 1, j]) < tolerance, Sold.PointAt(u3, v3).DistanceTo(quad[i - 1, j - 1]) < tolerance, Sold.PointAt(u4, v4).DistanceTo(quad[i, j - 1]) < tolerance }; if (flag[0] && flag[1] && flag[2] && flag[3]) { qmesh.Faces.AddFace(qindex[i, j], qindex[i - 1, j], qindex[i - 1, j - 1], qindex[i, j - 1]);// create quad-face currentStrip.Add(new Polyline() { quad[i, j], quad[i - 1, j], quad[i - 1, j - 1], quad[i, j - 1], quad[i, j] }); counter++; } else if (flag[0] || flag[1] || flag[2] || flag[3]) { Polyline temp = new Polyline() { quad[i, j], quad[i - 1, j], quad[i - 1, j - 1], quad[i, j - 1] }; Polyline trimmedTemp = new Polyline(); //temp = new Polyline() { quad[i, j], quad[i - 1, j], quad[i - 1, j - 1], quad[i, j - 1], quad[i, j] }; double t = R * 0.1; HashSet <int> intersectedSurfaceEdgeId = new HashSet <int>(); for (int l = 0; l < 4; l++) { //If point is ons surface Sold.ClosestPoint(temp[l], out double cpu, out double cpv); if (Sold.PointAt(cpu, cpv).DistanceTo(temp[l]) < Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance) { trimmedTemp.Add(temp[l]); } //Intersect line segment with closed brep Line faceSegment = new Line(temp[l], temp[MathUtil.Wrap(l + 1, 4)]); Point3d[] meshLinePts = Intersection.MeshLine(cutter, faceSegment, out int[] faceIds); if (meshLinePts.Length > 0) { trimmedTemp.Add(meshLinePts[0]); } } trimmedTemp.Close(); //cuts.Add(trimmedTemp); } break; } } if (preview.Enabled) { preview.Clear(); preview.AddMesh(mesh); preview.AddMesh(qmesh); preview.Redraw(); } } //if sphere intersection } //for j if (currentStrip.Count > 0) { strips[k].Add(currentStrip); } }//for i mesh.Append(qmesh);// add local mesh to target fourMeshes[k] = qmesh; }//for k //----------------------------------------------------------------------------------------------------------// //Output mesh.Weld(Math.PI); mesh.Compact(); mesh.Normals.ComputeNormals(); DA.SetData(0, mesh); DA.SetDataTree(1, NGonsCore.GrasshopperUtil.IE2(axis, 0)); this.PreparePreview(mesh, DA.Iteration, null, true, null, mesh.GetEdges()); //DA.SetDataList(2, cuts); //DA.SetDataTree(3, NGonsCore.GrasshopperUtil.IE4(patches.ToList(), 0)); //DA.SetDataList(4, fourMeshes); //DA.SetDataTree(5, GrasshopperUtil.IE3(strips, 0)); preview.Clear(); }catch (Exception e) { GrasshopperUtil.Debug(e); } }
public static double Area(this NurbsCurve curve) { throw new NotImplementedException(); }
public static double DerivativeFunction(this NurbsCurve curve, int i, int n, double t) { throw new NotImplementedException(); }
/***************************************************/ public static NurbsCurve Clone(this NurbsCurve curve) { return(new NurbsCurve { ControlPoints = curve.ControlPoints.Select(x => x.Clone()).ToList(), Weights = curve.Weights.ToList(), Knots = curve.Knots.ToList() }); }
public static double ParameterAtPoint(this NurbsCurve curve, Point point, double tolerance = Tolerance.Distance) { throw new NotImplementedException(); }
/***************************************************/ public static BoundingBox Bounds(this NurbsCurve curve) { return(curve == null ? null : curve.ControlPoints.Bounds()); }
protected IfcBSplineCurve(DatabaseIfc m, NurbsCurve nonRationalCurve, bool twoD) : this(m, nonRationalCurve.Degree, IfcBSplineCurveForm.UNSPECIFIED) { int ilast = nonRationalCurve.Points.Count - (nonRationalCurve.IsPeriodic ? mDegree : 0); if (twoD) { for (int icounter = 0; icounter < ilast; icounter++) { Point3d p3 = nonRationalCurve.Points[icounter].Location; mControlPointsList.Add(new IfcCartesianPoint(m, new Point2d(p3.X, p3.Y)).mIndex); } if (nonRationalCurve.IsPeriodic) { for (int icounter = 0; icounter < mDegree; icounter++) mControlPointsList.Add(mControlPointsList[icounter]); } } else { for (int icounter = 0; icounter < ilast; icounter++) mControlPointsList.Add(new IfcCartesianPoint(m, nonRationalCurve.Points[icounter].Location).mIndex); if (nonRationalCurve.IsPeriodic) { for (int icounter = 0; icounter < mDegree; icounter++) mControlPointsList.Add(mControlPointsList[icounter]); } } }
public static List <Point> LineIntersections(this NurbsCurve curve, Line line, bool useInfiniteLine = false, double tolerance = Tolerance.Distance) { throw new NotImplementedException(); }
private void adoptKnotsAndMultiplicities(NurbsCurve nc) { double tol = (nc.Knots[nc.Knots.Count - 1] - nc.Knots[0]) / Math.Max(1000, nc.Knots.Count) / 1000; if (nc.IsPeriodic) { int kc = 1; if (nc.Knots[1] - nc.Knots[0] < tol) kc = 2; else { mKnots.Add(nc.Knots[0] - (nc.Knots[1] - nc.Knots[0])); mMultiplicities.Add(1); } double knot = nc.Knots[0]; for (int icounter = 1; icounter < nc.Knots.Count; icounter++) { double t = nc.Knots[icounter]; if ((t - knot) > tol) { mKnots.Add(knot); mMultiplicities.Add(kc); knot = t; kc = 1; } else kc++; } mKnots.Add(knot); if (kc > 1) mMultiplicities.Add(kc + 1); else { mMultiplicities.Add(1); mKnots.Add(knot + (knot - nc.Knots[nc.Knots.Count - 2])); mMultiplicities.Add(1); } } else { int kc = 2; double knot = nc.Knots[0]; for (int icounter = 1; icounter < nc.Knots.Count; icounter++) { double t = nc.Knots[icounter]; if ((t - knot) > tol) { mKnots.Add(knot); mMultiplicities.Add(kc); knot = t; kc = 1; } else kc++; } mKnots.Add(knot); mMultiplicities.Add(kc + 1); } }
/***************************************************/ public static bool IsInPlane(this NurbsCurve curve, Plane plane, double tolerance = Tolerance.Distance) { return(curve.ControlPoints.IsInPlane(plane, tolerance)); }
public bool findCurve(leaf leaf,ref branch target, List<branch> listBranch, NurbsCurve curve) { var Points = curve.Points; var rPoints = curve.Points.Reverse().ToList(); foreach (var branch in listBranch) { if (branch.crv.Points[0].Location.DistanceTo(Points[0].Location) < 0.0001) { if (branch.crv.Points[1].Location.DistanceTo(Points[1].Location) < 0.0001) { target = branch; if (branch.branchType != branch.type.kink) { branch.target = leaf; } else { if (branch.left == null) branch.left = leaf; else branch.right = leaf; } return false; } } else if (branch.crv.Points[0].Location.DistanceTo(rPoints[0].Location) < 0.0001) { if (branch.crv.Points[1].Location.DistanceTo(rPoints[1].Location) < 0.0001) { target = branch; if (branch.branchType != branch.type.kink) { branch.target = leaf; } else { if (branch.left == null) branch.left = leaf; else branch.right = leaf; } return true; } } } ttt++; AddRuntimeMessage(Grasshopper.Kernel.GH_RuntimeMessageLevel.Error, "cannot find:"+ttt.ToString()); listError.Add(curve); return false; }
/***************************************************/ public static ICurve Geometry(this NurbsCurve curve) { return(curve); }
public static Commands.Result GetHelix(out Rhino.Geometry.NurbsCurve helix) { helix = null; Rhino.Geometry.NurbsCurve nc = new NurbsCurve(); IntPtr pCurve = nc.NonConstPointer(); uint rc = UnsafeNativeMethods.RHC_RhinoGetSpiralHelix(pCurve, false); Rhino.Commands.Result cmdRc = (Rhino.Commands.Result)rc; if (cmdRc == Rhino.Commands.Result.Success) helix = nc; return cmdRc; }
/***************************************************/ public static Plane FitPlane(this NurbsCurve curve, double tolerance = Tolerance.Distance) { return(curve.ControlPoints.FitPlane()); }
internal static GeometryBase CreateGeometryHelper(IntPtr pGeometry, object parent, int subobject_index) { if (IntPtr.Zero == pGeometry) return null; int type = UnsafeNativeMethods.ON_Geometry_GetGeometryType(pGeometry); if (type < 0) return null; GeometryBase rc = null; switch (type) { case idxON_Curve: //1 rc = new Curve(pGeometry, parent, subobject_index); break; case idxON_NurbsCurve: //2 rc = new NurbsCurve(pGeometry, parent, subobject_index); break; case idxON_PolyCurve: // 3 rc = new PolyCurve(pGeometry, parent, subobject_index); break; case idxON_PolylineCurve: //4 rc = new PolylineCurve(pGeometry, parent, subobject_index); break; case idxON_ArcCurve: //5 rc = new ArcCurve(pGeometry, parent, subobject_index); break; case idxON_LineCurve: //6 rc = new LineCurve(pGeometry, parent, subobject_index); break; case idxON_Mesh: //7 rc = new Mesh(pGeometry, parent); break; case idxON_Point: //8 rc = new Point(pGeometry, parent); break; case idxON_TextDot: //9 rc = new TextDot(pGeometry, parent); break; case idxON_Surface: //10 rc = new Surface(pGeometry, parent); break; case idxON_Brep: //11 rc = new Brep(pGeometry, parent); break; case idxON_NurbsSurface: //12 rc = new NurbsSurface(pGeometry, parent); break; case idxON_RevSurface: //13 rc = new RevSurface(pGeometry, parent); break; case idxON_PlaneSurface: //14 rc = new PlaneSurface(pGeometry, parent); break; case idxON_ClippingPlaneSurface: //15 rc = new ClippingPlaneSurface(pGeometry, parent); break; case idxON_Annotation2: // 16 rc = new AnnotationBase(pGeometry, parent); break; case idxON_Hatch: // 17 rc = new Hatch(pGeometry, parent); break; case idxON_TextEntity2: //18 rc = new TextEntity(pGeometry, parent); break; case idxON_SumSurface: //19 rc = new SumSurface(pGeometry, parent); break; case idxON_BrepFace: //20 { int faceindex = -1; IntPtr pBrep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref faceindex); if (pBrep != IntPtr.Zero && faceindex >= 0) { Brep b = new Brep(pBrep, parent); rc = b.Faces[faceindex]; } } break; case idxON_BrepEdge: // 21 { int edgeindex = -1; IntPtr pBrep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref edgeindex); if (pBrep != IntPtr.Zero && edgeindex >= 0) { Brep b = new Brep(pBrep, parent); rc = b.Edges[edgeindex]; } } break; case idxON_InstanceDefinition: // 22 rc = new InstanceDefinitionGeometry(pGeometry, parent); break; case idxON_InstanceReference: // 23 rc = new InstanceReferenceGeometry(pGeometry, parent); break; #if USING_V5_SDK case idxON_Extrusion: //24 rc = new Extrusion(pGeometry, parent); break; #endif case idxON_LinearDimension2: //25 rc = new LinearDimension(pGeometry, parent); break; case idxON_PointCloud: // 26 rc = new PointCloud(pGeometry, parent); break; case idxON_DetailView: // 27 rc = new DetailView(pGeometry, parent); break; case idxON_AngularDimension2: // 28 rc = new AngularDimension(pGeometry, parent); break; case idxON_RadialDimension2: // 29 rc = new RadialDimension(pGeometry, parent); break; case idxON_Leader: // 30 rc = new Leader(pGeometry, parent); break; case idxON_OrdinateDimension2: // 31 rc = new OrdinateDimension(pGeometry, parent); break; case idxON_Light: //32 rc = new Light(pGeometry, parent); break; case idxON_PointGrid: //33 rc = new Point3dGrid(pGeometry, parent); break; case idxON_MorphControl: //34 rc = new MorphControl(pGeometry, parent); break; case idxON_BrepLoop: //35 { int loopindex = -1; IntPtr pBrep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref loopindex); if (pBrep != IntPtr.Zero && loopindex >= 0) { Brep b = new Brep(pBrep, parent); rc = b.Loops[loopindex]; } } break; case idxON_BrepTrim: // 36 { int trimindex = -1; IntPtr pBrep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref trimindex); if (pBrep != IntPtr.Zero && trimindex >= 0) { Brep b = new Brep(pBrep, parent); rc = b.Trims[trimindex]; } } break; default: rc = new UnknownGeometry(pGeometry, parent, subobject_index); break; } return rc; }
public static NurbsCurve Transform(this NurbsCurve curve, TransformMatrix transform) { throw new NotImplementedException(); }
private static NurbsCurve _ZigZagDeformations_TryRemove__by_sorting_controlPoints(NurbsCurve crv, Surface srf, int[] zigzagIndexes, List <ZigZagDiapason> diapasons) { NurbsCurve res = null; var points3d = crv._Locations3d(); // set default all points are valid var indexes = new List <int>(); for (int i = 0; i < points3d.Length; i++) { indexes.Add(i); } // clear bad control points for (int di = 0; di < diapasons.Count; di++) { var d = diapasons[di]; for (int i = d.IndexStart + 1; i < d.IndexEnd; i++) { indexes[i] = -1; } } // // v1 - just remove - at least we will have some result if v2 fails // var res1 = _ZigZagDeformations_GetCurveFromPoints(crv, srf, points3d, false, indexes); if (res1 != null) { res = res1; } // // v2 - sort bad control points - try get better result // for (int di = 0; di < diapasons.Count; di++) { var d = diapasons[di]; var subPoints = new List <Point3d>(); for (int i = d.IndexStart; i <= d.IndexEnd; i++) { subPoints.Add(points3d[i]); } var subIndexesSorted = _Point3d._Sort(subPoints); for (int i = 0; i < d.IndexEnd - d.IndexStart + 1; i++) { var index = d.IndexStart + i; var indexSorted = d.IndexStart + subIndexesSorted[i]; indexes[index] = indexSorted; } } var res2 = _ZigZagDeformations_GetCurveFromPoints(crv, srf, points3d, false, indexes); if (res2 != null) { res = res2; } return(res); }
public NurbsCurve ToNurbsCurve() { return(NurbsCurve.CreateFromCircle(this)); }