public static List <Polyline> Map2DPolylinesBySurface(List <Polyline> C, Polyline S, Polyline T)
{
List <Polyline> polylines = new List <Polyline>(C.Count);
if (S.Count == 5 && T.Count == 5)
{
Surface s = Brep.CreateFromCornerPoints(S[0], S[1], S[2], S[3], 0.001).Surfaces[0];
Surface t = Brep.CreateFromCornerPoints(T[0], T[1], T[2], T[3], 0.001).Surfaces[0];
s.SetDomain(0, new Interval(0, 1));
s.SetDomain(1, new Interval(0, 1));
t.SetDomain(0, new Interval(0, 1));
t.SetDomain(1, new Interval(0, 1));
for (int i = 0; i < C.Count; i++)
{
Polyline m = new Polyline(C[i]);
for (int j = 0; j < C[i].Count; j++)
{
double u, v;
s.ClosestPoint(C[i][j], out u, out v);
m[j] = t.PointAt(u, v);
}
polylines.Add(m);
}
}
return(polylines);
}
public static Brep GetBrepFromElement(IMesh mesh, int eKey)
{
Brep brep = new Brep();
IElement e = mesh.GetElementWithKey(eKey);
if (e.TopologicDimension == 2)
{
Surface f;
Point3d[] pts = new Point3d[e.VerticesCount];
for (int i = 0; i < e.VerticesCount; i++)
{
pts[i] = mesh.GetVertexWithKey(e.Vertices[i]).RhinoPoint;
}
if (pts.Length == 4)
{
f = NurbsSurface.CreateFromCorners(pts[0], pts[1], pts[2], pts[3]);
}
else if (pts.Length == 3)
{
f = NurbsSurface.CreateFromCorners(pts[0], pts[1], pts[2]);
}
else
{
f = Brep.CreateEdgeSurface(new PolylineCurve[] { new PolylineCurve(pts), new PolylineCurve(new Point3d[] { pts[pts.Length - 1], pts[0] }) }).Surfaces[0];
}
brep = f.ToBrep();
}
else
{
Brep[] faces = new Brep[e.HalfFacetsCount];
for (int i = 1; i <= e.HalfFacetsCount; i++)
{
int[] hf;
e.GetHalfFacetWithPrincipalNodesOnly(i, out hf);
Point3d[] pts = new Point3d[hf.Length];
for (int j = 0; j < hf.Length; j++)
{
pts[j] = mesh.GetVertexWithKey(hf[j]).RhinoPoint;
}
if (pts.Length == 4)
{
faces[i - 1] = Brep.CreateFromCornerPoints(pts[0], pts[1], pts[2], pts[3], RhinoDoc.ActiveDoc.ModelAbsoluteTolerance);
}
else
{
faces[i - 1] = Brep.CreateFromCornerPoints(pts[0], pts[1], pts[2], RhinoDoc.ActiveDoc.ModelAbsoluteTolerance);
}
}
brep = Brep.JoinBreps(faces, RhinoDoc.ActiveDoc.ModelAbsoluteTolerance)[0];
}
return(brep);
}
public static Brep FromFaceToBrep(Face face)
{
Point3d pt1 = FromVectorToRhPoint(face.A);
Point3d pt2 = FromVectorToRhPoint(face.B);
Point3d pt3 = FromVectorToRhPoint(face.C);
if (face.Vertices.Length > 3)
{
Point3d pt4 = FromVectorToRhPoint(face.D);
return(Brep.CreateFromCornerPoints(pt1, pt2, pt3, pt4, TOLERANCE));
}
return(Brep.CreateFromCornerPoints(pt1, pt2, pt3, TOLERANCE));
}
/// <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 override bool Construct(bool append = false)
{
var beam = (Parts[0].Element as BeamElement).Beam;
Plane bplane;
if (CutPlane == Plane.Unset)
{
CutPlane = beam.GetPlane(Parts[0].Parameter);
bplane = beam.GetPlane(Parts[0].Parameter);
}
else
{
var res = Rhino.Geometry.Intersect.Intersection.CurvePlane(beam.Centreline, CutPlane, 0.01);
if (res == null || res.Count < 1)
{
return(false);
}
var pt = res[0].PointA;
bplane = beam.GetPlane(pt);
}
var proj = CutPlane.ProjectAlongVector(bplane.ZAxis);
double hw = beam.Width * 0.5;
double hh = beam.Height * 0.5;
var pts = new Point3d[4];
pts[0] = bplane.PointAt(-hw - Added, -hh - Added);
pts[1] = bplane.PointAt(-hw - Added, hh + Added);
pts[2] = bplane.PointAt(hw + Added, hh + Added);
pts[3] = bplane.PointAt(hw + Added, -hh - Added);
for (int i = 0; i < 4; ++i)
{
pts[i].Transform(proj);
}
var cutter = Brep.CreateFromCornerPoints(pts[0], pts[1], pts[2], pts[3], 0.01);
Parts[0].Geometry.Add(cutter);
return(true);
}
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 List <Brep> Get3DElementsAsBrep(IMesh mesh)
{
List <Brep> solids = new List <Brep>();
Brep b;
Brep[] faces;
foreach (IElement e in mesh.Elements)
{
if (e.TopologicDimension == 3)
{
b = new Brep();
faces = new Brep[e.HalfFacetsCount];
for (int i = 1; i <= e.HalfFacetsCount; i++)
{
int[] hf;
e.GetHalfFacetWithPrincipalNodesOnly(i, out hf);
Point3d[] pts = new Point3d[hf.Length];
for (int j = 0; j < hf.Length; j++)
{
pts[j] = mesh.GetVertexWithKey(hf[j]).RhinoPoint;
}
if (pts.Length == 4)
{
faces[i - 1] = Brep.CreateFromCornerPoints(pts[0], pts[1], pts[2], pts[3], RhinoDoc.ActiveDoc.ModelAbsoluteTolerance);
}
else
{
faces[i - 1] = Brep.CreateFromCornerPoints(pts[0], pts[1], pts[2], RhinoDoc.ActiveDoc.ModelAbsoluteTolerance);
}
}
b = Brep.JoinBreps(faces, RhinoDoc.ActiveDoc.ModelAbsoluteTolerance)[0];
solids.Add(b);
}
}
return(solids);
}
public List <Brep> CreateSurfaceMesh(List <Point3d> elementPoints)
{
Brep b1 = Brep.CreateFromCornerPoints(elementPoints[0], elementPoints[1], elementPoints[5], elementPoints[4], 0);
Brep b2 = Brep.CreateFromCornerPoints(elementPoints[1], elementPoints[2], elementPoints[6], elementPoints[5], 0);
Brep b3 = Brep.CreateFromCornerPoints(elementPoints[2], elementPoints[3], elementPoints[7], elementPoints[6], 0);
Brep b4 = Brep.CreateFromCornerPoints(elementPoints[0], elementPoints[3], elementPoints[7], elementPoints[4], 0);
Brep b5 = Brep.CreateFromCornerPoints(elementPoints[0], elementPoints[1], elementPoints[2], elementPoints[3], 0);
Brep b6 = Brep.CreateFromCornerPoints(elementPoints[4], elementPoints[5], elementPoints[6], elementPoints[7], 0);
List <Brep> surfaces = new List <Brep>()
{
b1,
b2,
b3,
b4,
b5,
b6
};
return(surfaces);
}
/// <summary>
/// Generate an end-surface of a glulam.
/// </summary>
/// <param name="side">0 for surface at the start, 1 for surface at the end</param>
/// <param name="offset">Offset of end-surface.</param>
/// <param name="extra_width">Amount to widen end-surface by.</param>
/// <param name="extra_height">Amount to heighten end-surface by.</param>
/// <param name="flip">Flip orientation of end-surface.</param>
/// <returns></returns>
public Brep GenerateEndSurface(int side, double offset, double extra_width, double extra_height, bool flip = false)
{
side = side.Modulus(2);
Plane end_plane = GetFrame(side == 0 ? Guide.Domain.Min : Guide.Domain.Max);
if ((flip && side == 1) || (!flip && side == 0))
{
end_plane = end_plane.FlipAroundYAxis();
}
end_plane.Origin = end_plane.Origin + end_plane.ZAxis * offset;
double hwidth = Data.LamellaSizeX * Data.LamellaCountX / 2 * extra_width;
double hheight = Data.LamellaSizeY * Data.LamellaCountY / 2 * extra_height;
return(Brep.CreateFromCornerPoints(
end_plane.Origin + end_plane.XAxis * -hwidth + end_plane.YAxis * -hheight,
end_plane.Origin + end_plane.XAxis * -hwidth + end_plane.YAxis * hheight,
end_plane.Origin + end_plane.XAxis * hwidth + end_plane.YAxis * hheight,
end_plane.Origin + end_plane.XAxis * hwidth + end_plane.YAxis * -hheight,
Tolerance));
}
public override bool Construct(bool append = false)
{
if (!append)
{
foreach (var part in Parts)
{
part.Geometry.Clear();
}
}
var m_glulam1 = (Over.Element as BeamElement).Beam as Glulam;
var m_glulam2 = (Under.Element as BeamElement).Beam as Glulam;
var m_offset1 = Offset1;
var m_offset2 = Offset2;
var m_extension = Extension;
var offset_center = OffsetCentre;
var m_result = new List <Brep>();
var m_drill_depth = 100.0;
double tolerance = Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance;
double widthA = m_glulam1.Width;
double heightA = m_glulam1.Height;
double widthB = m_glulam2.Width;
double heightB = m_glulam2.Height;
bool flip = false;
m_result = new List <Brep>();
//
// Find orientation relationship between glulams
//
Point3d ptA, ptB;
m_glulam1.Centreline.ClosestPoints(m_glulam2.Centreline, out ptA, out ptB);
Point3d CP = (ptA + ptB) / 2;
Plane cPlane;
double cDist = ptA.DistanceTo(ptB) / 2;
Plane plA = m_glulam1.GetPlane(ptA);
Plane plB = m_glulam2.GetPlane(ptB);
double ofc = offset_center;
double ofc2 = offset_center / 2;
Vector3d vAB = ptB - ptA;
Vector3d vBA = ptA - ptB;
if (vAB.IsZero || vBA.IsZero)
{
vAB = plA.YAxis;
vBA = -vAB;
}
else
{
vAB.Unitize();
vBA.Unitize();
}
int
yAFlip = vAB * plA.YAxis < 0 ? 1 : -1,
yBFlip = vBA * plB.YAxis < 0 ? 1 : -1,
xAFlip = plA.XAxis * plB.ZAxis < 0 ? 1 : -1,
xBFlip = plB.XAxis * plA.ZAxis < 0 ? 1 : -1;
m_result = new List <Brep>();
//
// Make center surface
//
Brep[] arrbrpCenterSides = new Brep[]
{
m_glulam1.GetSideSurface(0, (widthA / 2 - ofc2) * xAFlip, heightB * 3, m_extension, flip),
m_glulam1.GetSideSurface(0, -(widthA / 2 - ofc2) * xAFlip, heightB * 3, m_extension, flip)
};
Brep brpCenterFlat = m_glulam2.GetSideSurface(1, cDist * yAFlip, widthB - ofc, m_extension, flip);
Curve[] arrcrvCenterSides = new Curve[4];
Curve[] xCurves;
Point3d[] xPoints;
Rhino.Geometry.Intersect.Intersection.BrepBrep(arrbrpCenterSides[0], brpCenterFlat, tolerance, out xCurves, out xPoints);
if (xCurves.Length > 0)
{
arrcrvCenterSides[0] = xCurves[0];
}
else
{
m_result.Add(brpCenterFlat);
m_result.AddRange(arrbrpCenterSides);
//throw new Exception("Failed to intersect: 0");
return(false);
}
Rhino.Geometry.Intersect.Intersection.BrepBrep(arrbrpCenterSides[1], brpCenterFlat, tolerance, out xCurves, out xPoints);
if (xCurves.Length > 0)
{
arrcrvCenterSides[1] = xCurves[0];
}
else
{
m_result.Add(brpCenterFlat);
m_result.AddRange(arrbrpCenterSides);
//throw new Exception("Failed to intersect: 1");
return(false);
}
Point3d[] cPoints = new Point3d[4];
cPoints[0] = arrcrvCenterSides[0].PointAtStart;
cPoints[1] = arrcrvCenterSides[0].PointAtEnd;
cPoints[2] = arrcrvCenterSides[1].PointAtStart;
cPoints[3] = arrcrvCenterSides[1].PointAtEnd;
Plane.FitPlaneToPoints(cPoints, out cPlane);
cPlane.Origin = CP;
for (int i = 0; i < 4; ++i)
{
cPoints[i] = cPlane.ClosestPoint(cPoints[i]);
}
//arrcrvCenterSides[2] = new Line(arrcrvCenterSides[0].PointAtStart, arrcrvCenterSides[1].PointAtStart).ToNurbsCurve();
//arrcrvCenterSides[3] = new Line(arrcrvCenterSides[0].PointAtEnd, arrcrvCenterSides[1].PointAtEnd).ToNurbsCurve();
arrcrvCenterSides[0] = new Line(cPoints[0], cPoints[1]).ToNurbsCurve();
arrcrvCenterSides[1] = new Line(cPoints[2], cPoints[3]).ToNurbsCurve();
arrcrvCenterSides[2] = new Line(cPoints[0], cPoints[2]).ToNurbsCurve();
arrcrvCenterSides[3] = new Line(cPoints[1], cPoints[3]).ToNurbsCurve();
Brep brpCenterBrep = Brep.CreateEdgeSurface(arrcrvCenterSides);
//
// GlulamA Top
//
Brep brpGlulamATop = m_glulam1.GetSideSurface(1, (heightA / 2 + m_offset1) * -yAFlip, widthA + m_offset2, m_extension, false);
//
// GlulamA Sides
//
Brep[] arrbrpGlulamASides = new Brep[2];
arrbrpGlulamASides[0] = m_glulam1.GetSideSurface(0, (widthA / 2 + m_offset1) * xAFlip, heightA * 2 + m_offset2, m_extension, flip);
arrbrpGlulamASides[1] = m_glulam1.GetSideSurface(0, -(widthA / 2 + m_offset1) * xAFlip, heightA * 2 + m_offset2, m_extension, flip);
//
// GlulamB Bottom
//
Brep brpGlulamBBtm = m_glulam2.GetSideSurface(1, (heightB / 2 + m_offset1) * -yBFlip, widthB + m_offset2, m_extension, false);
//
// GlulamB Sides
//
Brep[] arrbrpGlulamBSides = new Brep[2];
arrbrpGlulamBSides[0] = m_glulam2.GetSideSurface(0, (widthB / 2 + m_offset1) * xAFlip, heightB * 2 + m_offset2, m_extension, flip);
arrbrpGlulamBSides[1] = m_glulam2.GetSideSurface(0, -(widthB / 2 + m_offset1) * xAFlip, heightB * 2 + m_offset2, m_extension, flip);
//
// Intersect GlulamA Top with GlulamB Sides
//
//m_result.Add(brpGlulamATop);
//m_result.AddRange(arrbrpGlulamBSides);
//return;
Curve[] arrcrvATopBSides = new Curve[2];
Rhino.Geometry.Intersect.Intersection.BrepBrep(brpGlulamATop, arrbrpGlulamBSides[0], tolerance, out xCurves, out xPoints);
if (xCurves.Length > 0)
{
arrcrvATopBSides[0] = xCurves[0];
}
Rhino.Geometry.Intersect.Intersection.BrepBrep(brpGlulamATop, arrbrpGlulamBSides[1], tolerance, out xCurves, out xPoints);
if (xCurves.Length > 0)
{
arrcrvATopBSides[1] = xCurves[0];
}
if (arrcrvATopBSides[0] == null || arrcrvATopBSides[1] == null)
{
//throw new Exception("Top sides are null.");
return(false);
}
//
// Intersect GlulamB Bottom with GlulamA Sides
//
Curve[] arrcrvBBtmASides = new Curve[2];
Rhino.Geometry.Intersect.Intersection.BrepBrep(brpGlulamBBtm, arrbrpGlulamASides[0], tolerance, out xCurves, out xPoints);
if (xCurves.Length > 0)
{
arrcrvBBtmASides[0] = xCurves[0];
}
Rhino.Geometry.Intersect.Intersection.BrepBrep(brpGlulamBBtm, arrbrpGlulamASides[1], tolerance, out xCurves, out xPoints);
if (xCurves.Length > 0)
{
arrcrvBBtmASides[1] = xCurves[0];
}
if (arrcrvBBtmASides[0] == null || arrcrvBBtmASides[1] == null)
{
return(false);
}
//
// Loft GlulamA Tops with Center
//
if (arrcrvCenterSides[3].TangentAtStart * arrcrvATopBSides[0].TangentAtStart < 0.0)
{
arrcrvATopBSides[0].Reverse();
}
Brep[] arrbrpTopCenterLoft1 =
Brep.CreateFromLoft(
new Curve[] { arrcrvCenterSides[3], arrcrvATopBSides[0] },
Point3d.Unset, Point3d.Unset,
LoftType.Straight, false);
if (arrcrvCenterSides[2].TangentAtStart * arrcrvATopBSides[1].TangentAtStart < 0.0)
{
arrcrvATopBSides[1].Reverse();
}
Brep[] arrbrpTopCenterLoft2 =
Brep.CreateFromLoft(
new Curve[] { arrcrvCenterSides[2], arrcrvATopBSides[1] },
Point3d.Unset, Point3d.Unset,
LoftType.Straight, false);
//
// Loft GlulamB Bottoms with Center
//
if (arrcrvCenterSides[0].TangentAtStart * arrcrvBBtmASides[0].TangentAtStart < 0.0)
{
arrcrvBBtmASides[0].Reverse();
}
Brep[] arrbrpBtmCenterLoft1 =
Brep.CreateFromLoft(
new Curve[] { arrcrvCenterSides[0], arrcrvBBtmASides[0] },
Point3d.Unset, Point3d.Unset,
LoftType.Straight, false);
if (arrcrvCenterSides[1].TangentAtStart * arrcrvBBtmASides[1].TangentAtStart < 0.0)
{
arrcrvBBtmASides[1].Reverse();
}
Brep[] arrbrpBtmCenterLoft2 =
Brep.CreateFromLoft(
new Curve[] { arrcrvCenterSides[1], arrcrvBBtmASides[1] },
Point3d.Unset, Point3d.Unset,
LoftType.Straight, false);
//
// Make webs
//
Brep web1 = Brep.CreateFromCornerPoints(
arrcrvCenterSides[0].PointAtStart,
arrcrvATopBSides[1].PointAtStart,
arrcrvBBtmASides[0].PointAtStart,
tolerance
);
Brep web2 = Brep.CreateFromCornerPoints(
arrcrvCenterSides[0].PointAtEnd,
arrcrvATopBSides[0].PointAtStart,
arrcrvBBtmASides[0].PointAtEnd,
tolerance
);
Brep web3 = Brep.CreateFromCornerPoints(
arrcrvCenterSides[1].PointAtEnd,
arrcrvATopBSides[0].PointAtEnd,
arrcrvBBtmASides[1].PointAtEnd,
tolerance
);
Brep web4 = Brep.CreateFromCornerPoints(
arrcrvCenterSides[1].PointAtStart,
arrcrvATopBSides[1].PointAtEnd,
arrcrvBBtmASides[1].PointAtStart,
tolerance
);
//
// Populate the result list.
//
m_result.Add(brpCenterBrep);
//m_result.Add(brpGlulamATop);
//m_result.Add(brpGlulamBTop);
m_result.AddRange(arrbrpTopCenterLoft1);
m_result.AddRange(arrbrpTopCenterLoft2);
m_result.AddRange(arrbrpBtmCenterLoft1);
m_result.AddRange(arrbrpBtmCenterLoft2);
m_result.Add(web1);
m_result.Add(web2);
m_result.Add(web3);
m_result.Add(web4);
var temp = Brep.JoinBreps(m_result, 0.001);
if (temp.Length > 0)
{
m_result.Clear();
m_result.AddRange(temp);
}
Under.Geometry.AddRange(m_result);
Over.Geometry.AddRange(m_result);
//var drill0 = new DoubleSidedCounterSunkDrill(
// cPlane,
// 5.0, m_drill_depth, 10.0, 6.0);
//drill0.Compute();
//m_result.AddRange(drill0.GetCuttingGeometry());
return(true);
}
public override bool Compute()
{
double tolerance = Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance;
double widthA = m_glulamA.Width;
double heightA = m_glulamA.Height;
double widthB = m_glulamB.Width;
double heightB = m_glulamB.Height;
m_result = new List <Brep>();
//
// Find orientation relationship between glulams
//
Point3d ptA, ptB;
m_glulamA.Centreline.ClosestPoints(m_glulamB.Centreline, out ptA, out ptB);
Plane plA = m_glulamA.GetPlane(ptA);
Plane plB = m_glulamB.GetPlane(ptB);
int sign = 1;
bool flip = false;
if (plA.XAxis * plB.XAxis > 0)
{
flip = !flip;
sign *= -1;
}
m_result = new List <Brep>();
//
// Make center surface
//
Brep[] arrbrpCenterSides = new Brep[]
{
m_glulamA.GetSideSurface(0, (widthA / 2 - offset_center) * sign, heightB, 5, flip),
m_glulamA.GetSideSurface(0, -(widthA / 2 - offset_center) * sign, heightB, 5, flip)
};
Brep brpCenterFlat = m_glulamB.GetSideSurface(1, 0, widthB - offset_center, 5, flip);
Curve[] arrcrvCenterSides = new Curve[4];
Curve[] xCurves;
Point3d[] xPoints;
Rhino.Geometry.Intersect.Intersection.BrepBrep(arrbrpCenterSides[0], brpCenterFlat, tolerance, out xCurves, out xPoints);
if (xCurves.Length > 0)
{
arrcrvCenterSides[0] = xCurves[0];
}
else
{
return(false);
}
//throw new Exception("Failed to intersect: 0");
Rhino.Geometry.Intersect.Intersection.BrepBrep(arrbrpCenterSides[1], brpCenterFlat, tolerance, out xCurves, out xPoints);
if (xCurves.Length > 0)
{
arrcrvCenterSides[1] = xCurves[0];
}
else
{
return(false);
}
//throw new Exception("Failed to intersect: 1");
arrcrvCenterSides[2] = new Line(arrcrvCenterSides[0].PointAtStart, arrcrvCenterSides[1].PointAtStart).ToNurbsCurve();
arrcrvCenterSides[3] = new Line(arrcrvCenterSides[0].PointAtEnd, arrcrvCenterSides[1].PointAtEnd).ToNurbsCurve();
Brep brpCenterBrep = Brep.CreateEdgeSurface(arrcrvCenterSides);
//
// GlulamA Top
//
Brep brpGlulamATop = m_glulamA.GetSideSurface(1, -(heightA / 2 + m_offset1), widthA + m_offset2, 5, false);
//
// GlulamA Sides
//
Brep[] arrbrpGlulamASides = new Brep[2];
arrbrpGlulamASides[0] = m_glulamA.GetSideSurface(0, (widthA / 2 + m_offset1) * sign, heightA * 2 + m_offset2, 5, flip);
arrbrpGlulamASides[1] = m_glulamA.GetSideSurface(0, -(widthA / 2 + m_offset1) * sign, heightA * 2 + m_offset2, 5, flip);
//
// GlulamB Bottom
//
Brep brpGlulamBBtm = m_glulamB.GetSideSurface(1, heightB / 2 + m_offset1, widthB + m_offset2, 5, false);
//
// GlulamB Sides
//
Brep[] arrbrpGlulamBSides = new Brep[2];
arrbrpGlulamBSides[0] = m_glulamB.GetSideSurface(0, (widthB / 2 + m_offset1) * sign, heightB * 2 + m_offset2, 5, flip);
arrbrpGlulamBSides[1] = m_glulamB.GetSideSurface(0, -(widthB / 2 + m_offset1) * sign, heightB * 2 + m_offset2, 5, flip);
//
// Intersect GlulamA Top with GlulamB Sides
//
//m_result.Add(brpGlulamATop);
//m_result.AddRange(arrbrpGlulamBSides);
//return;
Curve[] arrcrvATopBSides = new Curve[2];
Rhino.Geometry.Intersect.Intersection.BrepBrep(brpGlulamATop, arrbrpGlulamBSides[0], tolerance, out xCurves, out xPoints);
if (xCurves.Length > 0)
{
arrcrvATopBSides[0] = xCurves[0];
}
Rhino.Geometry.Intersect.Intersection.BrepBrep(brpGlulamATop, arrbrpGlulamBSides[1], tolerance, out xCurves, out xPoints);
if (xCurves.Length > 0)
{
arrcrvATopBSides[1] = xCurves[0];
}
//
// Intersect GlulamB Bottom with GlulamA Sides
//
Curve[] arrcrvBBtmASides = new Curve[2];
Rhino.Geometry.Intersect.Intersection.BrepBrep(brpGlulamBBtm, arrbrpGlulamASides[0], tolerance, out xCurves, out xPoints);
if (xCurves.Length > 0)
{
arrcrvBBtmASides[0] = xCurves[0];
}
Rhino.Geometry.Intersect.Intersection.BrepBrep(brpGlulamBBtm, arrbrpGlulamASides[1], tolerance, out xCurves, out xPoints);
if (xCurves.Length > 0)
{
arrcrvBBtmASides[1] = xCurves[0];
}
//
// Loft GlulamA Tops with Center
//
if (arrcrvCenterSides[3].TangentAtStart * arrcrvATopBSides[0].TangentAtStart < 0.0)
{
arrcrvATopBSides[0].Reverse();
}
Brep[] arrbrpTopCenterLoft1 =
Brep.CreateFromLoft(
new Curve[] { arrcrvCenterSides[3], arrcrvATopBSides[0] },
Point3d.Unset, Point3d.Unset,
LoftType.Straight, false);
if (arrcrvCenterSides[2].TangentAtStart * arrcrvATopBSides[1].TangentAtStart < 0.0)
{
arrcrvATopBSides[1].Reverse();
}
Brep[] arrbrpTopCenterLoft2 =
Brep.CreateFromLoft(
new Curve[] { arrcrvCenterSides[2], arrcrvATopBSides[1] },
Point3d.Unset, Point3d.Unset,
LoftType.Straight, false);
//
// Loft GlulamB Bottoms with Center
//
if (arrcrvCenterSides[0].TangentAtStart * arrcrvBBtmASides[0].TangentAtStart < 0.0)
{
arrcrvBBtmASides[0].Reverse();
}
Brep[] arrbrpBtmCenterLoft1 =
Brep.CreateFromLoft(
new Curve[] { arrcrvCenterSides[0], arrcrvBBtmASides[0] },
Point3d.Unset, Point3d.Unset,
LoftType.Straight, false);
if (arrcrvCenterSides[1].TangentAtStart * arrcrvBBtmASides[1].TangentAtStart < 0.0)
{
arrcrvBBtmASides[1].Reverse();
}
Brep[] arrbrpBtmCenterLoft2 =
Brep.CreateFromLoft(
new Curve[] { arrcrvCenterSides[1], arrcrvBBtmASides[1] },
Point3d.Unset, Point3d.Unset,
LoftType.Straight, false);
//
// Make webs
//
Brep web1 = Brep.CreateFromCornerPoints(
arrcrvCenterSides[0].PointAtStart,
arrcrvATopBSides[1].PointAtStart,
arrcrvBBtmASides[0].PointAtStart,
tolerance
);
Brep web2 = Brep.CreateFromCornerPoints(
arrcrvCenterSides[0].PointAtEnd,
arrcrvATopBSides[0].PointAtStart,
arrcrvBBtmASides[0].PointAtEnd,
tolerance
);
Brep web3 = Brep.CreateFromCornerPoints(
arrcrvCenterSides[1].PointAtEnd,
arrcrvATopBSides[0].PointAtEnd,
arrcrvBBtmASides[1].PointAtEnd,
tolerance
);
Brep web4 = Brep.CreateFromCornerPoints(
arrcrvCenterSides[1].PointAtStart,
arrcrvATopBSides[1].PointAtEnd,
arrcrvBBtmASides[1].PointAtStart,
tolerance
);
//
// Populate the result list.
//
m_result.Add(brpCenterBrep);
//m_result.Add(brpGlulamATop);
//m_result.Add(brpGlulamBTop);
m_result.AddRange(arrbrpTopCenterLoft1);
m_result.AddRange(arrbrpTopCenterLoft2);
m_result.AddRange(arrbrpBtmCenterLoft1);
m_result.AddRange(arrbrpBtmCenterLoft2);
m_result.Add(web1);
m_result.Add(web2);
m_result.Add(web3);
m_result.Add(web4);
//m_result.AddRange(arrbrpGlulamBSides);
return(true);
}
public Brep CreateBrep()
{
List <Point3d> curvePts = Vertices.Select(x => x.Point).ToList();
//var brpPoints = curvePts.Select(x => new Point(x)).ToList();
curvePts.Add(curvePts[0]);
Polyline pl = new Polyline(curvePts);
Curve plcrv = pl.ToNurbsCurve();
var result = Brep.CreatePlanarBreps(plcrv, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance);
if (result != null && result.Length == 1)
{
//result[0].SetVertices();
return(result[0]);
}
if (Vertices.Count == 4)
{
var bFace = Brep.CreateFromCornerPoints(Vertices[0].Point,
Vertices[1].Point, Vertices[2].Point, Vertices[3].Point, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance);
//bFace.SetVertices();
return(bFace);
}
if (Vertices.Count == 3)
{
var bFace = Brep.CreateFromCornerPoints(Vertices[0].Point,
Vertices[1].Point, Vertices[2].Point, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance);
//bFace.SetVertices();
return(bFace);
}
ComputeCentroid();
var brepFace = Brep.CreatePatch(new List <GeometryBase>()
{
plcrv, new Point(Centroid)
}, 5, 5, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance / 1000);
//var brepFace = Brep.CreateFromMesh(FMesh, true);
//brpPoints.Add(new Point(Centroid));
//brepFace.SetVertices();
return(brepFace);
/*
* else
* {
* Brep faceBrep = new Brep();
* ComputeCentroid();
* for (int i = 0; i < Vertices.Count; i++)
* {
* faceBrep.Append(Brep.CreateFromCornerPoints(Centroid, Vertices[i].Point, Vertices[(i + 1) % Vertices.Count].Point,
* Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance));
* }
* faceBrep.JoinNakedEdges(Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance);
* return faceBrep;
* }
*
*
*/
}
/// <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)
{
GH_Structure <IGH_GeometricGoo> iGeometry = new GH_Structure <IGH_GeometricGoo>();
double iAngle = 0.0;
List <string> iPatchNames = new List <string>();
List <int> iRefLvlGeom = new List <int>();
List <int> ieMeshRefLvl = new List <int>();
List <double> iX = new List <double>();
double iY = 0.0;
double iZ = 0.0;
Plane iZeroPlane = new Plane();
DA.GetDataTree(0, out iGeometry);
DA.GetData(1, ref iAngle);
DA.GetDataList(2, iPatchNames);
DA.GetDataList(3, iRefLvlGeom);
DA.GetDataList(4, ieMeshRefLvl);
DA.GetDataList(5, iX);
DA.GetData(6, ref iY);
DA.GetData(7, ref iZ);
DA.GetData(8, ref iZeroPlane);
DataTree <Brep> convertedGeomTree = new DataTree <Brep>();
List <GH_Path> pathList = new List <GH_Path>();
foreach (var path in iGeometry.Paths)
{
for (int i = 0; i < iGeometry.get_Branch(path).Count; i++)
{
pathList.Add(path);
}
}
var flattenedGeom = iGeometry.FlattenData();
for (int i = 0; i < flattenedGeom.Count; i++)
{
flattenedGeom[i].CastTo(out Brep tempBrep);
convertedGeomTree.Add(tempBrep, pathList[i]);
}
DataTree <Brep> rotatedGeomTree = convertedGeomTree;
Point3d centerPt = GetCenterPt(rotatedGeomTree.AllData());
foreach (GH_Path path in rotatedGeomTree.Paths)
{
foreach (var brep in rotatedGeomTree.Branch(path))
{
brep.Rotate(iAngle * Math.PI / 180, Vector3d.ZAxis, centerPt);
}
}
if (DA.GetData(8, ref iZeroPlane))
{
centerPt.Z = iZeroPlane.OriginZ;
}
double height = GetHeight(convertedGeomTree.AllData());
double width = GetWidth(convertedGeomTree.AllData());
double depth = GetDepth(convertedGeomTree.AllData());
if (!DA.GetDataList(2, iPatchNames))
{
for (int i = 0; i < rotatedGeomTree.BranchCount; i++)
{
iPatchNames.Add("PATCH_" + i);
}
}
if (!DA.GetDataList(3, iRefLvlGeom))
{
for (int i = 0; i < rotatedGeomTree.BranchCount; i++)
{
iRefLvlGeom.Add(2);
}
}
if (!DA.GetDataList(4, ieMeshRefLvl))
{
for (int i = 0; i < rotatedGeomTree.BranchCount; i++)
{
ieMeshRefLvl.Add(2);
}
}
if (!DA.GetDataList(5, iX))
{
iX.Add(4 * height);
iX.Add(12 * height);
}
if (!DA.GetData(6, ref iY))
{
iY = 6 * height;
}
if (!DA.GetData(7, ref iZ))
{
iZ = 6 * height;
}
if (iX[0] <= 0.5 * depth || iX[1] <= 0.5 * depth)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "The depth of the wind tunnel is too small!");
}
else if (iX[0] < 2.5 * height || iX[1] < 7.5 * height)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "The depth of the wind tunnel is small, be aware.");
}
if (iY < 4 * height)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "The width of the wind tunnel is small, be aware.");
}
else if (iY <= width)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "The width of the wind tunnel is too small!");
}
if (iZ < 6 * height)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "The height of the wind tunnel is small, be aware.");
}
else if (iZ <= height)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "The height of the wind tunnel is too small!");
}
List <Point3d> cornerPoints = new List <Point3d>
{
new Point3d(centerPt.X - iX[0], centerPt.Y - iY / 2, centerPt.Z),
new Point3d(centerPt.X + iX[1], centerPt.Y - iY / 2, centerPt.Z),
new Point3d(centerPt.X + iX[1], centerPt.Y + iY / 2, centerPt.Z),
new Point3d(centerPt.X - iX[0], centerPt.Y + iY / 2, centerPt.Z),
new Point3d(centerPt.X - iX[0], centerPt.Y - iY / 2, centerPt.Z + iZ),
new Point3d(centerPt.X + iX[1], centerPt.Y - iY / 2, centerPt.Z + iZ),
new Point3d(centerPt.X + iX[1], centerPt.Y + iY / 2, centerPt.Z + iZ),
new Point3d(centerPt.X - iX[0], centerPt.Y + iY / 2, centerPt.Z + iZ)
};
List <Brep> surfaceList = new List <Brep> {
Brep.CreateFromCornerPoints(cornerPoints[0], cornerPoints[4], cornerPoints[7], cornerPoints[3], 0.01),
Brep.CreateFromCornerPoints(cornerPoints[1], cornerPoints[2], cornerPoints[6], cornerPoints[5], 0.01),
Brep.CreateFromCornerPoints(cornerPoints[3], cornerPoints[7], cornerPoints[6], cornerPoints[2], 0.01),
Brep.CreateFromCornerPoints(cornerPoints[0], cornerPoints[1], cornerPoints[5], cornerPoints[4], 0.01),
Brep.CreateFromCornerPoints(cornerPoints[0], cornerPoints[3], cornerPoints[2], cornerPoints[1], 0.01),
Brep.CreateFromCornerPoints(cornerPoints[4], cornerPoints[5], cornerPoints[6], cornerPoints[7], 0.01)
};
List <string> nameList = new List <string>
{
"INLET",
"OUTLET",
"LEFTSIDE",
"RIGHTSIDE",
"BOTTOM",
"TOP"
};
DataTree <Brep> oGeometryList = new DataTree <Brep>();
int j = 0;
int k = 0;
foreach (var surface in surfaceList)
{
surface.SetUserString("Name", nameList[j]);
surface.SetUserString("RefLvl", "0");
surface.SetUserString("eMeshLvl", "0");
surface.SetUserString("RotAngle", iAngle.ToString());
oGeometryList.Add(surface, new GH_Path(k));
j++;
k++;
}
;
j = 0;
foreach (GH_Path path in rotatedGeomTree.Paths)
{
foreach (var brep in rotatedGeomTree.Branch(path))
{
brep.SetUserString("Name", iPatchNames[j]);
brep.SetUserString("RefLvl", iRefLvlGeom[j].ToString());
brep.SetUserString("eMeshLvl", ieMeshRefLvl[j].ToString());
brep.SetUserString("RotAngle", iAngle.ToString());
oGeometryList.Add(brep, new GH_Path(k));
}
j++;
k++;
}
DA.SetDataTree(0, oGeometryList);
}
public static IGH_GeometricGoo BldgPartToRoof(BuildingPart bldgPart)
{
IGH_GeometricGoo roof = bldgPart.PartGoo;
PolylineCurve pL = bldgPart.PartFootprint; ///Already at min height
bldgPart.PartOsmGeo.Tags.TryGetValue("roof:shape", out string roofShape);
bldgPart.PartOsmGeo.Tags.TryGetValue("height", out string heightString);
double height = GetHeightDimensioned(heightString);
bldgPart.PartOsmGeo.Tags.TryGetValue("min_height", out string minHeightString);
double min_height = GetHeightDimensioned(minHeightString);
bldgPart.PartOsmGeo.Tags.TryGetValue("roof:height", out string roofHeightString);
double roofHeight = GetHeightDimensioned(roofHeightString);
double facadeHeight = height - roofHeight;
///Make sure there's a minium facade height for SF Transamerica Pyramid case
if (facadeHeight <= 0)
{
facadeHeight = 2 * DocumentTolerance();
}
bldgPart.PartOsmGeo.Tags.TryGetValue("roof:orientation", out string roofOrientationString);
bldgPart.PartOsmGeo.Tags.TryGetValue("roof:direction", out string roofDirectionString);
double roofDirection = System.Convert.ToDouble(roofDirectionString);
Vector3d roofDirectionVector = Plane.WorldXY.YAxis;
roofDirectionVector.Rotate(RhinoMath.ToRadians(-roofDirection), Plane.WorldXY.ZAxis);
Line[] edges = pL.ToPolyline().GetSegments();
Point3d centroid = AreaMassProperties.Compute(pL).Centroid;
switch (roofShape)
{
case "pyramidal":
centroid.Z = height;
pL.TryGetPolyline(out Polyline pLPolyline);
Line[] pLLines = pLPolyline.GetSegments();
List <Brep> pyramidBrepList = Brep.CreatePlanarBreps(pL, DocumentTolerance()).ToList();
if (!string.IsNullOrEmpty(roofHeightString))
{
Plane facadeHeightPlane = Plane.WorldXY;
facadeHeightPlane.Translate(new Vector3d(0, 0, facadeHeight));
pLPolyline.Transform(Transform.PlanarProjection(facadeHeightPlane));
///Creating individual faces seems to work better/cleaner than lofting curves
for (int i = 0; i < pLLines.Count(); i++)
{
Line bottomEdge = pLLines[i];
Line topEdge = bottomEdge;
topEdge.Transform(Transform.PlanarProjection(facadeHeightPlane));
pyramidBrepList.Add(Brep.CreateFromCornerPoints(bottomEdge.PointAt(0), bottomEdge.PointAt(1), topEdge.PointAt(1), topEdge.PointAt(0), DocumentTolerance()));
}
}
foreach (Line edge in pLPolyline.GetSegments())
{
pyramidBrepList.Add(Brep.CreateFromCornerPoints(edge.PointAt(0), centroid, edge.PointAt(1), DocumentTolerance()));
}
Brep[] pyramidBrep = Brep.CreateSolid(pyramidBrepList, DocumentTolerance());
if (pyramidBrep[0].IsSolid)
{
roof = GH_Convert.ToGeometricGoo(pyramidBrep[0]);
}
break;
case "skillion":
Line frontEdge = new Line();
Line backEdge = new Line();
double frontAngleMin = RhinoMath.ToRadians(90);
double backAngleMin = RhinoMath.ToRadians(90);
foreach (Line edge in edges)
{
Point3d closestPt = edge.ClosestPoint(centroid, true);
Vector3d perpVector = closestPt - centroid;
double angleDifference = Vector3d.VectorAngle(roofDirectionVector, perpVector);
if (angleDifference < frontAngleMin)
{
frontEdge = edge;
frontAngleMin = angleDifference;
}
if (angleDifference > backAngleMin)
{
backEdge = edge;
backAngleMin = angleDifference;
}
}
Point3d backEdgeFrom = backEdge.From;
backEdgeFrom.Z = height;
Point3d backEdgeTo = backEdge.To;
backEdgeTo.Z = height;
Point3d frontEdgeFrom = frontEdge.From;
frontEdgeFrom.Z = facadeHeight;
Point3d frontEdgeTo = frontEdge.To;
frontEdgeTo.Z = facadeHeight;
List <Point3d> basePtList = new List <Point3d> {
backEdge.From, backEdge.To, frontEdge.From, frontEdge.To, backEdge.From
};
Polyline basePolyline = new Polyline(basePtList);
List <Point3d> topPtList = new List <Point3d> {
backEdgeFrom, backEdgeTo, frontEdgeFrom, frontEdgeTo, backEdgeFrom
};
Polyline topPolyline = new Polyline(topPtList);
///Creating individual faces seems to work better/cleaner than lofting curves
List <Brep> skillionBreps = new List <Brep>();
Line[] baseLines = basePolyline.GetSegments();
Line[] topLines = topPolyline.GetSegments();
for (int i = 0; i < baseLines.Count(); i++)
{
Line bottomEdge = baseLines[i];
Line topEdge = topLines[i];
skillionBreps.Add(Brep.CreateFromCornerPoints(bottomEdge.PointAt(0), bottomEdge.PointAt(1), topEdge.PointAt(1), topEdge.PointAt(0), DocumentTolerance()));
}
Brep baseSkillion = Brep.CreateFromCornerPoints(backEdge.From, backEdge.To, frontEdge.From, frontEdge.To, DocumentTolerance());
Brep topSkillion = Brep.CreateFromCornerPoints(backEdgeFrom, backEdgeTo, frontEdgeFrom, frontEdgeTo, DocumentTolerance());
skillionBreps.Add(baseSkillion);
skillionBreps.Add(topSkillion);
Brep[] skillion = Brep.CreateSolid(skillionBreps, DocumentTolerance());
if (skillion.Count() > 0)
{
roof = GH_Convert.ToGeometricGoo(skillion[0]);
}
break;
case "gabled":
///TODO: Look into getting oriented bbox using front edge as orientation plane,
///extrude gable roof profile from face of bbox, trim roof geo from footprint,
///loft between footprint and trimmed roof edges and join everything.
///Need to simply polylines with colinear segments. Angle tolerance based on Notre-Dame de Paris case
//pL.Simplify(CurveSimplifyOptions.All, 0, RhinoMath.ToRadians(2)).TryGetPolyline(out Polyline pLSimplified);
Polyline pLSimplified = pL.ToPolyline();
pLSimplified.MergeColinearSegments(DocumentAngleTolerance() * 5, true);
Line[] edgesSimplified = pLSimplified.GetSegments();
if (edgesSimplified.Count() != 4)
{
break;
}
Line ridge = new Line();
Line eaveOne = new Line();
Line eaveTwo = new Line();
Polyline topGablePolyline = new Polyline();
List <Brep> gableBreps = new List <Brep>();
if ((edgesSimplified[0].Length > edgesSimplified[1].Length && roofOrientationString != "across") || ((edgesSimplified[0].Length < edgesSimplified[1].Length && roofOrientationString == "across")))
{
ridge = new Line(edgesSimplified[3].PointAt(0.5), edgesSimplified[1].PointAt(0.5));
ridge.FromZ = height;
ridge.ToZ = height;
eaveOne = edgesSimplified[0];
eaveOne.FromZ = facadeHeight;
eaveOne.ToZ = facadeHeight;
eaveTwo = edgesSimplified[2];
eaveTwo.Flip();
eaveTwo.FromZ = facadeHeight;
eaveTwo.ToZ = facadeHeight;
topGablePolyline = new Polyline {
eaveOne.From, eaveOne.To, ridge.To, eaveTwo.To, eaveTwo.From, ridge.From, eaveOne.From
};
Brep[] gableRoof = Brep.CreateFromLoft(new List <Curve> {
eaveOne.ToNurbsCurve(), ridge.ToNurbsCurve(), eaveTwo.ToNurbsCurve()
}, Point3d.Unset, Point3d.Unset, LoftType.Straight, false);
gableRoof[0].Faces.SplitKinkyFaces();
gableBreps.Add(gableRoof[0]);
}
if ((edgesSimplified[0].Length > edgesSimplified[1].Length && roofOrientationString == "across") || (edgesSimplified[0].Length < edgesSimplified[1].Length && roofOrientationString != "across"))
{
ridge = new Line(edgesSimplified[0].PointAt(0.5), edgesSimplified[2].PointAt(0.5));
ridge.FromZ = height;
ridge.ToZ = height;
eaveOne = edgesSimplified[1];
eaveOne.FromZ = facadeHeight;
eaveOne.ToZ = facadeHeight;
eaveTwo = edgesSimplified[3];
eaveTwo.Flip();
eaveTwo.FromZ = facadeHeight;
eaveTwo.ToZ = facadeHeight;
topGablePolyline = new Polyline {
eaveTwo.From, ridge.From, eaveOne.From, eaveOne.To, ridge.To, eaveTwo.To, eaveTwo.From
};
Brep[] gableRoof = Brep.CreateFromLoft(new List <Curve> {
eaveOne.ToNurbsCurve(), ridge.ToNurbsCurve(), eaveTwo.ToNurbsCurve()
}, Point3d.Unset, Point3d.Unset, LoftType.Straight, false);
gableRoof[0].Faces.SplitKinkyFaces();
gableBreps.Add(gableRoof[0]);
}
Brep[] gablewalls = Brep.CreateFromLoft(new List <Curve> {
pLSimplified.ToPolylineCurve(), topGablePolyline.ToPolylineCurve()
}, Point3d.Unset, Point3d.Unset, LoftType.Straight, false);
gablewalls[0].Faces.SplitKinkyFaces();
gablewalls[0].MergeCoplanarFaces(DocumentTolerance());
gableBreps.Add(gablewalls[0]);
Brep baseGable = Brep.CreateFromCornerPoints(edgesSimplified[0].From, edgesSimplified[0].To, edgesSimplified[2].From, edgesSimplified[2].To, DocumentTolerance());
gableBreps.Add(baseGable);
Brep[] gable = Brep.JoinBreps(gableBreps, DocumentTolerance());
if (gable[0].IsValid)
{
roof = GH_Convert.ToGeometricGoo(gable[0]);
}
break;
default:
break;
}
return(roof);
}
public override bool Construct(bool append = false)
{
if (!append)
{
foreach (var part in Parts)
{
part.Geometry.Clear();
}
}
//var breps = new DataTree<Brep>();
var obeam = (Over.Element as BeamElement).Beam;
var ubeam = (Under.Element as BeamElement).Beam;
var oPlane = obeam.GetPlane(Over.Parameter);
var uPlane = ubeam.GetPlane(Under.Parameter);
Transform xform = Transform.PlaneToPlane(Plane.WorldXY, oPlane);
double added = 10.0;
double height = 0.0;
var plane = new Plane((oPlane.Origin + uPlane.Origin) / 2, Vector3d.CrossProduct(oPlane.ZAxis, uPlane.ZAxis));
// Create beam side planes
var planes = new Plane[4];
planes[0] = new Plane(oPlane.Origin + oPlane.XAxis * obeam.Width * 0.5,
oPlane.ZAxis, oPlane.YAxis);
planes[1] = new Plane(oPlane.Origin - oPlane.XAxis * obeam.Width * 0.5,
-oPlane.ZAxis, oPlane.YAxis);
planes[2] = new Plane(uPlane.Origin + uPlane.XAxis * ubeam.Width * 0.5,
uPlane.ZAxis, uPlane.YAxis);
planes[3] = new Plane(uPlane.Origin - uPlane.XAxis * ubeam.Width * 0.5,
-uPlane.ZAxis, uPlane.YAxis);
var planesOffset = planes.Select(x => new Plane(x.Origin + x.ZAxis * added, x.XAxis, x.YAxis)).ToArray();
var points = new Point3d[4];
Rhino.Geometry.Intersect.Intersection.PlanePlanePlane(plane, planes[0], planes[2], out points[0]);
Rhino.Geometry.Intersect.Intersection.PlanePlanePlane(plane, planes[0], planes[3], out points[1]);
Rhino.Geometry.Intersect.Intersection.PlanePlanePlane(plane, planes[1], planes[2], out points[2]);
Rhino.Geometry.Intersect.Intersection.PlanePlanePlane(plane, planes[1], planes[3], out points[3]);
// Create over cutter
var oSrf = new Brep[3];
height = obeam.Height * 0.5 + added;
var oPoints = new Point3d[] {
points[0] - oPlane.ZAxis * added,
points[1] + oPlane.ZAxis * added,
points[2] - oPlane.ZAxis * added,
points[3] + oPlane.ZAxis * added
};
oSrf[0] = Brep.CreateFromCornerPoints(oPoints[0], oPoints[1], oPoints[2], oPoints[3],
0.01);
oSrf[1] = Brep.CreateFromCornerPoints(oPoints[0], oPoints[1], oPoints[1] + plane.ZAxis * height, oPoints[0] + plane.ZAxis * height, 0.01);
oSrf[2] = Brep.CreateFromCornerPoints(oPoints[2], oPoints[3], oPoints[3] + plane.ZAxis * height, oPoints[2] + plane.ZAxis * height, 0.01);
var oJoined = Brep.JoinBreps(oSrf, 0.1);
if (oJoined == null)
{
oJoined = oSrf;
}
Under.Geometry.AddRange(oJoined);
// Create under cutter
var uSrf = new Brep[3];
height = ubeam.Height * 0.5 + added;
var uPoints = new Point3d[] {
points[0] + uPlane.ZAxis * added,
points[1] + uPlane.ZAxis * added,
points[2] - uPlane.ZAxis * added,
points[3] - uPlane.ZAxis * added
};
uSrf[0] = Brep.CreateFromCornerPoints(uPoints[0], uPoints[1], uPoints[2], uPoints[3], 0.01);
uSrf[1] = Brep.CreateFromCornerPoints(uPoints[0], uPoints[2], uPoints[2] - plane.ZAxis * height, uPoints[0] - plane.ZAxis * height, 0.01);
uSrf[2] = Brep.CreateFromCornerPoints(uPoints[1], uPoints[3], uPoints[3] - plane.ZAxis * height, uPoints[1] - plane.ZAxis * height, 0.01);
var uJoined = Brep.JoinBreps(uSrf, 0.1);
if (uJoined == null)
{
uJoined = uSrf;
}
Over.Geometry.AddRange(uJoined);
return(true);
}
public override bool Construct(bool append = false)
{
if (!append)
{
foreach (var part in Parts)
{
part.Geometry.Clear();
}
}
debug = new List <object>();
if (InnerSurface == null || OuterSurface == null)
{
throw new Exception("Surfaces not defined!");
}
// Sort elements around the joint normal
var dirs = SortPartsClockwise();
var beams = new Beam[4];
for (int i = 0; i < 4; ++i)
{
beams[i] = (Parts[i].Element as BeamElement).Beam;
}
// Get beam planes for each beam
var planes = new Plane[4];
for (int i = 0; i < 4; ++i)
{
planes[i] = beams[i].GetPlane(this.Plane.Origin);
}
// Construct proper planes for each element
for (int i = 0; i < 4; ++i)
{
int signX = 1, signY = 1, signZ = 1;
if (planes[i].ZAxis * dirs[i] < 0)
{
signZ = -1;
}
if (planes[i].YAxis * Normal < 0)
{
signY = -1;
}
planes[i] = new Plane(planes[i].Origin, planes[i].XAxis * signX * signZ, planes[i].YAxis * signY);
}
debug.Add(Plane);
//debug.Add(planes[1]);
//debug.Add(planes[2]);
//debug.Add(beams[0].Centreline);
//debug.Add(beams[1].Centreline);
//debug.Add(beams[2].Centreline);
//debug.Add(beams[3].Centreline);
// Array of lines that describe the seams between
// neighbouring beams.
// From = point on inner surface
// To = point on outer surface
// The first line is to the right of the beam
// I.e. the 2 seams for beam[0] are seams[0] and seams[3]
var seams = new Line[4];
for (int i = 0; i < 4; ++i)
{
int ii = (i + 1).Modulus(4);
// Create side planes for each seam
var p0 = new Plane(planes[i].Origin - planes[i].XAxis * beams[i].Width * 0.5,
planes[i].ZAxis, planes[i].YAxis);
var p1 = new Plane(planes[ii].Origin + planes[ii].XAxis * beams[ii].Width * 0.5,
planes[ii].ZAxis, planes[ii].YAxis);
// Find intersection of planes = find seam
Line xline;
Rhino.Geometry.Intersect.Intersection.PlanePlane(p0, p1, out xline);
xline.Transform(Transform.Scale((xline.From + xline.To) * 0.5, 500));
var xlineCrv = xline.ToNurbsCurve();
// Find intersection between surfaces and seam
Point3d[] xpts;
Curve[] overlapCurves;
Rhino.Geometry.Intersect.Intersection.CurveBrep(xlineCrv, InnerSurface, 0.01,
out overlapCurves, out xpts);
var innerPt = xpts[0];
Rhino.Geometry.Intersect.Intersection.CurveBrep(xlineCrv, OuterSurface, 0.01,
out overlapCurves, out xpts);
var outerPt = xpts[0];
seams[i] = new Line(innerPt, outerPt);
debug.Add(seams[i]);
}
// Vectors that describe the direction between opposing seams
var innerCrosses = new Vector3d[4];
var outerCrosses = new Vector3d[4];
for (int i = 0; i < 4; ++i)
{
int ii = (i + 2).Modulus(4);
outerCrosses[i] = seams[ii].To - seams[i].To;
innerCrosses[i] = seams[ii].From - seams[i].From;
}
debug.Add(new Line(seams[0].To, outerCrosses[0]));
debug.Add(new Line(seams[1].To, outerCrosses[1]));
debug.Add(new Line(seams[0].From, innerCrosses[0]));
debug.Add(new Line(seams[1].From, innerCrosses[1]));
var cutterInterval = new Interval(-1000, 1000);
/* INTERIOR JOINT SURFACES */
// Construct cutters
for (int i = 0; i < 4; ++i)
{
int ii = (i + 3).Modulus(4);
Point3d origin;
Vector3d xaxis, yaxis;
double d = CutterExtension;
double lip = CutterLipWidth;
// Handle first seam
var pts = new Point3d[8];
var cutter0 = new Brep[4];
// Construct outer surface for first seam
origin = seams[i].To;
xaxis = seams[i].From - seams[i].To;
yaxis = outerCrosses[i];
Plane pOuter0 = new Plane(origin, xaxis, yaxis);
var projOuter0 = this.Plane.ProjectAlongVector(xaxis);
pts[0] = origin + pOuter0.XAxis * d + pOuter0.YAxis * d;
pts[1] = origin + pOuter0.XAxis * d - pOuter0.YAxis * CutterToleranceExtension;
pts[2] = origin - pOuter0.XAxis * d - pOuter0.YAxis * CutterToleranceExtension;
pts[3] = origin - pOuter0.XAxis * d + pOuter0.YAxis * d;
pts[0].Transform(projOuter0); pts[0] = pts[0] - pOuter0.XAxis * lip;
pts[1].Transform(projOuter0); pts[1] = pts[1] - pOuter0.XAxis * lip;
cutter0[0] = Brep.CreateFromCornerPoints(pts[0], pts[1], pts[2], pts[3], 0.01);
// Construct inner surface for first seam
origin = seams[i].From;
xaxis = seams[i].To - seams[i].From;
yaxis = innerCrosses[i];
Plane pInner0 = new Plane(origin, xaxis, yaxis);
var projInner0 = this.Plane.ProjectAlongVector(xaxis);
pts[4] = origin + pInner0.XAxis * d + pInner0.YAxis * d;
pts[5] = origin + pInner0.XAxis * d - pInner0.YAxis * CutterToleranceExtension;
pts[6] = origin - pInner0.XAxis * d - pInner0.YAxis * CutterToleranceExtension;
pts[7] = origin - pInner0.XAxis * d + pInner0.YAxis * d;
pts[4].Transform(projInner0); pts[4] = pts[4] - pInner0.XAxis * lip;
pts[5].Transform(projInner0); pts[5] = pts[5] - pInner0.XAxis * lip;
cutter0[1] = Brep.CreateFromCornerPoints(pts[4], pts[5], pts[6], pts[7], 0.01);
cutter0[2] = Brep.CreateFromCornerPoints(pts[0], pts[1], pts[5], 0.01);
cutter0[3] = Brep.CreateFromCornerPoints(pts[5], pts[4], pts[0], 0.01);
debug.Add(pts[0]);
//debug.Add(pts[1]);
//debug.Add(pts[4]);
//debug.Add(pts[5]);
var cutter0Joined = Brep.JoinBreps(cutter0, 0.01);
Parts[i].Geometry.AddRange(cutter0Joined);
// Handle second seam
var cutter1 = new Brep[4];
// Construct outer surface for second seam
origin = seams[ii].To;
xaxis = seams[ii].From - seams[ii].To;
yaxis = outerCrosses[ii];
Plane pOuter1 = new Plane(origin, xaxis, yaxis);
var projOuter1 = this.Plane.ProjectAlongVector(xaxis);
pts[0] = origin + pOuter1.XAxis * d + pOuter1.YAxis * d;
pts[1] = origin + pOuter1.XAxis * d - pOuter1.YAxis * CutterToleranceExtension;
pts[2] = origin - pOuter1.XAxis * d - pOuter1.YAxis * CutterToleranceExtension;
pts[3] = origin - pOuter1.XAxis * d + pOuter1.YAxis * d;
pts[0].Transform(projOuter1); pts[0] = pts[0] - pOuter1.XAxis * lip;
pts[1].Transform(projOuter1); pts[1] = pts[1] - pOuter1.XAxis * lip;
cutter1[0] = Brep.CreateFromCornerPoints(pts[0], pts[1], pts[2], pts[3], 0.01);
// Construct inner surface for second seam
origin = seams[ii].From;
xaxis = seams[ii].To - seams[ii].From;
yaxis = innerCrosses[ii];
Plane pInner1 = new Plane(origin, xaxis, yaxis);
var projInner1 = this.Plane.ProjectAlongVector(xaxis);
pts[4] = origin + pInner1.XAxis * d + pInner1.YAxis * d;
pts[5] = origin + pInner1.XAxis * d - pInner1.YAxis * CutterToleranceExtension;
pts[6] = origin - pInner1.XAxis * d - pInner1.YAxis * CutterToleranceExtension;
pts[7] = origin - pInner1.XAxis * d + pInner1.YAxis * d;
pts[4].Transform(projInner1); pts[4] = pts[4] - pInner1.XAxis * lip;
pts[5].Transform(projInner1); pts[5] = pts[5] - pInner1.XAxis * lip;
cutter1[1] = Brep.CreateFromCornerPoints(pts[4], pts[5], pts[6], pts[7], 0.01);
//cutter1[2] = Brep.CreateFromCornerPoints(pts[0], pts[1], pts[5], pts[4], 0.01);
cutter1[2] = Brep.CreateFromCornerPoints(pts[0], pts[1], pts[5], 0.01);
cutter1[3] = Brep.CreateFromCornerPoints(pts[5], pts[4], pts[0], 0.01);
var cutter1Joined = Brep.JoinBreps(cutter1, 0.01);
Parts[i].Geometry.AddRange(cutter1Joined);
}
/* PLATE AND DOWELS */
// Create interior plate cutter and dowel positions
var endPlanes = new Plane[4];
var dowelPlanes = new Plane[4];
var dowelCutters = new Brep[4];
for (int i = 0; i < 4; ++i)
{
var dir = dirs[i];
dir.Unitize();
endPlanes[i] = new Plane(this.Plane.Origin + dir * PlateLength, dir);
var dowelPt = this.Plane.Origin + dir * DowelPosition;
var dp = beams[i].GetPlane(dowelPt);
debug.Add(endPlanes[i]);
dowelCutters[i] = new Cylinder(
new Circle(new Plane(dp.Origin - dp.YAxis * DowelLength * 0.5, dp.YAxis),
DowelDiameter * 0.5), DowelLength).ToBrep(true, true);
dowelPlanes[i] = dp;
}
var platePlane0 = new Plane(this.Plane.Origin - this.Plane.ZAxis * PlateThickness * 0.5,
this.Plane.XAxis, this.Plane.YAxis);
var platePlane1 = new Plane(this.Plane.Origin + this.Plane.ZAxis * PlateThickness * 0.5,
this.Plane.XAxis, this.Plane.YAxis);
var platePts = new Point3d[4];
for (int i = 0; i < 4; ++i)
{
int ii = (i + 1).Modulus(4);
Rhino.Geometry.Intersect.Intersection.PlanePlanePlane(
endPlanes[i], endPlanes[ii], platePlane0, out platePts[i]);
}
// Create plate outline and cutter
var plateOutline = new Polyline()
{
platePts[0], platePts[1], platePts[2], platePts[3], platePts[0]
}.ToNurbsCurve();
var plateSrf = Brep.CreateTrimmedPlane(platePlane0, plateOutline);
Brep[] outBlends, outWalls;
var plateBrep = Brep.CreateOffsetBrep(plateSrf, PlateThickness, true, true, 0.01, out outBlends, out outWalls)[0];
plateBrep.Flip();
for (int i = 0; i < 4; ++i)
{
Parts[i].Geometry.Add(plateBrep);
Parts[i].Geometry.Add(dowelCutters[i]);
debug.Add(dowelCutters[i]);
}
return(true);
}
public static Mesh CurveMesh(List <Line> lines, List <double> r_, double DivisionDist, int DivisionU, int DivisionV,
ref DataTree <Point3d> anchors0, ref DataTree <Point3d> anchors1, ref DataTree <Polyline> outlines, ref Circle[] graphNodes, List <Circle> circleRadius = null)
{
Tuple <Point3d[], List <string>, List <int>, List <int>, List <int>, DataTree <int> > data = GetGraphData(lines);
List <Point3d> TP = data.Item1.ToList();
List <int> U = data.Item3;
List <int> V = data.Item4;
DataTree <int> VAdj = data.Item6;
DataTree <Vector3d> sortedVecs = new DataTree <Vector3d>();
DataTree <Vector3d> sortedBisectors = new DataTree <Vector3d>();
DataTree <Polyline> output = new DataTree <Polyline>();
DataTree <Mesh> outputMesh = new DataTree <Mesh>();
DataTree <Point3d> outputPt = new DataTree <Point3d>();
DataTree <Point3d> outputPtArc = new DataTree <Point3d>();
Mesh joinedMesh = new Mesh();
DataTree <int> sortedIDs = new DataTree <int>();
var polys = new List <Polyline>();
double[] radius = Enumerable.Repeat(1.0, TP.Count).ToArray();
List <double> r = new List <double>();
if (r_.Count == 0)
{
r.Add(1);
}
else
{
r = r_;
}
if (r.Count < TP.Count)
{
radius = new double[radius.Length];
for (int i = 0; i < TP.Count; i++)
{
radius[i] = r[i % r.Count];
}
}
else
{
radius = r.ToArray();
// Rhino.RhinoApp.WriteLine("correct");
}
PointCloud cloud = new PointCloud(TP);
for (int i = 0; i < circleRadius.Count; i++)
{
int cp = cloud.ClosestPoint(circleRadius[i].Center);
if (cloud[cp].Location.DistanceToSquared(circleRadius[i].Center) < 0.01)
{
//r[cp] = circleRadius[i].Radius;
if (circleRadius[i].Plane.ZAxis != Vector3d.ZAxis)
{
radius[cp] = -circleRadius[i].Radius;
}
else
{
radius[cp] = circleRadius[i].Radius;
}
}
}
for (int i = 0; i < TP.Count; i++)
{
//create node vectors and sort them
//also sort ids
Vector3d[] vec = new Vector3d[VAdj.Branch(i).Count];
int[] nei = VAdj.Branch(i).ToArray();
for (int j = 0; j < VAdj.Branch(i).Count; j++)
{
Point3d p0 = TP[i];
Point3d p1 = TP[VAdj.Branch(i)[j]];
vec[j] = p1 - p0;
vec[j].Unitize();
vec[j] *= Math.Abs(radius[j]);
}
Array.Sort(vec, nei, new ClockwiseVector3dComparer());
sortedVecs.AddRange(vec, new GH_Path(i));
sortedIDs.AddRange(nei, new GH_Path(i));
//Bisector
Vector3d[] bisectors = new Vector3d[VAdj.Branch(i).Count];
if (VAdj.Branch(i).Count > 1)
{
for (int j = 0; j < VAdj.Branch(i).Count; j++)
{
Vector3d vec0 = vec[j];
Vector3d vec1 = vec[(j + 1) % VAdj.Branch(i).Count];
Vector3d bisector = new Vector3d(vec1);
Vector3d vvec0 = new Vector3d(vec0);
Vector3d vvec1 = new Vector3d(vec1);
vvec0.Unitize();
vvec1.Unitize();
vvec0.Rotate(-Math.PI * 0.5, Vector3d.ZAxis);
double angle = Vector3d.VectorAngle(vec0, vec1, new Plane(TP[i], vec0, vvec0)) * 0.5;
// Vector3d cross = Rhino.Geometry.Vector3d.CrossProduct(vvec0, vvec1);
// angle = Math.Atan2(cross * Vector3d.ZAxis, vvec0*vvec1);
bisector.Rotate(angle, Vector3d.ZAxis);
bisector.Unitize();
bisector *= Math.Abs(radius[i]);
bisectors[j] = bisector;
}
sortedBisectors.AddRange(bisectors, new GH_Path(i));
}
else
{
Vector3d vec0 = new Vector3d(vec[0]);
Vector3d vec1 = new Vector3d(vec[0]);
vec0.Rotate(-Math.PI * 0.5, Vector3d.ZAxis);
vec1.Rotate(Math.PI * 0.5, Vector3d.ZAxis);
vec0.Unitize();
vec1.Unitize();
vec0 *= Math.Abs(radius[i]);
vec1 *= Math.Abs(radius[i]);
Vector3d[] bisectors_ = new Vector3d[] { vec0, vec1 };
//Array.Sort(bisectors_, new ClockwiseVector3dComparer());
sortedBisectors.AddRange(bisectors_, new GH_Path(i));
}
}
DataTree <Polyline> polylines = new DataTree <Polyline>();
// for(int i = 0; i < 1;i++){//TP.Count
for (int i = 0; i < TP.Count; i++)
{
//for(int j = 1; j < 2;j++){//VAdj.Branch(i).Count
for (int j = 0; j < VAdj.Branch(i).Count; j++) //VAdj.Branch(i).Count
{
int currentNei = sortedIDs.Branch(i)[j];
int[] neinei = sortedIDs.Branch(currentNei).ToArray();
int neiID = Array.IndexOf(neinei, i);
neiID = NGonsCore.MathUtil.Wrap(neiID - 1, neinei.Length);
Vector3d neiVec = new Vector3d(sortedBisectors.Branch(currentNei)[neiID]);
if (neinei.Length == 1)
{
neiVec = new Vector3d(sortedBisectors.Branch(currentNei)[1]);
}
bool flag1 = sortedIDs.Branch(currentNei).Count == 1;
bool flag0 = sortedIDs.Branch(i).Count == 1;
Line line = Line.Unset;
Polyline anchorsPoly = new Polyline();
Arc anchorsArc = Arc.Unset;
Vector3d arcVec0 = Vector3d.Zero;
Arc arc0 = Arc.Unset;
if (flag0)
{
//Create arc for naked part
arcVec0 = TP[i] - TP[currentNei];
arcVec0.Unitize();
arcVec0 *= radius[i];//Negative gaussian flip
line = new Line(TP[i] + arcVec0, TP[i] + sortedBisectors.Branch(i)[j]);
anchorsPoly = new Polyline(new Point3d[] { TP[i] + sortedBisectors.Branch(i)[j], TP[i] + arcVec0, TP[i] - sortedBisectors.Branch(i)[j] });
anchorsArc = new Arc(TP[i] + sortedBisectors.Branch(i)[j], TP[i] - arcVec0, TP[i] - sortedBisectors.Branch(i)[j]);
// Rhino.RhinoDoc.ActiveDoc.Objects.AddArc(anchorsArc);
Vector3d arcVec0mid = (sortedBisectors.Branch(i)[j] + arcVec0);
arcVec0mid.Unitize();
arcVec0mid *= radius[i];
arc0 = new Arc(
TP[i] + arcVec0,
TP[i] + arcVec0mid,
TP[i] + sortedBisectors.Branch(i)[j]
);
// Rhino.RhinoDoc.ActiveDoc.Objects.AddArc(arc0);
}
Vector3d arcVec1 = Vector3d.Zero;
Arc arc1 = Arc.Unset;
if (flag1)
{
//Create arc for naked part
arcVec1 = TP[i] - TP[currentNei];
arcVec1.Unitize();
arcVec1 *= -radius[currentNei];//Negative gaussian flip
line = new Line(TP[currentNei] + arcVec1, TP[currentNei] + neiVec);
Vector3d arcVec1mid = (neiVec + arcVec1);
arcVec1mid.Unitize();
arcVec1mid *= -radius[currentNei];
arc1 = new Arc(
TP[currentNei] + arcVec1,
TP[currentNei] + arcVec1mid,
TP[currentNei] + neiVec
);
// Rhino.RhinoDoc.ActiveDoc.Objects.AddArc(arc1);
}
Polyline polyline = new Polyline(new Point3d[] {
TP[i] + arcVec0,
TP[i] + sortedBisectors.Branch(i)[j],
TP[currentNei] + neiVec,
TP[currentNei] + arcVec1,
});
polyline.Close();
polys.Add(polyline);
// if(neinei.Length == 1){
output.Add(polyline, new GH_Path(i));
//Rhino.RhinoDoc.ActiveDoc.Objects.AddLine(polyline.SegmentAt(1));
int dirV = (int)Math.Max(1, Math.Ceiling(polyline.SegmentAt(3).Length / DivisionDist));
//Rhino.RhinoApp.WriteLine(dirV.ToString());
if (DivisionDist == 0)
{
dirV = DivisionV;
}
//Create surface
/*
* Line line0 = new Line(TP[i] + arcVec0, TP[i] + sortedBisectors.Branch(i)[j]);
* Line line1 = new Line(TP[currentNei] + arcVec1, TP[currentNei] + neiVec);
* Brep loft = Brep.CreateFromLoft(new Curve[]{line0.ToNurbsCurve(),line1.ToNurbsCurve()}, Point3d.Unset, Point3d.Unset, LoftType.Tight, false)[0];
*
* if(flag0){
* loft = Brep.CreateFromLoft(new Curve[]{arc0.ToNurbsCurve(),line1.ToNurbsCurve()}, Point3d.Unset, Point3d.Unset, LoftType.Tight, false)[0];
* }else if(flag1){
* loft = Brep.CreateFromLoft(new Curve[]{line0.ToNurbsCurve(),arc1.ToNurbsCurve()}, Point3d.Unset, Point3d.Unset, LoftType.Tight, false)[0];
* // Rhino.RhinoDoc.ActiveDoc.Objects.AddBrep(loft);
* }
*/
Brep brep = Brep.CreateFromCornerPoints(polyline[0], polyline[1], polyline[2], polyline[3], Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance);
if (brep != null)
{
int dirU = Math.Max(1, DivisionU);
// if(line != Line.Unset){
// Point3d[] nakedPt;
// line.ToNurbsCurve().DivideByCount(dirU, true, out nakedPt);
// outputPt.AddRange(nakedPt, new GH_Path(i));
// }
if (anchorsArc != Arc.Unset)
{
Point3d[] nakedPt;
anchorsPoly.SegmentAt(0).ToNurbsCurve().DivideByCount(dirU, true, out nakedPt);
outputPt.AddRange(nakedPt, new GH_Path(i));
anchorsPoly.SegmentAt(1).ToNurbsCurve().DivideByCount(dirU, true, out nakedPt);
for (int k = 1; k < nakedPt.Length; k++)
{
outputPt.Add(nakedPt[k], new GH_Path(i));
}
anchorsArc.ToNurbsCurve().DivideByCount(dirU * 2, true, out nakedPt);
outputPtArc.AddRange(nakedPt, new GH_Path(i));
}
Surface surf = brep.Surfaces[0];
Mesh mesh = NGonsCore.MeshCreate.QuadMesh(surf, dirU, dirV, true, false);
outputMesh.Add(mesh, new GH_Path(i));
joinedMesh.Append(mesh);
}
}
}
joinedMesh.WeldUsingRTree(0.01);
anchors0 = outputPt;
anchors1 = outputPtArc;
outlines = output;
Circle[] circles = new Circle[data.Item1.Length];
for (int i = 0; i < circles.Length; i++)
{
circles[i] = new Circle(data.Item1[i], Math.Abs(radius[i]));
}
graphNodes = circles;
return(joinedMesh);
//A = sortedVecs;
//B = sortedBisectors;
// C = joinedMesh;
//D = output;
//E = outputPt;//anchors
//F = outputPtArc;//anchors
}
public override bool Construct(bool append = false)
{
var yaxes = new Vector3d[2];
var zaxes = new Vector3d[2];
var starts = new Point3d[2];
var ends = new Point3d[2];
var beams = new Beam[2];
double width = 0;
double extension = 1300;
double mult = 2.0;
beams[0] = (FirstHalf.Element as BeamElement).Beam;
beams[1] = (SecondHalf.Element as BeamElement).Beam;
for (int i = 0; i < 2; ++i)
{
var b = beams[i];
if (b.Height > width)
{
width = b.Height;
}
yaxes[i] = b.GetPlane(b.Centreline.Domain.Min).YAxis;
zaxes[i] = b.GetPlane(b.Centreline.Domain.Min).ZAxis;
starts[i] = b.Centreline.PointAt(b.Centreline.Domain.Min);
ends[i] = b.Centreline.PointAt(b.Centreline.Domain.Max);
}
//
var d0 = Utility.OverlapCurves(beams[0].Centreline, beams[1].Centreline);
var d1 = Utility.OverlapCurves(beams[1].Centreline, beams[0].Centreline);
starts[0] = beams[0].Centreline.PointAt(d0.Min);
starts[1] = beams[1].Centreline.PointAt(d1.Min);
ends[0] = beams[0].Centreline.PointAt(d0.Max);
ends[1] = beams[1].Centreline.PointAt(d1.Max);
//
if (zaxes[0] * zaxes[1] < 0)
{
//yaxes[1].Reverse();
var temp = starts[1];
starts[1] = ends[1];
ends[1] = temp;
}
var start = (starts[0] + starts[1]) / 2;
var end = (ends[0] + ends[1]) / 2;
var mid = (start + end) / 2;
var v = (yaxes[0] + yaxes[1]) / 2;
v.Unitize();
var n = end - start;
n.Unitize();
var p0 = start + v * width * 0.5 * mult - n * extension;
var p1 = end + v * width * 0.5 * mult + n * extension;
var p2 = end - v * width * 0.5 * mult + n * extension;
var p3 = start - v * width * 0.5 * mult - n * extension;
double t0, t1;
beams[0].Centreline.ClosestPoint(mid, out t0);
beams[1].Centreline.ClosestPoint(mid, out t1);
var brep = Brep.CreateFromCornerPoints(p0, p1, p2, p3, 0.001);
FirstHalf.Geometry.Add(brep);
SecondHalf.Geometry.Add(brep);
return(true);
}
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);
}
public override bool Construct(bool append = false)
{
debug = new List <object>();
var beams = new Beam[2];
beams[0] = (FirstHalf.Element as BeamElement).Beam;
beams[1] = (SecondHalf.Element as BeamElement).Beam;
var planes = new Plane[2];
for (int i = 0; i < 2; ++i)
{
planes[i] = beams[i].GetPlane(Parts[i].Parameter);
}
bool shift = Math.Abs(planes[0].XAxis * planes[1].XAxis) > Math.Abs(planes[0].XAxis * planes[1].YAxis) ? true : false;
var x0 = planes[0].XAxis;
var x1 = shift ? planes[1].XAxis : planes[1].YAxis;
if (x0 * x1 < 0)
{
x1 = -x1;
}
var commonX = (x0 + x1) / 2;
var y0 = planes[0].YAxis;
var y1 = shift ? planes[1].YAxis : planes[1].XAxis;
if (y0 * y1 < 0)
{
y1 = -y1;
}
var commonY = (y0 + y1) / 2;
var jplane = new Plane((planes[0].Origin + planes[1].Origin) / 2, commonX, commonY);
debug.Add(jplane);
var width0 = beams[0].Width;
var width1 = shift ? beams[1].Width : beams[1].Height;
var height0 = beams[0].Height;
var height1 = shift ? beams[1].Height : beams[1].Width;
double width = Math.Max(width0, width1) + Added * 2;
double height = Math.Max(height0, height1) + Added * 2;
double tan = Math.Tan(LapAngle);
double depth = tan * (LapLength / 2);
double back_depth = tan * (height * 0.5 - depth);
if (!BackCut)
{
back_depth = 0;
}
double hw = width / 2, hh = height / 2, hd = depth / 2;
var pts = new Point3d[8];
double hl = LapLength / 2;
pts[0] = jplane.PointAt(hw, -hh, hl - back_depth);
pts[1] = jplane.PointAt(-hw, -hh, hl - back_depth);
pts[2] = jplane.PointAt(hw, -depth, hl);
pts[3] = jplane.PointAt(-hw, -depth, hl);
pts[4] = jplane.PointAt(hw, depth, -hl);
pts[5] = jplane.PointAt(-hw, depth, -hl);
pts[6] = jplane.PointAt(hw, hh, -hl + back_depth);
pts[7] = jplane.PointAt(-hw, hh, -hl + back_depth);
// Create bottom points
var brep = Brep.CreateFromCornerPoints(pts[0], pts[1], pts[3], pts[2], 0.01);
brep.Join(Brep.CreateFromCornerPoints(pts[2], pts[3], pts[5], pts[4], 0.01), 0.01, true);
brep.Join(Brep.CreateFromCornerPoints(pts[4], pts[5], pts[7], pts[6], 0.01), 0.01, true);
debug.Add(brep);
FirstHalf.Geometry.Add(brep);
SecondHalf.Geometry.Add(brep);
var dowelPlane = new Plane(jplane.Origin, jplane.XAxis, jplane.ZAxis);
if (AngleDowels)
{
dowelPlane.Transform(Transform.Rotation(LapAngle, dowelPlane.XAxis, dowelPlane.Origin));
}
// Create dowels
var dowelPlanes = new Plane[2];
double dowelDistance = LapLength / 2;
dowelPlanes[0] = new Plane(dowelPlane.Origin + dowelPlane.YAxis * dowelDistance * 0.5, dowelPlane.ZAxis);
dowelPlanes[1] = new Plane(dowelPlane.Origin - dowelPlane.YAxis * dowelDistance * 0.5, dowelPlane.ZAxis);
dowelPlanes[0].Transform(Transform.Translation(dowelPlanes[0].ZAxis * -DowelLength * 0.5));
dowelPlanes[1].Transform(Transform.Translation(dowelPlanes[1].ZAxis * -DowelLength * 0.5));
var dowels = new Brep[2];
for (int i = 0; i < 2; ++i)
{
dowels[i] = new Cylinder(
new Circle(dowelPlanes[i], DowelDiameter * 0.5), DowelLength).ToBrep(true, true);
}
FirstHalf.Geometry.AddRange(dowels);
SecondHalf.Geometry.AddRange(dowels);
return(true);
}
public override bool Construct(bool append = false)
{
if (!append)
{
foreach (var part in Parts)
{
part.Geometry.Clear();
}
}
double added = ExtraLength;
var obeam = (Over.Element as BeamElement).Beam;
var ubeam = (Under.Element as BeamElement).Beam;
var oPlane = obeam.GetPlane(Over.Parameter);
var uPlane = ubeam.GetPlane(Under.Parameter);
// Calculate offset for backcut angle
double tan = Math.Tan(RhinoMath.ToRadians(Math.Max(1.0, TaperAngle)));
double addedTan = added * tan;
if (DepthOverride == 0.0) DepthOverride = obeam.Height;
double TaperOffset = DepthOverride * 0.5 * tan;
uPlane = UnifyPlanes(oPlane, uPlane);
var xaxis = oPlane.ZAxis;
var yaxis = uPlane.ZAxis;
var zaxis = Vector3d.CrossProduct(xaxis, yaxis);
zaxis.Unitize();
// Create centre plane
var plane = new Plane((oPlane.Origin + uPlane.Origin) / 2, zaxis);
var planeProj = plane.ProjectAlongVector(zaxis);
// Create side planes for Over
var oPlanes = new Plane[2];
oPlanes[0] = new Plane(oPlane.Origin - oPlane.XAxis * obeam.Width * 0.5,
oPlane.ZAxis, oPlane.YAxis);
oPlanes[1] = new Plane(oPlane.Origin + oPlane.XAxis * obeam.Width * 0.5,
-oPlane.ZAxis, oPlane.YAxis);
// Create side planes for Under
var uPlanes = new Plane[2];
uPlanes[0] = new Plane(uPlane.Origin - uPlane.XAxis * ubeam.Width * 0.5,
uPlane.ZAxis, uPlane.YAxis);
uPlanes[1] = new Plane(uPlane.Origin + uPlane.XAxis * ubeam.Width * 0.5,
-uPlane.ZAxis, uPlane.YAxis);
var corners = new Point3d[4];
Rhino.Geometry.Intersect.Intersection.PlanePlanePlane(plane, oPlanes[0], uPlanes[0], out corners[0]);
Rhino.Geometry.Intersect.Intersection.PlanePlanePlane(plane, oPlanes[0], uPlanes[1], out corners[1]);
Rhino.Geometry.Intersect.Intersection.PlanePlanePlane(plane, oPlanes[1], uPlanes[1], out corners[2]);
Rhino.Geometry.Intersect.Intersection.PlanePlanePlane(plane, oPlanes[1], uPlanes[0], out corners[3]);
var offsetCorners = new Point3d[3];
offsetCorners[0] = corners[0] - yaxis * TaperOffset;
offsetCorners[1] = corners[1] - yaxis * TaperOffset - xaxis * TaperOffset;
offsetCorners[2] = corners[2] - xaxis * TaperOffset;
var topCorners = new Point3d[4];
topCorners[0] = corners[0] - zaxis * (obeam.Height * 0.5 + added) + yaxis * addedTan;
topCorners[1] = corners[1] - zaxis * (obeam.Height * 0.5 + added) + yaxis * addedTan + xaxis * addedTan;
topCorners[2] = corners[2] - zaxis * (obeam.Height * 0.5 + added) + xaxis * addedTan;
topCorners[3] = corners[3] - zaxis * (obeam.Height * 0.5 + added);
var btmCorners = new Point3d[4];
btmCorners[0] = corners[0] + zaxis * (obeam.Height * 0.5 + added) + yaxis * addedTan;
btmCorners[1] = corners[1] + zaxis * (obeam.Height * 0.5 + added) + yaxis * addedTan + xaxis * addedTan;
btmCorners[2] = corners[2] + zaxis * (obeam.Height * 0.5 + added) + xaxis * addedTan;
btmCorners[3] = corners[3] + zaxis * (obeam.Height * 0.5 + added);
#if DEBUG
debug.Add(corners[0]);
debug.Add(corners[1]);
debug.Add(corners[2]);
debug.Add(corners[3]);
debug.Add(offsetCorners[0]);
debug.Add(offsetCorners[1]);
debug.Add(offsetCorners[2]);
debug.Add(topCorners[0]);
debug.Add(topCorners[1]);
debug.Add(topCorners[2]);
debug.Add(topCorners[3]);
debug.Add(btmCorners[0]);
debug.Add(btmCorners[1]);
debug.Add(btmCorners[2]);
debug.Add(btmCorners[3]);
#endif
var overSrf = new Brep[6];
overSrf[0] = Brep.CreateFromCornerPoints(offsetCorners[0], offsetCorners[1],
offsetCorners[2] - yaxis * added, corners[3] - yaxis * added,
0.01);
overSrf[1] = Brep.CreateFromCornerPoints(offsetCorners[0], btmCorners[0], btmCorners[1], offsetCorners[1],
0.01);
overSrf[2] = Brep.CreateFromCornerPoints(offsetCorners[1], topCorners[1],
topCorners[2] - yaxis * added, offsetCorners[2] - yaxis * added,
0.01);
overSrf[3] = Brep.CreateFromCornerPoints(corners[3] - yaxis * added, topCorners[3] - yaxis * added,
topCorners[0], offsetCorners[0],
0.01);
overSrf[4] = Brep.CreateFromCornerPoints(topCorners[0], offsetCorners[0], btmCorners[0],
0.01);
overSrf[5] = Brep.CreateFromCornerPoints(topCorners[1], offsetCorners[1], btmCorners[1],
0.01);
Over.Geometry.AddRange(Brep.JoinBreps(overSrf, 0.01));
Brep brepOver = Over.Geometry[0];
brepOver.MergeCoplanarFaces(0.01);
/* UNDER */
var underSrf = new Brep[6];
underSrf[0] = Brep.CreateFromCornerPoints(offsetCorners[0] - xaxis * added, offsetCorners[1],
offsetCorners[2], corners[3] - xaxis * added,
0.01);
underSrf[1] = Brep.CreateFromCornerPoints(offsetCorners[0] - xaxis * added, btmCorners[0] - xaxis * added,
btmCorners[1], offsetCorners[1],
0.01);
underSrf[2] = Brep.CreateFromCornerPoints(offsetCorners[1], topCorners[1],
topCorners[2], offsetCorners[2],
0.01);
underSrf[3] = Brep.CreateFromCornerPoints(offsetCorners[2], btmCorners[2],
btmCorners[3] - xaxis * added, corners[3] - xaxis * added,
0.01);
underSrf[4] = Brep.CreateFromCornerPoints(topCorners[2], offsetCorners[2], btmCorners[2],
0.01);
underSrf[5] = Brep.CreateFromCornerPoints(topCorners[1], offsetCorners[1], btmCorners[1],
0.01);
Under.Geometry.AddRange(Brep.JoinBreps(underSrf, 0.01));
Brep brepUnder = Under.Geometry[0];
brepUnder.MergeCoplanarFaces(0.01);
return true;
}
/// <summary>
///
/// </summary>
/// <param name="solid"></param>
/// <returns></returns>
public static Brep ToRhinoType(Parasite_BrepSolid solid, double RhinoDocTol)
{
int n = solid.Faces.Length;
Brep[] faces = new Brep[n];
for (int i = 0; i < n; i++)
{
Parasite_Point3d[] verts = solid.Faces[i].Vertices.ToArray();
if (verts.Length < 3)
{
throw new ParasiteArgumentException("A Brep Face cant be constructed from less than 2 vertices!");
}
else if (verts.Length == 3)
{
Point3d a = ToRhinoType(verts[0]);
Point3d b = ToRhinoType(verts[1]);
Point3d c = ToRhinoType(verts[2]);
faces[i] = Brep.CreateFromCornerPoints(a, b, c, RhinoDocTol);
}
else if (verts.Length == 4)
{
Point3d a = ToRhinoType(verts[0]);
Point3d b = ToRhinoType(verts[1]);
Point3d c = ToRhinoType(verts[2]);
Point3d d = ToRhinoType(verts[3]);
faces[i] = Brep.CreateFromCornerPoints(a, b, c, d, RhinoDocTol);
}
/// Build curve from vertices to then build a Brep face
else
{
IEnumerable <Parasite_Line> edges = solid.Faces[i].Edges;
IEnumerable <Curve> edgesAsCurves = ToRhinoType(edges);
Brep[] b = Brep.CreatePlanarBreps(edgesAsCurves, RhinoDocTol);
faces[i] = b[0];
}
}
Brep output = null;
try
{
Brep[] joinedBreps = Brep.JoinBreps(faces, RhinoDocTol);
output = joinedBreps[0];
}
catch
{
if (output == null)
{
// Check if folder exists, if not create it.
if (!Directory.Exists(FolderInfo.dirPath))
{
Directory.CreateDirectory(FolderInfo.dirPath);
}
string pathToFolder = Path.Combine(FolderInfo.dirPath, "RebelBreps");
FileStream fs = new FileStream(pathToFolder, FileMode.Create);
// Construct a BinaryFormatter and use it to serialize the data to the stream.
BinaryFormatter formatter = new BinaryFormatter();
try
{
formatter.Serialize(fs, faces);
}
catch (SerializationException e)
{
throw new SerializationException("Failed to serialize: " + e.Message);
}
finally
{
fs.Close();
}
throw new ParasiteConversionExceptions(output.GetType(), solid.GetType());
}
}
return(output);
}
public override bool Construct(bool append = false)
{
debug = new List <object>();
var beams = new Beam[2];
beams[0] = (FirstHalf.Element as BeamElement).Beam;
beams[1] = (SecondHalf.Element as BeamElement).Beam;
var planes = new Plane[2];
for (int i = 0; i < 2; ++i)
{
planes[i] = beams[i].GetPlane(Parts[i].Parameter);
}
bool shift = Math.Abs(planes[0].XAxis * planes[1].XAxis) > Math.Abs(planes[0].XAxis * planes[1].YAxis) ? true : false;
var x0 = planes[0].XAxis;
var x1 = shift ? planes[1].XAxis : planes[1].YAxis;
if (x0 * x1 < 0)
{
x1 = -x1;
}
var commonX = (x0 + x1) / 2;
var y0 = planes[0].YAxis;
var y1 = shift ? planes[1].YAxis : planes[1].XAxis;
if (y0 * y1 < 0)
{
y1 = -y1;
}
var commonY = (y0 + y1) / 2;
var jplane = new Plane((planes[0].Origin + planes[1].Origin) / 2, commonX, commonY);
bool flag = true;
if (beams[0].Width > beams[0].Height)
{
flag = false;
}
if (flag == Rotate)
{
jplane = new Plane(jplane.Origin, jplane.YAxis, -jplane.XAxis);
}
debug.Add(jplane);
var width0 = beams[0].Width;
var width1 = shift ? beams[1].Width : beams[1].Height;
var height0 = beams[0].Height;
var height1 = shift ? beams[1].Height : beams[1].Width;
double width = Math.Max(width0, width1) + Added * 2;
double height = Math.Max(height0, height1) + Added;
double depth = Math.Tan(Angle) * (height / 2);
if (flag == Rotate)
{
double temp = width;
width = height;
height = temp;
}
//if (width < height)
// jplane = new Plane(jplane.Origin, jplane.YAxis, -jplane.XAxis);
double hw = width / 2, hh = height / 2, hd = depth / 2;
// Create middle points
var pts = new Point3d[6];
pts[0] = jplane.PointAt(hw, 0, -hd);
pts[1] = jplane.PointAt(-hw, 0, -hd);
pts[2] = jplane.PointAt(hw, hh, hd);
pts[3] = jplane.PointAt(-hw, hh, hd);
// Create top points
pts[4] = jplane.PointAt(hw, -hh, hd);
pts[5] = jplane.PointAt(-hw, -hh, hd);
// Create bottom points
var brep = Brep.CreateFromCornerPoints(pts[0], pts[2], pts[3], pts[1], 0.01);
brep.Join(Brep.CreateFromCornerPoints(pts[0], pts[1], pts[5], pts[4], 0.01), 0.01, true);
FirstHalf.Geometry.Add(brep);
SecondHalf.Geometry.Add(brep);
// Create dowels
var dowelPlanes = new Plane[2];
double dowelDistance = flag ? beams[0].Height * 0.5 : beams[0].Width * 0.5;
Vector3d dowelY = flag ? planes[0].YAxis : planes[0].XAxis;
dowelPlanes[0] = new Plane(planes[0].Origin + dowelY * dowelDistance * 0.5, planes[0].ZAxis);
dowelPlanes[1] = new Plane(planes[0].Origin - dowelY * dowelDistance * 0.5, planes[0].ZAxis);
dowelPlanes[0].Transform(Transform.Translation(dowelPlanes[0].ZAxis * -DowelLength * 0.5));
dowelPlanes[1].Transform(Transform.Translation(dowelPlanes[1].ZAxis * -DowelLength * 0.5));
var dowels = new Brep[2];
for (int i = 0; i < 2; ++i)
{
dowels[i] = new Cylinder(
new Circle(dowelPlanes[i], DowelDiameter * 0.5), DowelLength).ToBrep(true, true);
}
FirstHalf.Geometry.AddRange(dowels);
SecondHalf.Geometry.AddRange(dowels);
if (DoDrilling)
{
// Create drillings
var drillTempPlane = beams[0].GetPlane(jplane.Origin - jplane.ZAxis * DrillDistanceOffset);
double drillDistance = flag ? beams[0].Height * 0.5 : beams[0].Width * 0.5;
double drillX, drillY;
Vector3d drillAngleAxis = flag ? -drillTempPlane.XAxis : drillTempPlane.YAxis;
for (int i = -1; i < 2; i += 2)
{
for (int j = -1; j < 2; j += 2)
{
drillX = flag ? DrillWidthOffset * i + (DrillDiameter + 2) * 0.5 * j : drillDistance * j;
drillY = !flag ? DrillWidthOffset * i + (DrillDiameter + 2) * 0.5 * j : drillDistance * j;
var drillPt = drillTempPlane.PointAt(drillX, drillY);
var drillAxis = flag ? drillTempPlane.YAxis * j : drillTempPlane.XAxis * j;
var drillPlane = new Plane(drillPt - drillAxis * DrillDepth, drillAxis);
var countersinkPlane = new Plane(drillPt - drillAxis * CountersinkDepth, drillAxis);
drillPlane.Transform(Transform.Rotation(DrillAngle * j, drillAngleAxis, drillPt));
countersinkPlane.Transform(Transform.Rotation(DrillAngle * j, drillAngleAxis, drillPt));
var countersinking = new Cylinder(new Circle(countersinkPlane, CountersinkDiameter * 0.5), CountersinkDepth + DrillApproachLength).ToBrep(true, true);
FirstHalf.Geometry.Add(countersinking);
var drilling = new Cylinder(new Circle(drillPlane, DrillDiameter * 0.5), DrillDepth + DrillApproachLength).ToBrep(true, true);
FirstHalf.Geometry.Add(drilling);
SecondHalf.Geometry.Add(drilling);
}
}
}
return(true);
}
public override bool Construct(bool append = false)
{
if (!append)
{
foreach (var part in Parts)
{
part.Geometry.Clear();
}
}
var bPart = Beam;
var beam = (bPart.Element as BeamElement).Beam;
var v0beam = (V0.Element as BeamElement).Beam;
var v1beam = (V1.Element as BeamElement).Beam;
var bplane = beam.GetPlane(bPart.Parameter);
int sign = 1;
var v0Crv = (V0.Element as BeamElement).Beam.Centreline;
if ((bplane.Origin - v0Crv.PointAt(v0Crv.Domain.Mid)) * bplane.XAxis > 0)
{
sign = -1;
}
// Get point and normal of intersection
var points = new Point3d[3];
var vectors = new Vector3d[3];
var average = Point3d.Origin;
for (int i = 0; i < Parts.Length; ++i)
{
var crv = (Parts[i].Element as BeamElement).Beam.Centreline;
points[i] = crv.PointAt(Parts[i].Parameter);
vectors[i] = crv.TangentAt(Parts[i].Parameter);
var midpt = crv.PointAt(crv.Domain.Mid);
if ((points[i] - midpt) * vectors[i] < 0)
{
vectors[i] = -vectors[i];
}
average = average + points[i];
}
average = average / 3;
// Create dividing surface for V-beams
var tangent = (vectors[0] + vectors[1]) / 2;
tangent.Unitize();
var normal = Vector3d.CrossProduct(vectors[0], vectors[1]);
var binormal = Vector3d.CrossProduct(tangent, normal);
Point3d vpt0, vpt1;
var res = v0beam.Centreline.ClosestPoints(v1beam.Centreline, out vpt0, out vpt1);
var vx = (vpt0 + vpt1) / 2;
var vv0 = JointUtil.GetEndConnectionVector(v0beam, vx);
var vv1 = JointUtil.GetEndConnectionVector(v1beam, vx);
var yaxis = (v0beam.GetPlane(V0.Parameter).YAxis + v1beam.GetPlane(V1.Parameter).YAxis) / 2;
var v0plane = v0beam.GetPlane(vx);
var v1plane = v1beam.GetPlane(vx);
var xaxis0 = v0plane.XAxis;
var xaxis1 = v1plane.XAxis;
if (xaxis1 * xaxis0 < 0)
{
xaxis1 = -xaxis1;
}
yaxis = Vector3d.CrossProduct(xaxis0, xaxis1);
var divPlane = new Plane(vx, (vv0 + vv1) / 2, yaxis);
var divider = Brep.CreatePlanarBreps(new Curve[] {
new Rectangle3d(divPlane, new Interval(-300, 300), new Interval(-300, 300)).ToNurbsCurve()
}, 0.01);
//vj.V0.Geometry.AddRange(divider);
V1.Geometry.AddRange(divider);
// Create temporary plate
var plane = new Plane(average, binormal, tangent);
// Create trimmer on bottom of Beam
var trimPlane = new Plane(bplane.Origin + bplane.XAxis * beam.Width * 0.5 * -sign, bplane.ZAxis, bplane.YAxis);
var trimmers = Brep.CreatePlanarBreps(new Curve[] { new Rectangle3d(trimPlane, new Interval(-300, 300), new Interval(-300, 300)).ToNurbsCurve() }, 0.01);
var sillPlane = new Plane(bplane.Origin + bplane.XAxis * beam.Width * 0.5 * sign, bplane.ZAxis, bplane.YAxis);
var sillTrimmer = Brep.CreatePlanarBreps(new Curve[] { new Rectangle3d(sillPlane, new Interval(-300, 300), new Interval(-300, 300)).ToNurbsCurve() }, 0.01);
var proj = sillPlane.ProjectAlongVector(divPlane.XAxis);
V0.Geometry.AddRange(trimmers);
V1.Geometry.AddRange(trimmers);
V1.Geometry.AddRange(sillTrimmer);
// Create cutter for through-tenon (V0)
var zz = trimPlane.Project(divPlane.ZAxis); zz.Unitize();
var yy = trimPlane.Project(divPlane.YAxis); yy.Unitize();
var origin = divPlane.Origin;
origin.Transform(proj);
double zheight = 100.0;
double tenonWidth = 60.0;
var srfsTop = new Brep[3];
sign = divPlane.ZAxis * vv0 < 0 ? 1 : -1;
var p = new Point3d[9];
for (int i = -1; i < 2; i += 2)
{
var srfs = new Brep[3];
p[0] = origin + yy * tenonWidth * 0.5 * i;
p[1] = p[0] + divPlane.XAxis * 200.0;
p[2] = p[1] + yy * zheight * i;
p[3] = p[0] + yy * zheight * i;
p[4] = p[0] - zz * 100 * sign;
p[5] = p[4] + yy * zheight * i;
p[6] = p[1] + zz * 100 * sign;
p[7] = p[6] - divPlane.XAxis * 500.0;
p[8] = p[4] - divPlane.XAxis * 300.0;
var poly = new Polyline(new Point3d[] { p[0], p[1], p[6], p[7], p[8], p[4], p[0] });
srfs[0] = Brep.CreateFromCornerPoints(p[0], p[1], p[2], p[3], 0.01);
srfs[1] = Brep.CreateFromCornerPoints(p[0], p[3], p[5], p[4], 0.01);
srfs[2] = Brep.CreatePlanarBreps(new Curve[] { poly.ToNurbsCurve() }, 0.01)[0];
var joined = Brep.JoinBreps(srfs, 0.01);
V0.Geometry.AddRange(joined);
}
// Create cutter for tenon cover (V1)
normal = Vector3d.CrossProduct(zz, divPlane.XAxis);
var tPlane = new Plane(origin, normal);
var ww = tPlane.Project(vv0);
var vv = tPlane.Project(vv1);
var buttPlane = new Plane(v0plane.Origin + v0plane.XAxis * v0beam.Width / 2, v0plane.ZAxis, v0plane.YAxis);
var proj2 = buttPlane.ProjectAlongVector(divPlane.XAxis);
var origin2 = origin;
origin2.Transform(proj2);
var srfs2 = new Brep[3];
p[0] = origin2 + yy * tenonWidth * 0.5 + ww * 20.0;
p[1] = p[0] - ww * 200.0;
p[2] = p[1] - vv * 500.0;
p[3] = p[0] - vv * 500.0;
p[4] = origin2 - yy * tenonWidth * 0.5 + ww * 20.0;
p[5] = p[4] - ww * 200.0;
p[6] = p[5] - vv * 500.0;
p[7] = p[4] - vv * 500.0;
srfs2[0] = Brep.CreateFromCornerPoints(p[0], p[1], p[2], p[3], 0.01);
srfs2[1] = Brep.CreateFromCornerPoints(p[4], p[5], p[6], p[7], 0.01);
srfs2[2] = Brep.CreateFromCornerPoints(p[0], p[1], p[5], p[4], 0.01);
var joined2 = Brep.JoinBreps(srfs2, 0.01);
V1.Geometry.AddRange(joined2);
// Create cutter for beam (Beam)
var dot = vv0 * trimPlane.ZAxis;
var srfTenon = new Brep[4];
double hw = v0beam.Width * 0.5 / dot; // TODO
int flip = -1;
for (int i = 0; i < 2; i++)
{
p[0 + 4 * i] = origin + yy * tenonWidth * 0.5 + zz * hw - ww * 150.0 * flip;
p[1 + 4 * i] = origin + yy * tenonWidth * 0.5 - zz * hw - ww * 150.0 * flip;
p[2 + 4 * i] = origin - yy * tenonWidth * 0.5 - zz * hw - ww * 150.0 * flip;
p[3 + 4 * i] = origin - yy * tenonWidth * 0.5 + zz * hw - ww * 150.0 * flip;
flip = -flip;
}
srfTenon[0] = Brep.CreateFromCornerPoints(p[0], p[1], p[5], p[4], 0.01);
srfTenon[1] = Brep.CreateFromCornerPoints(p[1], p[2], p[6], p[5], 0.01);
srfTenon[2] = Brep.CreateFromCornerPoints(p[2], p[3], p[7], p[6], 0.01);
srfTenon[3] = Brep.CreateFromCornerPoints(p[3], p[0], p[4], p[7], 0.01);
var joinedTenon = Brep.JoinBreps(srfTenon, 0.01);
Beam.Geometry.AddRange(joinedTenon);
return(true);
}
/// <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)
{
GH_Structure <GH_Brep> iGeometry;
int iN1exp = 0;
int iN2exp = 0;
int iN3exp = 0;
double iTimeSpacing = 1;
double iAlpha = 0.16;
double iFactor = 1;
double izRef = 10;
double ivRef = 25;
double iZRefBeonspek = 0;
DA.GetDataTree(0, out iGeometry);
DA.GetData(1, ref iN1exp);
DA.GetData(2, ref iN2exp);
DA.GetData(3, ref iN3exp);
DA.GetData(4, ref iTimeSpacing);
DA.GetData(5, ref iAlpha);
DA.GetData(6, ref iFactor);
DA.GetData(7, ref izRef);
DA.GetData(8, ref ivRef);
DA.GetData(9, ref iZRefBeonspek);
DataTree <Brep> convertedGeomTree = new DataTree <Brep>();
int newPath = 0;
Brep convertedBrep = null;
foreach (GH_Path path in iGeometry.Paths)
{
foreach (var geom in iGeometry.get_Branch(path))
{
GH_Convert.ToBrep(geom, ref convertedBrep, 0);
convertedGeomTree.Add(convertedBrep, new GH_Path(newPath));
convertedBrep = null;
}
newPath += 1;
}
double N1 = Math.Pow(2, iN1exp);
double N2 = Math.Pow(2, iN2exp);
double N3 = Math.Pow(2, iN3exp);
string Nstring = "N1=" + N1.ToString() + ",N2=" + N2.ToString() + ",N3=" + N3.ToString();
List <Point3d> cornerPointList = new List <Point3d>();
foreach (var cornerPoint in convertedGeomTree.Branch(0)[0].Vertices)
{
cornerPointList.Add(new Point3d(cornerPoint.Location));
}
double xMin = cornerPointList.OrderBy(p => p.X).ToList()[0].X;
double yMin = cornerPointList.OrderBy(p => p.Y).ToList()[0].Y;
double yMax = cornerPointList.OrderBy(p => p.Y).ToList()[cornerPointList.Count - 1].Y;
double zMin = cornerPointList.OrderBy(p => p.Z).ToList()[0].Z;
double zMax = cornerPointList.OrderBy(p => p.Z).ToList()[cornerPointList.Count - 1].Z;
double N1out = N1;
double N2out = Math.Ceiling((yMax - yMin) / iTimeSpacing * 1.2);
double N3out = Math.Ceiling((zMax - zMin) / iTimeSpacing * 1.1);
string inletCoordsString =
" xinlet = " + xMin + "\n" +
" yinlet = " + ((yMax + yMin) / 2 - N2out / 2 * iTimeSpacing) + "\n" +
" zinlet = " + zMin;
var oInlet = Brep.CreateFromCornerPoints(new Point3d(xMin, (yMax + yMin) / 2 - N2out / 2 * iTimeSpacing, zMin),
new Point3d(xMin, (yMax + yMin) / 2 - N2out / 2 * iTimeSpacing, zMin + N3out * iTimeSpacing),
new Point3d(xMin, (yMax + yMin) / 2 + N2out / 2 * iTimeSpacing, zMin + N3out * iTimeSpacing),
new Point3d(xMin, (yMax + yMin) / 2 + N2out / 2 * iTimeSpacing, zMin), 0.01);
string NoutString = "N1out=" + N1out.ToString() + ",N2out=" + N2out.ToString() + ",N3out=" + N3out.ToString();
double L1 = iTimeSpacing * N1;
double L2 = iTimeSpacing * N2;
double L3 = iTimeSpacing * N3;
string Lstring =
" L1 = " + L1 + "\n" +
" L2 = " + L2 + "\n" +
" L3 = " + L3;
List <Brep> flattedGeomTree = convertedGeomTree.AllData();
flattedGeomTree.RemoveRange(0, 6);
List <double> zCoordList = new List <double>();
foreach (var part in flattedGeomTree)
{
foreach (var vertex in part.Vertices)
{
zCoordList.Add(vertex.Location.Z);
}
}
zCoordList.Sort();
double geomHeigth = zCoordList[zCoordList.Count - 1] - zCoordList[0];
if (!DA.GetData(9, ref iZRefBeonspek))
{
iZRefBeonspek = Math.Ceiling(1.5 * geomHeigth);
}
if (8 * 0.59 * iZRefBeonspek >= L1)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "The length of the generated wind field is too small, currently " + L1.ToString() + " and needs to be bigger than 8L = " + (8 * 0.59 * iZRefBeonspek).ToString());
}
if (8 * 0.59 * iZRefBeonspek >= L2)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "The width of the generated wind field is too small, currently " + L2.ToString() + " and needs to be bigger than 8L = " + (8 * 0.59 * iZRefBeonspek).ToString());
}
if (8 * 0.59 * iZRefBeonspek >= L3)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "The height of the generated wind field is too small, currently " + L3.ToString() + " and needs to be bigger than 8L = " + (8 * 0.59 * iZRefBeonspek).ToString());
}
List <double> zList = new List <double>();
int i = 0;
while (iTimeSpacing * i < Math.Ceiling(geomHeigth))
{
i++;
zList.Add(iTimeSpacing * i);
}
List <double> uList = new List <double>();
foreach (var z in zList)
{
uList.Add(iFactor * ivRef * Math.Pow(z / izRef, iAlpha));
}
double uMean = uList.Average();
List <double> turbIntensity = new List <double>();
foreach (var z in zList)
{
turbIntensity.Add(0.19 * Math.Pow(z / izRef, -iAlpha));
}
#region shellString
string shellString =
"!---------------------------------------------------------------------\n" +
" PROGRAM wind FFT 3c3d\n" +
"! Program to generate multi correlated wind time series of the \n" +
"! 3 components \n" +
"! using the spatial 3 dimensional FFT of Numerical Recipes \n" +
"\n" +
"! Reference:\n" +
"! Jakob Mann: \"Wind field simulation\", 1998\n" +
"\n" +
"! written by A. Michalski 2006/07\n" +
"! \n" +
"! AMI 12.02.2008 output file for OpenFOAM \n" +
"! AMI 04.09.2008 only fourn parts active \n" +
"! AMI 14.12.2010 filter to detect maximum gust in defined box\n" +
"! filter to detect gust with defined speed \n" +
"! parameter iopt\n" +
"! AMI 16.12.2010 IFFT omp parallelized\n" +
"! AMI 12.01.2011 vtk_structured grid output file\n" +
"! AMI 22.02.2011 only output mean wind field \n" +
"! parameter imeanwind\n" +
"! AMI 31.03.2011 Write OpenFOAM Wind files\n" +
"! AMI 06.04.2011 Filter to detect wind field with defined variance\n" +
"! DA 17.06.2019 Output adapted for OpenFOAM v.6\n" +
"!---------------------------------------------------------------------\n" +
" use omp_lib\n" +
"! include 'omp_lib.h'\n" +
"\n" +
"! Openmp parallel\n" +
" integer ithr,tnr \n" +
" \n" +
" integer*4 N1, N2, N3\n" +
" integer*4 NDAT,N1I8,N2I8,N3I8\n" +
" integer*4 N1out, N2out, N3out,N1vtk\n" +
"! PARAMETERS\n" +
" parameter(ndim=3)\n" +
" parameter({0})\n" +
" parameter(N1I8=N1,N2I8=N2,N3I8=N3)\n" +
" parameter(NDAT=2*N1I8*N2I8*N3I8)\n" +
" parameter({1})\n" +
" parameter(N1vtk=256)! ARRAYS\n" +
"! - real\n" +
" real data1(NDAT)\n" +
" real data2(NDAT)\n" +
" real data3(NDAT)\n" +
" \n" +
" real matrix(N3out,N1out)\n" +
" \n" +
"! VARIABLES\n" +
"! - integer\n" +
" integer*8 il,nth\n" +
" integer*4 thp\n" +
" integer*4 ivalue, iflag, iout, iopt, imeanwind\n" +
" integer*8 n\n" +
" integer*4 nn(3)\n" +
" integer*4 j1,j2,j3\n" +
"!xxxxxxxx used for debugging xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx \n" +
"! integer*4 i \n" +
"!xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx \n" +
" \n" +
"\n" +
"! for OpenFOAM\n" +
"! - string\n" +
" character(LEN=18) mkdirname\n" +
" character(LEN=14) cddirname\n" +
" character(LEN=18) mkdirname2\n" +
" character(LEN=14) cddirname2\n" +
" integer is,is2\n" +
"! real*8 ui\n" +
" \n" +
"! - real \n" +
" real S1re, S1im, S2re, S2im, S3re, S3im\n" +
" real*8 sumen1, sumen2, sumen3\n" +
"!xxxxxxxx used for debugging xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx \n" +
"! integer item,jtem,iktem\n" +
"! real tsimtem,data1tem\n" +
"!xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n" +
"\n" +
" real*8 L1, L2, L3\n" +
" real*8 d1,d2,d3 \n" +
" real*8 k1,k2,k3,k,ks,k1s,k2s,k3s,k0,k0s,k0ksfak,k30,k30s\n" +
"\n" +
" real*8 z\n" +
" real*8 ustar\n" +
" real*8 E, En\n" +
" \n" +
" real F21re\n" +
" real*8 L\n" +
" real*8 fak\n" +
" real*8 Cfakt\n" +
" real fakhyp\n" +
" real*8 beta\n" +
" real*8 gam\n" +
" real*8 sita1, sita2, Ce1, Ce2\n" +
" real*8 atanfak, atanfak1\n" +
" \n" +
" real*8 xn1re, xn1im, xn2re, xn2im, xn3re, xn3im\n" +
" real*8 uref, alfa, zref, ubasic, aquer,bquer\n" +
" real*8 uz,umeanz,umzSBCi,umzECNA\n" +
" real fscale\n" +
" \n" +
" real*8 dt,tsim\n" +
" \n" +
"! real xlength1, xlength2, xlenght3\n" +
"\n" +
"! gustbox\n" +
" real*8 ugust, ugustm, ugustms\n" +
" integer*4 n1b,n2b,n3b,n123b\n" +
" integer*4 j1a,j1e,j1am,j1em,j1ams,iter,maxiter\n" +
" integer*4 j1d\n" +
" integer*4 j2a,j2e,j3a,j3e\n" +
" real*8 B1,B2,B3,zgb\n" +
" real*8 lgs, ugs\n" +
" \n" +
" integer iterende\n" +
" integer checkl,usegust\n" +
" real*8 gustarray(N1)\n" +
" real*8 xlength,xinlet,yinlet,zinlet\n" +
" real*8 checkvar, checkvarlimit,dustar\n" +
"\n" +
"! - complex \n" +
" complex xn1, xn2, xn3\n" +
" complex xn2check(N1)\n" +
" complex dZiso1, dZiso2, dZiso3\n" +
" complex S1,S2,S3\n" +
" complex hypgeo\n" +
" complex ah, bh, ch, zh\n" +
" complex F21\n" +
"\n" +
"\n" +
"! Wind speed profile according to EC\n" +
"! Roughness length z0EC\n" +
" real*8 z0EC \n" +
"! Terrain factor krEC\n" +
" real*8 krEC\n" +
"! Roughness factor crzEC\n" +
" real*8 crzEC\n" +
"! Basic wind speed EC\n" +
" real*8 vbasicEC\n" +
"! Mean wind speed vmzEC\n" +
" real*8 umzEC\n" +
"! Standard deviation sdEC\n" +
" real*8 sdEC\n" +
"! Turbulence intensity IvEC\n" +
" real*8 IvEC\n" +
"! Peak velocity pressure\n" +
" real*8 qpzEC\n" +
"! Peak velocity\n" +
" real*8 vpzEC\n" +
" \n" +
"! COMMON BLOCKS\n" +
" common /dataar/ data1, data2, data3\n" +
" common /statist/ umean, vmean, wmean, uvar, vvar, wvar,uw,uv,vw \n" +
"\n" +
"! OPEN FILES \n" +
" open(unit=58,file='log.dat')\n" +
" rewind(58)\n" +
" \n" +
" write(*,*)\n" +
" write(*,*) 'Software to generate multicorrelated wind time' \n" +
" write(*,*) 'histories of u,v,w wind components in x,y,z '\n" +
" write(*,*) 'directions ' \n" +
" write(*,*)\n" +
" write(*,*) 'Open files'\n" +
" write(*,*)\n" +
" \n" +
" write(58,*)\n" +
" write(58,*) 'Software to generate multicorrelated wind time' \n" +
" write(58,*) 'histories of u,v,w wind components in x,y,z '\n" +
" write(58,*) 'directions ' \n" +
" write(58,*)\n" +
" write(58,*) 'Open files'\n" +
" write(58,*)\n" +
" \n" +
" \n" +
" \n" +
"!xxxxxxxx used for debugging xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n" +
"! Temporre out files to check the direct access routines \n" +
"! open(unit=8,file='u_out_temp.dat')\n" +
"! open(unit=9,file='v_out_temp.dat')\n" +
"! open(unit=10,file='w_out_temp.dat') \n" +
"\n" +
"! Temporary output files to check quality \n" +
"! open(unit=14,file='checkdaccess.dat')\n" +
"! open(unit=20,file='bug.dat')\n" +
"! open(unit=21,file='input.dat')\n" +
"! open(unit=22,file='ifft.dat') \n" +
"! rewind(8)\n" +
"! rewind(9)\n" +
"! rewind(10)\n" +
"! rewind(20)\n" +
"! rewind(21)\n" +
"! rewind(22)\n" +
"! rewind(14)\n" +
"!xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n" +
" \n" +
"! FOURIER NORM \n" +
" nn(1) = N1\n" +
" nn(2) = N2\n" +
" nn(3) = N3\n" +
"\n" +
" write(*,*) 'Read input values...'\n" +
" write(*,*)\n" +
" write(58,*) 'Read input values...'\n" +
" write(58,*)\n" +
" \n" +
"! INPUT VALUES\n" +
"! - Length of domain\n" +
"{2}\n" +
" umeanz = {3}\n" +
"! - grid size \n" +
" d1 = L1/N1\n" +
" d2 = L2/N2\n" +
" d3 = L3/N3\n" +
"! - gridpoints \n" +
"! nth = N1 * N2 * N3\n" +
" nth = N1I8 * N2I8 * N3I8\n" +
"! - wavelenth interval\n" +
" dk1 = 6.2831853/ L1\n" +
" dk2 = 6.2831853/ L2\n" +
" dk3 = 6.2831853/ L3 \n" +
"! - spatial grid resolution \n" +
" delta = d1*d2*d3 \n" +
"! - Mean wind profile\n" +
"! EC\n" +
" alfa = {4}\n" +
" uref = {5}d0*{6}\n" +
" zref = {7}.d0\n" +
"! SBC\n" +
"! ubasic = 105.0\n" +
"! aquer = 0.25\n" +
"! bquer = 0.45\n" +
"\n" +
"! - Coupling routine \n" +
"! ivalue = 0: read fluctuations, ivalue=1: read mean + fluctuation \n" +
" ivalue = 1\n" +
"! iflag = 0: linear interpolation in time, \n" +
"! 1: bicubic spline interpolation in time \n" +
" iflag = 0 \n" +
"\n" +
"! - OpenFOAM output files\n" +
"! iout = 1: OpenFOAM output additionally \n" +
" iout = 1 \n" +
"! mean wind input file for OpenFOAM\n" +
"! imeanwind = 1 --> write meanwind file\n" +
" imeanwind = 0\n" +
"{8}\n" +
"\n" +
"! MEANWIND inflow file \n" +
" if (imeanwind.eq.1) then \n" +
" write(*,*)\n" +
" write(*,*) 'Write MEANWIND inflow for OpenFOAM'\n" +
" write(*,*)\n" +
" write(58,*)\n" +
" write(58,*) 'Write MEANWIND inflow for OpenFOAM'\n" +
" write(58,*) \n" +
" open(unit=88,file='points',status='unknown')\n" +
" open(unit=99,file='U',status='unknown')\n" +
" call meanwind(N1,N2out,N3out,d1,d2,d3,nn,uref,zref,alfa, \n" +
" & xinlet,yinlet,zinlet)\n" +
" write(*,*) '...DONE'\n" +
" write(*,*) \n" +
" write(58,*) '...DONE'\n" +
" write(58,*)\n" +
" close(88)\n" +
" close(99)\n" +
" goto 122\n" +
" endif\n" +
" \n" +
"! - Turbulence parameters \n" +
" ustar = 1.57d0\n" +
" \n" +
"! - Spectral energy fit to KAIMAL Spectrum (J. Mann) \n" +
" z = {9}\n" +
" L = 0.59*z\n" +
" fak = 3.2 * (ustar**2.d0)/(z**0.6666)*(L**1.6666)\n" +
" fscale = 2.0\n" +
"! (scale total isotropic variance of wind field with fscaleý)\n" +
"! - Spectral tensor parameters (J.Mann 1998)\n" +
"! - Non-dimensional shear distortion parameter\n" +
"! gamma = 0 --> isotropic model \n" +
" gam = 3.9\n\r";
#endregion
string turbFile = string.Format(shellString, Nstring, NoutString, Lstring, uMean.ToString(), iAlpha.ToString(), ivRef.ToString(), iFactor.ToString(), izRef.ToString(), inletCoordsString, iZRefBeonspek.ToString()) + "\n" + StaticTextFiles.Get3c3dFile();
var o3c3dFile = new TextFile(turbFile, "3c3d_FOURN_structured.f");
string oInfo = "Wind field duration = " + (Math.Ceiling(N1 * iTimeSpacing / uMean / 60 * 100) / 100).ToString() + "min";
List <double> oUProfile = new List <double>();
oUProfile = uList;
List <double> oTurbIntensity = new List <double>();
oTurbIntensity = turbIntensity;
DA.SetData(0, oInfo);
DA.SetData(1, oInlet);
DA.SetDataList(2, zList);
DA.SetDataList(3, oUProfile);
DA.SetDataList(4, oTurbIntensity);
DA.SetData(5, o3c3dFile);
}
public override bool Construct(bool append = false)
{
if (!append)
{
foreach (var part in Parts)
{
part.Geometry.Clear();
}
}
var tbeam = (Tenon.Element as BeamElement).Beam;
var mbeam = (Mortise.Element as BeamElement).Beam;
var tplane = tbeam.GetPlane(Tenon.Parameter);
var mplane = mbeam.GetPlane(Mortise.Parameter);
Transform xform = Transform.PlaneToPlane(Plane.WorldXY, tplane);
// Align plane directions
int sign = 1;
var tz = Math.Abs(Tenon.Parameter - tbeam.Centreline.Domain.Min) >
Math.Abs(Tenon.Parameter - tbeam.Centreline.Domain.Max) ?
tplane.ZAxis : -tplane.ZAxis;
Plane mSidePlane = Plane.Unset;
sign = mplane.XAxis * tz > 0 ? -1 : 1;
mSidePlane = new Plane(mplane.Origin + mplane.XAxis * mbeam.Width * 0.5 * sign,
mplane.ZAxis, mplane.YAxis);
var mSidePlane2 = new Plane(mplane.Origin - mplane.XAxis * mbeam.Width * 0.5 * sign,
mplane.ZAxis, mplane.YAxis);
// Create tenon cutting geometry
double added = 10.0;
{
var proj0 = mSidePlane.ProjectAlongVector(tz);
var proj1 = mSidePlane2.ProjectAlongVector(tz);
var pt0 = new Point3d(-tbeam.Width * 0.5 - added, 0, 0);
var pt1 = new Point3d(tbeam.Width * 0.5 + added, 0, 0);
pt0.Transform(xform);
pt1.Transform(xform);
var pt2 = pt0 + tz * (mbeam.Width + added);
var pt3 = pt1 + tz * (mbeam.Width + added);
// Create projection along Tenon Z-axis onto the Mortise side plane
pt0.Transform(proj0);
pt1.Transform(proj0);
var tsrf0 = Brep.CreateFromCornerPoints(pt0, pt1, pt2, pt3, 0.001);
var pt4 = pt0 + tplane.YAxis * (tbeam.Height * 0.5 + added);
var pt5 = pt1 + tplane.YAxis * (tbeam.Height * 0.5 + added);
pt4.Transform(proj0);
pt5.Transform(proj0);
var tsrf1 = Brep.CreateFromCornerPoints(pt0, pt1, pt5, pt4, 0.001);
var joined = Brep.JoinBreps(new Brep[] { tsrf0, tsrf1 }, 0.01);
if (joined == null)
{
joined = new Brep[] { tsrf0, tsrf1 }
}
;
Tenon.Geometry.AddRange(joined);
// Create trim cut surface
var pt6 = new Point3d(-tbeam.Width * 0.5 - added, -tbeam.Height * 0.5 - added, 0);
var pt7 = new Point3d(tbeam.Width * 0.5 + added, -tbeam.Height * 0.5 - added, 0);
var pt8 = new Point3d(-tbeam.Width * 0.5 + added, tbeam.Height * 0.5 + added, 0);
var pt9 = new Point3d(tbeam.Width * 0.5 - added, tbeam.Height * 0.5 + added, 0);
pt6.Transform(xform);
pt7.Transform(xform);
pt8.Transform(xform);
pt9.Transform(xform);
pt6.Transform(proj1);
pt7.Transform(proj1);
pt8.Transform(proj1);
pt9.Transform(proj1);
var tsrf2 = Brep.CreateFromCornerPoints(pt6, pt7, pt8, pt9, 0.001);
Tenon.Geometry.Add(tsrf2);
}
// Create mortise cutting geometry
{
var pt0 = new Point3d(-tbeam.Width * 0.5, 0, (mbeam.Width * 0.5 + added) * -sign);
var pt1 = new Point3d(tbeam.Width * 0.5, 0, (mbeam.Width * 0.5 + added) * -sign);
pt0.Transform(xform);
pt1.Transform(xform);
var mSidePlane0 = new Plane(mplane.Origin + mplane.XAxis * mbeam.Width * 0.5 * sign - tz * added,
mplane.ZAxis, mplane.YAxis);
var mSidePlane1 = new Plane(mplane.Origin - mplane.XAxis * mbeam.Width * 0.5 * sign + tz * added,
mplane.ZAxis, mplane.YAxis);
var proj0 = mSidePlane0.ProjectAlongVector(tz);
var proj1 = mSidePlane1.ProjectAlongVector(tz);
pt0.Transform(proj0);
pt1.Transform(proj0);
var pt2 = pt0; pt2.Transform(proj1);
var pt3 = pt1; pt3.Transform(proj1);
var msrf0 = Brep.CreateFromCornerPoints(pt0, pt1, pt3, pt2, 0.001);
var pt4 = pt0 - tplane.YAxis * tbeam.Height;
var pt5 = pt2 - tplane.YAxis * tbeam.Height;
pt4.Transform(proj0);
pt5.Transform(proj1);
var msrf1 = Brep.CreateFromCornerPoints(pt0, pt2, pt5, pt4, 0.001);
var pt6 = pt1 - tplane.YAxis * tbeam.Height;
var pt7 = pt3 - tplane.YAxis * tbeam.Height;
pt6.Transform(proj0);
pt7.Transform(proj1);
var msrf2 = Brep.CreateFromCornerPoints(pt1, pt3, pt7, pt6, 0.001);
var joined = Brep.JoinBreps(new Brep[] { msrf0, msrf1, msrf2 }, 0.01);
if (joined == null)
{
joined = new Brep[] { msrf0, msrf1, msrf2 }
}
;
Mortise.Geometry.AddRange(joined);
}
return(true);
}
}
}
protected override void SolveInstance(IGH_DataAccess DA)
{
ETABS2013.cOAPI ETABS = null;
if (!DA.GetData(0, ref ETABS))
{
return;
}
//Gets the ETABS geometry
int numberNames = 0;
string [] shellList = null;
ETABS.SapModel.AreaObj.GetNameList(ref numberNames, ref shellList);
//if there are selcted objects only export these
List <string> selectedShellsList = new List <string>();
bool selected = false;
for (int i = 0; i < shellList.Count(); i++)
{
ETABS.SapModel.AreaObj.GetSelected(shellList[i], ref selected);
if (selected)
{
selectedShellsList.Add(shellList[i]);
}
}
//if no objects are selected export all
if (selectedShellsList.Count == null)
{
selectedShellsList.AddRange(shellList);
}
List <Brep> outBreps = new List <Brep>();
List <int> IDs = new List <int>();
for (int i = 0; i < selectedShellsList.Count(); i++)
{
int numberPoints = 0;
string [] points = null;
ETABS.SapModel.AreaObj.GetPoints(selectedShellsList[i], ref numberPoints, ref points);
//Creates the Rhino Geometry
List <Point3d> cornerPoints = new List <Point3d>();
Point3d cornerPoint;
foreach (string point in points)
{
double x = 0;
double y = 0;
double z = 0;
ETABS.SapModel.PointObj.GetCoordCartesian(point, ref x, ref y, ref z);
cornerPoint = new Point3d(x, y, z);
cornerPoints.Add(cornerPoint);
}
Brep outBrep;
if (cornerPoints.Count == 3)
{
outBrep = Brep.CreateFromCornerPoints(cornerPoints[0], cornerPoints[1], cornerPoints[2], 0.01);
outBreps.Add(outBrep);
}
else if (cornerPoints.Count == 4)
{
outBrep = Brep.CreateFromCornerPoints(cornerPoints[0], cornerPoints[1], cornerPoints[2], cornerPoints[3], 0.01);
outBreps.Add(outBrep);
}
else
{
//TODO: Deal with area objects with more than 4 corner points
//For now add null items so lists match up
outBrep = null;
outBreps.Add(null);
}
int ID = Convert.ToInt32(shellList[i]);
IDs.Add(ID);
}
DA.SetDataList(0, IDs);
DA.SetDataList(1, outBreps);
}
