// 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);
}
