/*====================================================================*\
FUNCTION : ProUtilFeatureElementsDump()
PURPOSE : To write a decription of a feature elements to a text file
\*====================================================================*/
void ProUtilFeatureElementsDump(
ProModelitem *feature,
FILE *fp)
{
ProError status;
ProElement elem_tree;
FeatureElemPrintData print_data;
ElemtreeElement *elements;
int elements_num, i;
/*----------------------------------------------*\
Create a copy of the feature element tree
\*----------------------------------------------*/
status = ProFeatureElemtreeExtract( feature, NULL, PRO_FEAT_EXTRACT_NO_OPTS, &elem_tree );
TEST_CALL_REPORT("ProFeatureElemtreeExtract()",
"ProUtilFeatureElementsDump()", status,
(status != PRO_TK_NO_ERROR) && (status != PRO_TK_INVALID_TYPE));
/*-----------------------------------------------------------*\
For non-supported features, don't dump the element info
\*-----------------------------------------------------------*/
if (status == PRO_TK_INVALID_TYPE)
{
ProTKFprintf(fp, "Element tree is not supported for this feature\n");
}
else
if (status == PRO_TK_NO_ERROR)
{
print_data.fp = fp;
print_data.p_feature = feature;
status = ProUtilCollectElemtreeElements (elem_tree, NULL, &elements);
if (status == PRO_TK_NO_ERROR)
{
status = ProArraySizeGet ((ProArray)elements, &elements_num);
TEST_CALL_REPORT( "ProArraySizeGet()",
"ProUtilFeatureElementsDump()",
status, status != PRO_TK_NO_ERROR );
for (i = 0; i < elements_num; i++)
{
status = ProUtilElemPrint (elem_tree, elements[i].p_element,
elements[i].p_elempath, &print_data);
}
status = ProUtilElemtreeElementArrayFree (&elements);
}
}
}
// 特征过滤函数 判断哪些特征需要检查
ProError CSDMdlAttrFeaSystemCheck::FeatureNameFilter(ProFeature* pFeature, ProAppData app_data)
{
NameFeaVisitData &visitData=*(NameFeaVisitData*)app_data;
// 检查特征类型
ProFeattype feaType;
ProFeatureTypeGet(pFeature, &feaType);
if(feaType!=visitData.nFeaType)
{
return PRO_TK_CONTINUE;
}
ProError status;
// 检查特征子类型（不同类型特征检查方式不一样）
switch (feaType)
{
case PRO_FEAT_GEOM_COPY: // 区分复制几何、发布几何、收缩包络
{
ProElement pro_e_feature_tree = NULL;
ProFeatureElemtreeExtract(pFeature, NULL, PRO_FEAT_EXTRACT_NO_OPTS, &pro_e_feature_tree);
ProElempathItem path_items[1];
path_items[0].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
path_items[0].path_item.elem_id = PRO_E_CG_FEAT_SUB_TYPE;
ProElempath path;
ProElempathAlloc(&path);
ProElempathDataSet(path, path_items, 1);
ProElement pElement = NULL;
ProElemtreeElementGet(pro_e_feature_tree, path, &pElement);
ProValue pValue = NULL;
status = ProElementValueGet(pElement, &pValue);
ProValueData valueData;
status = ProValueDataGet(pValue, &valueData);
ProElementFree(&pro_e_feature_tree);
if (valueData.v.i != visitData.nSubType)
return PRO_TK_CONTINUE;
}
break;
default:
break;
}
return PRO_TK_NO_ERROR;
}
// 草绘裁剪
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();
}
