double CSDMdlMachChamferAngCheck::GetChamferLeg2Val(ProFeature *pFeature, int SetNum)
{
ProError status;
ProValue value;
ProValueData value_data;
ProElempath Leg2_path;
ProElempathItem Leg2_pathItem[6];//参数2
Leg2_pathItem[0].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
Leg2_pathItem[0].path_item.elem_id = PRO_E_RNDCH_SETS;
Leg2_pathItem[1].type = PRO_ELEM_PATH_ITEM_TYPE_INDEX;
Leg2_pathItem[1].path_item.elem_id = SetNum;
Leg2_pathItem[2].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
Leg2_pathItem[2].path_item.elem_id = PRO_E_RNDCH_RADII;
Leg2_pathItem[3].type = PRO_ELEM_PATH_ITEM_TYPE_INDEX;
Leg2_pathItem[3].path_item.elem_id = 0;
Leg2_pathItem[4].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
Leg2_pathItem[4].path_item.elem_id = PRO_E_RNDCH_LEG2;
Leg2_pathItem[5].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
Leg2_pathItem[5].path_item.elem_id = PRO_E_RNDCH_LEG_VALUE;
status = ProElempathAlloc (&Leg2_path);
status = ProElempathDataSet (Leg2_path, Leg2_pathItem, 6);
status = ProFeatureElemValueGet(pFeature,Leg2_path,&value);
status = ProValueDataGet (value, &value_data);
return value_data.v.d;
}
// 检查壁特征，获取折弯半径
BOOL CSDMdlMachBendRadiusCheck::GetBendRadius(ProFeature *pFeature, double& dRadius)
{
ProError status;
ProElempath pElemPath = NULL;
ProValue pValue = NULL;
ProValueData value_data;
ProElempathItem pathItems[2];
pathItems[0].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
pathItems[0].path_item.elem_id = PRO_E_SMT_FILLETS;
pathItems[1].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
pathItems[1].path_item.elem_id = PRO_E_SMT_FILLETS_VALUE;
status = ProElempathAlloc (&pElemPath);
status = ProElempathDataSet (pElemPath, pathItems, 2);
status = ProFeatureElemValueGet(pFeature, pElemPath, &pValue);
if (status != PRO_TK_NO_ERROR)
{
status = ProElempathFree(&pElemPath);
return FALSE;
}
status = ProValueDataGet(pValue, &value_data);
dRadius = value_data.v.d;
status = ProElempathFree(&pElemPath);
return TRUE;
}
// 特征过滤函数 判断哪些特征需要检查
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();
}
// 检查倒角特征，若倒角角度值小于输入值，返回FALSE，否则返回TRUE
BOOL CSDMdlMachChamferAngCheck::CheckChamferFeature(ProFeature *pFeature, CString strAngle)
{
ProError status;
double Leg1Val;
double Leg2Val;
ProElempathItem pathItems[3];
pathItems[0].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
pathItems[0].path_item.elem_id = PRO_E_RNDCH_SETS;
pathItems[1].type = PRO_ELEM_PATH_ITEM_TYPE_INDEX;
pathItems[1].path_item.elem_index = 0;
pathItems[2].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
pathItems[2].path_item.elem_id = PRO_E_RNDCH_DIMENSIONAL_SCHEMA;
CStringArray arrChamferAng;
CStringToCStringArray(strAngle, arrChamferAng);
ProElempath pElemPath = NULL;
ProValue pValue = NULL;
ProValueData value_data;
for (int i = 0;; i++)
{
status = ProElempathAlloc (&pElemPath);
pathItems[1].path_item.elem_index = i;
status = ProElempathDataSet (pElemPath, pathItems, 3);
status = ProFeatureElemValueGet(pFeature, pElemPath, &pValue);
if (status == PRO_TK_NO_ERROR)
{
status = ProValueDataGet(pValue, &value_data);
if ((PRO_CHM_D_X_D == value_data.v.i)||(PRO_CHM_45_X_D == value_data.v.i))
{
int nTempResult = FALSE;
for (int i = 0; i <arrChamferAng.GetSize(); i++ )
{
if(DEQUAL(_wtof(arrChamferAng.GetAt(i)), 45.0))
{
return TRUE;
}
}
if (nTempResult == FALSE)
{
return FALSE;
}
}
else if (PRO_CHM_D1_X_D2 == value_data.v.i)
{
Leg1Val = GetChamferLeg1Val(pFeature,i);
Leg2Val = GetChamferLeg2Val(pFeature,i);
double dFeaAngle;
dFeaAngle = atan(Leg1Val/Leg2Val);
int nTempResult = FALSE;
for (int i = 0; i <arrChamferAng.GetSize(); i++ )
{
if (DEQUAL(dFeaAngle/PI*180, _wtof(arrChamferAng.GetAt(i))) || DEQUAL(dFeaAngle/PI*180, 180 - _wtof(arrChamferAng.GetAt(i))))
{
nTempResult = TRUE;
}
}
if (nTempResult == FALSE)
{
return FALSE;
}
}
else if (PRO_CHM_ANG_X_D == value_data.v.i)
{
Leg2Val = GetChamferLeg2Val(pFeature,i);
int nTempResult = FALSE;
for (int i = 0; i <arrChamferAng.GetSize(); i++ )
{
if (DEQUAL(Leg2Val, _wtof(arrChamferAng.GetAt(i))) || DEQUAL(Leg2Val, 180 - _wtof(arrChamferAng.GetAt(i))))
{
nTempResult = TRUE;
}
}
if (nTempResult == FALSE)
{
return FALSE;
}
}
}
else
{
break;
}
status = ProElempathFree(&pElemPath);
}
return TRUE;
}
/*====================================================================*\
FUNCTION : ProUtilElemPrint()
PURPOSE : Visit function.
\*====================================================================*/
ProError ProUtilElemPrint(
ProElement elem_tree,
ProElement elem,
ProElempath elem_path,
FeatureElemPrintData* p_data )
{
ProError status;
ProElemId elem_id;
int dimension_id = -1;
ProBoolean is_visible;
ProBoolean is_incomplete;
ProBoolean is_compound;
ProBoolean is_array;
ProBoolean is_multival;
ProValue* p_values;
ProValue value;
int array_size;
ProValueData value_data;
char value_data_str[ 48 ];
int i;
ProBoolean flag = PRO_B_TRUE;
status = ProElementIdGet( elem, &elem_id );
TEST_CALL_REPORT("ProElementIdGet()",
"ProUtilElemPrint()",
PRO_TK_NO_ERROR, status != PRO_TK_NO_ERROR);
ProTKFprintf( p_data->fp, "Element ID: %d\n", elem_id );
status = ProFeatureElemIsVisible( p_data->p_feature, elem_path,
&is_visible );
#if 0
TEST_CALL_REPORT("ProFeatureElemIsVisible()",
"ProUtilElemPrint()", status,
status != PRO_TK_NO_ERROR );
#else
/* This function return PRO_TK_E_NOT_FOUND for Element FEATURE_TYPE,
from feature PRO_FEAT_DATUM_QUILT (it's a bug)*/
TEST_CALL_REPORT("ProFeatureElemIsVisible()",
"ProUtilElemPrint()", status,
0);
#endif
status = ProFeatureElemIsIncomplete( p_data->p_feature, elem_path,
&is_incomplete );
#if 0
/* spr 751801 */
TEST_CALL_REPORT( "ProFeatureElemIsIncomplete()", "ProUtilElemPrint()", status, status != PRO_TK_NO_ERROR);
#else
TEST_CALL_REPORT( "ProFeatureElemIsIncomplete()", "ProUtilElemPrint()", status, 0 );
#endif
status = ProElementIsCompound( elem, NULL, &is_compound );
TEST_CALL_REPORT("ProElementIsCompound()", "ProUtilElemPrint()",
status, status != PRO_TK_NO_ERROR);
status = ProElementIsArray(elem, NULL, &is_array );
TEST_CALL_REPORT("ProElementIsArray()", "ProUtilElemPrint()",
status, status != PRO_TK_NO_ERROR);
ProTKFprintf( p_data->fp, is_visible == PRO_B_TRUE ? "\tVisible\n" : "\tInvisible\n" );
ProTKFprintf( p_data->fp, is_incomplete == PRO_B_TRUE ? "\tIncomplete\n" :
"\tComplete\n" );
ProTKFprintf( p_data->fp, is_compound == PRO_B_TRUE ? "\tCompound\n" :
(is_array == PRO_B_TRUE ? "\tArray\n" :
"\tNeither compound nor array\n"));
if( is_compound == PRO_B_TRUE || is_array == PRO_B_TRUE)
return PRO_TK_NO_ERROR;
status = ProFeatureElemDimensionIdGet( p_data->p_feature, elem_path,
&dimension_id );
TEST_CALL_REPORT("ProFeatureElemDimensionIdGet()",
"ProUtilElemPrint()",
status, (status != PRO_TK_NO_ERROR)&&
(status != PRO_TK_E_NOT_FOUND));
if (status != PRO_TK_E_NOT_FOUND)
ProTKFprintf( p_data->fp, "\tDimension ID: %d\n", dimension_id );
else
ProTKFprintf( p_data->fp, "\tThis element does not contain dimension\n");
status = ProArrayAlloc( 0, sizeof(ProValue), 1, (ProArray*)&p_values );
TEST_CALL_REPORT( "ProArrayAlloc()", "ProUtilElemPrint()",
status, status != PRO_TK_NO_ERROR );
status = ProElementIsMultival(elem, NULL, &is_multival);
TEST_CALL_REPORT( "ProElementIsMultival",
"ProUtilElemPrint", status, status != PRO_TK_NO_ERROR);
if (is_multival == PRO_B_TRUE)
{
status = ProFeatureElemValuesGet( p_data->p_feature,
elem_path, &p_values );
#if 0
TEST_CALL_REPORT( "ProFeatureElemValuesGet()", "ProUtilElemPrint()",
status,
status != PRO_TK_NO_ERROR );
#else
/* ProFeatureElemValuesGet() - returns PRO_TK_E_NOT_FOUND in the PIPE mode
for Element PRO_E_STD_EDGE_CHAMF_EDGES.(bugminsk1347)*/
TEST_CALL_REPORT( "ProFeatureElemValuesGet()", "ProUtilElemPrint()",
status,
0 );
#endif
}
else
{
status = ProElementValueGet(elem, &value);
TEST_CALL_REPORT( "ProElementValueGet", "ProUtilElemPrint",
status, status != PRO_TK_NO_ERROR);
status = ProArrayObjectAdd((ProArray*)&p_values, PRO_VALUE_UNUSED,
1, &value);
TEST_CALL_REPORT( "ProArrayObjectAdd", "ProUtilElemPrint",
status, status != PRO_TK_NO_ERROR);
}
if (p_values!=NULL){
array_size = 0;
status = ProArraySizeGet( (ProArray)p_values, &array_size );
TEST_CALL_REPORT( "ProArraySizeGet()", "ProUtilElemPrint()",
status, status != PRO_TK_NO_ERROR );
ProTKFprintf( p_data->fp, "\t%s\n",(i=1)?"Value:":"Values:" );
for( i=0; i<array_size; i++ )
{
/*To avoid PRO_E_SKETCHER and PRO_E_PATTERN, following condition is set*/
if(( elem_id == 458) || (elem_id == 27))
flag = PRO_B_FALSE;
if(flag == PRO_B_TRUE)
{
status = ProValueDataGet( p_values[i], &value_data );
TEST_CALL_REPORT( "ProValueDataGet()", "ProUtilElemPrint()",
status, status != PRO_TK_NO_ERROR );
switch( value_data.type )
{
case PRO_VALUE_TYPE_INT:
ProTKSprintf( value_data_str, "%d", value_data.v.i );
break;
case PRO_VALUE_TYPE_DOUBLE:
ProTKSprintf( value_data_str, "%f", value_data.v.d );
break;
case PRO_VALUE_TYPE_POINTER:
ProTKSprintf( value_data_str, "Pointer=*", value_data.v.p );
break;
case PRO_VALUE_TYPE_STRING:
if ( value_data.v.s !=NULL)
ProTKSprintf( value_data_str, "%s", value_data.v.s );
else
ProTKSprintf( value_data_str,"<NULL>" );
break;
case PRO_VALUE_TYPE_WSTRING:
/* NOTE - NULL is possible in some element trees
(for example, for the element PRO_E_STD_FEATURE_NAME
where NULL means that feature has the default name) */
if ( value_data.v.w !=NULL)
ProWstringToString( value_data_str, value_data.v.w );
else
ProTKSprintf( value_data_str,"<NULL>" );
break;
case PRO_VALUE_TYPE_SELECTION:
ProTKSprintf( value_data_str, "Selection" );
break;
case PRO_VALUE_TYPE_TRANSFORM:
ProTKSprintf( value_data_str, "Transformation" );
break;
default:
ProTKSprintf( value_data_str, "**UNKNOWN**\n" );
}
ProTKFprintf( p_data->fp, "\t%s\n", value_data_str );
}
}
status = ProArrayFree( (ProArray*)&p_values );
TEST_CALL_REPORT( "ProArrayFree()", "ProUtilFeatureElementsDump()",
status, status != PRO_TK_NO_ERROR );
}
return PRO_TK_NO_ERROR;
}
