/// <summary>
/// 投影曲线
/// </summary>
/// <param name="features"></param>
/// <param name="curves">要投影的曲线</param>
/// <param name="originPoint">投影平面原点</param>
/// <param name="normal">投影方向</param>
/// <returns></returns>
public static ProjectCurve CreateProjectCurve(this FeatureCollection features, IBaseCurve[] curves, Point3d originPoint, Vector3d normal)
{
NXOpen.Features.ProjectCurveBuilder projectCurveBuilder = features.CreateProjectCurveBuilder(null);
Plane plane1 = WorkPart.Planes.CreatePlane(originPoint, normal, NXOpen.SmartObject.UpdateOption.WithinModeling);
plane1.SetMethod(NXOpen.PlaneTypes.MethodType.Distance);
plane1.SetFlip(false);
plane1.SetReverseSide(false);
plane1.SetAlternate(NXOpen.PlaneTypes.AlternateType.One);
plane1.Evaluate();
projectCurveBuilder.PlaneToProjectTo = plane1;
projectCurveBuilder.CurveFitData.Tolerance = 0.025;
projectCurveBuilder.CurveFitData.AngleTolerance = 0.5;
projectCurveBuilder.ProjectionOption = NXOpen.Features.ProjectCurveBuilder.ProjectionOptionType.ProjectBothSides;
projectCurveBuilder.AngleToProjectionVector.RightHandSide = "0";
projectCurveBuilder.SectionToProject.DistanceTolerance = 0.025;
projectCurveBuilder.SectionToProject.ChainingTolerance = 0.02375;
projectCurveBuilder.SectionToProject.AngleTolerance = 0.5;
projectCurveBuilder.SectionToProject.SetAllowedEntityTypes(NXOpen.Section.AllowTypes.CurvesAndPoints);
#if NX12
CurveDumbRule curveFeatureRule1 = (WorkPart as BasePart).ScRuleFactory.CreateRuleBaseCurveDumb(curves);
#else
CurveDumbRule curveFeatureRule1 = WorkPart.ScRuleFactory.CreateRuleBaseCurveDumb(curves);
#endif
projectCurveBuilder.SectionToProject.AllowSelfIntersection(true);
SelectionIntentRule[] rules1 = new SelectionIntentRule[1] {
curveFeatureRule1
};
Point3d helpPoint1 = new Point3d(1614.13079321387, -713.841520793069, 769.877304064383);
projectCurveBuilder.SectionToProject.AddToSection(rules1, (NXObject)curves[0], null, null, helpPoint1, NXOpen.Section.Mode.Create, false);
ProjectCurve projectCurve = (ProjectCurve)projectCurveBuilder.CommitFeature();
projectCurveBuilder.SectionToProject.CleanMappingData();
projectCurveBuilder.Destroy();
return(projectCurve);
}
/// <summary>
/// 获取极限点
/// </summary>
/// <param name="measureManager"></param>
/// <param name="curves">要计算的曲线</param>
/// <param name="measureDirection">测量方向</param>
/// <param name="secondDirection">第二方向，以防在第一个方向上出现多个极值点</param>
/// <param name="thirdDirection">第三方向</param>
/// <returns>极限点</returns>
public static Point3d MeasureExtreme(this MeasureManager measureManager, IBaseCurve[] curves, Vector3d measureDirection, Vector3d secondDirection, Vector3d thirdDirection)
{
NXOpen.Unit unit1 = WorkPart.UnitCollection.FindObject("MilliMeter");
Point3d origin1 = new Point3d(0.0, 0.0, 0.0);
Direction direction1 = WorkPart.Directions.CreateDirection(origin1, measureDirection, NXOpen.SmartObject.UpdateOption.WithinModeling);
Direction direction2 = WorkPart.Directions.CreateDirection(origin1, secondDirection, NXOpen.SmartObject.UpdateOption.WithinModeling);
Direction direction3 = WorkPart.Directions.CreateDirection(origin1, thirdDirection, NXOpen.SmartObject.UpdateOption.WithinModeling);
ScCollector scCollector1;
scCollector1 = WorkPart.ScCollectors.CreateCollector();
CurveDumbRule curveDumbRule1 = WorkPart.ScRuleFactory.CreateRuleBaseCurveDumb(curves);
SelectionIntentRule[] rules1 = new SelectionIntentRule[1] {
curveDumbRule1
};
scCollector1.ReplaceRules(rules1, false);
MeasureRectangularExtreme extreme = WorkPart.MeasureManager.NewRectangularExtreme(unit1, direction1, direction2, direction3, scCollector1, false);
Point3d extremePoint = extreme.Point;
int nErrs1 = TheSession.UpdateManager.AddToDeleteList(direction1);
scCollector1.Destroy();
return(extremePoint);
}
internal static SelectionIntentRule[] CreateSelectionIntentRule(params Snap.NX.ICurve[] icurves)
{
List <SelectionIntentRule> list = new List <SelectionIntentRule>();
for (int i = 0; i < icurves.Length; i++)
{
if (icurves[i] is Snap.NX.Curve)
{
NXOpen.Curve[] curves = new NXOpen.Curve[] { icurves[i] as Snap.NX.Curve };
CurveDumbRule rule = Globals.NXOpenWorkPart.ScRuleFactory.CreateRuleCurveDumb(curves);
SelectionIntentRule[] ruleArray = new SelectionIntentRule[] { rule };
for (int j = 0; j < ruleArray.Length; j++)
{
list.Add(ruleArray[j]);
}
}
else
{
NXOpen.Edge[] edges = new NXOpen.Edge[] { icurves[i] as Snap.NX.Edge };
EdgeDumbRule rule2 = Globals.NXOpenWorkPart.ScRuleFactory.CreateRuleEdgeDumb(edges);
SelectionIntentRule[] ruleArray2 = new SelectionIntentRule[] { rule2 };
for (int k = 0; k < ruleArray2.Length; k++)
{
list.Add(ruleArray2[k]);
}
}
}
return(list.ToArray());
}
/// <summary>
/// 抽取曲线
/// </summary>
/// <param name="features"></param>
/// <param name="curves"></param>
/// <param name="associative"></param>
/// <returns></returns>
public static CompositeCurve CreateExtractGeometry(this FeatureCollection features, IBaseCurve[] curves, bool associative = false)
{
NXOpen.Features.CompositeCurveBuilder compositeCurveBuilder1 = _workPart.Features.CreateCompositeCurveBuilder(null);
compositeCurveBuilder1.Tolerance = 0.01;
compositeCurveBuilder1.Associative = associative;
compositeCurveBuilder1.FixAtCurrentTimestamp = true;
compositeCurveBuilder1.JoinOption = NXOpen.Features.CompositeCurveBuilder.JoinMethod.Genernal;
compositeCurveBuilder1.ParentPart = NXOpen.Features.CompositeCurveBuilder.PartType.WorkPart;
compositeCurveBuilder1.Section.DistanceTolerance = 0.01;
compositeCurveBuilder1.Section.ChainingTolerance = 0.0095;
compositeCurveBuilder1.HideOriginal = false;
compositeCurveBuilder1.InheritDisplayProperties = false;
compositeCurveBuilder1.Section.SetAllowedEntityTypes(NXOpen.Section.AllowTypes.CurvesAndPoints);
CurveDumbRule curveDumbRule1 = _workPart.ScRuleFactory.CreateRuleBaseCurveDumb(curves);
compositeCurveBuilder1.Section.AllowSelfIntersection(false);
SelectionIntentRule[] rules1 = new SelectionIntentRule[1] {
curveDumbRule1
};
Point3d helpPoint1 = new Point3d(1885.57193958882, -793.938033503939, 819.818721208804);
compositeCurveBuilder1.Section.AddToSection(rules1, curves[0] as NXObject, null, null, helpPoint1, NXOpen.Section.Mode.Create, false);
CompositeCurve compositeCurve = (CompositeCurve)compositeCurveBuilder1.CommitFeature();
compositeCurveBuilder1.Destroy();
return(compositeCurve);
}
/// <summary>
/// 创建单边偏置的拉伸
/// </summary>
/// <param name="features"></param>
/// <param name="curves"></param>
/// <param name="extrudeDirection"></param>
/// <param name="startDistance"></param>
/// <param name="endDistance"></param>
/// <param name="bodyStyle"></param>
/// <param name="offsetValue"></param>
/// <returns></returns>
public static Extrude CreateExtrude(this FeatureCollection features, IBaseCurve[] curves, Vector3d extrudeDirection, double startDistance, double endDistance, NXOpen.GeometricUtilities.FeatureOptions.BodyStyle bodyStyle, double offsetValue)
{
NXOpen.Features.ExtrudeBuilder extrudeBuilder = features.CreateExtrudeBuilder(null);
Section section1 = WorkPart.Sections.CreateSection(0.0095, 0.01, 0.5);
extrudeBuilder.Section = section1;
extrudeBuilder.AllowSelfIntersectingSection(true);
extrudeBuilder.BooleanOperation.Type = NXOpen.GeometricUtilities.BooleanOperation.BooleanType.Create;
extrudeBuilder.Offset.Option = NXOpen.GeometricUtilities.Type.SingleOffset;
extrudeBuilder.Offset.EndOffset.Value = offsetValue;
extrudeBuilder.Draft.DraftOption = NXOpen.GeometricUtilities.SimpleDraft.SimpleDraftType.NoDraft;
extrudeBuilder.FeatureOptions.BodyType = bodyStyle;
section1.DistanceTolerance = 0.01;
section1.ChainingTolerance = 0.0095;
section1.SetAllowedEntityTypes(NXOpen.Section.AllowTypes.OnlyCurves);
extrudeBuilder.Direction = WorkPart.Directions.CreateDirection(new Point3d(0.0, 0.0, 0.0), extrudeDirection, NXOpen.SmartObject.UpdateOption.WithinModeling);
#if NX12
CurveDumbRule curveDumbRule = (WorkPart as BasePart).ScRuleFactory.CreateRuleBaseCurveDumb(curves);
#else
CurveDumbRule curveDumbRule = WorkPart.ScRuleFactory.CreateRuleBaseCurveDumb(curves);
#endif
section1.AllowSelfIntersection(true);
SelectionIntentRule[] rules1 = new SelectionIntentRule[1] {
curveDumbRule
};
section1.AddToSection(rules1, (NXObject)curves[0], null, null, new Point3d(0, 0, 0), NXOpen.Section.Mode.Create, false);
extrudeBuilder.Limits.StartExtend.TrimType = NXOpen.GeometricUtilities.Extend.ExtendType.Value;
extrudeBuilder.Limits.EndExtend.TrimType = NXOpen.GeometricUtilities.Extend.ExtendType.Value;
extrudeBuilder.Limits.EndExtend.Value.RightHandSide = endDistance.ToString();
extrudeBuilder.Limits.StartExtend.Value.RightHandSide = startDistance.ToString();
extrudeBuilder.ParentFeatureInternal = false;
Extrude extrude = (Extrude)extrudeBuilder.CommitFeature();
extrudeBuilder.Destroy();
return(extrude);
}
private void CreateExtrude(int layerNr)
{
// Create Section
NXObject[] myObjcts = mySketch.GetAllGeometry();
Section mySection = workPart.Sections.CreateSection(0.00095, 0.001, 0.05);
foreach (NXObject obj in myObjcts)
{
if (obj.GetType().ToString() == "NXOpen.Line")
{
Curve[] curves = { (Curve)obj };
CurveDumbRule dumbrule = workPart.ScRuleFactory.CreateRuleCurveDumb(curves);
SelectionIntentRule[] rules = { dumbrule };
mySection.AddToSection(rules, null, null, null, new Point3d(0, 0, 0), Section.Mode.Create, false);
}
}
// Create extrude
Point3d origin = new Point3d(0, 0, 0);
Vector3d axisZ = new Vector3d(0, 0, 1);
SmartObject.UpdateOption updateOption = SmartObject.UpdateOption.DontUpdate;
ExtrudeBuilder extrudeBuilder = workPart.Features.CreateExtrudeBuilder(null);
extrudeBuilder.Section = mySection;
extrudeBuilder.Direction = workPart.Directions.CreateDirection(origin, axisZ, updateOption);
extrudeBuilder.AllowSelfIntersectingSection(true);
extrudeBuilder.DistanceTolerance = 0.001;
extrudeBuilder.Limits.StartExtend.Value.RightHandSide = "0";
extrudeBuilder.Limits.EndExtend.Value.RightHandSide = layerHeight.ToString();
Extrude myExtrude;
if (previousExtrude != null)
{
extrudeBuilder.BooleanOperation.Type = BooleanOperation.BooleanType.Unite;
//extrudeBuilder.BooleanOperation.SetBooleanOperationAndBody(BooleanOperation.BooleanType.Unite, );
myExtrude = (Extrude)extrudeBuilder.Commit();
extrudeBuilder.Destroy();
}
else
{
extrudeBuilder.BooleanOperation.Type = BooleanOperation.BooleanType.Create;
myExtrude = (Extrude)extrudeBuilder.Commit();
extrudeBuilder.Destroy();
}
myExtrude.SetName("Extrude_Layer_" + layerNr.ToString());
DisplayableObject[] objects = { mySketch };
theSession.DisplayManager.BlankObjects(objects); // hide sketch
}
internal static SelectionIntentRule[] CreateSelectionIntentRule(params Snap.NX.Point[] points)
{
if (points == null)
{
return(null);
}
NXOpen.Point[] pointArray = new NXOpen.Point[points.Length];
for (int i = 0; i < pointArray.Length; i++)
{
pointArray[i] = (NXOpen.Point)points[i];
}
CurveDumbRule rule = Globals.NXOpenWorkPart.ScRuleFactory.CreateRuleCurveDumbFromPoints(pointArray);
return(new SelectionIntentRule[] { rule });
}
public Tag CreateSheet()
{
UFSession ufsession = UFSession.GetUFSession();
Point3d point3d = V2.MidPoint3d(V3);
Session session = Session.GetSession();
Part work = session.Parts.Work;
RuledBuilder ruledBuilder = work.Features.CreateRuledBuilder(null);
#if NX12
CurveDumbRule curveDumbRule = (work as BasePart).ScRuleFactory.CreateRuleCurveDumbFromPoints(new Point[] { work.Points.CreatePoint(V1) });
#else
CurveDumbRule curveDumbRule = work.ScRuleFactory.CreateRuleCurveDumbFromPoints(new Point[] { work.Points.CreatePoint(V1) });
#endif
ruledBuilder.FirstSection.AddToSection(new SelectionIntentRule[]
{
curveDumbRule
}, null, null, null, default(Point3d), Section.Mode.Create, false);
Line line = work.Curves.CreateLine(V2, V3);
#if NX12
CurveDumbRule curveDumbRule2 = (work as BasePart).ScRuleFactory.CreateRuleCurveDumb(new Curve[] { line });
#else
CurveDumbRule curveDumbRule2 = work.ScRuleFactory.CreateRuleCurveDumb(new Curve[]
{ line });
#endif
ruledBuilder.SecondSection.AddToSection(new SelectionIntentRule[]
{
curveDumbRule2
}, null, null, null, default(Point3d), Section.Mode.Create, false);
ruledBuilder.PositionTolerance = 0.001;
ruledBuilder.AlignmentMethod.AlignType = AlignmentMethodBuilder.Type.SpineCurve;
ruledBuilder.AlignmentMethod.AlignCurve.DistanceTolerance = 0.01;
ruledBuilder.FirstSection.DistanceTolerance = 0.01;
ruledBuilder.SecondSection.DistanceTolerance = 0.01;
ruledBuilder.FirstSection.SetAllowedEntityTypes(Section.AllowTypes.CurvesAndPoints);
ruledBuilder.SecondSection.SetAllowedEntityTypes(Section.AllowTypes.CurvesAndPoints);
NXObject nxobject = ruledBuilder.Commit();
Ruled ruled = nxobject as Ruled;
Body body = (ruled != null) ? ruled.GetBodies()[0] : null;
ufsession.Modl.DeleteBodyParms(new Tag[]
{
body.Tag
});
line.Delete();
return(body.Tag);
}
internal static Snap.NX.ProjectCurve CreateProjectCurve2(Snap.NX.Curve[] curves, Snap.NX.Point[] points, Snap.NX.Face face)
{
NXOpen.Part work = Globals.Session.Parts.Work;
NXOpen.Features.ProjectCurveBuilder featureBuilder = work.Features.CreateProjectCurveBuilder(null);
featureBuilder.CurveFitData.Tolerance = Globals.DistanceTolerance;
featureBuilder.AngleToProjectionVector.RightHandSide = "0";
featureBuilder.SectionToProject.DistanceTolerance = Globals.DistanceTolerance;
featureBuilder.SectionToProject.ChainingTolerance = (Globals.UnitType == Globals.Unit.Millimeter) ? 0.02413 : 0.00095;
featureBuilder.SectionToProject.SetAllowedEntityTypes(NXOpen.Section.AllowTypes.CurvesAndPoints);
if (curves != null)
{
Snap.NX.Section sectionToProject = featureBuilder.SectionToProject;
for (int i = 0; i < curves.Length; i++)
{
sectionToProject.AddICurve(new Snap.NX.ICurve[] { curves[i] });
}
}
if (points != null)
{
NXOpen.Point[] pointArray = new NXOpen.Point[points.Length];
for (int j = 0; j < pointArray.Length; j++)
{
pointArray[j] = (NXOpen.Point)points[j];
}
CurveDumbRule rule = work.ScRuleFactory.CreateRuleCurveDumbFromPoints(pointArray);
featureBuilder.SectionToProject.AllowSelfIntersection(true);
SelectionIntentRule[] ruleArray = new SelectionIntentRule[] { rule };
Point3d helpPoint = new Point3d(0.0, 0.0, 0.0);
featureBuilder.SectionToProject.AddToSection(ruleArray, null, null, null, helpPoint, NXOpen.Section.Mode.Create, false);
}
ScCollector collector = work.ScCollectors.CreateCollector();
NXOpen.Face[] faces = new NXOpen.Face[] { face };
FaceDumbRule rule2 = work.ScRuleFactory.CreateRuleFaceDumb(faces);
SelectionIntentRule[] rules = new SelectionIntentRule[] { rule2 };
collector.ReplaceRules(rules, false);
featureBuilder.FaceToProjectTo.Add(collector);
NXOpen.Features.Feature feature = (NXOpen.Features.Feature)Snap.NX.Feature.CommitFeature(featureBuilder);
featureBuilder.SectionToProject.CleanMappingData();
featureBuilder.Destroy();
return((NXOpen.Features.ProjectCurve)feature);
}
internal static Snap.NX.ProjectCurve CreateProjectCurve2(Snap.NX.DatumPlane datumPlane, Snap.NX.Curve[] curves, Snap.NX.Point[] points)
{
NXOpen.Part work = Globals.Session.Parts.Work;
NXOpen.Features.ProjectCurveBuilder featureBuilder = work.Features.CreateProjectCurveBuilder(null);
//featureBuilder.CurveFitData.Tolerance = Globals.DistanceTolerance;
featureBuilder.Tolerance = Globals.DistanceTolerance;
featureBuilder.AngleToProjectionVector.RightHandSide = "0";
featureBuilder.SectionToProject.DistanceTolerance = Globals.DistanceTolerance;
featureBuilder.SectionToProject.ChainingTolerance = (Globals.UnitType == Globals.Unit.Millimeter) ? 0.02413 : 0.00095;
featureBuilder.SectionToProject.SetAllowedEntityTypes(NXOpen.SectionEx.AllowTypes.CurvesAndPoints);
if (curves != null)
{
Snap.NX.Section sectionToProject = featureBuilder.SectionToProject;
for (int i = 0; i < curves.Length; i++)
{
sectionToProject.AddICurve(new Snap.NX.ICurve[] { curves[i] });
}
}
if (points != null)
{
NXOpen.Point[] pointArray = new NXOpen.Point[points.Length];
for (int j = 0; j < pointArray.Length; j++)
{
pointArray[j] = (NXOpen.Point)points[j];
}
CurveDumbRule rule = work.ScRuleFactory.CreateRuleCurveDumbFromPoints(pointArray);
featureBuilder.SectionToProject.AllowSelfIntersection(true);
SelectionIntentRule[] rules = new SelectionIntentRule[] { rule };
Point3d helpPoint = new Point3d(0.0, 0.0, 0.0);
featureBuilder.SectionToProject.AddToSection(rules, null, null, null, helpPoint, NXOpen.Section.Mode.Create, false);
}
Position origin = datumPlane.Origin;
Vector normal = datumPlane.Normal;
NXOpen.Plane plane = Globals.NXOpenWorkPart.Planes.CreatePlane((Point3d)origin, (Vector3d)normal, SmartObject.UpdateOption.WithinModeling);
featureBuilder.PlaneToProjectTo = plane;
NXOpen.Features.Feature feature = (NXOpen.Features.Feature)Snap.NX.Feature.CommitFeature(featureBuilder);
featureBuilder.SectionToProject.CleanMappingData();
featureBuilder.Destroy();
return((NXOpen.Features.ProjectCurve)feature);
}
/// <summary>
/// 创建有界平面
/// </summary>
/// <param name="featureCollection"></param>
/// <param name="boundingCurves"></param>
/// <returns></returns>
public static BoundedPlane CreateBoundedPlane(this FeatureCollection featureCollection, IBaseCurve[] boundingCurves)
{
if (boundingCurves.Length != 0)
{
BoundedPlaneBuilder boundedPlaneBuilder = _workPart.Features.CreateBoundedPlaneBuilder(null);
boundedPlaneBuilder.BoundingCurves.SetAllowedEntityTypes(NXOpen.Section.AllowTypes.OnlyCurves);
CurveDumbRule curveDumbRule1 = _workPart.ScRuleFactory.CreateRuleBaseCurveDumb(boundingCurves);
boundedPlaneBuilder.BoundingCurves.AllowSelfIntersection(true);
NXOpen.SelectionIntentRule[] rules1 = new SelectionIntentRule[1];
rules1[0] = curveDumbRule1;
boundedPlaneBuilder.BoundingCurves.AddToSection(rules1, boundingCurves[0] as NXObject, null, null, new Point3d(), Section.Mode.Create, false);
BoundedPlane nXObject1 = (BoundedPlane)boundedPlaneBuilder.Commit();
boundedPlaneBuilder.Destroy();
return(nXObject1);
}
return(null);
}
