/// <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)
{
HM.hMember member = null;
List <Point3d> points = new List <Point3d>();
List <string> types = new List <string>();
if (!DA.GetData(0, ref member))
{
return;
}
if (!DA.GetDataList(1, points))
{
return;
}
if (!DA.GetDataList(2, types))
{
return;
}
if (points.Count != types.Count)
{
return;
}
var newMember = new HM.hMember(member);
for (int i = 0; i < points.Count; i++)
{
newMember.AddOperationByPointType(HMGHUtil.PointToTriple(points[i]), types[i]);
}
DA.SetData(0, newMember);
}
/// <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)
{
// Get names
var names = new List <string>();
if (!DA.GetDataList(0, names))
{
return;
}
// Get normals
var vectors = new List <Vector3d>();
if (!DA.GetDataList(1, vectors))
{
return;
}
// There should be the same number of names and normals
if (names.Count != vectors.Count)
{
return;
}
// Create dictionary
var dictionary = new Dictionary <string, HM.Triple>();
for (int i = 0; i < names.Count; i++)
{
dictionary[names[i]] = HMGHUtil.VectorToTriple(vectors[i]);
}
DA.SetData(0, dictionary);
}
/// <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)
{
// 1. Declare placeholder variables and assign initial invalid data.
// This way, if the input parameters fail to supply valid data, we know when to abort.
HM.hMember member = null;
// 2. Retrieve input data.
if (!DA.GetData(0, ref member))
{
return;
}
var webNormal = member.WebNormal;
DA.SetData(0, HMGHUtil.TripleToVector(webNormal));
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object can be used to retrieve data from input parameters and
/// to store data in output parameters.</param>
protected override void SolveInstance(IGH_DataAccess DA)
{
// 1. Declare placeholder variables and assign initial invalid data.
// This way, if the input parameters fail to supply valid data, we know when to abort.
Line line = Line.Unset;
Vector3d vector = Vector3d.Unset;
string name = string.Empty;
// 2. Retrieve input data.
if (!DA.GetData(0, ref line))
{
return;
}
if (!DA.GetData(1, ref vector))
{
return;
}
if (!DA.GetData(2, ref name))
{
name = "<name>";
}
// 3. Abort on invalid inputs.
if (!line.IsValid)
{
return;
}
if (!vector.IsValid)
{
return;
}
// 4. Build hMember.
var mem = new HM.hMember(HMGHUtil.GHLineToHMLine(line), HMGHUtil.VectorToTriple(vector));
mem.Name = name;
// 9. Assign output.
DA.SetData(0, mem);
}
/// <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)
{
// Declare placeholder variables and assign initial invalid data.
List <Line> inputLines = new List <Line>();
List <string> names = new List <string>();
bool firstConnectionIsFTF = false;
Dictionary <string, HM.Triple> webNormalsDictionary = null;
Dictionary <string, int> prioritiesDictionary = null;
Dictionary <string, int> extensionDictionary = null;
double tolerance = 0.001;
// Retrieve input data.
if (!DA.GetDataList(0, inputLines))
{
return;
}
if (!DA.GetDataList(1, names))
{
names = null;
}
if (!DA.GetData(2, ref firstConnectionIsFTF))
{
firstConnectionIsFTF = false;
}
if (!DA.GetData(3, ref webNormalsDictionary))
{
webNormalsDictionary = null;
}
if (!DA.GetData(4, ref prioritiesDictionary))
{
prioritiesDictionary = null;
}
if (!DA.GetData(5, ref extensionDictionary))
{
extensionDictionary = null;
}
if (!DA.GetData(6, ref tolerance))
{
tolerance = 0.001;
}
if (names == null)
{
names = new List <string>();
for (int j = 0; j < inputLines.Count; j++)
{
names.Add(j.ToString());
}
}
if (names.Count < inputLines.Count)
{
throw new Exception("You must provide a name for every member.");
}
// Convert GH lines to HM lines
var HMLines = new List <HM.Line>();
var i = 0;
foreach (Line l in inputLines)
{
HMLines.Add(HMGHUtil.GHLineToHMLine(l));
}
// Create Structure
var structure = HM.hStructure.StructureFromLines(
HMLines,
names,
webNormalsDict: webNormalsDictionary,
priorityDict: prioritiesDictionary,
extensionDict: extensionDictionary,
firstConnectionIsFTF: firstConnectionIsFTF,
intersectionTolerance: tolerance,
planarityTolerance: tolerance);
DA.SetDataList(0, structure.Members);
DA.SetDataList(1, structure._solveOrder);
DA.SetDataList(2, structure._solvedBy);
}
/// <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)
{
// 1. Declare placeholder variables and assign initial invalid data.
// This way, if the input parameters fail to supply valid data, we know when to abort.
HM.hMember member = null;
// 2. Retrieve input data.
if (!DA.GetData(0, ref member))
{
return;
}
// 3. Abort on invalid inputs.
//if (!member.IsValid) { return; }
var webAxisLine = member.WebAxis;
var webNormal = member.WebNormal;
var OP1 = webAxisLine.StartPoint;
var OP2 = webAxisLine.EndPoint;
var webAxis = HM.Triple.ByTwoPoints(OP1, OP2);
var normal = webNormal;
var lateral = webAxis.Cross(normal);
lateral = lateral.Normalized();
lateral = lateral.Scale(1.75);
normal = normal.Normalized();
normal = normal.Scale(1.5);
var lateralR = new HM.Triple(lateral.X * -1, lateral.Y * -1, lateral.Z * -1);
var webAxisR = new HM.Triple(webAxis.X * -1, webAxis.Y * -1, webAxis.Z * -1);
var normalR = new HM.Triple(normal.X * -1, normal.Y * -1, normal.Z * -1);
var p0 = HMGHUtil.TripleToPoint(OP1.Add(normal.Add(lateral)));
var p1 = HMGHUtil.TripleToPoint(OP2.Add(normal.Add(lateral)));
var p2 = HMGHUtil.TripleToPoint(OP1.Add(lateral));
var p3 = HMGHUtil.TripleToPoint(OP2.Add(lateral));
var p6 = HMGHUtil.TripleToPoint(OP1.Add(normal.Add(lateralR)));
var p7 = HMGHUtil.TripleToPoint(OP2.Add(normal.Add(lateralR)));
var p4 = HMGHUtil.TripleToPoint(OP1.Add(lateralR));
var p5 = HMGHUtil.TripleToPoint(OP2.Add(lateralR));
lateral = lateral.Normalized().Scale(1.25);
lateralR = lateralR.Normalized().Scale(1.25);
var p8 = HMGHUtil.TripleToPoint(OP1.Add(lateralR).Add(normal));
var p9 = HMGHUtil.TripleToPoint(OP2.Add(lateralR).Add(normal));
var p10 = HMGHUtil.TripleToPoint(OP1.Add(lateral).Add(normal));
var p11 = HMGHUtil.TripleToPoint(OP2.Add(lateral).Add(normal));
var flange1 = NurbsSurface.CreateFromCorners(p0, p1, p3, p2);
var flange2 = NurbsSurface.CreateFromCorners(p4, p5, p7, p6);
var web = NurbsSurface.CreateFromCorners(p2, p3, p5, p4);
var lip1 = NurbsSurface.CreateFromCorners(p0, p1, p11, p10);
var lip2 = NurbsSurface.CreateFromCorners(p6, p7, p9, p8);
var memGeo = new List <Brep>()
{
Brep.CreateFromSurface(flange1), Brep.CreateFromSurface(flange2), Brep.CreateFromSurface(web), Brep.CreateFromSurface(lip1), Brep.CreateFromSurface(lip2)
};
var brep = Brep.JoinBreps(memGeo, 0.001)[0];
DA.SetData(0, brep);
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param>
protected override void SolveInstance(IGH_DataAccess DA)
{
// Get member from input
HM.hMember member = null;
if (!DA.GetData(0, ref member))
{
return;
}
// Get member properties as Rhino Geometry
var webAxisLine = HMGHUtil.HMLineToGHLine(member.WebAxis);
var webAxisDirection = HMGHUtil.TripleToVector(member.WebAxis.Direction.Normalized());
var webNormal = HMGHUtil.TripleToVector(member.WebNormal.Normalized());
var flangeNormal = HMGHUtil.TripleToVector(member.WebNormal.Cross(member.WebAxis.Direction).Normalized());
// Get operations as curves
var opCurves = new List <Curve>();
foreach (HM.hOperation op in member.Operations)
{
// Get centerpoints
var centerTriples = member.GetOperationPunchCenterPoint(op);
var centerPoints = new List <Point3d>();
foreach (HM.Triple t in centerTriples)
{
centerPoints.Add(HMGHUtil.TripleToPoint(t));
}
switch (op._type)
{
case HM.Operation.BOLT:
opCurves.Add(new Circle(new Plane(centerPoints[0], webNormal), 0.25).ToNurbsCurve());
break;
case HM.Operation.SERVICE_HOLE:
opCurves.Add(new Circle(new Plane(centerPoints[0], webNormal), 0.5).ToNurbsCurve());
break;
case HM.Operation.WEB:
foreach (Point3d p in centerPoints)
{
opCurves.Add(new Circle(new Plane(p, webNormal), 0.0625).ToNurbsCurve());
}
break;
case HM.Operation.DIMPLE:
foreach (Point3d p in centerPoints)
{
opCurves.Add(new Circle(new Plane(p, flangeNormal), 0.0625).ToNurbsCurve());
}
break;
case HM.Operation.NOTCH:
opCurves.Add(new Rectangle3d(new Plane(centerPoints[0], flangeNormal, webAxisDirection), new Interval(-1.75, 1.75), new Interval(-1.75 / 2, 1.75 / 2)).ToNurbsCurve());
break;
case HM.Operation.END_TRUSS:
var midPoint = member.WebAxis.PointAtParameter(0.5);
var endPoint = member.WebAxis.PointAtParameter(member.WebAxis.ParameterAtPoint(centerTriples[0]));
var endTrussDirection = HMGHUtil.TripleToVector(HM.Triple.ByTwoPoints(endPoint, midPoint).Normalized());
foreach (Point3d p in centerPoints)
{
var p1 = Point3d.Add(p, Vector3d.Multiply(0.25, webNormal));
var p2 = Point3d.Add(p, Vector3d.Multiply(0.75, webNormal));
var p3 = Point3d.Add(p2, Vector3d.Multiply(0.5, endTrussDirection));
opCurves.Add(new Polyline(new List <Point3d> {
p1, p2, p3, p1
}).ToNurbsCurve());
var p4 = Point3d.Add(p, Vector3d.Multiply(-0.25, webNormal));
var p5 = Point3d.Add(p, Vector3d.Multiply(-0.75, webNormal));
var p6 = Point3d.Add(p5, Vector3d.Multiply(0.5, endTrussDirection));
opCurves.Add(new Polyline(new List <Point3d> {
p4, p5, p6, p4
}).ToNurbsCurve());
}
break;
case HM.Operation.LIP_CUT:
foreach (Point3d p in centerPoints)
{
opCurves.Add(new Rectangle3d(new Plane(p, flangeNormal, webAxisDirection), new Interval(-0.25, 0.25), new Interval(-1.75 / 2, 1.75 / 2)).ToNurbsCurve());
}
break;
case HM.Operation.SWAGE:
var left = Vector3d.Multiply(1.25, flangeNormal);
var right = Vector3d.Multiply(-1.25, flangeNormal);
var up = Vector3d.Multiply(0.875, webAxisDirection);
var down = Vector3d.Multiply(-0.875, webAxisDirection);
var pt1 = Point3d.Add(Point3d.Add(centerPoints[0], left), up);
var pt2 = Point3d.Add(Point3d.Add(centerPoints[0], left), down);
var pt3 = Point3d.Add(Point3d.Add(centerPoints[0], right), up);
var pt4 = Point3d.Add(Point3d.Add(centerPoints[0], right), down);
opCurves.Add(new Line(pt1, pt2).ToNurbsCurve());
opCurves.Add(new Line(pt3, pt4).ToNurbsCurve());
break;
}
}
DA.SetDataList(0, opCurves);
}
