/// <summary>
/// 获取对角线
/// </summary>
static Snap.NX.Line GetDiagonalLine(Snap.NX.Body body, out Snap.NX.Face baseFace)
{
Snap.NX.Line result = null;
var workPart = Snap.Globals.WorkPart;
var box = body.Box;
var p2 = new Snap.Position((box.MaxX + box.MinX) / 2, (box.MaxY + box.MinY) / 2);
var lines = new List <NXOpen.NXObject>();
if (!string.IsNullOrEmpty(body.Name))
{
lines = workPart.NXOpenPart.Layers.GetAllObjectsOnLayer(body.Layer).Where(l => l is NXOpen.Line).ToList();
lines.ToList().ForEach(u =>
{
Snap.NX.Line line = u as NXOpen.Line;
bool isRemove = true;
if (Snap.Compute.Distance(line, body) < SnapEx.Helper.Tolerance)
{
var p1 = (line.StartPoint + line.EndPoint) / 2;
p2.Z = p1.Z;
if (SnapEx.Helper.Equals(p1, p2, SnapEx.Helper.Tolerance))
{
isRemove = false;
}
}
if (isRemove)
{
lines.Remove(u);
}
});
}
GetBaseFace(body, Enumerable.Select(lines, u => Snap.NX.Line.Wrap(u.Tag)).ToList(), out baseFace, out result);
return(result);
}
/// <summary>
/// 获取拔模角度
/// </summary>
public static double GetDraftAngle(this Snap.NX.Face face, Snap.Vector draftVector)
{
var result = 0.0;
var angles = new List <double>();
var vector = new Snap.Vector(double.NaN, double.NaN, double.NaN);
switch (face.ObjectSubType)
{
case Snap.NX.ObjectTypes.SubType.FacePlane:
vector = face.GetFaceDirection();
break;
}
if (double.IsNaN(vector.X) || double.IsNaN(vector.Y) || double.IsNaN(vector.Z))
{
var posLst = SnapEx.Create.GetFacePoints(face);
posLst.ForEach(u => {
angles.Add(90 - Snap.Vector.Angle(draftVector, GetFaceDirectionByPoint(face, u)));
});
}
else
{
angles.Add(90 - Snap.Vector.Angle(draftVector, vector));
}
if (angles.Count > 0)
{
int count = angles.Count;
angles.ForEach(u => {
result += u / count;
});
}
return(result);
}
/// <summary>
/// 获取面上所有的测量点
/// </summary>
public static List <Snap.Position> GetFacePoints(Snap.NX.Face face, CMMTool.CMMConfig config, List <Snap.NX.Curve> edges, bool isRoundInt = false, double max_facet_size = 1)
{
//var mark = Snap.Globals.SetUndoMark(Globals.MarkVisibility.Invisible, "GetFacePointsEx");
var positions = new List <Snap.Position>();
try
{
positions = SnapEx.Create.GetFacePoints(face, max_facet_size);
////所有边上的点都不取
//var minD = double.MaxValue;
//var probeDatas = config.ProbeDatas ?? new List<CMMTool.ProbeData>();
//foreach (var data in probeDatas)
//{
// minD = System.Math.Min(data.D, minD);
//}
//positions.ToList().ForEach(p => {
// if (Helper.GetPointToEdgeMinDistance(p, edges) < minD)
// {
// positions.Remove(p);
// }
//});
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
//Snap.Globals.UndoToMark(mark, null);
}
return(positions);
}
public override Snap.NX.Face GetChamferFace()
{
if (ChamferFace != null)
{
return(ChamferFace);
}
Snap.NX.Face result = null;
var results = new List <Snap.NX.Face>();
if (BaseFace != null)
{
var baseFOriention = new Snap.Orientation(BaseFace.GetFaceDirection());
var v1 = Snap.Vector.Unit(baseFOriention.AxisX);
var v2 = Snap.Vector.Unit(baseFOriention.AxisY);
var v3 = Snap.Vector.Unit(v1 + v2);
var v4 = v3.Copy(Snap.Geom.Transform.CreateRotation(new Snap.Position(), BaseFace.GetFaceDirection(), 90)).Unitize();
var chamferFaces = ElecBody.Faces.Where(u => u.ObjectSubType == Snap.NX.ObjectTypes.SubType.FacePlane && Snap.Compute.Distance(u, BaseFace) < SnapEx.Helper.Tolerance).ToList();
chamferFaces.ForEach(u =>
{
var faceDir = u.GetFaceDirection();
if (SnapEx.Helper.Equals(v3, faceDir, SnapEx.Helper.Tolerance) ||
SnapEx.Helper.Equals(-v3, faceDir, SnapEx.Helper.Tolerance) ||
SnapEx.Helper.Equals(-v4, faceDir, SnapEx.Helper.Tolerance) ||
SnapEx.Helper.Equals(v4, faceDir, SnapEx.Helper.Tolerance)
)
{
results.Add(u);
}
});
}
result = results.FirstOrDefault();
if (results.Count > 1)
{
var baseFaceBoxUV = BaseFace.BoxUV;
var elecBasePos = BaseFace.Position((baseFaceBoxUV.MinU + baseFaceBoxUV.MaxU) / 2, (baseFaceBoxUV.MinV + baseFaceBoxUV.MaxV) / 2);
var faceDirection = BaseFace.GetFaceDirection();
var plane = new Snap.Geom.Surface.Plane(elecBasePos, faceDirection);
foreach (var u in results)
{
var uv = u.BoxUV;
var cneterPoint = u.Position((uv.MaxU + uv.MinU) / 2, (uv.MaxV + uv.MaxV) / 2);
var resullt = Snap.Compute.ClosestPoints(cneterPoint, plane);
var dir = Snap.Vector.Unit(resullt.Point1 - resullt.Point2);
if (SnapEx.Helper.Equals(dir, -faceDirection) && Snap.Compute.Distance(BaseFace, u) < SnapEx.Helper.Tolerance)
{
result = u;
break;
}
}
}
ChamferFace = result;
return(result);
}
internal static Snap.NX.FaceBlend CreateFaceBlend(Snap.NX.Face face1, Snap.NX.Face face2, Snap.Number radius)
{
NXOpen.Part workPart = (NXOpen.Part)Globals.WorkPart;
NXOpen.Features.FaceBlendBuilder featureBuilder = workPart.Features.CreateFaceBlendBuilder(null);
featureBuilder.Tolerance = Globals.DistanceTolerance;
ScCollector collector = workPart.ScCollectors.CreateCollector();
NXOpen.Face[] boundaryFaces = new NXOpen.Face[0];
FaceTangentRule rule = workPart.ScRuleFactory.CreateRuleFaceTangent((NXOpen.Face)face1, boundaryFaces, 0.5);
SelectionIntentRule[] rules = new SelectionIntentRule[] { rule };
collector.ReplaceRules(rules, false);
featureBuilder.FirstFaceCollector = collector;
featureBuilder.ReverseFirstFaceNormal = true;
ScCollector collector2 = workPart.ScCollectors.CreateCollector();
NXOpen.Face[] faceArray2 = new NXOpen.Face[0];
FaceTangentRule rule2 = workPart.ScRuleFactory.CreateRuleFaceTangent((NXOpen.Face)face2, faceArray2, 0.5);
SelectionIntentRule[] ruleArray2 = new SelectionIntentRule[] { rule2 };
collector2.ReplaceRules(ruleArray2, false);
featureBuilder.SecondFaceCollector = collector2;
featureBuilder.ReverseSecondFaceNormal = true;
featureBuilder.CircularCrossSection.SetRadius(radius.ToString());
NXOpen.Features.Feature feature = (NXOpen.Features.Feature)Snap.NX.Feature.CommitFeature(featureBuilder);
featureBuilder.Destroy();
return((NXOpen.Features.FaceBlend)feature);
}
/// <summary>
/// 获取平面投影面积
/// </summary>
public static double GetPlaneProjectArea(this Snap.NX.Face face, Snap.Vector baseDir)
{
var topFaceDir = -baseDir;
var topFaceOrientation = new Snap.Orientation(topFaceDir);
var box = SnapEx.Ex.AcsToWcsBox3d(face.BoxEx(), topFaceOrientation);
return(System.Math.Abs(box.MinX - box.MaxX) * System.Math.Abs(box.MinY - box.MaxY));
}
public static Vector GetFaceDirectionByPoint(this Snap.NX.Face face, Snap.Position pos)
{
var ufSession = NXOpen.UF.UFSession.GetUFSession();
double[] param = new double[2], faceOnPoint = pos.Array, u1 = new double[3], v1 = new double[3], u2 = new double[3], v2 = new double[3], unitNorm = new double[3], radii = new double[2];
ufSession.Modl.AskFaceParm(face.NXOpenTag, faceOnPoint, param, faceOnPoint);
ufSession.Modl.AskFaceProps(face.NXOpenTag, param, faceOnPoint, u1, v1, u2, v2, unitNorm, radii);
return(Snap.Vector.Unit(new Snap.Vector(unitNorm)));
}
private static ObjectTypes.SubType GetFaceType(Snap.NX.Face snapFace)
{
ObjectTypes.SubType faceUnknown = ObjectTypes.SubType.FaceUnknown;
NXOpen.Face.FaceType undefined = NXOpen.Face.FaceType.Undefined;
try
{
undefined = snapFace.NXOpenFace.SolidFaceType;
}
catch
{
}
switch (undefined)
{
case NXOpen.Face.FaceType.Planar:
faceUnknown = ObjectTypes.SubType.FacePlane;
break;
case NXOpen.Face.FaceType.Cylindrical:
faceUnknown = ObjectTypes.SubType.FaceCylinder;
break;
case NXOpen.Face.FaceType.Conical:
faceUnknown = ObjectTypes.SubType.FaceCone;
break;
case NXOpen.Face.FaceType.Spherical:
faceUnknown = ObjectTypes.SubType.FaceSphere;
break;
case NXOpen.Face.FaceType.Parametric:
faceUnknown = ObjectTypes.SubType.FaceBsurface;
break;
case NXOpen.Face.FaceType.Blending:
faceUnknown = ObjectTypes.SubType.FaceBlend;
break;
case NXOpen.Face.FaceType.Offset:
faceUnknown = ObjectTypes.SubType.FaceOffset;
break;
case NXOpen.Face.FaceType.Swept:
faceUnknown = ObjectTypes.SubType.FaceExtruded;
break;
}
if (undefined != NXOpen.Face.FaceType.SurfaceOfRevolution)
{
return(faceUnknown);
}
double num = GetSurfaceRadii(snapFace)[1];
if (num != 0.0)
{
return(ObjectTypes.SubType.FaceTorus);
}
return(ObjectTypes.SubType.FaceRevolved);
}
public PointData IsIntervene(Snap.Position p, ProbeData data)
{
PointData result = null;
PointType pointType = PointType.UNKOWN;
Snap.NX.Face face = null;
//基准顶面
if (_horizontalDatumFace != null)
{
if (IsPointAtFace(_horizontalDatumFace, p))
{
face = _horizontalDatumFace;
pointType = PointType.HorizontalDatumFace;
}
}
if (pointType == PointType.UNKOWN)
{
foreach (var u in GetVerticalDatumFaces())
{
if (IsPointAtFace(u, p))
{
face = u;
pointType = PointType.VerticalDatumFace;
break;
}
}
}
if (pointType == PointType.UNKOWN)
{
foreach (var u in GetElectrodeHeadFace())
{
if (IsPointAtFace(u, p))
{
face = u;
pointType = PointType.HeadFace;
break;
}
}
}
if (pointType != PointType.UNKOWN)
{
result = IsIntervene(p, face.GetFaceDirection(), data);
if (result != null)
{
result.PointType = pointType;
}
}
return(result);
}
private static void GetSurfaceData(Snap.NX.Face face, out int surfaceType, out Snap.Position axisPoint, out Vector axisVector, out double radius1, out double radius2, out int normalFlip)
{
UFSession uFSession = Globals.UFSession;
double[] point = new double[3];
double[] dir = new double[3];
double[] box = new double[6];
uFSession.Modl.AskFaceData(face.NXOpenTag, out surfaceType, point, dir, box, out radius1, out radius2, out normalFlip);
axisPoint = new Snap.Position(point);
axisVector = new Vector(dir);
}
/// <summary>
/// 是否是边上的点
/// </summary>
static bool IsPointOnEdge(Snap.NX.Face face, Snap.Position p)
{
foreach (var item in face.EdgeCurves)
{
var d = Compute.Distance(p, item);
if (d < _tolerance)
{
return(true);
}
}
return(false);
}
/// <summary>
/// 获取基准面
/// </summary>
static void GetBaseFace(Snap.NX.Body body, List <Snap.NX.Line> diagonalLines, out Snap.NX.Face face, out Snap.NX.Line line)
{
Snap.NX.Face outFace = null;
Snap.NX.Line outLine = null;
var faces = body.Faces.ToList();
faces = faces.Where(u => u.ObjectSubType == Snap.NX.ObjectTypes.SubType.FacePlane).ToList();
var baseFace = faces.Where(u => u.IsHasAttr(ELEC_BASE_EDM_FACE)).FirstOrDefault();
if (baseFace != null)
{
faces = new List <Snap.NX.Face> {
baseFace
};
}
var tempFaces = faces.Where(u => SnapEx.Helper.Equals(u.GetFaceDirection(), -Snap.Globals.WcsOrientation.AxisZ, SnapEx.Helper.Tolerance)).ToList();
tempFaces = tempFaces.OrderByDescending(u => {
var uv = u.BoxUV;
return(Math.Abs(uv.MinU - uv.MaxU) * Math.Abs(uv.MaxV - uv.MinV));
}).ToList();
tempFaces.ForEach(u =>
{
faces.Remove(u);
});
faces.InsertRange(0, tempFaces);
foreach (var u in faces)
{
var corners = u.Box.Corners.Distinct().ToList();
foreach (var item in diagonalLines)
{
Snap.NX.Line diagonalLine = item;
if (Snap.Compute.Distance(diagonalLine, u) < SnapEx.Helper.Tolerance)
{
var startPos = corners.Where(m => SnapEx.Helper.Equals(m, diagonalLine.StartPoint, SnapEx.Helper.Tolerance));
var endPos = corners.Where(m => SnapEx.Helper.Equals(m, diagonalLine.EndPoint, SnapEx.Helper.Tolerance));
if (startPos.Count() > 0 && endPos.Count() > 0)
{
outFace = u;
outLine = diagonalLine;
face = outFace;
line = outLine;
return;
}
}
}
}
face = outFace;
line = outLine;
}
static Snap.Geom.Box3d GetBox3d(List <Face> faces)
{
double minX = 0, maxX = 0, minY = 0, maxY = 0, minZ = 0, maxZ = 0;
if (faces.Count > 0)
{
Snap.NX.Face snapFace = faces.FirstOrDefault();
var box = snapFace.Box;
minX = box.MinX;
maxX = box.MaxX;
minY = box.MinY;
maxY = box.MaxY;
minZ = box.MinZ;
maxZ = box.MaxZ;
faces.ForEach(u =>
{
Snap.NX.Face face = u;
var b = face.Box;
if (minX > b.MinX)
{
minX = b.MinX;
}
if (minY > b.MinY)
{
minY = b.MinY;
}
if (minZ > b.MinZ)
{
minZ = b.MinZ;
}
if (maxX < b.MaxX)
{
maxX = b.MaxX;
}
if (maxY < b.MaxY)
{
maxY = b.MaxY;
}
if (maxZ < b.MaxZ)
{
maxZ = b.MaxZ;
}
});
}
return(new Snap.Geom.Box3d(minX, minY, minZ, maxX, maxY, maxZ));
}
private static double[] GetSurfaceRadii(Snap.NX.Face face)
{
int num;
Snap.Position position;
Vector vector;
int num2;
double[] numArray = new double[2];
GetSurfaceData(face, out num, out position, out vector, out numArray[0], out numArray[1], out num2);
return(numArray);
}
private static Vector GetSurfaceAxisVector(Snap.NX.Face face)
{
int num;
Snap.Position position;
Vector vector;
double num2;
double num3;
int num4;
GetSurfaceData(face, out num, out position, out vector, out num2, out num3, out num4);
return(vector);
}
/// <summary>
/// 获取对角线
/// </summary>
static Snap.NX.Line GetDiagonalLine(Snap.NX.Body body, out Snap.NX.Face baseFace)
{
Snap.NX.Line result = null;
baseFace = null;
var workPart = Snap.Globals.WorkPart;
var box = body.Box;
var p2 = new Snap.Position((box.MaxX + box.MinX) / 2, (box.MaxY + box.MinY) / 2, (box.MaxZ + box.MinZ) / 2);
var lines = new List <Snap.NX.Line>();
if (!string.IsNullOrEmpty(body.Name))
{
lines = workPart.NXOpenPart.Layers.GetAllObjectsOnLayer(body.Layer).ToArray().Where(u => u is NXOpen.Line).Select(u => Snap.NX.Line.Wrap(u.Tag)).ToList();
foreach (var line in lines.ToList())
{
if (!Entry.Instance.IsDistinguishSideElec)
{
var p1 = (line.StartPoint + line.EndPoint) / 2;
var tempVec = p1 - p2;
var tempOri = Snap.Globals.Wcs.Orientation.AxisZ;
if ((
SnapEx.Helper.Equals(tempVec, tempOri, SnapEx.Helper.Tolerance) ||
SnapEx.Helper.Equals(tempVec, -tempOri, SnapEx.Helper.Tolerance) ||
SnapEx.Helper.Equals(p1, p2, SnapEx.Helper.Tolerance)
) && Snap.Compute.Distance(line, body) < SnapEx.Helper.Tolerance
)
{
}
else
{
lines.Remove(line);
}
}
else
{
if (Snap.Compute.Distance(line, body) < SnapEx.Helper.Tolerance)
{
}
else
{
lines.Remove(line);
}
}
}
}
if (lines.Count > 0)
{
GetBaseFace(body, lines, out baseFace, out result);
}
return(result);
}
public static bool AskPointContainment(Snap.Position position, Snap.NX.Face face)
{
return(Snap.Compute.Distance(position, face) <= SnapEx.Helper.Tolerance);
var ufSession = NXOpen.UF.UFSession.GetUFSession();
int pt_status = 0;
ufSession.Modl.AskPointContainment(position.Array, face.NXOpenTag, out pt_status);
if (0x1 == pt_status || 0x3 == pt_status)
{
return(true);
}
return(false);
}
/// <summary>
/// 创建拉伸体
/// </summary>
public static Extrude Extrude(Snap.NX.Face face, double height)
{
var curves = face.EdgeCurves;
Session theSession = Session.GetSession();
Part workPart = theSession.Parts.Work;
Part displayPart = theSession.Parts.Display;
var normal = face.Normal(face.BoxUV.MinU, face.BoxUV.MinV);
var point = face.Position(face.BoxUV.MinU, face.BoxUV.MinV);
var curveList = new List <NXOpen.Curve>();
curves.ToList().ForEach(u =>
{
curveList.Add(u);
});
//创建拉伸
NXOpen.Features.Feature nullFeatures_Feature = null;
ExtrudeBuilder extrudeBuilder1;
extrudeBuilder1 = workPart.Features.CreateExtrudeBuilder(nullFeatures_Feature);
//方向
extrudeBuilder1.Direction = workPart.Directions.CreateDirection(point, normal, SmartObject.UpdateOption.WithinModeling);
//曲面
Section section1;
section1 = workPart.Sections.CreateSection();
extrudeBuilder1.Section = section1;
var curveDumbRule1 = workPart.ScRuleFactory.CreateRuleCurveDumb(curveList.ToArray());
SelectionIntentRule[] rules1 = new SelectionIntentRule[1];
rules1[0] = curveDumbRule1;
section1.AddToSection(rules1, curves.FirstOrDefault(), null, null, new Point3d(), NXOpen.Section.Mode.Create);
//开始值、结束值
extrudeBuilder1.Limits.StartExtend.Value.Value = 0;
extrudeBuilder1.Limits.EndExtend.Value.Value = height;
Extrude feature1;
feature1 = (Extrude)extrudeBuilder1.CommitFeature();
extrudeBuilder1.Destroy();
return(feature1);
}
private static double[,] GetBsurfaceWeights(Snap.NX.Face face)
{
UFModl.Bsurface bsurfaceData = GetBsurfaceData(face);
int num = bsurfaceData.num_poles_u;
int num2 = bsurfaceData.num_poles_v;
double[,] numArray = new double[num, num2];
for (int i = 0; i < num2; i++)
{
for (int j = 0; j < num; j++)
{
int num5 = j + (i * num);
numArray[j, i] = bsurfaceData.poles[num5, 3];
}
}
return(numArray);
}
public static Electrode GetElectrode(Snap.NX.Body body)
{
Electrode result = null;
Snap.NX.Face baseFace = null;
var diagonalLine = GetDiagonalLine(body, out baseFace);
if (diagonalLine != null)
{
var faceDirection = baseFace.GetFaceDirection();
var model = new JYElectrode();
model.DiagonalLine = diagonalLine;
model.BaseFace = baseFace;
model.ElecBody = body;
result = model;
}
return(result);
}
private static Snap.Position[,] GetBsurfacePoles(Snap.NX.Face face)
{
UFModl.Bsurface bsurfaceData = GetBsurfaceData(face);
int num = bsurfaceData.num_poles_u;
int num2 = bsurfaceData.num_poles_v;
Snap.Position[,] positionArray = new Snap.Position[num, num2];
for (int i = 0; i < num2; i++)
{
for (int j = 0; j < num; j++)
{
int num5 = j + (i * num);
positionArray[j, i].X = bsurfaceData.poles[num5, 0];
positionArray[j, i].Y = bsurfaceData.poles[num5, 1];
positionArray[j, i].Z = bsurfaceData.poles[num5, 2];
}
}
return(positionArray);
}
/// <summary>
/// 获取基准角
/// </summary>
public static Snap.NX.Face GetBaseCornerFace(Snap.Position startPoint, Snap.Position endPoint, Snap.NX.Body body)
{
Snap.NX.Face result = null;
Snap.Position basePoint = (startPoint + endPoint) / 2;
Snap.NX.Face baseFace = GetBaseFace(startPoint, endPoint, body);
var faces = body.Faces.ToList();
if (baseFace != null)
{
faces.Remove(baseFace);
var baseFaceDir = new Snap.Orientation(baseFace.GetFaceDirection());
var tempFaces = new List <Snap.NX.Face>();
faces.Where(u => u.ObjectSubType == Snap.NX.ObjectTypes.SubType.FacePlane).ToList().ForEach(u =>
{
var director = u.GetFaceDirection();
var angle = Snap.Vector.Angle(baseFaceDir.AxisX, director);
if (Math.Abs(angle - 45) < _tolerance ||
Math.Abs(angle - 135) < _tolerance
)
{
tempFaces.Add(u);
}
});
if (tempFaces.Count > 1)
{
tempFaces.RemoveAll(u => u.Box.MaxZ <= basePoint.Z);
}
if (tempFaces.Count > 0)
{
result = tempFaces.FirstOrDefault();
}
}
return(result);
}
internal static Snap.NX.TrimBody CreateTrimBody(Snap.NX.Body targetBody, Snap.NX.Face toolFace, bool direction)
{
NXOpen.Part workPart = (NXOpen.Part) Globals.WorkPart;
TrimBody2Builder featureBuilder = workPart.Features.CreateTrimBody2Builder(null);
featureBuilder.Tolerance = Globals.DistanceTolerance;
featureBuilder.BooleanTool.ExtrudeRevolveTool.ToolSection.DistanceTolerance = Globals.DistanceTolerance;
featureBuilder.BooleanTool.ExtrudeRevolveTool.ToolSection.ChainingTolerance = (Globals.UnitType == Globals.Unit.Millimeter) ? 0.02413 : 0.00095;
ScCollector collector = workPart.ScCollectors.CreateCollector();
NXOpen.Body[] bodies = new NXOpen.Body[] { targetBody };
BodyDumbRule rule = workPart.ScRuleFactory.CreateRuleBodyDumb(bodies);
SelectionIntentRule[] rules = new SelectionIntentRule[] { rule };
collector.ReplaceRules(rules, false);
featureBuilder.TargetBodyCollector = collector;
SelectionIntentRule[] ruleArray2 = new SelectionIntentRule[] { workPart.ScRuleFactory.CreateRuleFaceBody((NXOpen.Body) toolFace.Body) };
featureBuilder.BooleanTool.FacePlaneTool.ToolFaces.FaceCollector.ReplaceRules(ruleArray2, false);
featureBuilder.BooleanTool.ReverseDirection = direction;
TrimBody2 trim = (TrimBody2) Snap.NX.Feature.CommitFeature(featureBuilder);
featureBuilder.Destroy();
return new Snap.NX.TrimBody(trim);
}
/// <summary>
/// 获取基准面
/// </summary>
public static Snap.NX.Face GetBaseFace(Snap.Position startPoint, Snap.Position endPoint, Snap.NX.Body body)
{
Snap.Position basePoint = (startPoint + endPoint) / 2;
Snap.NX.Face baseFace = null;
var faces = body.Faces.ToList();
faces.ForEach(u =>
{
var box = u.BoxUV;
var p1 = u.Position((box.MinU + box.MaxU) / 2, (box.MaxV + box.MinV) / 2);
if (SnapEx.Helper.Equals(p1, basePoint, _tolerance))
{
baseFace = u;
return;
}
});
return(baseFace);
}
private static Vector[] SurfaceEvaluate(Snap.NX.Face face, int mode, double u, double v)
{
IntPtr ptr;
double[] numArray = new double[] { u / face.FactorU, v / face.FactorV };
UFEvalsf evalsf = Globals.UFSession.Evalsf;
Tag nXOpenTag = face.NXOpenTag;
evalsf.Initialize2(nXOpenTag, out ptr);
ModlSrfValue value2 = new ModlSrfValue();
evalsf.Evaluate(ptr, mode, numArray, out value2);
Vector vector = new Vector(value2.srf_pos);
Vector vector2 = new Vector(value2.srf_du);
Vector vector3 = new Vector(value2.srf_dv);
Vector vector4 = new Vector(value2.srf_unormal);
vector2 = (Vector)((1.0 / face.FactorU) * vector2);
vector3 = (Vector)((1.0 / face.FactorV) * vector3);
return(new Vector[] { vector, vector2, vector3, vector4 });
}
/// <summary>
/// 获取基准角法向
/// </summary>
public static Snap.Vector GetBaseCornerDirection(Snap.Vector director, Snap.NX.Body body, Snap.Position basePoint)
{
var vec = new Snap.Vector();
director = director.Copy(Snap.Geom.Transform.CreateRotation(basePoint, 90));
Snap.NX.Face baseFace = null;
var faces = body.Faces.ToList();
faces.ForEach(u =>
{
var box = u.BoxUV;
var p1 = u.Position((box.MinU + box.MaxU) / 2, (box.MaxV + box.MinV) / 2);
if (SnapEx.Helper.Equals(p1, basePoint, _tolerance))
{
baseFace = u;
return;
}
});
if (baseFace != null)
{
faces.Remove(baseFace);
faces.ForEach(u =>
{
if (u.ObjectSubType == Snap.NX.ObjectTypes.SubType.FacePlane &&
u.Box.MaxZ > basePoint.Z &&
SnapEx.Helper.Equals(u.GetFaceDirection(), director) &&
SnapEx.Helper.Equals(u.GetFaceDirection(), -director)
)
{
u.Color = System.Drawing.Color.Red;
}
});
}
return(vec);
}
/// <summary>
/// 获取BOX
/// </summary>
/// <param name="face"></param>
/// <returns></returns>
public static Snap.Geom.Box3d BoxEx(this Snap.NX.Face face)
{
int surfaceType;
double radius1;
double radius2;
int normalFlip;
double[] point = new double[3];
double[] dir = new double[3];
double[] box = new double[6];
try
{
NXOpen.UF.UFSession uFSession = NXOpen.UF.UFSession.GetUFSession();
uFSession.Modl.AskFaceData(face.NXOpenTag, out surfaceType, point, dir, box, out radius1, out radius2, out normalFlip);
var faceBox = new Snap.Geom.Box3d(box[0], box[1], box[2], box[3], box[4], box[5]);
return(faceBox);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(face.Box);
}
}
internal static Snap.NX.Face CreateFace(NXOpen.Face nxopenFace)
{
Snap.NX.Face snapFace = new Snap.NX.Face(nxopenFace);
switch (GetFaceType(snapFace))
{
case ObjectTypes.SubType.FaceBlend:
return(new Blend(nxopenFace));
case ObjectTypes.SubType.FaceBsurface:
return(new Bsurface(nxopenFace));
case ObjectTypes.SubType.FaceCone:
return(new Cone(nxopenFace));
case ObjectTypes.SubType.FaceCylinder:
return(new Cylinder(nxopenFace));
case ObjectTypes.SubType.FaceExtruded:
return(new Extruded(nxopenFace));
case ObjectTypes.SubType.FaceOffset:
return(new Offset(nxopenFace));
case ObjectTypes.SubType.FacePlane:
return(new Plane(nxopenFace));
case ObjectTypes.SubType.FaceRevolved:
return(new Revolved(nxopenFace));
case ObjectTypes.SubType.FaceSphere:
return(new Sphere(nxopenFace));
case ObjectTypes.SubType.FaceTorus:
return(new Torus(nxopenFace));
}
return(snapFace);
}
/// <summary>
/// 获取所有的侧面
/// </summary>
protected static List <Snap.NX.Face> GetBaseSideFaces(Snap.NX.Face baseFace, List <Snap.NX.Face> allSideFaces)
{
var result = new List <Snap.NX.Face>();
var faceDirection = baseFace.GetFaceDirection();
var baseFaceCenterPoint = baseFace.GetCenterPoint();
var orientation = new Snap.Orientation(faceDirection);
var firstFace = allSideFaces.Where(u => SnapEx.Helper.Equals(u.GetFaceDirection(), -orientation.AxisY));
var twoFace = allSideFaces.Where(u => SnapEx.Helper.Equals(u.GetFaceDirection(), orientation.AxisX));
var threeFace = allSideFaces.Where(u => SnapEx.Helper.Equals(u.GetFaceDirection(), orientation.AxisY));
var fourFace = allSideFaces.Where(u => SnapEx.Helper.Equals(u.GetFaceDirection(), -orientation.AxisX));
Action <List <Snap.NX.Face> > action = itemFace => {
if (itemFace.Count() > 1)
{
var fFace = itemFace
.Where(u => Snap.Compute.Distance(u, baseFace) < SnapEx.Helper.Tolerance)
.OrderByDescending(u => Snap.Compute.Distance(baseFaceCenterPoint, ((Snap.NX.Face.Plane)u).Geometry))
.ThenByDescending(u => u.GetPlaneProjectArea())
.FirstOrDefault();
if (fFace != null)
{
result.Add(fFace);
}
}
else
{
result.AddRange(itemFace);
}
};
action(firstFace.ToList());
action(twoFace.ToList());
action(threeFace.ToList());
action(fourFace.ToList());
return(result);
}
public Snap.NX.Arc[] Divide(Snap.NX.Face face, Position helpPoint)
{
Snap.NX.Curve[] curveArray = base.Divide(face, helpPoint);
return(this.ArcArray(curveArray));
}
