int qiaowei_tool::apply_cb()
{
int errorCode = 0; // 错误代码，0表示成功
NXOpen::Body* firstExtrudeBody = nullptr;// 将声明移到函数作用域
try
{
// 获取NX会话和工作部件
NXOpen::Session* theSession = NXOpen::Session::GetSession();
NXOpen::Part* workPart = theSession->Parts()->Work();
NXOpen::UI* theUI = NXOpen::UI::GetUI();
// ===== 1. 获取边界边曲线 =====
std::vector<NXOpen::Curve*> boundaryCurves;
if (bianjie_edge)
{
// 获取曲线选择器属性列表
std::unique_ptr<NXOpen::BlockStyler::PropertyList> props(bianjie_edge->GetProperties());
// 获取选中的对象集合
std::vector<NXOpen::TaggedObject*> selObjs = props->GetTaggedObjectVector("SelectedObjects");
// 遍历选中对象并转换为曲线
for (NXOpen::TaggedObject* obj : selObjs) {
if (NXOpen::Curve* curve = dynamic_cast<NXOpen::Curve*>(obj)) {
boundaryCurves.push_back(curve);
}
}
}
// ===== 2. 获取出料边曲线 =====
std::vector<NXOpen::Curve*> dischargeCurves;
if (chuliao_edge)
{
std::unique_ptr<NXOpen::BlockStyler::PropertyList> props(chuliao_edge->GetProperties());
std::vector<NXOpen::TaggedObject*> selObjs = props->GetTaggedObjectVector("SelectedObjects");
for (NXOpen::TaggedObject* obj : selObjs) {
if (NXOpen::Curve* curve = dynamic_cast<NXOpen::Curve*>(obj)) {
dischargeCurves.push_back(curve);
}
}
}
// ===== 3. 获取出料沉桥值 =====
double materialThickness = 0.0;
if (expression_clcq)
{
std::unique_ptr<NXOpen::BlockStyler::PropertyList> props(expression_clcq->GetProperties());
// 获取表达式数值
materialThickness = props->GetDouble("Value");
}
// ===== 4. 获取上模厚度值 =====
double scanHeight = 0.0;
if (expression_smh)
{
std::unique_ptr<NXOpen::BlockStyler::PropertyList> props(expression_smh->GetProperties());
scanHeight = props->GetDouble("Value");
}
// ===== 5. 获取进料沉桥值 =====
double clearanceValue = 0.0;
if (expression_jlcq)
{
std::unique_ptr<NXOpen::BlockStyler::PropertyList> props(expression_jlcq->GetProperties());
clearanceValue = props->GetDouble("Value");
}
// ===== 6. 获取倒桥角度值 =====
double currentAngle = 0.0;
if (expression_dqjiaodu)
{
std::unique_ptr<NXOpen::BlockStyler::PropertyList> props(expression_dqjiaodu->GetProperties());
currentAngle = props->GetDouble("Value");
}
// ===== 7. 获取倒角开关状态 =====
bool chamferToggle = false;
if (toggle_daojiao)
{
std::unique_ptr<NXOpen::BlockStyler::PropertyList> props(toggle_daojiao->GetProperties());
// 获取开关状态（选中/未选中）
chamferToggle = props->GetLogical("Value");
}
// ===== 8. 获取倒角半径值 =====
double chamferRadius = 0.0;
if (expression_rjiao && chamferToggle) // 仅在倒角开启时获取
{
std::unique_ptr<NXOpen::BlockStyler::PropertyList> props(expression_rjiao->GetProperties());
chamferRadius = props->GetDouble("Value");
}
// ===== 9. 获取偏移开关状态 =====
bool offsetToggle = false;
if (toggle_pianzhi)
{
std::unique_ptr<NXOpen::BlockStyler::PropertyList> props(toggle_pianzhi->GetProperties());
offsetToggle = props->GetLogical("Value");
}
// ===== 10. 获取偏移距离值 =====
double offsetDistance = 0.0;
if (expression_pianzhi && offsetToggle) // 仅在偏移开启时获取
{
std::unique_ptr<NXOpen::BlockStyler::PropertyList> props(expression_pianzhi->GetProperties());
offsetDistance = props->GetDouble("Value");
}
// ===== 11. 获取矢量方向 =====
NXOpen::Vector3d directionVector(0.0, 0.0, 1.0); // 默认Z轴方向
if (vector0)
{
std::unique_ptr<NXOpen::BlockStyler::PropertyList> props(vector0->GetProperties());
// 获取用户指定的矢量方向
directionVector = props->GetVector("Vector");
}
// ===== 12. 验证必要输入 =====
if (boundaryCurves.size() < 2) {
throw std::runtime_error("需要选择两条桥位边界曲线!");
}
if (dischargeCurves.empty()) {
throw std::runtime_error("出料边曲线未选择!");
}
if (scanHeight <= 0) {
throw std::runtime_error("上模厚度必须大于0!");
}
// ===== 13. 计算两条边界曲线端点间的最短距离并创建两条连接直线 =====
tag_t line1Tag = NULL_TAG;
tag_t line2Tag = NULL_TAG;
double minDist = 0.0;
double remainingDist = 0.0;
try {
// 获取前两条边界曲线
NXOpen::Curve* curve1 = boundaryCurves[0];
NXOpen::Curve* curve2 = boundaryCurves[1];
// 获取曲线端点
double curve1Start[3] = { 0.0 }, curve1End[3] = { 0.0 };
double curve2Start[3] = { 0.0 }, curve2End[3] = { 0.0 };
// 获取曲线1端点
UF_EVAL_p_t evaluator1 = NULL;
if (UF_EVAL_initialize(curve1->Tag(), &evaluator1) != 0) {
throw std::runtime_error("无法初始化曲线1的评估器");
}
double limits1[2];
if (UF_EVAL_ask_limits(evaluator1, limits1) != 0) {
UF_EVAL_free(evaluator1);
throw std::runtime_error("无法获取曲线1的参数范围");
}
if (limits1[0] > limits1[1]) std::swap(limits1[0], limits1[1]);
if (UF_EVAL_evaluate(evaluator1, 0, limits1[0], curve1Start, NULL) != 0 ||
UF_EVAL_evaluate(evaluator1, 0, limits1[1], curve1End, NULL) != 0) {
UF_EVAL_free(evaluator1);
throw std::runtime_error("无法评估曲线1的端点");
}
UF_EVAL_free(evaluator1);
// 获取曲线2端点
UF_EVAL_p_t evaluator2 = NULL;
if (UF_EVAL_initialize(curve2->Tag(), &evaluator2) != 0) {
throw std::runtime_error("无法初始化曲线2的评估器");
}
double limits2[2];
if (UF_EVAL_ask_limits(evaluator2, limits2) != 0) {
UF_EVAL_free(evaluator2);
throw std::runtime_error("无法获取曲线2的参数范围");
}
if (limits2[0] > limits2[1]) std::swap(limits2[0], limits2[1]);
if (UF_EVAL_evaluate(evaluator2, 0, limits2[0], curve2Start, NULL) != 0 ||
UF_EVAL_evaluate(evaluator2, 0, limits2[1], curve2End, NULL) != 0) {
UF_EVAL_free(evaluator2);
throw std::runtime_error("无法评估曲线2的端点");
}
UF_EVAL_free(evaluator2);
// 转换为NXOpen点对象
NXOpen::Point3d p1_start(curve1Start[0], curve1Start[1], curve1Start[2]);
NXOpen::Point3d p1_end(curve1End[0], curve1End[1], curve1End[2]);
NXOpen::Point3d p2_start(curve2Start[0], curve2Start[1], curve2Start[2]);
NXOpen::Point3d p2_end(curve2End[0], curve2End[1], curve2End[2]);
// 计算两点间距离的函数
auto distance = [](const NXOpen::Point3d& a, const NXOpen::Point3d& b) -> double {
return sqrt(pow(a.X - b.X, 2) + pow(a.Y - b.Y, 2) + pow(a.Z - b.Z, 2));
};
// 计算四种可能的端点组合距离
double dist1 = distance(p1_start, p2_start);
double dist2 = distance(p1_start, p2_end);
double dist3 = distance(p1_end, p2_start);
double dist4 = distance(p1_end, p2_end);
// 找出最小距离对应的点对
minDist = std::min({ dist1, dist2, dist3, dist4 });
NXOpen::Point3d minPoint1, minPoint2;
int minIndex = 0;
if (minDist == dist1) {
minPoint1 = p1_start; minPoint2 = p2_start;
}
else if (minDist == dist2) {
minPoint1 = p1_start; minPoint2 = p2_end;
}
else if (minDist == dist3) {
minPoint1 = p1_end; minPoint2 = p2_start;
}
else {
minPoint1 = p1_end; minPoint2 = p2_end;
}
// 确定剩余的两个端点
auto isPointEqual = [](const NXOpen::Point3d& a, const NXOpen::Point3d& b, double tol = 1e-6) -> bool {
return (fabs(a.X - b.X) < tol) && (fabs(a.Y - b.Y) < tol) && (fabs(a.Z - b.Z) < tol);
};
NXOpen::Point3d remainingPoint1 = isPointEqual(minPoint1, p1_start) ? p1_end : p1_start;
NXOpen::Point3d remainingPoint2 = isPointEqual(minPoint2, p2_start) ? p2_end : p2_start;
remainingDist = distance(remainingPoint1, remainingPoint2);
// ===== 创建两条连接直线 =====
// 创建第一条直线（最短距离连接）
UF_CURVE_line_t line1Coords;
line1Coords.start_point[0] = minPoint1.X;
line1Coords.start_point[1] = minPoint1.Y;
line1Coords.start_point[2] = minPoint1.Z;
line1Coords.end_point[0] = minPoint2.X;
line1Coords.end_point[1] = minPoint2.Y;
line1Coords.end_point[2] = minPoint2.Z;
if (UF_CURVE_create_line(&line1Coords, &line1Tag) != 0 || line1Tag == NULL_TAG) {
throw std::runtime_error("创建最短距离直线失败");
}
// 设置第一条直线属性
int workLayer = workPart->Layers()->WorkLayer();
UF_OBJ_set_layer(line1Tag, 254);
// 创建第二条直线（剩余端点连接）
UF_CURVE_line_t line2Coords;
line2Coords.start_point[0] = remainingPoint1.X;
line2Coords.start_point[1] = remainingPoint1.Y;
line2Coords.start_point[2] = remainingPoint1.Z;
line2Coords.end_point[0] = remainingPoint2.X;
line2Coords.end_point[1] = remainingPoint2.Y;
line2Coords.end_point[2] = remainingPoint2.Z;
if (UF_CURVE_create_line(&line2Coords, &line2Tag) != 0 || line2Tag == NULL_TAG) {
throw std::runtime_error("创建剩余端点直线失败");
}
// 设置第二条直线属性
UF_OBJ_set_layer(line2Tag, 254);
UF_LAYER_set_status(254, UF_LAYER_INACTIVE_LAYER);
// 更新显示
UF_DISP_refresh();
// 显示成功信息
char msg[256];
snprintf(msg, sizeof(msg),
"已创建两条连接直线:\n"
"1. 最短距离直线: %.2f mm\n"
"2. 剩余端点直线: %.2f mm",
minDist, remainingDist);
theUI->NXMessageBox()->Show("操作成功",
NXOpen::NXMessageBox::DialogTypeInformation, msg);
}
catch (std::exception& ex) {
char errMsg[256];
snprintf(errMsg, sizeof(errMsg), "端点距离计算或直线创建失败: %s", ex.what());
theUI->NXMessageBox()->Show("错误",
NXOpen::NXMessageBox::DialogTypeError, errMsg);
errorCode = 2;
return errorCode; // 提前返回，不再继续后续操作
}
// ===== 14. 创建拉伸特征（新建体） =====
try {
// 设置撤销标记
NXOpen::Session::UndoMarkId markId = theSession->SetUndoMark(
NXOpen::Session::MarkVisibilityVisible, "桥位拉伸");
// 创建拉伸构建器
NXOpen::Features::ExtrudeBuilder* extrudeBuilder =
workPart->Features()->CreateExtrudeBuilder(nullptr);
// 创建截面
NXOpen::Section* section = workPart->Sections()->CreateSection(
0.001, 0.001, 0.05);
extrudeBuilder->SetSection(section);
// 准备截面曲线：边界曲线 + 连接直线
std::vector<NXOpen::Curve*> sectionCurves;
sectionCurves.push_back(boundaryCurves[0]);
sectionCurves.push_back(boundaryCurves[1]);
// 将直线标签转换为曲线对象
NXOpen::Curve* line1Curve = dynamic_cast<NXOpen::Curve*>(
NXOpen::NXObjectManager::Get(line1Tag));
NXOpen::Curve* line2Curve = dynamic_cast<NXOpen::Curve*>(
NXOpen::NXObjectManager::Get(line2Tag));
if (line1Curve) sectionCurves.push_back(line1Curve);
if (line2Curve) sectionCurves.push_back(line2Curve);
// 创建曲线规则
std::vector<NXOpen::SelectionIntentRule*> rules;
if (!sectionCurves.empty()) {
NXOpen::SelectionIntentRule* curveRule =
workPart->ScRuleFactory()->CreateRuleCurveDumb(sectionCurves);
rules.push_back(curveRule);
}
// 获取帮助点（中点）
NXOpen::Point3d helpPoint(0.0, 0.0, 0.0);
if (!sectionCurves.empty()) {
tag_t curveTag = sectionCurves[0]->Tag();
UF_EVAL_p_t evaluator = NULL;
double limits[2];
if (UF_EVAL_initialize(curveTag, &evaluator) == 0) {
if (UF_EVAL_ask_limits(evaluator, limits) == 0) {
if (limits[0] > limits[1]) std::swap(limits[0], limits[1]);
double midParam = (limits[0] + limits[1]) / 2.0;
double midPoint[3];
if (UF_EVAL_evaluate(evaluator, 0, midParam, midPoint, NULL) == 0) {
helpPoint = NXOpen::Point3d(midPoint[0], midPoint[1], midPoint[2]);
}
}
UF_EVAL_free(evaluator);
}
}
// 添加到截面
section->AddToSection(
rules,
sectionCurves[0],
NULL,
NULL,
helpPoint,
NXOpen::Section::ModeCreate
);
// 设置拉伸方向
NXOpen::Point3d origin(0.0, 0.0, 0.0);
NXOpen::Direction* extrudeDirection =
workPart->Directions()->CreateDirection(
origin,
directionVector,
NXOpen::SmartObject::UpdateOptionWithinModeling
);
extrudeBuilder->SetDirection(extrudeDirection);
// 设置拉伸范围
NXOpen::GeometricUtilities::Limits* limitsObj = extrudeBuilder->Limits();
limitsObj->StartExtend()->Value()->SetRightHandSide(
std::to_string(materialThickness).c_str());
double endDistance = scanHeight - clearanceValue;
limitsObj->EndExtend()->Value()->SetRightHandSide(
std::to_string(endDistance).c_str());
// ===== 设置布尔操作为新建体 =====
extrudeBuilder->BooleanOperation()->SetType(
NXOpen::GeometricUtilities::BooleanOperation::BooleanTypeCreate);
// ===== 执行拉伸操作 =====
try {
// 提交拉伸操作
NXOpen::NXObject* featureNXObject = extrudeBuilder->Commit();
// 将特征对象转换为Extrude类型
NXOpen::Features::Extrude* extrudeFeature =
dynamic_cast<NXOpen::Features::Extrude*>(featureNXObject);
if (extrudeFeature) {
// 正确获取拉伸创建的实体
std::vector<NXOpen::Body*> resultBodies = extrudeFeature->GetBodies();
// 保存第一个实体（用于后续求差）
if (!resultBodies.empty()) {
firstExtrudeBody = resultBodies[0]; // 赋值给函数作用域的变量
}
// 显示结果信息
char successMsg[256];
if (!resultBodies.empty()) {
snprintf(successMsg, sizeof(successMsg),
"创建新实体成功!\n实体数量: %d\n起始距离: %.2f mm\n结束距离: %.2f mm",
resultBodies.size(), materialThickness, endDistance);
}
else {
snprintf(successMsg, sizeof(successMsg),
"拉伸操作完成但未创建实体!\n起始距离: %.2f mm\n结束距离: %.2f mm",
materialThickness, endDistance);
}
theUI->NXMessageBox()->Show("操作结果",
NXOpen::NXMessageBox::DialogTypeInformation, successMsg);
}
else {
throw std::runtime_error("创建的特征不是拉伸类型");
}
// 清理资源
extrudeBuilder->Destroy();
section->Destroy();
}
catch (std::exception& ex) {
// 拉伸操作错误处理
char errMsg[256];
snprintf(errMsg, sizeof(errMsg), "拉伸操作失败: %s", ex.what());
theUI->NXMessageBox()->Show("错误",
NXOpen::NXMessageBox::DialogTypeError, errMsg);
errorCode = 3;
// 特殊错误处理：布尔操作冲突
if (std::string(ex.what()).find("boolean") != std::string::npos) {
theUI->NXMessageBox()->Show("布尔操作错误",
NXOpen::NXMessageBox::DialogTypeError,
"请检查布尔操作设置是否与现有几何冲突");
errorCode = 4;
}
// 确保资源被清理
if (extrudeBuilder) extrudeBuilder->Destroy();
if (section) section->Destroy();
}
}
catch (std::exception& ex) {
// 外层异常处理
char errMsg[256];
snprintf(errMsg, sizeof(errMsg), "拉伸特征创建过程出错: %s", ex.what());
theUI->NXMessageBox()->Show("错误",
NXOpen::NXMessageBox::DialogTypeError, errMsg);
errorCode = 5;
}
// ===== 在拉伸操作成功后添加出料边曲线处理 =====
try {
// 设置撤销标记
NXOpen::Session::UndoMarkId curveMarkId = theSession->SetUndoMark(
NXOpen::Session::MarkVisibilityVisible, "出料边曲线长度编辑");
// 定义存储所有延伸曲线的向量（用于后续拉伸操作）
std::vector<NXOpen::Curve*> extendedCurves;
// 遍历所有出料边曲线
for (NXOpen::Curve* dischargeCurve : dischargeCurves) {
// 创建截面对象（用于曲线长度特征）
NXOpen::Section* section = workPart->Sections()->CreateSection(0.00095, 0.001, 0.05);
// 创建曲线长度构建器（用于延伸曲线）
NXOpen::Features::CurveLengthBuilder* curveLengthBuilder =
workPart->Features()->CreateCurvelengthBuilder(nullptr);
curveLengthBuilder->SetSection(section);
curveLengthBuilder->SetDistanceTolerance(0.001); // 设置距离容差
// 设置曲线延伸参数：对称延伸，增量方式
curveLengthBuilder->CurvelengthData()->SetExtensionMethod(
NXOpen::GeometricUtilities::ExtensionMethodIncremental);
curveLengthBuilder->CurvelengthData()->SetExtensionSide(
NXOpen::GeometricUtilities::ExtensionSideSymmetric);
curveLengthBuilder->CurvelengthData()->SetExtensionDirection(
NXOpen::GeometricUtilities::ExtensionDirectionNatural);
// 设置延伸距离（两端各延伸100mm）
curveLengthBuilder->CurvelengthData()->SetStartDistance("100");
curveLengthBuilder->CurvelengthData()->SetEndDistance("100");
// 创建选择规则：基于单条曲线
std::vector<NXOpen::IBaseCurve*> baseCurves(1);
baseCurves[0] = dynamic_cast<NXOpen::IBaseCurve*>(dischargeCurve);
if (!baseCurves[0]) continue; // 类型转换失败则跳过
NXOpen::CurveDumbRule* curveRule =
workPart->ScRuleFactory()->CreateRuleBaseCurveDumb(baseCurves);
// 计算曲线中点作为帮助点（用于选择定位）
double midParam = 0.0;
double midPoint[3] = { 0 };
UF_EVAL_p_t evaluator = NULL;
if (UF_EVAL_initialize(dischargeCurve->Tag(), &evaluator) == 0) {
double limits[2];
if (UF_EVAL_ask_limits(evaluator, limits) == 0) {
midParam = (limits[0] + limits[1]) / 2.0;
UF_EVAL_evaluate(evaluator, 0, midParam, midPoint, NULL);
}
UF_EVAL_free(evaluator);
}
NXOpen::Point3d helpPoint(midPoint[0], midPoint[1], midPoint[2]);
// 创建规则集合
std::vector<NXOpen::SelectionIntentRule*> rules;
rules.push_back(curveRule);
// 添加曲线到截面
section->AddToSection(rules, dischargeCurve, nullptr, nullptr,
helpPoint, NXOpen::Section::ModeCreate, false);
// 提交曲线长度特征
NXOpen::Features::Feature* curveLengthFeature =
dynamic_cast<NXOpen::Features::Feature*>(curveLengthBuilder->Commit());
// 获取新创建的延伸曲线（关键修改：直接添加到外部集合）
if (curveLengthFeature) {
std::vector<NXOpen::NXObject*> createdEntities = curveLengthFeature->GetEntities();
for (NXOpen::NXObject* obj : createdEntities) {
if (NXOpen::Curve* curve = dynamic_cast<NXOpen::Curve*>(obj)) {
extendedCurves.push_back(curve); // 添加到外部集合
}
}
}
// 清理资源
curveLengthBuilder->Destroy();
section->Destroy();
// 显示曲线处理信息
char curveMsg[256];
snprintf(curveMsg, sizeof(curveMsg),
"曲线处理成功:\n原始曲线: %s\n延伸距离: 100 mm\n创建新曲线: %d条",
dischargeCurve->JournalIdentifier().GetText(), extendedCurves.size());
theUI->NXMessageBox()->Show("曲线处理",
NXOpen::NXMessageBox::DialogTypeInformation, curveMsg);
} // 结束出料边曲线遍历循环
// 更新模型
theSession->UpdateManager()->DoUpdate(curveMarkId);
// 显示成功信息
char msg[256];
snprintf(msg, sizeof(msg), "已处理%d条出料边曲线", dischargeCurves.size());
theUI->NXMessageBox()->Show("曲线处理完成",
NXOpen::NXMessageBox::DialogTypeInformation, msg);
// ===== 创建第二个拉伸特征（在曲线长度处理后）=====
try {
// 设置撤销标记
NXOpen::Session::UndoMarkId markId2 = theSession->SetUndoMark(
NXOpen::Session::MarkVisibilityVisible, "出料边拉伸求差");
// 验证延伸曲线是否可用
if (extendedCurves.empty()) {
throw std::runtime_error("没有可用的延伸曲线作为拉伸截面");
}
// 选择第一条延伸曲线作为拉伸截面
NXOpen::Curve* curveForExtrude = extendedCurves[0];
// 创建拉伸构建器
NXOpen::Features::ExtrudeBuilder* extrudeBuilder2 =
workPart->Features()->CreateExtrudeBuilder(nullptr);
// 创建截面对象
NXOpen::Section* section2 = workPart->Sections()->CreateSection(
0.001, 0.001, 0.05); // 距离公差0.001mm，角度公差0.05度
extrudeBuilder2->SetSection(section2);
// 创建曲线选择规则
std::vector<NXOpen::Curve*> sectionCurves2;
sectionCurves2.push_back(curveForExtrude);
NXOpen::SelectionIntentRule* curveRule2 =
workPart->ScRuleFactory()->CreateRuleCurveDumb(sectionCurves2);
// 获取曲线中点作为帮助点
NXOpen::Point3d helpPoint2(0.0, 0.0, 0.0);
{
tag_t curveTag = curveForExtrude->Tag();
UF_EVAL_p_t evaluator = NULL;
double limits[2];
if (UF_EVAL_initialize(curveTag, &evaluator) == 0) {
if (UF_EVAL_ask_limits(evaluator, limits) == 0) {
if (limits[0] > limits[1]) std::swap(limits[0], limits[1]);
double midParam = (limits[0] + limits[1]) / 2.0;
double midPoint[3];
if (UF_EVAL_evaluate(evaluator, 0, midParam, midPoint, NULL) == 0) {
helpPoint2 = NXOpen::Point3d(midPoint[0], midPoint[1], midPoint[2]);
}
}
UF_EVAL_free(evaluator);
}
}
// 添加曲线到截面
std::vector<NXOpen::SelectionIntentRule*> rules2;
rules2.push_back(curveRule2);
section2->AddToSection(
rules2, // 曲线规则集合
curveForExtrude, // 主要曲线对象
nullptr, // 不指定曲线起点
nullptr, // 不指定曲线终点
helpPoint2, // 帮助点（中点）
NXOpen::Section::ModeCreate // 创建模式
);
// 设置拉伸方向（与第一个拉伸相同）
NXOpen::Point3d origin(0.0, 0.0, 0.0);
NXOpen::Direction* extrudeDirection2 =
workPart->Directions()->CreateDirection(
origin,
directionVector, // 使用相同的方向矢量
NXOpen::SmartObject::UpdateOptionWithinModeling
);
extrudeBuilder2->SetDirection(extrudeDirection2);
// 设置拉伸范围
NXOpen::GeometricUtilities::Limits* limitsObj2 = extrudeBuilder2->Limits();
// 起始距离 = 材料厚度（与第一个拉伸相同）
limitsObj2->StartExtend()->Value()->SetRightHandSide(
std::to_string(materialThickness).c_str());
// 结束距离 = 扫描高度 + 10mm
limitsObj2->EndExtend()->Value()->SetRightHandSide(
std::to_string(scanHeight + 10.0).c_str());
// ===== 设置偏置模式 =====
// 获取拉伸特征的偏置构建器
NXOpen::GeometricUtilities::FeatureOffset* featureOffset = extrudeBuilder2->Offset();
// 设置非对称偏置（两侧不同距离）
featureOffset->SetOption(NXOpen::GeometricUtilities::TypeNonsymmetricOffset);
// 设置具体偏置值
featureOffset->StartOffset()->SetRightHandSide("0"); // 起始端偏置0
featureOffset->EndOffset()->SetRightHandSide("100");
// 设置拔模类型：从起始位置简单拔模
extrudeBuilder2->Draft()->SetDraftOption(
NXOpen::GeometricUtilities::SimpleDraft::SimpleDraftTypeSimpleFromStart);
// 设置前拔模角度（从截面开始处拔模）
extrudeBuilder2->Draft()->FrontDraftAngle()->SetRightHandSide(
std::to_string(currentAngle).c_str());
// 设置后拔模角度（这里我们设为0，因为只需要单边拔模）
extrudeBuilder2->Draft()->BackDraftAngle()->SetRightHandSide("0");
// ===== 设置布尔操作 =====
// 设置操作类型：求差（从第一个拉伸实体中减去此拉伸）
extrudeBuilder2->BooleanOperation()->SetType(
NXOpen::GeometricUtilities::BooleanOperation::BooleanTypeSubtract);
// 设置布尔操作类型（创建新实体）
extrudeBuilder2->BooleanOperation()->SetType(
NXOpen::GeometricUtilities::BooleanOperation::BooleanTypeCreate);
//// 设置布尔操作类型（求差）
//// 设置目标体（第一个拉伸创建的实体）
// std::vector<NXOpen::Body*> targetBodies;
// if (firstExtrudeBody) {
// targetBodies.push_back(firstExtrudeBody);
// extrudeBuilder2->BooleanOperation()->SetTargetBodies(targetBodies);
// }
// else {
// throw std::runtime_error("第一个拉伸实体未找到");
// }//求差
// ===== 执行拉伸操作 =====
NXOpen::NXObject* featureNXObject2 = extrudeBuilder2->Commit();
// 检查是否成功创建特征
if (!featureNXObject2) {
throw std::runtime_error("第二个拉伸特征创建失败");
}
// ===== 新增：找出拉伸截面中点并与边界曲线比较 =====
// ===== 修正后的曲线中点距离判断规则 =====
try {
// 1. 确保有两条延伸曲线和两条边界曲线
if (extendedCurves.size() < 2 || boundaryCurves.size() < 2) {
throw std::runtime_error("需要两条延伸曲线和两条边界曲线");
}
// 2. 获取两条延伸曲线和两条边界曲线
NXOpen::Curve* extCurve1 = extendedCurves[0];
NXOpen::Curve* extCurve2 = extendedCurves[1];
NXOpen::Curve* bndCurve1 = boundaryCurves[0];
NXOpen::Curve* bndCurve2 = boundaryCurves[1];
// 3. 计算所有曲线的中点
struct CurveMidPoint {
NXOpen::Curve* curve;
double midPoint[3];
};
// 计算中点函数
auto calculateMidPoint = [](NXOpen::Curve* curve) -> double* {
static double midPoint[3] = { 0 };
UF_EVAL_p_t evaluator = NULL;
if (UF_EVAL_initialize(curve->Tag(), &evaluator) == 0) {
double limits[2];
if (UF_EVAL_ask_limits(evaluator, limits) == 0) {
double midParam = (limits[0] + limits[1]) / 2.0;
UF_EVAL_evaluate(evaluator, 0, midParam, midPoint, NULL);
}
UF_EVAL_free(evaluator);
}
return midPoint;
};
// 存储所有曲线的中点
CurveMidPoint extMid1 = { extCurve1, {0} };
memcpy(extMid1.midPoint, calculateMidPoint(extCurve1), 3 * sizeof(double));
CurveMidPoint extMid2 = { extCurve2, {0} };
memcpy(extMid2.midPoint, calculateMidPoint(extCurve2), 3 * sizeof(double));
CurveMidPoint bndMid1 = { bndCurve1, {0} };
memcpy(bndMid1.midPoint, calculateMidPoint(bndCurve1), 3 * sizeof(double));
CurveMidPoint bndMid2 = { bndCurve2, {0} };
memcpy(bndMid2.midPoint, calculateMidPoint(bndCurve2), 3 * sizeof(double));
// 4. 计算距离函数
auto distance = [](double p1[3], double p2[3]) -> double {
double dx = p1[0] - p2[0];
double dy = p1[1] - p2[1];
double dz = p1[2] - p2[2];
return sqrt(dx * dx + dy * dy + dz * dz);
};
// 5. 计算所有可能的距离组合
double d11 = distance(extMid1.midPoint, bndMid1.midPoint); // 延伸1-边界1
double d12 = distance(extMid1.midPoint, bndMid2.midPoint); // 延伸1-边界2
double d21 = distance(extMid2.midPoint, bndMid1.midPoint); // 延伸2-边界1
double d22 = distance(extMid2.midPoint, bndMid2.midPoint); // 延伸2-边界2
// 6. 找出最近的两个中点组合（无冲突配对）
std::vector<std::pair<NXOpen::Curve*, NXOpen::Curve*>> closestPairs;
// 确定延伸曲线1的最佳配对
if (d11 < d12) {
closestPairs.push_back({ extCurve1, bndCurve1 });
}
else {
closestPairs.push_back({ extCurve1, bndCurve2 });
}
// 确定延伸曲线2的最佳配对（排除已使用的边界曲线）
if (closestPairs[0].second == bndCurve1) {
// 如果边界1已被使用，延伸2只能配边界2
closestPairs.push_back({ extCurve2, bndCurve2 });
}
else {
// 如果边界2已被使用，延伸2只能配边界1
closestPairs.push_back({ extCurve2, bndCurve1 });
}
// 7. 找出与拉伸二截面线相关的边界曲线
// 假设拉伸二使用的是延伸曲线2
NXOpen::Curve* stretchTwoCurve = extCurve2;
NXOpen::Curve* relatedBoundaryCurve = nullptr;
for (auto& pair : closestPairs) {
if (pair.first == stretchTwoCurve) {
relatedBoundaryCurve = pair.second;
break;
}
}
// 8. 高亮显示相关的边界曲线
if (relatedBoundaryCurve) {
// 高亮相关边界曲线
UF_DISP_set_highlight(relatedBoundaryCurve->Tag(), 1); // 高亮显示
// 刷新显示
UF_DISP_refresh();
// 显示结果信息
char resultMsg[512];
snprintf(resultMsg, sizeof(resultMsg),
"曲线中点配对结果：\n\n"
"延伸曲线1中点与边界曲线1中点距离: %.4f mm\n"
"延伸曲线1中点与边界曲线2中点距离: %.4f mm\n"
"延伸曲线2中点与边界曲线1中点距离: %.4f mm\n"
"延伸曲线2中点与边界曲线2中点距离: %.4f mm\n\n"
"拉伸二使用曲线: %s\n"
"已高亮显示相关边界曲线: %s",
d11, d12, d21, d22,
stretchTwoCurve->JournalIdentifier().GetText(),
relatedBoundaryCurve->JournalIdentifier().GetText());
theUI->NXMessageBox()->Show("曲线中点配对结果",
NXOpen::NXMessageBox::DialogTypeInformation, resultMsg);
}
else {
throw std::runtime_error("未找到与拉伸二截面线相关的边界曲线");
}
}
catch (std::exception& ex) {
char warnMsg[256];
snprintf(warnMsg, sizeof(warnMsg), "曲线中点配对失败: %s", ex.what());
theUI->NXMessageBox()->Show("警告",
NXOpen::NXMessageBox::DialogTypeWarning, warnMsg);
}
// 获取创建的实体
NXOpen::Features::Extrude* extrudeFeature2 =
dynamic_cast<NXOpen::Features::Extrude*>(featureNXObject2);
std::vector<NXOpen::Body*> resultBodies2;
if (extrudeFeature2) {
resultBodies2 = extrudeFeature2->GetBodies();
}
// 清理资源
extrudeBuilder2->Destroy();
section2->Destroy();
// 显示成功信息
char successMsg[256];
snprintf(successMsg, sizeof(successMsg),
"第二个拉伸创建成功!\n"
"拔模角度: %.2f°\n"
"偏置范围: 0-100 mm\n"
"创建实体: %d个",
currentAngle, resultBodies2.size());
theUI->NXMessageBox()->Show("操作结果",
NXOpen::NXMessageBox::DialogTypeInformation, successMsg);
}
catch (std::exception& ex) {
// 错误处理
char errMsg[256];
snprintf(errMsg, sizeof(errMsg), "第二个拉伸创建失败: %s", ex.what());
theUI->NXMessageBox()->Show("错误",
NXOpen::NXMessageBox::DialogTypeError, errMsg);
errorCode = 7; // 设置新的错误代码
}
// 刷新显示
UF_DISP_refresh();
} // 结束出料边曲线处理try块
catch (std::exception& ex) {
char errMsg[256];
snprintf(errMsg, sizeof(errMsg), "曲线处理失败: %s", ex.what());
theUI->NXMessageBox()->Show("错误",
NXOpen::NXMessageBox::DialogTypeError, errMsg);
errorCode = 6; // 设置新的错误代码
}
// 刷新显示
UF_DISP_refresh();
} // 结束主try块
catch (std::exception& ex)
{
// 异常处理
char errMsg[256];
snprintf(errMsg, sizeof(errMsg), "操作失败: %s", ex.what());
qiaowei_tool::theUI->NXMessageBox()->Show("错误",
NXOpen::NXMessageBox::DialogTypeError, errMsg);
errorCode = 1;
}
return errorCode;
}里面“// 7. 找出与拉伸二截面线相关的边界曲线
// 假设拉伸二使用的是延伸曲线2
NXOpen::Curve* stretchTwoCurve = extCurve2;
NXOpen::Curve* relatedBoundaryCurve = nullptr;”这部分没有正确的找到我拉伸2里面使用的是哪条截面线
在使用NX制图软件时，若遇到表格注释合并单元格时报错NXerrorstatus:32的情况，可能并非由直接操作引起。通过检查前面的代码逻辑，清理标注操作等步骤，可以有效定位并解决问题。本文提供了解决此类问题的方法和思路。
扫一扫
358
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
