/*===============================================================*\
FUNCTION : ProUtilFeatCreate
PURPOSE : Creates feature in no mode option
returns :
PRO_TK_NO_ERROR - Successfully executed
\*===============================================================*/
ProError ProUtilFeatCreate(ProAsmcomppath *p_comp_path ,ProMdl model,
ProElement pro_e_feature_tree,
ProFeature *feature)
{
ProError status = PRO_TK_GENERAL_ERROR;
ProSelection model_sel;
ProModelitem model_item;
ProErrorlist p_errors;
ProFeatureCreateOptions no_mode_option[1];
int no_opts = 1;
no_mode_option[0] = PRO_FEAT_CR_NO_OPTS;
status = ProMdlToModelitem( model, &model_item );
TEST_CALL_REPORT("ProMdlToModelitem", "ProUtilFeatCreate",
status, status != PRO_TK_NO_ERROR );
status = ProSelectionAlloc (p_comp_path, &model_item, &model_sel);
status = ProFeatureCreate (model_sel, pro_e_feature_tree,
no_mode_option, no_opts, feature, &p_errors);
TEST_CALL_REPORT("ProFeatureCreate", "ProUtilFeatCreate",
status, status != PRO_TK_NO_ERROR );
ProSelectionFree(&model_sel);
return status;
}
/**
For different feature types different geometries are appropriate:
DTM_PLN : PRO_TYPE_SURFACE
DTM_AXIS : PRO_TYPE_AXIS
Rather than ProModelitemByNameInit() maybe one of the following would be a better choice:
ProGeomitemFeatureGet();
ProGeomitemToSurface();
ProSurfaceDataGet();
ProFeatureSelectionGet();
ProFeatureGeomitemVisit(); // *I think this is the correct approach*
ProSurfaceDataGet();
*/
Selector::Selector( ProMdl in_model, ProFeature in_feature, ProType in_geom_type )
: m_log_f(log4cpp::Category::getInstance(LOGCAT_LOGFILEONLY)),
m_log_cf(log4cpp::Category::getInstance(LOGCAT_CONSOLEANDLOGFILE))
{
ProError status;
ProModelitem model_item;
if (in_geom_type == PRO_TYPE_UNUSED) {
model_item = static_cast<ProModelitem>(in_feature);
} else {
ProAppData select_geom_data = static_cast<ProAppData>(&model_item);
switch( status = ProFeatureGeomitemVisit(&in_feature, in_geom_type,
select_geom_action, NULL, select_geom_data) )
{
case PRO_TK_NO_ERROR: break;
case PRO_TK_BAD_INPUTS:
m_log_cf.warnStream() << "one or more arguments was invalid.";
break;
default:
m_log_cf.warnStream()
<< "the action function returned a value other than PRO_TK_NO_ERROR and visiting stopped. "
<< status;
}
}
m_log_cf.infoStream() << "model selected: "
<< " id = " << model_item.id << " type = " << model_item.type;
switch( status = ProSelectionAlloc(NULL, &model_item, &m_self) ) {
case PRO_TK_NO_ERROR: break;
case PRO_TK_BAD_INPUTS:
m_log_cf.errorStream() << "the allocation failed due to bad inputs.";
m_log_cf.errorStream() << " component-path: NULL "
<< " model-item: " << model_item.id;
throw std::runtime_error("selector allocation failed");
default:
m_log_cf.errorStream() << "could not allocate selection: " << status;
throw std::runtime_error("selector allocation failed");
}
}
// 草绘裁剪
void OnTrimBySketchActFn()
{
/*if (!QuickCheckValidLicense(SMART_PROFESSIONAL))
return;*/
AFX_MANAGE_STATE(AfxGetStaticModuleState());
DestroyAllDialog();
CancelSelectDialog();
Sleep(50);
ProError status;
ProMdl pMdl = GetCurrentMdl();
if (pMdl == NULL)
{
MessageBox(NULL, L"当前环境未发现模型！", L"提示", MB_OK|MB_ICONWARNING);
return;
}
// 选择草绘
vector<ProSelection> arrSel;
ShowMessageTip(L"Tips.选择草绘特征...");
while (SelectObject(arrSel, "feature"))
{
// 检查是否为草绘曲线
ProFeature featSketch;
status = ProSelectionModelitemGet(arrSel[0], &featSketch);
ProFeattype featType;
status = ProFeatureTypeGet(&featSketch, &featType);
if (featType == PRO_FEAT_CURVE)
{
ProAsmcomppath acomppath;
ProSelectionAsmcomppathGet(arrSel[0], &acomppath);
ProSelection selQuilt; // 待裁剪的平面
BOOL bGetQuilt = FALSE;
// 获取草绘曲线所在的平面
ProElement elemTreeCurve = NULL;
ProFeatureElemtreeExtract(&featSketch, NULL, PRO_FEAT_EXTRACT_NO_OPTS, &elemTreeCurve);
ProElempathItem pathItemType[1];
pathItemType[0].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
pathItemType[0].path_item.elem_id = PRO_E_CURVE_TYPE;
ProElempath elemPathCurveType;
ProElempathAlloc(&elemPathCurveType);
ProElempathDataSet(elemPathCurveType, pathItemType, 1);
ProElement elemType;
status = ProElemtreeElementGet(elemTreeCurve, elemPathCurveType, &elemType);
if (status == PRO_TK_NO_ERROR)
{
ProValue valType;
status = ProElementValueGet(elemType, &valType);
ProValueData valdataType;
status = ProValueDataGet(valType, &valdataType);
if (valdataType.v.i == PRO_CURVE_TYPE_SKETCHED)
{
// 确定为草绘曲线，进而获取草绘平面
ProElempathItem pathItemSketchPlane[3];
pathItemSketchPlane[0].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
pathItemSketchPlane[0].path_item.elem_id = PRO_E_STD_SECTION;
pathItemSketchPlane[1].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
pathItemSketchPlane[1].path_item.elem_id = PRO_E_STD_SEC_SETUP_PLANE;
pathItemSketchPlane[2].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
pathItemSketchPlane[2].path_item.elem_id = PRO_E_STD_SEC_PLANE;
ProElempath elemPathPlane;
ProElempathAlloc(&elemPathPlane);
ProElempathDataSet(elemPathPlane, pathItemSketchPlane, 3);
ProElement elemPlane;
status = ProElemtreeElementGet(elemTreeCurve, elemPathPlane, &elemPlane);
if (status == PRO_TK_NO_ERROR)
{
ProValue valPlane;
status = ProElementValueGet(elemPlane, &valPlane);
ProValueData valdataPlane;
status = ProValueDataGet(valPlane, &valdataPlane);
ProGeomitem itemSurf;
ProSelectionModelitemGet(valdataPlane.v.r, &itemSurf);
ProSurface surf;
ProGeomitemToSurface(&itemSurf, &surf);
// 获取面所在面组
ProQuilt quilt;
status = ProSurfaceQuiltGet(ProMdlToSolid(pMdl), surf, &quilt);
if (status == PRO_TK_NO_ERROR)
{
ProGeomitem itemQuilt;
status = ProQuiltToGeomitem(ProMdlToSolid(pMdl), quilt, &itemQuilt);
status = ProSelectionAlloc(&acomppath, &itemQuilt, &selQuilt);
bGetQuilt = TRUE;
}
}
}
}
if (!bGetQuilt)
{
ShowMessageTip(L"Tips.草绘的放置面非可裁剪面，请手动选择需裁剪的面...");
// 手动选取待裁剪的面
vector<ProSelection> arrSelSrf;
if (SelectObject(arrSelSrf, "dtmqlt"))
{
ProSelectionCopy(arrSelSrf[0], &selQuilt);
}
else
{
break;
}
}
// 遍历特征，获取特征中的全部复合曲线
vector<ProGeomitem> arrItemCurves;
status = ProFeatureGeomitemVisit(&featSketch, PRO_CURVE, FeatureGeomsGetAction, NULL, &arrItemCurves);
vector<int> arrFeatID;
for (int i=0; i<arrItemCurves.size(); i++)
{
ProCurve curve;
status = ProGeomitemToCurve(&arrItemCurves[i], &curve);
// 检查是否为复合曲线
ProEnttype curveType;
status = ProCurveTypeGet(curve, &curveType);
if (curveType == PRO_ENT_CMP_CRV)
{
// 进行裁剪
ProSelection selCurve;
status = ProSelectionAlloc(&acomppath, &arrItemCurves[i], &selCurve);
int nFeatID = TrimQuiltByCurve(pMdl, selQuilt, selCurve, PRO_EDGE_SAME_DIRECTION);
if (nFeatID > 0)
{
// 创建成功，记录特征ID
arrFeatID.push_back(nFeatID);
// 第8步：提示是否反向或继续修剪
CDlgConfirm dlg;
while (1)
{
int nResult = (int)dlg.DoModal();
if (nResult == IDOK)
{
break;
}
else if (nResult == IDRETRY)
{
// 修改裁剪方向
ProFeature feat;
feat.id = nFeatID;
feat.type = PRO_FEATURE;
feat.owner = pMdl;
ReverseTrimDirection(feat);
}
else
{
InvalidateDrawing();
ProMessageClear();
return;
}
}
}
}
}
// 合并成组
CreateFeatGroup(pMdl, arrFeatID, L"包覆面_裁剪");
break;
}
else
{
//
MessageBox(NULL, L"所选特征非草绘特征，请重新选择！", L"提示", MB_OK);
}
}
InvalidateDrawing();
ProMessageClear();
}
// 从边界(链)创建
void OnCreateByChainActFn()
{
/*if (!QuickCheckValidLicense(SMART_PROFESSIONAL))
return;*/
AFX_MANAGE_STATE(AfxGetStaticModuleState());
DestroyAllDialog();
CancelSelectDialog();
Sleep(50);
// 检查当前模型环境
ProMdl pMdl = GetCurrentMdl();
if (pMdl == NULL)
{
MessageBox(NULL, L"当前环境未发现模型！", L"提示", MB_OK|MB_ICONWARNING);
return;
}
int nFeatID[3]={0};
ProModelitem itemCurve[2];
// 第1步：选取第一条边链的两条边
ShowMessageTip(L"Tips.选取同一个面上的两条边创建第一条边链...");
vector<ProSelection> arrSelEdge;
if (!SelectObject(arrSelEdge, "edge", 2))
{
return;
}
// 第2步：创建第一条边链
int nSelCount = (int)arrSelEdge.size();
if (nSelCount == 1)
arrSelEdge.push_back(arrSelEdge[0]);
nFeatID[0] = CreateFromToCurveByCopy(pMdl, arrSelEdge[0], arrSelEdge[1], itemCurve[0]);
if (nFeatID[0] <= 0)
{
MessageBox(NULL, L"第一条边链创建失败，详见模型特征树！", L"提示", MB_OK);
return;
}
// 是否反向
InvalidateDrawing();
if (MessageBox(NULL, L"是否反向？", L"提示", MB_YESNO|MB_ICONQUESTION) == IDYES)
{
int nfeatArray[] = {nFeatID[0]};
ProFeatureDeleteOptions opt[] = {PRO_FEAT_DELETE_NO_OPTS};
ProFeatureDelete(ProMdlToSolid(pMdl), nfeatArray, 1, opt, 1);
nFeatID[0] = CreateFromToCurveByCopy(pMdl, arrSelEdge[1], arrSelEdge[0], itemCurve[0]);
if (nFeatID[0] <= 0)
{
MessageBox(NULL, L"第一条边链创建失败，详见模型特征树！", L"提示", MB_OK);
return;
}
InvalidateDrawing();
}
// 第3步：选取面上的两条边
ShowMessageTip(L"Tips.选取同一个面上的两条边创建第二条边链...");
vector<ProSelection> arrSelEdge2;
if (!SelectObject(arrSelEdge2, "edge", 2))
{
return;
}
// 第4步：创建第二条边链
int nSelCount2 = (int)arrSelEdge2.size();
if (nSelCount2 == 1)
arrSelEdge2.push_back(arrSelEdge2[0]);
nFeatID[1] = CreateFromToCurveByCopy(pMdl, arrSelEdge2[0], arrSelEdge2[1], itemCurve[1]);
if (nFeatID[1] <= 0)
{
MessageBox(NULL, L"第二条边链创建失败，详见模型特征树！", L"提示", MB_OK);
return;
}
// 是否反向
InvalidateDrawing();
if (MessageBox(NULL, L"是否反向？", L"提示", MB_YESNO|MB_ICONQUESTION) == IDYES)
{
int nfeatArray[] = {nFeatID[1]};
ProFeatureDeleteOptions opt[] = {PRO_FEAT_DELETE_NO_OPTS};
ProFeatureDelete(ProMdlToSolid(pMdl), nfeatArray, 1, opt, 1);
nFeatID[1] = CreateFromToCurveByCopy(pMdl, arrSelEdge2[1], arrSelEdge2[0], itemCurve[1]);
if (nFeatID[1] <= 0)
{
MessageBox(NULL, L"第二条边链创建失败，详见模型特征树！", L"提示", MB_OK);
return;
}
InvalidateDrawing();
}
// 第5步：创建边界混合面
ProSelection selCurve[2];
ProSelectionAlloc(NULL, &itemCurve[0], &selCurve[0]);
ProSelectionAlloc(NULL, &itemCurve[1], &selCurve[1]);
ProModelitem itemQuilt;
nFeatID[2] = CreateSurfByTwoCurve(pMdl, selCurve[0], selCurve[1], itemQuilt);
if (nFeatID[2] > 0)
{
SetSurfColor(itemQuilt, 154, 205, 7);
ProGroup group;
ProLocalGroupCreate(ProMdlToSolid(pMdl), nFeatID, 3, L"包覆面_创建", &group);
}
else
{
MessageBox(NULL, L"创建失败，详见模型特征树！", L"提示", MB_OK);
}
//ExportElemTreeXML();
/*ProChaincollUIControl ui[1]={PRO_CHAINCOLLUI_FROM_TO};
ProCollection collect1, collect2;
status = ProCrvcollectionAlloc(&collect1);
status = ProCrvcollectionAlloc(&collect2);
ProCurvesCollect(ui, 1, NULL, NULL, &collect1, NULL, NULL);
ProCurvesCollect(ui, 1, NULL, NULL, &collect2, NULL, NULL);
ProSelection* r_result_sellist1, *r_result_sellist2;
int nNum1, nNum2;
status = ProCrvcollectionRegenerate(collect1, &r_result_sellist1, &nNum1);
status = ProCrvcollectionRegenerate(collect2, &r_result_sellist2, &nNum2);
ProModelitem itemQuilt;
CreateBlendSurfByChain(pMdl, r_result_sellist1[0], r_result_sellist2[0], itemQuilt);*/
/*vector<ProSelection> arrSelEdges;
ProSelection selSrf = NULL;
if (SelectObject(arrSelEdges, "edge", 2))
{
ProCollection collect;
status = ProCrvcollectionAlloc(&collect);
ProCrvcollinstr instCurv;
status = ProCrvcollinstrAlloc(PRO_CURVCOLL_FROM_TO_INSTR, &instCurv);
for (int i=0; i<(int)arrSelEdges.size(); i++)
{
ProReference refCurve;
status = ProSelectionToReference(arrSelEdges[i], &refCurve);
status = ProCrvcollinstrReferenceAdd(instCurv, refCurve);
}
status = ProCrvcollinstrAttributeSet(instCurv, PRO_CURVCOLL_ALL);
status = ProCrvcollectionInstructionAdd(collect, instCurv);*/
//ProSelection* r_result_sellist;
//int nNum;
//ProCrvcollectionRegenerate(collect, &r_result_sellist, &nNum);
//ProSelectionHighlight(selSrf, PRO_COLOR_WARNING);
///*status = ProCollectionFree(&collect);
//status = ProCrvcollinstrFree(instCurv);*/
/*}*/
InvalidateDrawing();
ProMessageClear();
}
// 表面清理
void OnCleanActFn()
{
/*if (!QuickCheckValidLicense(SMART_PROFESSIONAL))
return;*/
AFX_MANAGE_STATE(AfxGetStaticModuleState());
DestroyAllDialog();
CancelSelectDialog();
Sleep(50);
// 第1步：检查当前模型环境
ProMdl pMdl = GetCurrentMdl();
if (pMdl == NULL)
{
MessageBox(NULL, L"当前环境未发现模型！", L"提示", MB_OK|MB_ICONWARNING);
return;
}
// 第2步：选择参考
ShowMessageTip(L"Tips.选择几何平面进行清理，可多选...");
vector<ProSelection> arrSelSrf;
vector<ProModelitem> arrItemSrf;
while (SelectObject(arrSelSrf, "surface", MAX_SELECTION))
{
BOOL bError = FALSE;
// 第3步：创建基准面
for (int i=0; i<(int)arrSelSrf.size(); i++)
{
ProModelitem itemSurf;
ProSelectionModelitemGet(arrSelSrf[i], &itemSurf);
ProModelitem itemPlane;
int nDatumFeatID = CreateDatumPlane(pMdl, arrSelSrf[i], itemPlane);
if (nDatumFeatID > 0)
{
arrItemSrf.push_back(itemPlane);
}
}
// 第4步：创建实体化特征
for (int i=0; i<(int)arrItemSrf.size(); i++)
{
ProSelection selPlane;
ProSelectionAlloc(NULL, &arrItemSrf[i], &selPlane);
if (CreateSolidify(pMdl, selPlane) < 0)
{
bError = TRUE;
}
SAFE_DELETE_SELECTION(selPlane);
}
arrSelSrf.clear();
arrItemSrf.clear();
// 第5步：显示处理结果
if (bError && MessageBox(NULL, L"部分特征创建失败，详见模型特征树。是否继续？", L"提示", MB_YESNO) == IDNO)
{
break;
}
}
InvalidateDrawing();
ProMessageClear();
}
// 加载包覆对象
void OnLoadSolidActFn()
{
/*if (!QuickCheckValidLicense(SMART_PROFESSIONAL))
return;*/
AFX_MANAGE_STATE(AfxGetStaticModuleState());
DestroyAllDialog();
CancelSelectDialog();
Sleep(50);
// 选择一个本地的待包覆模型
ProPath pathSelModel;
if (ProFileOpen(L"选择待包覆模型", L"*.prt,*.asm,*.stp,*.stl", NULL, NULL, NULL, NULL, pathSelModel) == PRO_TK_NO_ERROR)
{
ProPath pathFolder;
ProName nameModel, nameExt;
int nVersion;
ProFilenameParse(pathSelModel, pathFolder, nameModel, nameExt, &nVersion);
ProMdl pMdlToCoating;
if (CString(nameExt).CompareNoCase(L"stp") == 0 || CString(nameExt).CompareNoCase(L"step") == 0)
{
LoadStep(CString(pathSelModel), pMdlToCoating);
}
else
{
ProMdlLoad(pathSelModel, PRO_MDL_UNUSED, PRO_B_FALSE, &pMdlToCoating);
}
// 创建一个装配体
CString strSolidName;
strSolidName = nameModel;
strSolidName.Format(L"%s_3DCoat", strSolidName);
ProName nameSolid;
wcsncpy_s(nameSolid, PRO_NAME_SIZE, strSolidName, _TRUNCATE);
ProSolid solid;
ProSolidCreate(nameSolid, PRO_ASSEMBLY, &solid);
// 创建默认坐标系
ProError status;
ProElement elemTree = NULL;
ProElementAlloc(PRO_E_FEATURE_TREE, &elemTree);
{
// 特征类型PRO_E_FEATURE_TYPE
ProElement elemType;
status = ProElementAlloc(PRO_E_FEATURE_TYPE, &elemType);
status = ProElemtreeElementAdd(elemTree, NULL, elemType);
ProValueData valdataType;
valdataType.type = PRO_VALUE_TYPE_INT;
valdataType.v.i = PRO_FEAT_CSYS;
ProValue valueType = NULL;
status = ProValueAlloc(&valueType);
status = ProValueDataSet(valueType, &valdataType);
status = ProElementValueSet(elemType, valueType);
}
ProModelitem itemAssmble;
ProMdlToModelitem(ProAssemblyToMdl(solid), &itemAssmble);
ProSelection selAssmble;
ProSelectionAlloc(NULL, &itemAssmble, &selAssmble);
ProErrorlist errorsList;
ProFeatureCreateOptions opts[1] = {PRO_FEAT_CR_NO_OPTS};
ProFeature feat;
status = ProFeatureCreate(selAssmble, elemTree, opts, 1, &feat, &errorsList);
// 将选择的待装配模型装配到装配体下
ProMatrix initPos = {
{1.0, 0.0, 0.0, 0.0},
{0.0, 1.0, 0.0, 0.0},
{0.0, 0.0, 1.0, 0.0},
{0.0, 0.0, 0.0, 1.0}
};
ProAsmcomp comp;
ProAsmcompAssemble(ProAssembly(solid), ProMdlToSolid(pMdlToCoating), initPos, &comp);
ProAsmcompconstraint compConstr;
ProAsmcompconstraintAlloc(&compConstr);
ProAsmcompconstraintTypeSet(compConstr, PRO_ASM_DEF_PLACEMENT);
ProAsmcompconstraint* compConstrs;
ProArrayAlloc (0, sizeof (ProAsmcompconstraint), 1, (ProArray*)&compConstrs);
status = ProArrayObjectAdd ((ProArray*)&compConstrs, -1, 1, &compConstr);
ProAsmcompConstraintsSet(NULL, &comp, compConstrs);
ProMdlDisplay(solid);
int nWnd;
ProWindowCurrentGet(&nWnd);
ProWindowActivate(nWnd);
}
InvalidateDrawing();
ProMessageClear();
}
// 生成包覆体
void OnCreateBodyActFn()
{
/*if (!QuickCheckValidLicense(SMART_PROFESSIONAL))
return;*/
AFX_MANAGE_STATE(AfxGetStaticModuleState());
DestroyAllDialog();
CancelSelectDialog();
Sleep(50);
// 检查当前模型环境
ProMdl pMdl = GetCurrentMdl();
if (pMdl == NULL)
{
MessageBox(NULL, L"当前环境未发现模型！", L"提示", MB_OK|MB_ICONWARNING);
return;
}
ProMdlType typeMdl;
ProMdlTypeGet(pMdl, &typeMdl);
if (typeMdl != PRO_MDL_ASSEMBLY)
{
MessageBox(NULL, L"该功能仅在装配环境下有效！", L"提示", MB_OK|MB_ICONWARNING);
return;
}
//ExportElemTreeXML();
// 选择一个面组
vector<ProSelection> arrSelQlt;
ShowMessageTip(L"Tips.选择要加厚的包覆面...");
if (SelectObject(arrSelQlt, "dtmqlt"))
{
// 输入整体加厚值
double dThickValue;
ShowMessageTip(L"指定厚度值，不能为0，负值表示向内加厚：");
if (ProMessageDoubleRead(NULL, &dThickValue) == PRO_TK_NO_ERROR)
{
// 创建发布几何
int nPubFeatID = CreatePublishGeom(pMdl, arrSelQlt[0]);
ProName nameAsm;
ProMdlNameGet(pMdl, nameAsm);
CString strNamePart = nameAsm;
ProName namePart;
for (int i=101; ;i++)
{
CString strTemp;
strTemp.Format(L"%s_%d", nameAsm, i);
wcsncpy_s(namePart, PRO_NAME_SIZE, strTemp, _TRUNCATE);
ProMdl pMdlTemp;
if (ProMdlInit(namePart, PRO_MDL_PART, &pMdlTemp) == PRO_TK_E_NOT_FOUND)
break;
}
// 新建一个零件
ProAsmcomp compPart;
ProAsmcompCreateCopy(ProMdlToAssembly(pMdl), namePart, PRO_MDL_PART, NULL, PRO_B_FALSE, &compPart);
//ProSolidRegenerate(pMdl);
ProMdl pMdlPart;
ProAsmcompMdlGet(&compPart, &pMdlPart);
ProModelitem itemAsm;
ProMdlToModelitem(pMdl, &itemAsm);
ProSelection selAsm;
ProSelectionAlloc(NULL, &itemAsm, &selAsm);
ProFeature featPub;
featPub.id = nPubFeatID;
featPub.owner = pMdl;
featPub.type = PRO_FEATURE;
ProSelection selPubFeat;
ProSelectionAlloc(NULL, &featPub, &selPubFeat);
// 创建复制几何
ProModelitem itemCopyQuilt;
CreateCopyGeom(pMdlPart, selAsm, selPubFeat, itemCopyQuilt);
ProSelection selCopyQuilt;
ProSelectionAlloc(NULL, &itemCopyQuilt, &selCopyQuilt);
// 弹出提示：是否要对单个面设置厚度
if (MessageBox(NULL, L"是否要对单个面设置厚度", L"提示", MB_YESNO|MB_ICONQUESTION) == IDYES)
{
ProMdlDisplay(pMdlPart);
int nWndIDPart;
ProMdlWindowGet(pMdlPart, &nWndIDPart);
ProWindowActivate(nWndIDPart);
// 弹出对话框
if (g_pDlgThick != NULL)
{
if (g_pDlgThick->GetSafeHwnd() != NULL)
g_pDlgThick->DestroyWindow();
SAFE_DELETE_POINTER(g_pDlgThick);
}
g_pDlgThick = new CDlgSetThick();
g_pDlgThick->InitSurfData(pMdl, selCopyQuilt, dThickValue);
g_pDlgThick->Create(IDD_DLG_SETTHICK);
g_pDlgThick->ShowWindow(SW_SHOW);
}
else
{
ThickQuilt(pMdlPart, selCopyQuilt, dThickValue);
}
}
}
InvalidateDrawing();
ProMessageClear();
}
// 底面切除
void OnBottomCutActFn()
{
/*if (!QuickCheckValidLicense(SMART_PROFESSIONAL))
return;*/
AFX_MANAGE_STATE(AfxGetStaticModuleState());
DestroyAllDialog();
CancelSelectDialog();
Sleep(50);
ProError status;
// 第1步：检查当前模型环境
ProMdl pMdl = GetCurrentMdl();
if (pMdl == NULL)
{
MessageBox(NULL, L"当前环境未发现模型！", L"提示", MB_OK|MB_ICONWARNING);
return;
}
// 第2步：选择参考
ShowMessageTip(L"Tips.选择拼接后的包覆面进行切除...");
vector<ProSelection> arrSelQlt;
ProSelection selQlt = NULL;
if (SelectObject(arrSelQlt, "dtmqlt"))
{
status = ProSelectionCopy(arrSelQlt[0], &selQlt);
// 第3步：暂时隐藏选择的面，选取完成后恢复显示
ProModelitem itemQuilt;
status = ProSelectionModelitemGet(arrSelQlt[0], &itemQuilt);
status = ProModelitemHide(&itemQuilt);
// 第4步：选择底面
ShowMessageTip(L"Tips.选择需要平齐的底面...");
vector<ProSelection> arrSelSrf;
if (SelectObject(arrSelSrf, "surface"))
{
status = ProModelitemUnhide(&itemQuilt);
// 第5步：以底面为参照创建基准面
ProModelitem itemPlane;
int nDatumFeatID = CreateDatumPlane(pMdl, arrSelSrf[0], itemPlane);
if (nDatumFeatID > 0)
{
ProSelection selRef;
status = ProSelectionAlloc(NULL, &itemPlane, &selRef);
int nFeatID = TrimSurfaceBySurf(pMdl, selQlt, selRef, 1);
if (nFeatID > 0)
{
// 第8步：提示是否反向或继续修剪
CDlgConfirm dlg;
while (1)
{
int nResult = (int)dlg.DoModal();
if (nResult == IDRETRY)
{
// 修改裁剪方向
ProFeature feat;
feat.id = nFeatID;
feat.type = PRO_FEATURE;
feat.owner = pMdl;
ReverseTrimDirection(feat);
}
else
{
break;
}
}
}
else
{
MessageBox(NULL, L"切除失败，详见模型特征树！", L"提示", MB_OK);
}
}
}
else
status = ProModelitemUnhide(&itemQuilt);
}
InvalidateDrawing();
ProMessageClear();
}
// 拼接（智能选取）
void OnMergeAutoActFn()
{
/*if (!QuickCheckValidLicense(SMART_PROFESSIONAL))
return;*/
AFX_MANAGE_STATE(AfxGetStaticModuleState());
DestroyAllDialog();
CancelSelectDialog();
Sleep(50);
ProMdl pMdl = GetCurrentMdl();
if (pMdl == NULL)
{
MessageBox(NULL, L"当前环境未发现模型！", L"提示", MB_OK|MB_ICONWARNING);
return;
}
ProError status;
// 选取一个包覆面
ShowMessageTip(L"Tips.选择需要拼接的包覆面...");
vector<ProSelection> arrSelQuilts;
if (SelectObject(arrSelQuilts, "dtmqlt"))
{
ProModelitem itemQuiltStart;
status = ProSelectionModelitemGet(arrSelQuilts[0], &itemQuiltStart);
ProQuilt quiltStart;
status = ProGeomitemToQuilt(&itemQuiltStart, &quiltStart);
vector<ProQuilt> arrQuiltMerge;
arrQuiltMerge.push_back(quiltStart);
// 获取全部Quilt
vector<ProQuilt> arrQuilt;
status = ProSolidQuiltVisit(ProMdlToSolid(pMdl), SolidQuiltsGetAction, NULL, &arrQuilt);
ProQuilt quiltCurr;
for (int i=0; i<arrQuiltMerge.size(); i++)
{
quiltCurr = arrQuiltMerge[i];
for (int j=0; j<arrQuilt.size(); )
{
if (quiltCurr == arrQuilt[j])
{
// 剔除自身
arrQuilt.erase(arrQuilt.begin()+j);
continue;
}
if (CheckTwoQuiltNeighbor(pMdl, quiltCurr, arrQuilt[j]))
{
arrQuiltMerge.push_back(arrQuilt[j]);
arrQuilt.erase(arrQuilt.begin()+j);
continue;
}
j++;
}
}
vector<ProSelection> arrSelMergeQuilt;
for (int i=0; i<arrQuiltMerge.size(); i++)
{
ProModelitem itemQuilt;
ProQuiltToGeomitem(ProMdlToSolid(pMdl), arrQuiltMerge[i], &itemQuilt);
ProSelection selQuilt = NULL;
ProSelectionAlloc(NULL, &itemQuilt, &selQuilt);
arrSelMergeQuilt.push_back(selQuilt);
}
ProFeature featMerge;
MergeQuilts(pMdl, arrSelMergeQuilt, PRO_SRF_MRG_INTSCT, featMerge);
}
InvalidateDrawing();
ProMessageClear();
}
