// Rectangles now and forever forward will become polylines public static SpecklePolyline ToSpeckle(this Rectangle3d rect) { return(new SpecklePolyline((new Point3d[] { rect.Corner(0), rect.Corner(1), rect.Corner(2), rect.Corner(3) }).ToFlatArray()) { Closed = true }); }
// Rectangles now and forever forward will become polylines public Polyline PolylineToSpeckle(Rectangle3d rect) { return(new Polyline( PointsToFlatArray(new Point3d[] { rect.Corner(0), rect.Corner(1), rect.Corner(2), rect.Corner(3) }), ModelUnits) { closed = true }); }
private Curve RoundedRectangle(Plane plane, double width, double height, double radius) { var dw = width * 0.5; var dh = height * 0.5; var x_interval = new Interval(-dw, dw); var y_interval = new Interval(-dh, dh); var rect = new Rectangle3d(plane, x_interval, y_interval); var a = rect.Corner(0); var b = rect.Corner(1); var c = rect.Corner(2); var d = rect.Corner(3); var x = plane.XAxis * radius; var y = plane.YAxis * radius; var crv = new PolyCurve(); // bottom edge if (width > 2 * radius) { crv.Append(new Line(a + x, b - x)); } // lower right fillet crv.Append(new Arc(b - x, plane.XAxis, b + y)); // right edge if (height > 2 * radius) { crv.Append(new Line(b + y, c - y)); } // upper right fillet crv.Append(new Arc(c - y, plane.YAxis, c - x)); // top edge if (width > 2 * radius) { crv.Append(new Line(c - x, d + x)); } // upper left fillet crv.Append(new Arc(d + x, -plane.XAxis, d - y)); // left edge if (height > 2 * radius) { crv.Append(new Line(d - y, a + y)); } // bottom left fillet crv.Append(new Arc(a + y, -plane.YAxis, a + x)); return(crv); }
private void replace_core_values(ref List <Point3d> locations, ref List <int> default_values, Rectangle3d core) { // points of rectangle Point3d[] poly = { core.Corner(0), core.Corner(1), core.Corner(2), core.Corner(3) }; for (int i = 0; i < locations.Count; i++) { if (point_in_polygon(poly, locations[i])) { default_values[i] = 0; } } }
/// <summary> /// The method for generating Context Brep and a single mesh from the input Breps. /// </summary> /// <param name="breps"> Brep inputs that represent the search area for the pathfinding algorithm.</param> /// <returns>Rturns a list of generic types. First Item is a Brep representing the context of the navigation model. /// Second item of the list is a Mesh generated from the input Breps. /// </returns> private List <object> GenerateContext(GH_Structure <GH_Brep> breps) { List <object> result = new List <object>(); List <GH_Brep> searchArea = breps.FlattenData(); Mesh searchAreaMesh = new Mesh(); Brep context = new Brep(); // Generating a joined mesh from Breps if (searchArea.Count > 0) { for (int i = 0; i < searchArea.Count; i++) { if (i == 0) { searchAreaMesh = Mesh.CreateFromBrep(searchArea[i].Value)[0]; } else { searchAreaMesh.Append(Mesh.CreateFromBrep(searchArea[i].Value)[0]); } } } else { searchAreaMesh = Mesh.CreateFromBrep(searchArea[0].Value)[0]; } // Generating Context BoundingBox bBox = searchAreaMesh.GetBoundingBox(true); Point3d origin = bBox.Corner(true, false, true); Point3d oposite = bBox.Corner(false, true, true); double deltaX = System.Math.Abs(origin.X - oposite.X); double deltaY = System.Math.Abs(origin.Y - oposite.Y); double dimension = System.Math.Max(deltaX, deltaY); Rectangle3d contextBounds = new Rectangle3d(new Plane(origin, Vector3d.ZAxis), dimension, -dimension); context = Brep.CreateFromCornerPoints(contextBounds.Corner(0), contextBounds.Corner(1), contextBounds.Corner(2), contextBounds.Corner(3), 0.001); result.Add(context); result.Add(searchAreaMesh); return(result); }
public static List <Rectangle3d> GridTiles(Rectangle3d B, double IP, double EP, int C, int R, int PA) { var m_tileSet = new List <Rectangle3d>(); Plane m_basePlane = new Plane(B.Corner(0), B.Plane.XAxis, B.Plane.YAxis); double m_padSource = (PA == 0 ? B.Width : B.Height); var m_iPadding = IP * m_padSource; var m_ePadding = EP * m_padSource; var m_cellWidth = (B.Width - (m_iPadding * (C - 1)) - (m_ePadding * 2)) / C; var m_cellHeight = (B.Height - (m_iPadding * (R - 1)) - (m_ePadding * 2)) / R; for (int i = 0; i < R; i++) { double m_llY = m_ePadding + m_cellHeight * i + m_iPadding * i; double m_urY = m_ePadding + (m_cellHeight * (i + 1)) + m_iPadding * i; for (int j = 0; j < C; j++) { double m_llX = m_ePadding + m_cellWidth * j + m_iPadding * j; double m_urX = m_ePadding + (m_cellWidth * (j + 1)) + m_iPadding * j; Rectangle3d relayRect = new Rectangle3d(m_basePlane, m_basePlane.PointAt(m_llX, m_llY, 0), m_basePlane.PointAt(m_urX, m_urY, 0)); m_tileSet.Add(new Rectangle3d(new Plane(relayRect.Corner(0), relayRect.Plane.XAxis, relayRect.Plane.YAxis), relayRect.Width, relayRect.Height)); } } return(m_tileSet); }
public static List <Rectangle3d> HorizontalTiles(Rectangle3d B, List <double> R, double H, double WP, double HP, out Rectangle3d rest) { var m_tileSet = new List <Rectangle3d>(); Plane m_basePlane = new Plane(B.Corner(0), B.Plane.XAxis, B.Plane.YAxis); var m_available = B.Width - (WP * B.Width); double m_total = R.Sum(); double m_hPadding = (HP * B.Height) / 2; double m_wPadding = (WP * B.Width) / (R.Count + 1); double m_height = B.Height * H - (HP * B.Height) / 2; double m_xValue = 0; for (int i = 0; i < R.Count; i++) { m_xValue += m_wPadding; double m_nextX = m_xValue + (R[i] / m_total) * m_available; Rectangle3d relayRect = new Rectangle3d(m_basePlane, m_basePlane.PointAt(m_xValue, m_hPadding, 0), m_basePlane.PointAt(m_nextX, m_height, 0)); m_tileSet.Add(new Rectangle3d(new Plane(relayRect.Corner(0), relayRect.Plane.XAxis, relayRect.Plane.YAxis), relayRect.Width, relayRect.Height)); m_xValue = m_nextX; } rest = new Rectangle3d(m_basePlane, new Interval(0, B.Width), new Interval(B.Height * H, B.Height)); return(m_tileSet); }
// Rectangles now and forever forward will become polylines public Polyline PolylineToSpeckle(Rectangle3d rect, string units = null) { var u = units ?? ModelUnits; var length = rect.Height * 2 + rect.Width * 2; var sPoly = new Polyline( PointsToFlatArray(new Point3d[] { rect.Corner(0), rect.Corner(1), rect.Corner(2), rect.Corner(3) }), u) { closed = true, area = rect.Area, bbox = BoxToSpeckle(new RH.Box(rect.BoundingBox), u), length = length, domain = new Interval(0, length) }; return(sPoly); }
public Brep GetEndSurface(int side, double offset, double extra_width, double extra_height, bool flip = false) { side = side.Modulus(2); Plane endPlane = GetPlane(side == 0 ? Centreline.Domain.Min : Centreline.Domain.Max); if ((flip && side == 1) || (!flip && side == 0)) { endPlane = endPlane.FlipAroundYAxis(); } endPlane.Origin = endPlane.Origin + endPlane.ZAxis * offset; double hwidth = Data.LamWidth * Data.NumWidth / 2 + extra_width; double hheight = Data.LamHeight * Data.NumHeight / 2 + extra_height; Rectangle3d rec = new Rectangle3d(endPlane, new Interval(-hwidth, hwidth), new Interval(-hheight, hheight)); return(Brep.CreateFromCornerPoints(rec.Corner(0), rec.Corner(1), rec.Corner(2), rec.Corner(3), Tolerance)); }
public static SpeckleObject fromRectangle(Rectangle3d rect) { SpeckleObject obj = new SpeckleObject(); obj.value = new ExpandoObject(); obj.properties = new ExpandoObject(); obj.type = "Rectangle"; obj.hash = "Rectangle." + SpeckleConverter.getHash("RH:" + SpeckleConverter.getBase64(rect)); obj.value.A = fromPoint(rect.Corner(0)); obj.value.B = fromPoint(rect.Corner(1)); obj.value.C = fromPoint(rect.Corner(2)); obj.value.D = fromPoint(rect.Corner(3)); obj.value.plane = fromPlane(rect.Plane); obj.properties.length = rect.Circumference; obj.properties.area = rect.Area; return(obj); }
/// <summary> /// Create a new projection. /// </summary> /// <param name="boundary">Bitmap boundary.</param> /// <param name="width">Horizontal resolution.</param> /// <param name="height">Vertical resolution.</param> public BitmapProjection(Rectangle3d boundary, int width, int height) { Boundary = boundary; Width = width; Height = height; _plane = boundary.Plane; _plane.Origin = boundary.Corner(0); _uFactor = 1.0 / boundary.Width; _vFactor = 1.0 / boundary.Height; }
public static List <Rectangle3d> IrregularTiles(Rectangle3d B, List <double> XR, List <double> YR, double EP, double IP, int PA) { var m_tileSet = new List <Rectangle3d>(); Plane m_basePlane = new Plane(B.Corner(0), B.Plane.XAxis, B.Plane.YAxis); double m_xSum = XR.Sum(); double m_ySum = YR.Sum(); double m_padSource = (PA == 0 ? B.Width : B.Height); var m_iPadding = IP * m_padSource; var m_ePadding = EP * m_padSource; double m_availableWidth = B.Width - (2 * m_ePadding) - ((XR.Count - 1) * m_iPadding); double m_availableHeight = B.Height - (2 * m_ePadding) - ((YR.Count - 1) * m_iPadding); double m_rowVal = 0; for (int i = 0; i < YR.Count; i++) { m_rowVal += (i == 0 ? m_ePadding : m_iPadding); double m_nextY = m_rowVal + (YR[i] / m_ySum) * m_availableHeight; double m_colVal = 0; for (int j = 0; j < XR.Count; j++) { m_colVal += (j == 0 ? m_ePadding : m_iPadding); double m_nextX = m_colVal + (XR[j] / m_xSum) * m_availableWidth; Rectangle3d relayRect = new Rectangle3d(m_basePlane, m_basePlane.PointAt(m_colVal, m_rowVal, 0), m_basePlane.PointAt(m_nextX, m_nextY, 0)); m_tileSet.Add(new Rectangle3d(new Plane(relayRect.Corner(0), relayRect.Plane.XAxis, relayRect.Plane.YAxis), relayRect.Width, relayRect.Height)); m_colVal = m_nextX; } m_rowVal = m_nextY; } return(m_tileSet); }
protected override void onClickOculusAX(ref VREvent_t vrEvent) { //TODO-support projection curve Point3d planeCenter = new Point3d(); if (!isProjection) { Brep[] shapes = Brep.CreatePlanarBreps(modelcurve); modelBrep = shapes[0]; //Util.addRhinoObjectSceneNode(ref mScene, ref modelBrep, ref mesh_m, shapeType.ToString(), out renderObjSN); UtilOld.addSceneNode(ref mScene, ref modelBrep, ref mesh_m, shapeType.ToString(), out renderObjSN); if (shapeType == ShapeType.Circle) { Circle circle; if (modelcurve.TryGetCircle(out circle)) { planeCenter = circle.Center; } mScene.iPointList.Add(UtilOld.platformToVRPoint(ref mScene, UtilOld.RhinoToOpenTKPoint(circle.Center))); mScene.iPointList.Add(UtilOld.platformToVRPoint(ref mScene, UtilOld.RhinoToOpenTKPoint(circle.PointAt(0)))); } else if (shapeType == ShapeType.Rect) { Rhino.Geometry.Polyline polyline; if (modelcurve.TryGetPolyline(out polyline)) { Rectangle3d rect = Rectangle3d.CreateFromPolyline(polyline); planeCenter = rect.Center; mScene.iPointList.Add(UtilOld.platformToVRPoint(ref mScene, UtilOld.RhinoToOpenTKPoint(rect.Center))); mScene.iPointList.Add(UtilOld.platformToVRPoint(ref mScene, UtilOld.RhinoToOpenTKPoint(rect.Corner(3)))); } } } //update modelPlane and use tolerance to support unplanar surface Plane curvePlane = new Plane(); Double tolerance = 0; while (tolerance < 400) { if (modelcurve.TryGetPlane(out curvePlane, tolerance)) { modelPlane = curvePlane; break; } tolerance++; } int size = 240; PlaneSurface plane_surface = new PlaneSurface(curvePlane, new Interval(-size, size), new Interval(-size, size)); Brep newPlaneBrep = Brep.CreateFromSurface(plane_surface); Guid newPlaneID = UtilOld.addRhinoObject(ref mScene, ref newPlaneBrep, "3DP"); //might be better to use Replace(), just need to be careful about the referece count pointOnObjRef = null; pointOnObjRef = new ObjRef(newPlaneID); //add icurveList since we don't use EditPoint2 for circle and rect modelcurve.SetUserString(CurveData.CurveOnObj.ToString(), newPlaneID.ToString()); modelcurve.SetUserString(CurveData.PlaneOrigin.ToString(), curvePlane.Origin.ToString()); modelcurve.SetUserString(CurveData.PlaneNormal.ToString(), curvePlane.Normal.ToString()); mScene.iCurveList.Add(modelcurve); //call next interaction in the chain afterCurveCount = mScene.iCurveList.Count; mScene.pushInteractionFromChain(); }
private void computeContourCurve() { if (targetPRhObjID == Guid.Empty) { return; } ObjRef targetpObjRef = new ObjRef(targetPRhObjID); snapPointsList = new List <Point3d>(); Double tolerance = 0; if (drawnType != DrawnType.In3D) { Brep targetBrep = (Brep)(targetpObjRef.Object().Geometry); //TODO- topLeftP won't be on the face in the 3D case. so probably use orgin float minD = 1000000f; int minIndex = -1; for (int i = 0; i < targetBrep.Faces.Count; i++) { //cast BrepFace to Brep for ClosestPoint(P) menthod double dist = targetBrep.Faces[i].DuplicateFace(false).ClosestPoint(projectP).DistanceTo(projectP); if (dist < minD) { minD = (float)dist; minIndex = i; } } Surface s = targetBrep.Faces[minIndex]; //surface might not be a perfect planar surface while (tolerance < toleranceMax) { if (s.TryGetPlane(out curvePlane, tolerance)) { break; } tolerance++; } if (tolerance >= toleranceMax) { double u, v; if (s.ClosestPoint(projectP, out u, out v)) { Rhino.Geometry.Vector3d normal = s.NormalAt(u, v); //TODO fix the issue when normal is inward curvePlane = new Plane(projectP, normal); } } else { //testing finding the edge curve Rhino.Geometry.Curve[] edgeCurves = (targetBrep.Faces[minIndex].DuplicateFace(false)).DuplicateEdgeCurves(true); double tol = mScene.rhinoDoc.ModelAbsoluteTolerance * 2.1; edgeCurves = Rhino.Geometry.Curve.JoinCurves(edgeCurves, tol); // TODO: Check if null contourCurve = edgeCurves[0]; //detect whether it's rect or circle then generate a snap pointList Circle circle; Rhino.Geometry.Polyline polyline; if (contourCurve.TryGetCircle(out circle)) { snapPointsList.Add(circle.Center); snapPointsList.Add(circle.PointAt(0)); snapPointsList.Add(circle.PointAt(Math.PI / 2)); snapPointsList.Add(circle.PointAt(Math.PI)); snapPointsList.Add(circle.PointAt(Math.PI * 1.5)); } else if (contourCurve.TryGetPolyline(out polyline)) { Rectangle3d rect = Rectangle3d.CreateFromPolyline(polyline); snapPointsList.Add(rect.Center); snapPointsList.Add(rect.Corner(0)); snapPointsList.Add(rect.Corner(1)); snapPointsList.Add(rect.Corner(2)); snapPointsList.Add(rect.Corner(3)); } else { double u = 0; double v = 0; s.ClosestPoint(s.GetBoundingBox(true).Center, out u, out v); snapPointsList.Add(s.PointAt(u, v)); } } } }
public Brep GetGlulamFace(Side side) { Plane[] planes; double[] parameters; int N = Math.Max(Data.Samples, 6); GenerateCrossSectionPlanes(N, out planes, out parameters, Data.InterpolationType); double hWidth = this.Width / 2; double hHeight = this.Height / 2; double x1, y1, x2, y2; x1 = y1 = x2 = y2 = 0; Rectangle3d face; GetSectionOffset(out double offsetX, out double offsetY); switch (side) { case (Side.Back): face = new Rectangle3d(planes.First(), new Interval(-hWidth + offsetX, hWidth + offsetX), new Interval(-hHeight + offsetY, hHeight + offsetY)); return(Brep.CreateFromCornerPoints(face.Corner(0), face.Corner(1), face.Corner(2), face.Corner(3), 0.001)); case (Side.Front): face = new Rectangle3d(planes.Last(), new Interval(-hWidth + offsetX, hWidth + offsetX), new Interval(-hHeight + offsetY, hHeight + offsetY)); return(Brep.CreateFromCornerPoints(face.Corner(0), face.Corner(1), face.Corner(2), face.Corner(3), 0.001)); case (Side.Left): x1 = hWidth + offsetX; y1 = hHeight + offsetY; x2 = hWidth + offsetX; y2 = -hHeight + offsetY; break; case (Side.Right): x1 = -hWidth + offsetX; y1 = hHeight + offsetY; x2 = -hWidth + offsetX; y2 = -hHeight + offsetY; break; case (Side.Top): x1 = hWidth + offsetX; y1 = hHeight + offsetY; x2 = -hWidth + offsetX; y2 = hHeight + offsetY; break; case (Side.Bottom): x1 = hWidth + offsetX; y1 = -hHeight + offsetY; x2 = -hWidth + offsetX; y2 = -hHeight + offsetY; break; } Curve[] rules = new Curve[parameters.Length]; for (int i = 0; i < planes.Length; ++i) { rules[i] = new Line( planes[i].Origin + planes[i].XAxis * x1 + planes[i].YAxis * y1, planes[i].Origin + planes[i].XAxis * x2 + planes[i].YAxis * y2 ).ToNurbsCurve(); } Brep[] loft = Brep.CreateFromLoft(rules, Point3d.Unset, Point3d.Unset, LoftType.Normal, false); if (loft == null || loft.Length < 1) { throw new Exception("Glulam::GetGlulamFace::Loft failed!"); } Brep brep = loft[0]; return(brep); }
/// <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) { Plane origin = new Plane(0, 0, 0, 0); double xSize = 0.0; double ySize = 0.0; int xCount = 0; int yCount = 0; if (!DA.GetData(0, ref origin)) { return; } if (!DA.GetData(3, ref xSize)) { return; } if (!DA.GetData(4, ref ySize)) { return; } if (!DA.GetData(1, ref xCount)) { return; } if (!DA.GetData(2, ref yCount)) { return; } double xStart = origin.OriginX; double yStart = origin.OriginY; List <Point3d> oPoints = new List <Point3d>(); List <Rectangle3d> oRect = new List <Rectangle3d>(); List <Line> oLines0 = new List <Line>(); List <Line> oLines1 = new List <Line>(); List <Line> oLines2 = new List <Line>(); for (double i = xStart; i < xCount + xStart; i += xSize) { for (double j = yStart; j < yCount + yStart; j += ySize) { Vector3d zV = new Vector3d(0, 0, 1); Point3d pt = new Point3d(i, j, 0); Plane pl = new Plane(pt, zV); Rectangle3d rect = new Rectangle3d(pl, xSize, ySize); oRect.Add(rect); oPoints.Add(pt); Point3d pt1 = rect.Corner(0); Point3d pt2 = rect.Corner(1); Point3d pt3 = rect.Corner(2); Point3d pt4 = rect.Corner(3); Line ln1 = new Line(pt1, pt2); Line ln2 = new Line(pt3, pt4); Line ln3 = new Line(pt2, pt3); Line ln4 = new Line(pt1, pt4); Point3d pt5 = ln1.PointAt(0.5); Point3d pt6 = ln2.PointAt(0.5); Point3d pt7 = ln3.PointAt(0.5); Point3d pt8 = ln4.PointAt(0.5); Point3d pt9 = ln1.PointAt(0.3); Point3d pt10 = ln2.PointAt(0.7); Point3d pt11 = ln1.PointAt(0.7); Point3d pt12 = ln2.PointAt(0.3); Line ln9 = new Line(pt9, pt10); oLines0.Add(ln9); oLines2.Add(ln9); Line ln10 = new Line(pt11, pt12); oLines0.Add(ln10); oLines2.Add(ln10); Line ln5 = new Line(pt5, pt7); oLines1.Add(ln5); oLines2.Add(ln5); Line ln6 = new Line(pt6, pt8); oLines1.Add(ln6); oLines2.Add(ln6); Line ln7 = new Line(pt6, pt7); oLines1.Add(ln7); oLines2.Add(ln7); Line ln8 = new Line(pt5, pt8); oLines1.Add(ln8); oLines2.Add(ln8); } } DA.SetDataList(0, oLines2); DA.SetDataList(1, oLines0); DA.SetDataList(2, oLines1); }
public List <GeometryBase> Draw(Plane plane, Vector3d vec) { List <GeometryBase> list = new List <GeometryBase>(); Rectangle3d rec = new Rectangle3d( plane, ZERO_DEGREE.GetLength(), ZERO_DEGREE.GetWidth()); Vector3d move = new Vector3d(rec.Center.X - plane.Origin.X, rec.Center.Y - plane.Origin.Y, rec.Center.Z - plane.Origin.Z); move.Reverse(); rec.Transform(Transform.Translation(move)); if (!isDoubleRow) { list.Add(rec.ToNurbsCurve()); } else { // 分裂 NurbsCurve stallUp = rec.ToNurbsCurve(); NurbsCurve stallDown = rec.ToNurbsCurve(); Vector3d vecUp = new Vector3d(vec); // 平面几何余弦定理 Vector3d a = new Vector3d(rec.Corner(3) - rec.Corner(0)); Vector3d b = new Vector3d((rec.Corner(2) - rec.Corner(3))); if (degree == Math.PI / 2) { vecUp = b / 2; } else if (degree == 0) { vecUp = a / 2; } else { b.Unitize(); b = b * (length - width / Math.Tan(degree)); // () is the b length vecUp = new Vector3d(a + b) / 2; } Vector3d vecDown; /* * // dist * double dist; * if (degree == 0) * { * dist = width / 2; * } else if (degree == Math.PI / 2) * { * dist = length / 2; * } else * { * dist = length * Math.Sin(degree) / 2; * } */ // vecUp.Unitize(); // vecUp = new Vector3d(vecUp.X * dist, vecUp.Y*dist, vecUp.Z*dist); stallUp.Transform(Transform.Translation(vecUp)); list.Add(stallUp); vecDown = new Vector3d(vecUp); vecDown.Reverse(); stallDown.Transform(Transform.Translation(vecDown)); list.Add(stallDown); } return(list); }