internal static Snap.NX.Chamfer CreateChamfer(Snap.NX.Edge edge, Snap.Number distance1, Snap.Number distance2, bool offsetFaces)
{
NXOpen.Part workPart = (NXOpen.Part)Globals.WorkPart;
NXOpen.Features.ChamferBuilder featureBuilder = workPart.Features.CreateChamferBuilder(null);
featureBuilder.Option = NXOpen.Features.ChamferBuilder.ChamferOption.TwoOffsets;
if (offsetFaces)
{
featureBuilder.Method = NXOpen.Features.ChamferBuilder.OffsetMethod.FacesAndTrim;
}
else
{
featureBuilder.Method = NXOpen.Features.ChamferBuilder.OffsetMethod.EdgesAlongFaces;
}
featureBuilder.FirstOffset = distance1.ToString();
featureBuilder.SecondOffset = distance2.ToString();
//featureBuilder.Tolerance = Globals.DistanceTolerance;
ScCollector collector = workPart.ScCollectors.CreateCollector();
EdgeTangentRule rule = workPart.ScRuleFactory.CreateRuleEdgeTangent((NXOpen.Edge)edge, null, false, Globals.AngleTolerance, false, false);
SelectionIntentRule[] rules = new SelectionIntentRule[] { rule };
collector.ReplaceRules(rules, false);
featureBuilder.SmartCollector = collector;
NXOpen.Features.Feature feature = (NXOpen.Features.Feature)Snap.NX.Feature.CommitFeature(featureBuilder);
featureBuilder.Destroy();
return((NXOpen.Features.Chamfer)feature);
}
internal static Snap.NX.SplitBody CreateSplitBody(Snap.NX.Body targetBody, Snap.NX.Face[] toolFaces)
{
NXOpen.Part work = Globals.Session.Parts.Work;
NXOpen.Features.SplitBodyBuilder featureBuilder = work.Features.CreateSplitBodyBuilder(null);
featureBuilder.BooleanTool.ExtrudeRevolveTool.ToolSection.PrepareMappingData();
featureBuilder.BooleanTool.ExtrudeRevolveTool.ToolSection.DistanceTolerance = Globals.DistanceTolerance;
featureBuilder.BooleanTool.ExtrudeRevolveTool.ToolSection.ChainingTolerance = (Globals.UnitType == Globals.Unit.Millimeter) ? 0.02413 : 0.00095;
ScCollector collector = work.ScCollectors.CreateCollector();
NXOpen.Body[] bodies = new NXOpen.Body[] { targetBody };
BodyDumbRule rule = work.ScRuleFactory.CreateRuleBodyDumb(bodies);
SelectionIntentRule[] rules = new SelectionIntentRule[] { rule };
collector.ReplaceRules(rules, false);
featureBuilder.TargetBodyCollector = collector;
SelectionIntentRule[] ruleArray2 = new SelectionIntentRule[toolFaces.Length];
for (int i = 0; i < toolFaces.Length; i++)
{
ruleArray2[i] = work.ScRuleFactory.CreateRuleFaceBody((NXOpen.Body)toolFaces[i].Body);
}
featureBuilder.BooleanTool.FacePlaneTool.ToolFaces.FaceCollector.ReplaceRules(ruleArray2, false);
NXOpen.Features.SplitBody split = (NXOpen.Features.SplitBody)Snap.NX.Feature.CommitFeature(featureBuilder);
featureBuilder.Destroy();
return(new Snap.NX.SplitBody(split));
}
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);
}
internal static Snap.NX.EdgeBlend CreateEdgeBlend(Snap.Number radius, Snap.NX.Edge[] edges)
{
NXOpen.Part workPart = (NXOpen.Part)Globals.WorkPart;
NXOpen.Features.EdgeBlendBuilder featureBuilder = workPart.Features.CreateEdgeBlendBuilder(null);
BlendLimitsData limitsListData = featureBuilder.LimitsListData;
ScCollector collector = workPart.ScCollectors.CreateCollector();
NXOpen.Edge[] seedEdges = new NXOpen.Edge[edges.Length];
for (int i = 0; i < seedEdges.Length; i++)
{
seedEdges[i] = (NXOpen.Edge)edges[i];
}
EdgeMultipleSeedTangentRule rule = workPart.ScRuleFactory.CreateRuleEdgeMultipleSeedTangent(seedEdges, Globals.AngleTolerance, true);
SelectionIntentRule[] rules = new SelectionIntentRule[] { rule };
collector.ReplaceRules(rules, false);
featureBuilder.Tolerance = Globals.DistanceTolerance;
featureBuilder.AllInstancesOption = false;
featureBuilder.RemoveSelfIntersection = true;
featureBuilder.ConvexConcaveY = false;
featureBuilder.RollOverSmoothEdge = true;
featureBuilder.RollOntoEdge = true;
featureBuilder.MoveSharpEdge = true;
featureBuilder.TrimmingOption = false;
featureBuilder.OverlapOption = NXOpen.Features.EdgeBlendBuilder.Overlap.AnyConvexityRollOver;
featureBuilder.BlendOrder = NXOpen.Features.EdgeBlendBuilder.OrderOfBlending.ConvexFirst;
featureBuilder.SetbackOption = NXOpen.Features.EdgeBlendBuilder.Setback.SeparateFromCorner;
featureBuilder.AddChainset(collector, radius.ToString());
NXOpen.Features.Feature feature = (NXOpen.Features.Feature)Snap.NX.Feature.CommitFeature(featureBuilder);
featureBuilder.Destroy();
return((NXOpen.Features.EdgeBlend)feature);
}
internal static Snap.NX.ProjectCurve CreateProjectCurve(Snap.NX.Curve[] curves, Snap.NX.Point[] points, Snap.NX.Face face)
{
NXOpen.Part workPart = (NXOpen.Part)Globals.WorkPart;
NXOpen.Features.ProjectCurveBuilder featureBuilder = workPart.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);
featureBuilder.ProjectionDirectionMethod = NXOpen.Features.ProjectCurveBuilder.DirectionType.AlongFaceNormal;
Snap.NX.Section sectionToProject = featureBuilder.SectionToProject;
sectionToProject.AddICurve(curves);
sectionToProject.AddPoints(points);
ScCollector collector = workPart.ScCollectors.CreateCollector();
NXOpen.Face[] faces = new NXOpen.Face[] { face };
FaceDumbRule rule = workPart.ScRuleFactory.CreateRuleFaceDumb(faces);
SelectionIntentRule[] rules = new SelectionIntentRule[] { rule };
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);
}
/// <summary>
/// 获取极限点
/// </summary>
/// <param name="measureManager"></param>
/// <param name="faces">要进行计算的面</param>
/// <param name="measureDirection">第一个方向</param>
/// <param name="secondDirection">第二个方向</param>
/// <param name="thirdDirection">第三个方向</param>
/// <returns>结果点</returns>
public static Point3d MeasureExtreme(this MeasureManager measureManager, Face[] faces, Vector3d measureDirection, Vector3d secondDirection, Vector3d thirdDirection)
{
NXOpen.Unit lengthUnit = WorkPart.UnitCollection.FindObject("MilliMeter");
#if NX12
FaceDumbRule faceDumbRule = (WorkPart as BasePart).ScRuleFactory.CreateRuleFaceDumb(faces);
#else
FaceDumbRule faceDumbRule = WorkPart.ScRuleFactory.CreateRuleFaceDumb(faces);
#endif
ScCollector scCollector = WorkPart.ScCollectors.CreateCollector();
scCollector.ReplaceRules(new SelectionIntentRule[] { faceDumbRule }, false);
Direction direction1 = WorkPart.Directions.CreateDirection(new Point3d(), measureDirection, NXOpen.SmartObject.UpdateOption.WithinModeling);
Direction direction2 = WorkPart.Directions.CreateDirection(new Point3d(), secondDirection, NXOpen.SmartObject.UpdateOption.WithinModeling);
Direction direction3 = WorkPart.Directions.CreateDirection(new Point3d(), thirdDirection, NXOpen.SmartObject.UpdateOption.WithinModeling);
var facesExtreme = measureManager.NewRectangularExtreme(lengthUnit, direction1, direction2, direction3, scCollector, false);
return(facesExtreme.Point);
}
internal static Snap.NX.Chamfer CreateChamfer(Snap.NX.Edge edge, Snap.Number distance, Snap.Number angle)
{
NXOpen.Part workPart = (NXOpen.Part)Globals.WorkPart;
NXOpen.Features.ChamferBuilder featureBuilder = workPart.Features.CreateChamferBuilder(null);
featureBuilder.Option = NXOpen.Features.ChamferBuilder.ChamferOption.OffsetAndAngle;
featureBuilder.FirstOffset = distance.ToString();
featureBuilder.Angle = angle.ToString();
//featureBuilder.Tolerance = Globals.DistanceTolerance;
ScCollector collector = workPart.ScCollectors.CreateCollector();
EdgeTangentRule rule = workPart.ScRuleFactory.CreateRuleEdgeTangent((NXOpen.Edge)edge, null, true, Globals.AngleTolerance, false, false);
SelectionIntentRule[] rules = new SelectionIntentRule[] { rule };
collector.ReplaceRules(rules, false);
featureBuilder.SmartCollector = collector;
featureBuilder.AllInstances = false;
NXOpen.Features.Feature feature = (NXOpen.Features.Feature)Snap.NX.Feature.CommitFeature(featureBuilder);
featureBuilder.Destroy();
return((NXOpen.Features.Chamfer)feature);
}
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);
}
/// <summary>
/// 创建圆柱特征
/// </summary>
/// <param name="zAxis">轴</param>
/// <param name="centerPt">中心点</param>
/// <param name="offset"></param>
/// <param name="toolingBoxFeature"></param>
/// <param name="objs"></param>
/// <returns></returns>
public static ToolingBox CreateToolingCylinder(Vector3d zAxis, Point3d centerPt, double[] offset, ToolingBox toolingBoxFeature = null, params TaggedObject[] objs)
{
Part workPart = theSession.Parts.Work;
SelectionRuleFactory rules = new SelectionRuleFactory(objs.ToList());
//ToolingBox nullToolingBox = null;
ToolingBoxBuilder toolingBoxBuilder = workPart.Features.ToolingFeatureCollection.CreateToolingBoxBuilder(toolingBoxFeature);
toolingBoxBuilder.Type = ToolingBoxBuilder.Types.BoundedCylinder;
Direction dir = workPart.Directions.CreateDirection(centerPt, zAxis, SmartObject.UpdateOption.WithinModeling);
toolingBoxBuilder.AxisVector = dir;
toolingBoxBuilder.RadialOffset.Value = offset[2];
toolingBoxBuilder.OffsetPositiveZ.Value = offset[0];
toolingBoxBuilder.OffsetNegativeZ.Value = offset[1];
// toolingBoxBuilder.SingleOffset = false;
ScCollector scCollector = toolingBoxBuilder.BoundedObject;
scCollector.ReplaceRules(rules.CreateSelectionRule().ToArray(), false);
toolingBoxBuilder.CalculateBoxSize();
NXObject[] selections = new NXObject[1];
NXObject[] deselections = new NXObject[1];
selections[0] = (NXObject)objs[0];
toolingBoxBuilder.SetSelectedOccurrences(selections, deselections);
toolingBoxBuilder.CalculateBoxSize();
NXOpen.Session.UndoMarkId markId = theSession.SetUndoMark(NXOpen.Session.MarkVisibility.Invisible, "Start ToolingBox");
try
{
return(toolingBoxBuilder.CommitFeature() as ToolingBox);
}
catch (Exception ex)
{
LogMgr.WriteLog("Basic.ToolingFeature.CreateToolingBox:错误：" + ex.Message);
return(null);
}
finally
{
toolingBoxBuilder.Destroy();
theSession.UpdateManager.DoUpdate(markId);
theSession.DeleteUndoMark(markId, "End ToolingBox");
}
}
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>
/// <param name="matr">矩阵</param>
/// <param name="centerPt">中心坐标</param>
/// <param name="offset">偏置 offset[6]</param>
/// <param name="toolingBoxFeature">方块盒特征</param>
/// <param name="objs"></param>
/// <returns></returns>
public static ToolingBox CreateToolingBlockBox(Matrix3x3 matr, Point3d centerPt, double[] offset, ToolingBox toolingBoxFeature = null, params TaggedObject[] objs)
{
Part workPart = theSession.Parts.Work;
SelectionRuleFactory rules = new SelectionRuleFactory(objs.ToList());
//ToolingBox nullToolingBox = null;
ToolingBoxBuilder toolingBoxBuilder = workPart.Features.ToolingFeatureCollection.CreateToolingBoxBuilder(toolingBoxFeature);
toolingBoxBuilder.Type = ToolingBoxBuilder.Types.BoundedBlock;
toolingBoxBuilder.OffsetPositiveX.Value = offset[0];
toolingBoxBuilder.OffsetNegativeX.Value = offset[1];
toolingBoxBuilder.OffsetPositiveY.Value = offset[2];
toolingBoxBuilder.OffsetNegativeY.Value = offset[3];
toolingBoxBuilder.OffsetPositiveZ.Value = offset[4];
toolingBoxBuilder.OffsetNegativeZ.Value = offset[5];
toolingBoxBuilder.SingleOffset = false;
toolingBoxBuilder.SetBoxMatrixAndPosition(matr, centerPt);
ScCollector scCollector = toolingBoxBuilder.BoundedObject;
scCollector.ReplaceRules(rules.CreateSelectionRule().ToArray(), false);
toolingBoxBuilder.CalculateBoxSize();
NXOpen.Session.UndoMarkId markId = theSession.SetUndoMark(NXOpen.Session.MarkVisibility.Invisible, "Start ToolingBox");
try
{
return(toolingBoxBuilder.CommitFeature() as ToolingBox);
}
catch (Exception ex)
{
LogMgr.WriteLog("Basic.ToolingFeature.CreateToolingBox:错误：" + ex.Message);
return(null);
}
finally
{
toolingBoxBuilder.Destroy();
theSession.UpdateManager.DoUpdate(markId);
theSession.DeleteUndoMark(markId, "End ToolingBox");
}
}
/// <summary>
/// 测量点到一组对象之间的最短距离，只能是当前工作部件中的对象，可用类型为 Point, Curve, Edge, Face, Body, Datum Plane.
/// </summary>
/// <param name="measureManager"></param>
/// <param name="point">出发点</param>
/// <param name="objects"></param>
/// <returns>距离值</returns>
public static (bool Success, double Distance, Point3d PointOnObjects) MeasureDistance(this MeasureManager measureManager, Point3d point, NXObject[] objects)
{
try
{
#if NX12
NXOpen.CurveDumbRule curveDumbRule1 = (WorkPart as BasePart).ScRuleFactory.CreateRuleCurveDumbFromPoints(new Point[] { WorkPart.Points.CreatePoint(point) });
#else
NXOpen.CurveDumbRule curveDumbRule1 = WorkPart.ScRuleFactory.CreateRuleCurveDumbFromPoints(new Point[] { WorkPart.Points.CreatePoint(point) });
#endif
ScCollector scCollector1 = WorkPart.ScCollectors.CreateCollector();
scCollector1.ReplaceRules(new SelectionIntentRule[] { curveDumbRule1 }, false);
ScCollector scCollector2 = CreateCollector(objects);
NXOpen.Unit lengthUnit = WorkPart.UnitCollection.FindObject("MilliMeter");
var minimumMeasure = measureManager.NewScDistance(lengthUnit, MeasureManager.MeasureType.Minimum, true, scCollector1, scCollector2);
var measureFeature = minimumMeasure.CreateFeature();
var measureLine = measureFeature.GetEntities()[0] as Line;
var minimumDistance = measureLine.GetLength();
Point3d pointOnObjects = measureLine.EndPoint;
measureFeature.Delete();
return(true, minimumDistance, pointOnObjects);
}
catch (Exception)
{
return(false, 0, new Point3d());
}
}
//------------------------------------------------------------------------------
// Callback Name: apply_cb
// Following callback is associated with the "changeDialog" Styler item.
// Input: eventObject - object of UIStyler.StylerEvent class
//------------------------------------------------------------------------------
//Following is Apply Callback - This function is responsible for creating Edge Blend.
public NXOpen.UIStyler.DialogState apply_cb(NXOpen.UIStyler.StylerEvent eventObject)
{
try
{
Part workPart = theSession.Parts.Work;
Part displayPart = theSession.Parts.Display;
// ----------------------------------------------
// Menu: Insert->Detail Feature->Edge Blend...
// ----------------------------------------------
Session.UndoMarkId markId1 = theSession.SetUndoMark(Session.MarkVisibility.Visible, "Start");
NXOpen.Features.Feature nullFeatures_Feature = null;
NXOpen.Features.EdgeBlendBuilder edgeBlendBuilder1 = workPart.Features.CreateEdgeBlendBuilder(nullFeatures_Feature);
theSession.SetUndoMarkName(markId1, "Edge Blend");
Boolean featureAlerts1 = theSession.Preferences.Modeling.FeatureAlerts;
ScCollector scCollector1 = workPart.ScCollectors.CreateCollector();
NXOpen.Features.Block block1 = (NXOpen.Features.Block)workPart.Features.FindObject("BLOCK(1)");
Boolean featureAlerts2 = theSession.Preferences.Modeling.FeatureAlerts;
Boolean featureAlerts3 = theSession.Preferences.Modeling.FeatureAlerts;
Edge[] seedEdges1 = new Edge[htEdges.Count];
IDictionaryEnumerator en = htEdges.GetEnumerator();
int EdgeIndex = 0;
while (en.MoveNext())
{
Edge edgeVar = (Edge)en.Value;;
seedEdges1[EdgeIndex] = edgeVar;
EdgeIndex += 1;
}
EdgeMultipleSeedTangentRule edgeMultipleSeedTangentRule2 = workPart.ScRuleFactory.CreateRuleEdgeMultipleSeedTangent(seedEdges1, 0.5, true);
SelectionIntentRule[] rules2 = new SelectionIntentRule[1];
rules2[0] = edgeMultipleSeedTangentRule2;
scCollector1.ReplaceRules(rules2, false);
Boolean featureAlerts4 = theSession.Preferences.Modeling.FeatureAlerts;
Boolean featureAlerts5 = theSession.Preferences.Modeling.FeatureAlerts;
Session.UndoMarkId markId2 = theSession.SetUndoMark(Session.MarkVisibility.Invisible, "Edge Blend");
//Following can set the Tolerance for Edge Blend.
edgeBlendBuilder1.Tolerance = changeReal6.ItemValue;
edgeBlendBuilder1.AllInstancesOption = false;
//Following can set the Remove Self Intersection option for the Edge Blend.
edgeBlendBuilder1.RemoveSelfIntersection = changeToggle6.ItemValue;
edgeBlendBuilder1.ConvexConcaveY = false;
edgeBlendBuilder1.RollOverSmoothEdge = true;
edgeBlendBuilder1.RollOntoEdge = true;
edgeBlendBuilder1.MoveSharpEdge = true;
edgeBlendBuilder1.OverlapOption = NXOpen.Features.EdgeBlendBuilder.Overlap.AnyConvexityRollOver;
edgeBlendBuilder1.BlendOrder = NXOpen.Features.EdgeBlendBuilder.OrderOfBlending.ConvexFirst;
edgeBlendBuilder1.SetbackOption = NXOpen.Features.EdgeBlendBuilder.Setback.SeparateFromCorner;
//Following sets the value for Blend Radius.
int csIndex1 = edgeBlendBuilder1.AddChainset(scCollector1, changeStr0.ItemValue);
NXOpen.Features.Feature feature1 = edgeBlendBuilder1.CommitFeature();
theSession.DeleteUndoMark(markId2, null);
edgeBlendBuilder1.Destroy();
htEdges.Clear();
changeLabel1.SetLabel("Select Edges (0)");
}
catch (NXOpen.NXException ex)
{
// ---- Enter your exception handling code here -----
theUI.NXMessageBox.Show("UI Styler", NXMessageBox.DialogType.Error, ex.Message);
}
// Callback acknowledged, do not terminate dialog
// A return value of NXOpen.UIStyler.DialogState.ExitDialog will not be accepted
// for this callback type. You must respond to your apply button.
return(NXOpen.UIStyler.DialogState.ContinueDialog);
}
