static IEnumerable <NXOpen.Arc> ToEdgeCurveMany(ArcCurve curve)
{
NXOpen.Point3d ToXYZ(Point3d p) => new NXOpen.Point3d(p.X, p.Y, p.Z);
if (curve.IsClosed(DistanceTolerance * 1.01))
{
var interval = curve.Domain;
double min = interval.Min, mid = interval.Mid, max = interval.Max;
var points = new NXOpen.Point3d[]
{
ToXYZ(curve.PointAt(min)),
ToXYZ(curve.PointAt(min + (mid - min) * 0.5)),
ToXYZ(curve.PointAt(mid)),
ToXYZ(curve.PointAt(mid + (max - mid) * 0.5)),
ToXYZ(curve.PointAt(max)),
};
yield return(WorkPart.Curves.CreateArc(points[0], points[2], points[1], false, out _));
yield return(WorkPart.Curves.CreateArc(points[2], points[4], points[3], false, out _));
}
else
{
yield return(WorkPart.Curves.CreateArc(ToXYZ(curve.Arc.StartPoint), ToXYZ(curve.Arc.EndPoint), ToXYZ(curve.Arc.MidPoint), false, out _));
}
}
public static Point3d ToRhino(this NXOpen.Point3d value)
{
Point3d rhino = RawDecoder.ToRhino(value);
UnitConverter.Scale(ref rhino, UnitConverter.NXToRhinoUnitsRatio);
return(rhino);
}
static global::NXOpen.Point3d[] ToNXPoint3dArray(NurbsCurvePointList list, double factor)
{
var count = list.Count;
var points = new global::NXOpen.Point3d[count];
int p = 0;
if (factor == 1.0)
{
while (p < count)
{
var location = list[p].Location;
points[p++] = new NXOpen.Point3d(location.X, location.Y, location.Z);
}
}
else
{
while (p < count)
{
var location = list[p].Location;
points[p++] = new NXOpen.Point3d(location.X * factor, location.Y * factor, location.Z * factor);
}
}
return(points);
}
public static NXOpen.Point3d[] ToHost(NurbsCurvePointList list)
{
var count = list.Count;
var points = new NXOpen.Point3d[count];
for (int p = 0; p < count; ++p)
{
var location = list[p].Location;
points[p] = new NXOpen.Point3d(location.X, location.Y, location.Z);
}
return(points);
}
public static IEnumerable <NXOpen.Line> ToNXLines(PolylineCurve value, double factor)
{
int pointCount = value.PointCount;
if (pointCount > 1)
{
NXOpen.Point3d end, start = value.Point(0).ToXYZ(factor);
for (int p = 1; p < pointCount; start = end, ++p)
{
end = value.Point(p).ToXYZ(factor);
yield return(WorkPart.Curves.CreateLine(start, end));
}
}
}
public static NXOpen.Point3d[] ToHost(NurbsSurfacePointList list)
{
var count = list.CountU * list.CountV;
var points = new NXOpen.Point3d[count];
int p = 0;
foreach (var point in list)
{
var location = point.Location;
points[p++] = new NXOpen.Point3d(location.X, location.Y, location.Z);
}
return(points);
}
static IEnumerable <NXOpen.Line> ToEdgeCurveMany(PolylineCurve curve)
{
NXOpen.Part workPart = _theSession.Parts.Work;
int pointCount = curve.PointCount;
if (pointCount > 1)
{
var point = curve.Point(0);
NXOpen.Point3d end, start = new NXOpen.Point3d(point.X, point.Y, point.Z);
for (int p = 1; p < pointCount; start = end, ++p)
{
point = curve.Point(p);
end = new NXOpen.Point3d(point.X, point.Y, point.Z);
yield return(workPart.Curves.CreateLine(start, end));
}
}
}
static RevSurface ToRhinoConicalSurface(NXOpen.Face face, FaceEx.FaceData faceData)
{
double totalHeight; // 圆锥总高度
NXOpen.Point3d top; // 圆锥顶点
double radius; // 锥底半径
var faceBoundingBox = face.GetAlignedBoundingBox(faceData.Direction);
if (face.GetEdges().Length == 1 && face.GetEdges()[0].SolidEdgeType == NXOpen.Edge.EdgeType.Circular)
{
// 无修剪的锥形
TheUfSession.Eval.Initialize2(face.GetEdges()[0].Tag, out var edgeEvaluator);
TheUfSession.Eval.AskArc(edgeEvaluator, out var arc);
TheUfSession.Eval.Free(edgeEvaluator);
NXOpen.Point3d bottom = arc.center.ToPoint3d(); // 锥底中心点
totalHeight = faceBoundingBox.Height;
top = bottom.Move(faceBoundingBox.HeightDirection, totalHeight);
radius = arc.radius;
}
else
{
var tangentOfHalfAngle = Math.Tan(faceData.RadiusData);
top = faceData.Point.Move(faceBoundingBox.HeightDirection, faceData.Radius / tangentOfHalfAngle);
totalHeight = faceBoundingBox.Height + faceData.Radius / Math.Tan(faceData.RadiusData);
radius = faceData.Radius + faceBoundingBox.Height * tangentOfHalfAngle;
}
var cone = new Cone(new Plane(top.ToRhino(), faceBoundingBox.HeightDirection.Reverse().ToRhino()), totalHeight, radius);
return(cone.ToRevSurface());
// var curve = new LineCurve(outerPointOnCircle.ToRhino(), top.ToRhino());
// return RevSurface.Create(curve, new Line(bottom.ToRhino(), top.ToRhino()), 0.0, Math.PI * 2.0);
}
private void button1_Click(object sender, EventArgs e)
{
OpenFileDialog ofd = new OpenFileDialog();
ofd.Filter = "Файлы PRT (*.prt)|*.prt|Все файлы (*.*)|*.*";
if (ofd.ShowDialog() == DialogResult.OK)
{
Say("Импорт данных из файла: " + ofd.FileName);
NXOpen.Session ses = null;
try
{
ses = NXOpen.Session.GetSession();
}
catch (Exception ex)
{
Say("Ошибка: " + ex.ToString());
}
if (ses != null)
{
NXOpen.PartLoadStatus status = null;
ses.Parts.Open(ofd.FileName, out status);
foreach (NXOpen.Part part in ses.Parts)
{
string name = part.Name;
int pointNumber = 1;
foreach (NXOpen.Body bd in part.Bodies)
{
Say("bd.Name=" + bd.Name);
NXOpen.Face[] faces = bd.GetFaces();
for (int f = 0; f < faces.Length; f++)
{
Say("faces.Name=" + faces[f].Name);
NXOpen.Edge[] edges = faces[f].GetEdges();
for (int g = 0; g < edges.Length; g++)
{
Say("edges.Name=" + edges[g].Name);
NXOpen.Point3d vert1 = new NXOpen.Point3d();
NXOpen.Point3d vert2 = new NXOpen.Point3d();
edges[g].GetVertices(out vert1, out vert2);
Say(string.Format("faces[{0}].edges[{1}].vert1: X={2:0.0000}; Y={3:0.0000}; Z={4:0.0000}", f, g, vert1.X, vert1.Y, vert2.Z));
Say(string.Format("faces[{0}].edges[{1}].vert2: X={2:0.0000}; Y={3:0.0000}; Z={4:0.0000}", f, g, vert2.X, vert2.Y, vert2.Z));
}
}
}
foreach (NXOpen.Sketch sk in part.Sketches)
{
NXOpen.NXObject[] objs = sk.GetAllGeometry();
Say(string.Format("objs.Length = {0}", objs.Length));
Say(string.Format("sk.Name = {0}", sk.Name));
for (int i = 0; i < objs.Length; i++)
{
int any_length = objs[i].GetAttributeTitlesByType(NXOpen.NXObject.AttributeType.Any).Length;
if (objs[i] is NXOpen.Line)
{
NXOpen.Line line = (NXOpen.Line)objs[i];
Say(string.Format("[StartPoint] X={0}, Y={1}, Z={2}", line.StartPoint.X, line.StartPoint.Y, line.StartPoint.Z));
Say(string.Format("[EndPoint] X={0}, Y={1}, Z={2}", line.EndPoint.X, line.EndPoint.Y, line.EndPoint.Z));
}
}
}
}
}
else
{
Say("Ошибка получения сессии NX!");
}
}
}
public static IEnumerable <NXOpen.Curve> ToNXCurves(NurbsCurve value, double factor)
{
if (value.Degree == 1)
{
var curvePoints = value.Points;
int pointCount = curvePoints.Count;
if (pointCount > 1)
{
NXOpen.Point3d end, start = curvePoints[0].Location.ToXYZ(factor);
for (int p = 1; p < pointCount; start = end, ++p)
{
end = curvePoints[p].Location.ToXYZ(factor);
yield return(WorkPart.Curves.CreateLine(start, end));
}
}
}
else if (value.Degree == 2)
{
for (int s = 0; s < value.SpanCount; ++s)
{
var segment = value.Trim(value.SpanDomain(s)) as NurbsCurve;
yield return(CurveEncoder.ToNXSpline(segment, factor));
}
}
else if (value.IsClosable(DistanceTolerance * 1.01))
{
var segments = value.DuplicateSegments();
if (segments.Length == 1)
{
if
(
value.NormalizedLengthParameter(0.5, out var mid) &&
value.Split(mid) is Curve[] half
)
{
yield return((half[0] as NurbsCurve).ToNXSpline(factor));
yield return((half[1] as NurbsCurve).ToNXSpline(factor));
}
else
{
throw new Exception("Failed to Split closed Edge");
}
}
else
{
foreach (var segment in segments)
{
yield return((segment as NurbsCurve).ToNXSpline(factor));
}
}
}
else if (value.GetNextDiscontinuity(Continuity.C1_continuous, value.Domain.Min, value.Domain.Max, out var t))
{
var splitters = new List <double>()
{
t
};
while (value.GetNextDiscontinuity(Continuity.C1_continuous, t, value.Domain.Max, out t))
{
splitters.Add(t);
}
var segments = value.Split(splitters);
foreach (var segment in segments.Cast <NurbsCurve>())
{
yield return(CurveEncoder.ToNXSpline(segment, factor));
}
}
else
{
yield return(CurveEncoder.ToNXSpline(value, factor));
}
}
public static Point3d ToRhino(NXOpen.Point3d value)
{
return(new Point3d(value.X, value.Y, value.Z));
}
