/***************************************************/
public static BHG.Cylinder FromRhino(this RHG.Cylinder cylinder)
{
BHG.Point centre = cylinder.Center.FromRhino() + cylinder.Axis.FromRhino() * cylinder.Height1;
return(new BHG.Cylinder {
Centre = centre, Axis = cylinder.Axis.FromRhino(), Height = cylinder.TotalHeight, Radius = cylinder.CircleAt(0.0).Radius
});
}
public List <Brep> ComputeAnchorGeometry()
{
Vector3d NormNormalVec = NormalVec / NormalVec.Length;
Point3d A = Origin + NormNormalVec * Height1 / 2;
Point3d B = Origin - NormNormalVec * Height1 / 2;
Point3d C = Origin - NormNormalVec * (Height1 / 2 + Height2);
List <Brep> displayGeometry = new List <Brep>();
Rhino.Geometry.Plane planea = new Rhino.Geometry.Plane(A, NormNormalVec);
Rhino.Geometry.Plane planeb = new Rhino.Geometry.Plane(B, NormNormalVec);
Rhino.Geometry.Plane planec = new Rhino.Geometry.Plane(C, NormNormalVec);
Rhino.Geometry.Circle circlea = new Rhino.Geometry.Circle(planea, Radius2);
Rhino.Geometry.Circle circleb = new Rhino.Geometry.Circle(planeb, Radius1);
Rhino.Geometry.Circle circlec = new Rhino.Geometry.Circle(planec, Radius2);
Rhino.Geometry.Cylinder cylindera = new Rhino.Geometry.Cylinder(circlea, Height2);
Rhino.Geometry.Brep brepa = cylindera.ToBrep(true, true);
displayGeometry.Add(brepa);
Rhino.Geometry.Cylinder cylinderb = new Rhino.Geometry.Cylinder(circleb, Height1);
Rhino.Geometry.Brep brepb = cylinderb.ToBrep(true, true);
displayGeometry.Add(brepb);
Rhino.Geometry.Cylinder cylinderc = new Rhino.Geometry.Cylinder(circlec, Height2);
Rhino.Geometry.Brep brepc = cylinderc.ToBrep(true, true);
displayGeometry.Add(brepc);
return(displayGeometry);
}
static NurbsSurface ToRhinoCylindricalSurface(NXOpen.Face face, FaceEx.FaceData faceData)
{
NXOpen.Point3d top; // 圆柱顶点
double radius; // 圆柱半径
NXOpen.Point3d bottom; // 圆柱底面中心点
var faceBoundingBox = face.GetAlignedBoundingBox(faceData.Direction);
double totalHeight = faceBoundingBox.Height; // 圆柱总高度
if (face.GetEdges().Length == 2 && face.GetEdges().All(obj => obj.SolidEdgeType == NXOpen.Edge.EdgeType.Circular))
{
// 未修剪的圆柱
TheUfSession.Eval.Initialize2(face.GetEdges()[0].Tag, out var edgeEvaluator);
TheUfSession.Eval.AskArc(edgeEvaluator, out var arc1);
TheUfSession.Eval.Free(edgeEvaluator);
TheUfSession.Eval.Initialize2(face.GetEdges()[1].Tag, out edgeEvaluator);
TheUfSession.Eval.AskArc(edgeEvaluator, out var arc2);
TheUfSession.Eval.Free(edgeEvaluator);
if (arc2.center.ToPoint3d().Subtract(arc1.center.ToPoint3d()).GetUnitVector().EqualsTo(faceData.Direction.GetUnitVector()))
{
bottom = arc1.center.ToPoint3d();
}
else
{
bottom = arc2.center.ToPoint3d();
}
top = bottom.Move(faceBoundingBox.HeightDirection, totalHeight);
radius = arc1.radius;
}
else
{
var topExtremePt = WorkPart.MeasureManager.MeasureRectangularExtreme(face, faceBoundingBox.HeightDirection, faceBoundingBox.LengthDirection, faceBoundingBox.WidthDirection);
var distToFacePoint = topExtremePt.DistanceTo(faceData.Point, faceData.Direction);
top = faceData.Point.Move(faceBoundingBox.HeightDirection, distToFacePoint);
bottom = top.Move(faceBoundingBox.HeightDirection.Reverse(), totalHeight);
radius = faceData.Radius;
}
Circle baseCircle = new Circle(new Plane(bottom.ToRhino(), faceBoundingBox.HeightDirection.ToRhino()), radius);
var cyl = new Rhino.Geometry.Cylinder(baseCircle, totalHeight);
return(cyl.ToNurbsSurface());
}
public static Rhino.Commands.Result AddCylinder(Rhino.RhinoDoc doc)
{
Rhino.Geometry.Point3d center_point = new Rhino.Geometry.Point3d(0, 0, 0);
Rhino.Geometry.Point3d height_point = new Rhino.Geometry.Point3d(0, 0, 10);
Rhino.Geometry.Vector3d zaxis = height_point - center_point;
Rhino.Geometry.Plane plane = new Rhino.Geometry.Plane(center_point, zaxis);
double radius = 5;
Rhino.Geometry.Circle circle = new Rhino.Geometry.Circle(plane, radius);
Rhino.Geometry.Cylinder cylinder = new Rhino.Geometry.Cylinder(circle, zaxis.Length);
Rhino.Geometry.Brep brep = cylinder.ToBrep(true, true);
if (brep != null)
{
doc.Objects.AddBrep(brep);
doc.Views.Redraw();
}
return Rhino.Commands.Result.Success;
}
/// <summary>
/// Draw a wireframe cylinder.
/// </summary>
/// <param name="cylinder">Cylinder to draw.</param>
/// <param name="color">Color to draw with.</param>
/// <param name="thickness">Thickness (in pixels) of cylinder wires.</param>
public void DrawCylinder(Cylinder cylinder, System.Drawing.Color color, int thickness)
{
int argb = color.ToArgb();
UnsafeNativeMethods.CRhinoDisplayPipeline_DrawCylinder(m_ptr, ref cylinder, argb, thickness);
}
/// <summary>
/// Gets an extrusion form of a pipe.
/// </summary>
/// <param name="cylinder">IsFinite must be true.</param>
/// <param name="otherRadius">
/// If cylinder.Radius is less than other radius, then the cylinder will be the inside
/// of the pipe.
/// </param>
/// <param name="capBottom">If true, the end at cylinder.Height1 will be capped.</param>
/// <param name="capTop">If true, the end at cylinder.Height2 will be capped.</param>
/// <returns>Extrusion on success. null on failure.</returns>
public static Extrusion CreatePipeExtrusion(Cylinder cylinder, double otherRadius, bool capTop, bool capBottom)
{
IntPtr pExtrusion = UnsafeNativeMethods.ON_Extrusion_CreatePipe(ref cylinder, otherRadius, capBottom, capTop);
return IntPtr.Zero == pExtrusion ? null : new Extrusion(pExtrusion, null);
}
/// <summary>
/// Gets an extrusion form of a cylinder.
/// </summary>
/// <param name="cylinder">IsFinite must be true.</param>
/// <param name="capBottom">If true, the end at cylinder.Height1 will be capped.</param>
/// <param name="capTop">If true, the end at cylinder.Height2 will be capped.</param>
/// <returns>Extrusion on success. null on failure.</returns>
public static Extrusion CreateCylinderExtrusion(Cylinder cylinder, bool capBottom, bool capTop)
{
IntPtr pExtrusion = UnsafeNativeMethods.ON_Extrusion_CreateCylinder(ref cylinder, capBottom, capTop);
return IntPtr.Zero == pExtrusion ? null : new Extrusion(pExtrusion, null);
}
/// <summary>Constrains the picked point to lie on a cylinder.</summary>
/// <param name="cylinder">A cylinder to use as constraint.</param>
/// <returns>true if constraint could be applied.</returns>
public bool Constrain(Cylinder cylinder)
{
IntPtr ptr = NonConstPointer();
return UnsafeNativeMethods.CRhinoGetPoint_Constrain6(ptr, ref cylinder);
}
/// <summary>Create a cylindrical projection texture mapping.</summary>
/// <param name="cylinder">
/// cylinder in world space used to define a cylindrical coordinate system.
/// The angular parameter maps (0,2pi) to texture "u" (0,1), The height
/// parameter maps (height[0],height[1]) to texture "v" (0,1), and the
/// radial parameter maps (0,r) to texture "w" (0,1).
/// </param>
/// <param name="capped">
/// If true, the cylinder is treated as a finite capped cylinder
/// </param>
/// <remarks>
/// When the cylinder is capped and m_texture_space = divided, the
/// cylinder is mapped to texture space as follows:
/// The side is mapped to 0 <= "u" <= 2/3.
/// The bottom is mapped to 2/3 <= "u" <= 5/6.
/// The top is mapped to 5/6 <= "u" <= 5/6.
/// This is the same convention box mapping uses.
/// </remarks>
/// <returns>TextureMapping instance if input is valid</returns>
public static TextureMapping CreateCylinderMapping(Cylinder cylinder, bool capped)
{
TextureMapping rc = new TextureMapping();
IntPtr pMapping = rc.NonConstPointer();
if (!UnsafeNativeMethods.ON_TextureMapping_SetCylinderMapping(pMapping, ref cylinder, capped))
{
rc.Dispose();
rc = null;
}
return rc;
}
/// <summary>Tests a surface to see if it is a portion of a cylinder within RhinoMath.ZeroTolerance and return the cylinder.</summary>
/// <param name="cylinder">On success, the cylinder parameters are filled in.</param>
/// <returns>true if the surface is a portion of a cylinder.</returns>
public bool TryGetCylinder(out Cylinder cylinder)
{
return TryGetCylinder(out cylinder, RhinoMath.ZeroTolerance);
}
/// <summary>
/// Gets an extrusion form of a pipe.
/// </summary>
/// <param name="cylinder">IsFinite must be true.</param>
/// <param name="otherRadius">
/// If cylinder.Radius is less than other radius, then the cylinder will be the inside
/// of the pipe.
/// </param>
/// <param name="capBottom">If true, the end at cylinder.Height1 will be capped.</param>
/// <param name="capTop">If true, the end at cylinder.Height2 will be capped.</param>
/// <returns>Extrusion on success. null on failure.</returns>
public static Extrusion CreatePipeExtrusion(Cylinder cylinder, double otherRadius, bool capTop, bool capBottom)
{
IntPtr ptr_new_extrusion = UnsafeNativeMethods.ON_Extrusion_CreatePipe(ref cylinder, otherRadius, capBottom, capTop);
return(IntPtr.Zero == ptr_new_extrusion ? null : new Extrusion(ptr_new_extrusion, null));
}
protected override void SolveInstance(IGH_DataAccess DA)
{
//declare and set primary variables
List<Curve> L = new List<Curve>();
int S = 0;
List<double> Rs = new List<double>();
List<double> Re = new List<double>();
double D = 0;
double ND = 0;
bool O = false;
if (!DA.GetDataList(0, L)) { return; }
if (!DA.GetData(1, ref S)) { return; }
if (!DA.GetDataList(2, Rs)) { return; }
if (!DA.GetDataList(3, Re)) { return; }
if (!DA.GetData(4, ref ND)) { return; }
if (!DA.GetData(5, ref D)) { return; }
if (!DA.GetData(6, ref O)) { return; }
if (L == null || L.Count == 0) { return; }
if (S < 3) { return; }
if (Rs == null || Rs.Count == 0 || Rs.Contains(0)) { return; }
if (Re == null || Re.Count == 0 || Rs.Contains(0)) { return; }
if (D == 0) { return; }
//declare node and strut lists and reference lookups
double Sides = (double)S;
List<Point3d> Nodes = new List<Point3d>();
List<List<int>> NodeStruts = new List<List<int>>();
List<Curve> Struts = new List<Curve>();
List<int> StrutNodes = new List<int>();
List<double> StrutRadii = new List<double>();
double tol = RhinoDoc.ActiveDoc.ModelAbsoluteTolerance;
//set the index counter for matching start and end radii from input list
int IdxL = 0;
//register unique nodes and struts, with reference lookups
//each full strut is broken into two half-struts, with the even-indexed
//element being the start point, and the odd-indexed element being the end point
//initialise first node
Nodes.Add(L[0].PointAtStart);
NodeStruts.Add(new List<int>());
Rhino.Collections.Point3dList NodeLookup = new Rhino.Collections.Point3dList(Nodes);
foreach (Curve StartL in L)
{
double StrutStartRadius = 0;
if (Rs.Count - 1 > IdxL) StrutStartRadius = Rs[IdxL];
else StrutStartRadius = Rs.Last();
double StrutEndRadius = 0;
if (Re.Count - 1 > IdxL) StrutEndRadius = Re[IdxL];
else StrutEndRadius = Re.Last();
Point3d StrutCenter = new Point3d((StartL.PointAtStart + StartL.PointAtEnd) / 2);
int StartTestIdx = NodeLookup.ClosestIndex(StartL.PointAtStart);
if (Nodes[StartTestIdx].DistanceTo(StartL.PointAtStart) < tol)
{
NodeStruts[StartTestIdx].Add(Struts.Count);
StrutNodes.Add(StartTestIdx);
}
else
{
StrutNodes.Add(Nodes.Count);
Nodes.Add(StartL.PointAtStart);
NodeLookup.Add(StartL.PointAtStart);
NodeStruts.Add(new List<int>());
NodeStruts.Last().Add(Struts.Count());
}
Struts.Add(new LineCurve(StartL.PointAtStart, StrutCenter));
StrutRadii.Add(StrutStartRadius);
int EndTestIdx = NodeLookup.ClosestIndex(StartL.PointAtEnd);
if (Nodes[EndTestIdx].DistanceTo(StartL.PointAtEnd) < tol)
{
NodeStruts[EndTestIdx].Add(Struts.Count);
StrutNodes.Add(EndTestIdx);
}
else
{
StrutNodes.Add(Nodes.Count);
Nodes.Add(StartL.PointAtEnd);
NodeLookup.Add(StartL.PointAtEnd);
NodeStruts.Add(new List<int>());
NodeStruts.Last().Add(Struts.Count);
}
Struts.Add(new LineCurve(StartL.PointAtEnd, StrutCenter));
StrutRadii.Add(StrutEndRadius);
IdxL += 1;
}
Plane[] StrutPlanes = new Plane[Struts.Count]; //base plane for each strut
double[] PlaneOffsets = new double[Struts.Count]; //distance for each base plane to be set from node
Point3d[,] StrutHullVtc = new Point3d[Struts.Count, S]; //two-dimensional array for vertices along each strut for executing hull
bool[] StrutSolo = new bool[Struts.Count]; //tag for struts that don't share a node with other struts (ends)
Mesh Hulls = new Mesh(); //main output mesh
//cycle through each node to generate hulls
for (int NodeIdx = 0; NodeIdx < Nodes.Count; NodeIdx++)
{
List<int> StrutIndices = NodeStruts[NodeIdx];
double MinOffset = 0;
double MaxRadius = 0;
//orientation & size drivers for knuckle vertices
List<Vector3d> Knuckles = new List<Vector3d>();
double KnuckleMin = 0;
//compare all unique combinations of struts in a given node to calculate plane offsets for
//hulling operations and for adjusting vertices to potential non-convex hulls
for (int I1 = 0; I1 < StrutIndices.Count - 1; I1++)
{
for (int I2 = I1 + 1; I2 < StrutIndices.Count; I2++)
{
//identify minimum offset distances for calculating hulls by comparing each outgoing strut to each other
double R1 = StrutRadii[StrutIndices[I1]] / Math.Cos(Math.PI / S);
double R2 = StrutRadii[StrutIndices[I2]] / Math.Cos(Math.PI / S);
double Radius = Math.Max(R1, R2);
double Theta = Vector3d.VectorAngle(Struts[StrutIndices[I1]].TangentAtStart, Struts[StrutIndices[I2]].TangentAtStart);
double TestOffset = Radius * Math.Cos(Theta * 0.5) / Math.Sin(Theta * 0.5);
if (TestOffset > MinOffset) MinOffset = TestOffset;
if (MaxRadius < Radius) MaxRadius = Radius;
//set offsets for shrinking hull vertices into a non-convex hull based on desired node offsets (ND) and adjacent struts
double Offset1 = 0;
double Offset2 = 0;
//calculates final offsets for potential shrinking of nodes into non-convex hull
ExoTools.OffsetCalculator(Theta, R1, R2, ref Offset1, ref Offset2);
if (PlaneOffsets[StrutIndices[I1]] < Offset1) PlaneOffsets[StrutIndices[I1]] = Math.Max(Offset1, ND);
if (PlaneOffsets[StrutIndices[I2]] < Offset2) PlaneOffsets[StrutIndices[I2]] = Math.Max(Offset2, ND);
//set offsets for knuckle to be the size of the smallest outgoing strut radius
double KnuckleMinSet = Math.Min(StrutRadii[StrutIndices[I1]], StrutRadii[StrutIndices[I2]]);
if (I1 == 0 || KnuckleMin > KnuckleMinSet) KnuckleMin = KnuckleMinSet;
}
}
//ensures that if a two struts are linear to one another in a two-strut node that there is an offset for hulling
if (MinOffset < RhinoDoc.ActiveDoc.ModelAbsoluteTolerance) MinOffset = MaxRadius * 0.5;
//direction for dealing with struts at ends
if (StrutIndices.Count == 1)
{
PlaneOffsets[StrutIndices[0]] = 0;
//PlaneOffsets[StrutIndices[0]] = ND;
if (O) StrutSolo[StrutIndices[0]] = true;
}
//build base planes, offset them for hulling, and array hull vertices for each strut
for (int I1 = 0; I1 < StrutIndices.Count; I1++)
{
//build base planes
Curve Strut = Struts[StrutIndices[I1]];
Plane StrutPlane;
//sets the strut plane
if (StrutIndices[I1] % 2 == 0) Strut.PerpendicularFrameAt(0, out StrutPlane);
else
{
Curve LookupStrut = Struts[StrutIndices[I1] - 1];
LookupStrut.PerpendicularFrameAt(0, out StrutPlane);
}
//offset planes for hulling
StrutPlane.Origin = Strut.PointAtStart + Strut.TangentAtStart * MinOffset;
double StrutRadius = StrutRadii[StrutIndices[I1]];
//add strut tangent to list of knuckle orientation vectors
Knuckles.Add(-Strut.TangentAtStart);
//add hulling vertices
for (int HV = 0; HV < S; HV++) StrutHullVtc[StrutIndices[I1], HV] = StrutPlane.PointAt(Math.Cos((HV / Sides) * Math.PI * 2) * StrutRadius, Math.Sin((HV / Sides) * Math.PI * 2) * StrutRadius);
double OffsetMult = PlaneOffsets[StrutIndices[I1]];
if (ND > OffsetMult) OffsetMult = ND;
if (StrutIndices[I1] % 2 != 0) StrutPlane.Rotate(Math.PI, StrutPlane.YAxis, StrutPlane.Origin);
if (StrutIndices.Count ==1) OffsetMult = 0;
StrutPlanes[StrutIndices[I1]] = StrutPlane;
StrutPlanes[StrutIndices[I1]].Origin = Strut.PointAtStart + Strut.TangentAtStart * OffsetMult;
}
//collect all of the hull points from each strut in a given node for hulling, including knuckle points
if (StrutIndices.Count > 1)
{
List<Point3d> HullPts = new List<Point3d>();
List<int> PlaneIndices = new List<int>();
double KnuckleOffset = MinOffset * 0.5;
for (int HV = 0; HV < S; HV++)
{
for (int I1 = 0; I1 < StrutIndices.Count; I1++)
{
HullPts.Add(StrutHullVtc[StrutIndices[I1], HV]);
PlaneIndices.Add(StrutIndices[I1]);
if (HV == 0)
{
HullPts.Add(Nodes[NodeIdx] + (Knuckles[I1] * KnuckleOffset));
PlaneIndices.Add(-1);
}
}
double Angle = ((double)HV / S) * (Math.PI * 2);
}
Rhino.Collections.Point3dList LookupPts = new Rhino.Collections.Point3dList(HullPts);
//execute the hulling operation
Mesh HullMesh = new Mesh();
ExoTools.Hull(HullPts, ref HullMesh);
ExoTools.NormaliseMesh(ref HullMesh);
Point3d[] HullVertices = HullMesh.Vertices.ToPoint3dArray();
List<int> FaceVertices = new List<int>();
//relocate vertices to potentially non-convex configurations
for (int HullVtx = 0; HullVtx < HullVertices.Length; HullVtx++)
{
int CloseIdx = LookupPts.ClosestIndex(HullVertices[HullVtx]);
if (PlaneIndices[CloseIdx] > -1)
{
double OffsetMult = 0;
if (ND > PlaneOffsets[PlaneIndices[CloseIdx]]) OffsetMult = ND - MinOffset;
else OffsetMult = PlaneOffsets[PlaneIndices[CloseIdx]] - MinOffset;
HullVertices[HullVtx] += StrutPlanes[PlaneIndices[CloseIdx]].ZAxis * OffsetMult;
HullMesh.Vertices[HullVtx] = new Point3f((float)HullVertices[HullVtx].X, (float)HullVertices[HullVtx].Y, (float)HullVertices[HullVtx].Z);
FaceVertices.Add(PlaneIndices[CloseIdx]);
}
else
{
Vector3d KnuckleVector = new Vector3d(HullVertices[HullVtx] - Nodes[NodeIdx]);
KnuckleVector.Unitize();
Point3d KnucklePt = Nodes[NodeIdx] + (KnuckleVector * KnuckleMin);
HullMesh.Vertices[HullVtx] = new Point3f((float)KnucklePt.X, (float)KnucklePt.Y, (float)KnucklePt.Z);
FaceVertices.Add(PlaneIndices[CloseIdx]);
}
}
//delete all faces whose vertices are associated with the same plane
List<int> DeleteFaces = new List<int>();
for (int FaceIdx = 0; FaceIdx < HullMesh.Faces.Count; FaceIdx++)
{
if ((FaceVertices[HullMesh.Faces[FaceIdx].A] !=-1) && (FaceVertices[HullMesh.Faces[FaceIdx].A] == FaceVertices[HullMesh.Faces[FaceIdx].B]) &&
(FaceVertices[HullMesh.Faces[FaceIdx].B] == FaceVertices[HullMesh.Faces[FaceIdx].C])) DeleteFaces.Add(FaceIdx);
}
HullMesh.Faces.DeleteFaces(DeleteFaces);
ExoTools.NormaliseMesh(ref HullMesh);
Hulls.Append(HullMesh);
}
else if (!O)
{
Mesh EndMesh = new Mesh();
double KnuckleOffset = ND * 0.5;
EndMesh.Vertices.Add(Nodes[NodeIdx] + (Knuckles[0] * KnuckleOffset));
for (int HullVtx = 0; HullVtx < S; HullVtx++)
{
EndMesh.Vertices.Add(StrutHullVtc[StrutIndices[0], HullVtx]);
int StartVtx = HullVtx + 1;
int EndVtx = HullVtx + 2;
if (HullVtx == S - 1) EndVtx = 1;
EndMesh.Faces.AddFace(0, StartVtx, EndVtx);
}
Hulls.Append(EndMesh);
}
}
//add stocking meshes between struts
Rhino.Collections.Point3dList MatchPts = new Rhino.Collections.Point3dList(Hulls.Vertices.ToPoint3dArray());
Mesh StrutMeshes = new Mesh();
//if a strut is overwhelmed by its nodes then output a sphere centered on the failing strut
Mesh FailStruts = new Mesh();
for (int I1 = 0; I1 <= Struts.Count; I1++)
{
if (I1 % 2 !=0)
{
if (StrutPlanes[I1-1].Origin.DistanceTo(Struts[I1-1].PointAtStart) + StrutPlanes[I1].Origin.DistanceTo(Struts[I1].PointAtStart) > Struts[I1-1].GetLength()*2)
{
Plane FailPlane = new Plane(Struts[I1 - 1].PointAtStart, Struts[I1 - 1].TangentAtStart);
Cylinder FailCylinder = new Cylinder(new Circle(FailPlane, (StrutRadii[I1] + StrutRadii[I1 - 1]) / 2), Struts[I1 - 1].GetLength()*2);
FailStruts.Append(Mesh.CreateFromCylinder(FailCylinder,5,10));
}
Mesh StrutMesh = new Mesh();
double StrutLength = StrutPlanes[I1 - 1].Origin.DistanceTo(StrutPlanes[I1].Origin);
//calculate the number of segments between nodes
int Segments =(int)(Math.Round((StrutLength * 0.5) / D, 0) * 2) + 2;
double PlnZ = StrutLength / Segments;
bool Match = true;
if (O && StrutSolo[I1 - 1]) Match = false;
//build up vertices
ExoTools.VertexAdd(ref StrutMesh, StrutPlanes[I1 - 1], (double)S, StrutRadii[I1 - 1], Match, MatchPts, Hulls);
double StrutIncrement = (StrutRadii[I1] - StrutRadii[I1 - 1]) / Segments;
for (int PlnIdx = 1; PlnIdx <= Segments; PlnIdx++)
{
Plane PlnSet = new Plane(StrutPlanes[I1-1]);
PlnSet.Rotate((PlnIdx % 2) * -(Math.PI / (double)S), PlnSet.ZAxis);
PlnSet.Origin = PlnSet.PointAt(0, 0, PlnIdx * PlnZ);
bool Affix = false;
if (PlnIdx == Segments && (!StrutSolo[I1] || (StrutSolo[I1] && !O))) Affix = true;
ExoTools.VertexAdd(ref StrutMesh, PlnSet, (double)S, StrutRadii[I1 - 1] + (StrutIncrement * PlnIdx), Affix, MatchPts, Hulls);
}
//build up faces
ExoTools.StockingStitch(ref StrutMesh, Segments, S);
ExoTools.NormaliseMesh(ref StrutMesh);
Hulls.Append(StrutMesh);
}
}
if (FailStruts.Vertices.Count > 0)
{
DA.SetData(0, FailStruts);
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "One or more struts is engulfed by its nodes");
return;
}
Hulls.Faces.CullDegenerateFaces();
Hulls.Vertices.CullUnused();
Mesh[] OutMeshes = Hulls.SplitDisjointPieces();
for (int SplitMesh = 0; SplitMesh < OutMeshes.Length; SplitMesh++) { ExoTools.NormaliseMesh(ref OutMeshes[SplitMesh]); }
//ExoTools.NormaliseMesh(ref Hulls);
DA.SetDataList(0, OutMeshes);
}
/***************************************************/
public static void RenderRhinoMeshes(RHG.Cylinder cylinder, Rhino.Display.DisplayPipeline pipeline, DisplayMaterial material)
{
pipeline.DrawBrepShaded(cylinder.ToBrep(cylinder.IsFinite, cylinder.IsFinite), material);
}
/***************************************************/
public static RHG.Mesh CreatePreviewMesh(RHG.Cylinder cylinder, RHG.MeshingParameters parameters)
{
return(CreatePreviewMesh(cylinder.ToBrep(cylinder.IsFinite, cylinder.IsFinite), parameters));
}
/// <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)
{
#region INPUTS
// INPUTS
// import Silkworm Movement
List<GH_ObjectWrapper> s_Movement = new List<GH_ObjectWrapper>();
if (!DA.GetDataList(0, s_Movement)) { return; }
int res = new int();
//if (!DA.GetData(4, ref res)) { }
double startPrev = 0.0;
if (!DA.GetData(1, ref startPrev)) { }
double endPrev = 1.0;
if (!DA.GetData(2, ref endPrev)) { }
bool showlogistics = false;
if (!DA.GetData(3, ref showlogistics)) { }
bool showvalues = false;
if (!DA.GetData(4, ref showvalues)) { }
bool showmesh = false;
if (!DA.GetData(5, ref showmesh)) { }
bool showprinter = false;
if (!DA.GetData(6, ref showprinter)) { }
#endregion
//Initialise these properties as soon as solveinstance begins
if (DA.Iteration == 0)
{
//Visualise Print Logistics
displayLogistics = new bool();
startPoints = new List<Line>();
endPoints = new List<Line>();
DelimitMarkers = new List<Line>();
//Visualise Print Values
displayValues = new bool();
lineThicknesses = new List<double>();
Colors = new List<Color>();
Movements = new List<Line>();
blobPts = new List<Point3d>();
blobDiameter = new List<double>();
//Visualise Print Realistic
displayMesh = new bool();
//m_meshes = new List<Mesh>();
//Visualise Printer
displayPrinter = new bool();
bboxAll = new BoundingBox();
extclearance = new Mesh();
xcarriage = new List<Mesh>();
vizmaterial = new DisplayMaterial(Color.Yellow, 0.5);
printArea = new List<Point3d>();
}
//Output Holders
Mesh sMesh = new Mesh();
displayLogistics = showlogistics;
displayValues = showvalues;
displayMesh = showmesh;
displayPrinter = showprinter;
List<Point3d> startPts = new List<Point3d>();
List<Point3d> endPts = new List<Point3d>();
//Sort through input geometry, check that it is a Silkworm Model
foreach (GH_ObjectWrapper movement in s_Movement)
{
if (movement.Value is SilkwormModel)
{
SilkwormModel sModel = (SilkwormModel)movement.Value;
printArea.Add(new Point3d(0,0,0));
printArea.Add(new Point3d(0, sModel.bed_size.Y, 0));
printArea.Add(new Point3d(sModel.bed_size.X, sModel.bed_size.Y, 0));
printArea.Add(new Point3d(sModel.bed_size.X, 0, 0));
bboxAll = new BoundingBox(new Point3d(0, 0, 0), new Point3d(sModel.bed_size.X, sModel.bed_size.Y, sModel.bed_size.Z));
sModel.displayModel(startPrev, endPrev, showmesh, res,
out Movements,
out lineThicknesses,
out DelimitMarkers,
out blobPts,
out blobDiameter,
out Colors,
out sMesh,
out startPts,
out endPts);
//Create Clearance Visualisation Geometry
Point3d endPt = Movements[Movements.Count - 1].To;
Plane plane = new Plane(endPt,Plane.WorldXY.ZAxis);
Cone extcl = new Cone(plane, sModel.extruder_clearance_height, sModel.extruder_clearance_radius);
extclearance = Mesh.CreateFromCone(extcl, 12, 30);
double roddiameter = 8;
Point3d PtA1 = new Point3d(0, endPt.Y + ((sModel.xbar_width / 2) - (roddiameter / 2)), endPt.Z + (roddiameter / 2) + sModel.extruder_clearance_height);
Point3d PtA2 = new Point3d(0, endPt.Y - ((sModel.xbar_width / 2) - (roddiameter / 2)), endPt.Z + (roddiameter / 2)+sModel.extruder_clearance_height);
Cylinder clyA = new Cylinder(new Circle(new Plane(PtA1, Plane.WorldYZ.ZAxis), roddiameter/2), sModel.bed_size.X);
Cylinder clyB = new Cylinder(new Circle(new Plane(PtA2, Plane.WorldYZ.ZAxis), roddiameter/2), sModel.bed_size.X);
Mesh cylA = Mesh.CreateFromCylinder(clyA,12,30);
Mesh cylB = Mesh.CreateFromCylinder(clyB, 12,30);
xcarriage.AddRange(new Mesh[] {cylA,cylB});
foreach (Point3d point in startPts)
{
startPoints.Add(new Line(point, Plane.WorldXY.ZAxis, 0.01));
}
foreach (Point3d point in endPts)
{
endPoints.Add(new Line(point, Plane.WorldXY.ZAxis, 0.01));
}
}
else
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Please Input Only Silkworm Models");
continue;
}
}
//GH_Mesh outPipes = new GH_Mesh(sMesh);
//DA.SetData(0, outPipes);
}
/// <summary>
/// Gets an extrusion form of a cylinder.
/// </summary>
/// <param name="cylinder">IsFinite must be true.</param>
/// <param name="capBottom">If true, the end at cylinder.Height1 will be capped.</param>
/// <param name="capTop">If true, the end at cylinder.Height2 will be capped.</param>
/// <returns>Extrusion on success. null on failure.</returns>
public static Extrusion CreateCylinderExtrusion(Cylinder cylinder, bool capBottom, bool capTop)
{
IntPtr ptr_new_extrusion = UnsafeNativeMethods.ON_Extrusion_CreateCylinder(ref cylinder, capBottom, capTop);
return(IntPtr.Zero == ptr_new_extrusion ? null : new Extrusion(ptr_new_extrusion, null));
}
/***************************************************/
public static void RenderRhinoWires(RHG.Cylinder cylinder, Rhino.Display.DisplayPipeline pipeline, Color bhColour, int thickness)
{
pipeline.DrawCylinder(cylinder, bhColour);
}
/// <summary>Determines if the surface is a portion of a cylinder within a given tolerance.</summary>
/// <param name="tolerance">tolerance to use when checking.</param>
/// <returns>true if the surface is a portion of a cylinder.</returns>
public bool IsCylinder(double tolerance)
{
Cylinder cylinder = new Cylinder();
IntPtr pThis = ConstPointer();
return UnsafeNativeMethods.ON_Surface_IsCylinder(pThis, ref cylinder, tolerance, false);
}
/// <summary>
/// Constructs a new surface of revolution from the values of a cylinder.
/// </summary>
/// <param name="cylinder">A cylinder.</param>
/// <returns>A new surface of revolution, or null if any of the inputs is invalid or on error.</returns>
public static RevSurface CreateFromCylinder(Cylinder cylinder)
{
IntPtr pRevSurface = UnsafeNativeMethods.ON_Cylinder_RevSurfaceForm(ref cylinder);
if (IntPtr.Zero == pRevSurface)
return null;
return new RevSurface(pRevSurface, null);
}
/// <summary>Tests a surface to see if it is a portion of a cylinder and return the cylinder.</summary>
/// <param name="cylinder">On success, the cylinder parameters are filled in.</param>
/// <param name="tolerance">tolerance to use when checking.</param>
/// <returns>true if the surface is a portion of a cylinder.</returns>
public bool TryGetCylinder(out Cylinder cylinder, double tolerance)
{
cylinder = new Cylinder();
IntPtr pThis = ConstPointer();
return UnsafeNativeMethods.ON_Surface_IsCylinder(pThis, ref cylinder, tolerance, true);
}
/// <summary>
/// Get a cylindrical projection parameters from this texture mapping.
/// </summary>
/// <param name="cylinder"></param>
/// <returns>
/// Returns true if a valid cylinder is returned.
/// </returns>
/// <remarks>
/// Generally, GetMappingCylinder will not return the same parameters passed
/// to SetCylinderMapping. However, the location of the cylinder will be
/// the same. If this mapping is not cylindrical, the cylinder will
/// approximate the actual mapping primitive.
/// </remarks>
public bool TryGetMappingCylinder(out Cylinder cylinder)
{
var ptr = ConstPointer();
cylinder = Cylinder.Unset;
var success = UnsafeNativeMethods.ON_TextureMapping_GetMappingCylinder(ptr, ref cylinder);
return success;
}
