// 处理过程
BOOL CSDMdlSpecAsmImplicitCheck::DoAction(void *pData, const CheckData &checkData)
{
ProMdl pMdl = (ProMdl)pData;
if (NULL == pMdl)
return FALSE;
int nCount = (int)checkData.checkResult.arrErrorItems.GetCount();
ProModelitem mdlitem;
mdlitem.owner = pMdl;
mdlitem.type = PRO_FEATURE;
int* parrFeatID = NULL;
ProFeatureResumeOptions* parrOpt = NULL;
ProArrayAlloc(0, sizeof(int), 1, (ProArray*)&parrFeatID);
ProArrayAlloc(0, sizeof(ProFeatureResumeOptions), 1, (ProArray*)&parrOpt);
int nID = -1;
ProFeatureResumeOptions opt = PRO_FEAT_RESUME_NO_OPTS;
for (int i=0; i<nCount; i++)
{
nID = checkData.checkResult.arrErrorItems[i].nID;
ProArrayObjectAdd((ProArray*)&parrFeatID, PRO_VALUE_UNUSED, 1, &nID);
ProArrayObjectAdd((ProArray*)&parrOpt, PRO_VALUE_UNUSED, 1, &opt);
}
ProFeatureResume(ProMdlToSolid(pMdl), parrFeatID, nCount, parrOpt, nCount);
ProArrayFree((ProArray *)&parrFeatID);
ProArrayFree((ProArray *)&parrOpt);
return TRUE;
}
// 导出至STL
void OnExportSTLActFn()
{
/*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;
}
// 选取面组
vector<ProSelection> arrSelQlt;
if (SelectObject(arrSelQlt, "dtmqlt"))
{
ProName mdlName;
ProMdlNameGet(pMdl, mdlName);
CString strMdlName(mdlName);
ProFileName filename;
wcsncpy_s(filename, PRO_FILE_NAME_SIZE, strMdlName, _TRUNCATE);
// 选择保存位置
ProPath stlpath;
if (ProFileSave(NULL, L"*.stl", NULL, NULL, NULL, filename, stlpath) == PRO_TK_NO_ERROR)
{
CString strStlPath(stlpath);
ProGeomitem qltitem;
ProSelectionModelitemGet(arrSelQlt[0], &qltitem);
ProQuilt quilt;
ProGeomitemToQuilt(&qltitem, &quilt);
vector<ProSurface> arrSurfs;
ProQuiltSurfaceVisit(quilt, QuiltSurfacesGetAction, NULL, &arrSurfs);
vector<ProGeomitem> arrSurfsItems;
for (int i=0; i<(int)arrSurfs.size(); i++)
{
ProGeomitem srfitem;
ProSurfaceToGeomitem(ProMdlToSolid(pMdl), arrSurfs[i], &srfitem);
arrSurfsItems.push_back(srfitem);
}
if (ExportStl(arrSurfsItems, strStlPath, 0.5, 1.0))
{
MessageBox(NULL, L"导出stl成功", L"提示", MB_OK);
}
else
MessageBox(NULL, L"导出stl失败", L"提示", MB_OK|MB_ICONWARNING);
}
}
InvalidateDrawing();
ProMessageClear();
}
int CSDMdlAttrMatCheck::CheckAction(void *pData, const CheckRule &checkRule, CheckResult &checkResult)
{
ProMdl pMdl = (ProMdl)pData;
if (NULL == pMdl)
{
checkResult.nResultType = CHECK_RESULT_INVALID_MODEL;
return checkResult.nResultType;
}
if (!IsMdlTypeValid(pMdl, checkRule.dwMdlFilter))
{
checkResult.nResultType = CHECK_RESULT_INVALID_MODEL;
return checkResult.nResultType;
}
// 模型是否符合过滤器要求
if (!IsFilterValid(checkRule.strRuleName, pMdl))
{
checkResult.nResultType = CHECK_RESULT_INVALID_MODEL;
return checkResult.nResultType;
}
// 检查输入值有效性
if (checkRule.arrRuleContent.GetCount() < 1)
{
checkResult.nResultType = CHECK_RESULT_INVALID_INPUT;
return checkResult.nResultType;
}
ProMaterial MdlMat;
ProError status = ProMaterialCurrentGet(ProMdlToSolid(pMdl),&MdlMat);
CString strMatName = MdlMat.matl_name;
CString strRuleContent = checkRule.arrRuleContent[0];
if (status == PRO_TK_BAD_INPUTS)
{
if (strRuleContent.CompareNoCase(L"NULL") == 0)
{
checkResult.nResultType = CHECK_RESULT_NO_ERROR;
return CHECK_RESULT_NO_ERROR;
}else
{
checkResult.nResultType = CHECK_RESULT_ERROR_VALUE;
return CHECK_RESULT_ERROR_VALUE;
}
}
if (strMatName.CompareNoCase(strRuleContent) == 0)
{
checkResult.nResultType = CHECK_RESULT_NO_ERROR;
return CHECK_RESULT_NO_ERROR;
}else{
checkResult.nResultType = CHECK_RESULT_ERROR_VALUE;
return CHECK_RESULT_ERROR_VALUE;
}
}
ProError CSDMdl505PolarCheck::CsyVisitAction(ProCsys pCsy, ProError status, ProAppData pData)
{
UNUSED_ALWAYS(status);
int nCsyID = -1;
ProCsysIdGet(pCsy, &nCsyID);
CsysPolarVisitData &visitData = *((CsysPolarVisitData *)pData);
ProGeomitem item;
ProCsysToGeomitem(ProMdlToSolid(visitData.pMdl), pCsy, &item);
ProName nameFea;
ProModelitemNameGet(&item, nameFea);
CString strCsysName = nameFea;
if (visitData.bCheck1)
{
if (CompareWildCard(L"CS_*_X1", strCsysName) || CompareWildCard(L"CS_*_GA1", strCsysName))
{
visitData.strCsyName = strCsysName.Left(strCsysName.GetLength()-1) + L"2";
// 检索成对的坐标系
visitData.bCheck1 = FALSE;
if (ProSolidCsysVisit(ProMdlToSolid(visitData.pMdl),
CsyVisitAction,
NULL,
pData) == PRO_TK_USER_ABORT)
{
visitData.arrID1.Add(nCsyID);
visitData.arrCsysName.Add(strCsysName.Left(strCsysName.GetLength()-1));
}
}
}
else
{
if (strCsysName.CompareNoCase(visitData.strCsyName) == 0)
{
visitData.bCheck1 = TRUE;
visitData.arrID2.Add(nCsyID);
return PRO_TK_USER_ABORT;
}
}
return PRO_TK_NO_ERROR;
}
BOOL CSDMdlAttrMatDensCheck::DoAction(void *pData, const CheckData &checkData)
{
ProMdl pMdl = (ProMdl)pData;
ProError status;
if (checkData.checkResult.arrErrorItems.GetCount()<4)
{
return FALSE;
}
double dScale = _wtof(checkData.checkResult.arrErrorItems[2].strItemName);
double dTarget = _wtof(checkData.checkResult.arrErrorItems[3].strItemName);
ProMaterial mdlMat;
status = ProMaterialCurrentGet(ProMdlToSolid(pMdl), &mdlMat);
if (status != PRO_TK_NO_ERROR)
{
return FALSE;
}
ProMaterialItem matItem;
status = ProModelitemByNameInit(pMdl, PRO_RP_MATERIAL, mdlMat.matl_name, &matItem);
if (status != PRO_TK_NO_ERROR)
{
return FALSE;
}
ProParamvalue val;
val.type = PRO_PARAM_DOUBLE;
val.value.d_val= dTarget/dScale;
status = ProMaterialPropertySet(&matItem, PRO_MATPROP_MASS_DENSITY, &val, NULL);
if (status != PRO_TK_NO_ERROR)
{
return FALSE;
}
return TRUE;
}
// 草绘裁剪
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 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 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();
}
// 检查开始，传出检查结果
int CSDMdlAttrMatDensCheck::CheckAction(void *pData, const CheckRule &checkRule, CheckResult &checkResult)
{
// 检查模型句柄有效性
ProMdl pMdl = (ProMdl)pData;
if (NULL == pMdl)
{
checkResult.nResultType = CHECK_RESULT_INVALID_MODEL;
return checkResult.nResultType;
}
// 检查模型类型有效性
if (!IsMdlTypeValid(pMdl, checkRule.dwMdlFilter))
{
checkResult.nResultType = CHECK_RESULT_INVALID_MODEL;
return checkResult.nResultType;
}
// 检查输入值有效性
if (checkRule.arrRuleContent.GetCount() < 1)
{
checkResult.nResultType = CHECK_RESULT_INVALID_INPUT;
return checkResult.nResultType;
}
// 解析材料和密度对应表
CStringArray arrItems;
CStringToCStringArray(checkRule.arrRuleContent[0], arrItems);
MdlMatDensArray arrMatDens;
for (int i = 0; i < arrItems.GetSize(); i ++)
{
MdlMatDens tempMatDens;
tempMatDens.strMatName = arrItems[i].Left(arrItems[i].Find(L"("));
int nCount = arrItems[i].Find(L")") - arrItems[i].Find(L"(") - 1;
tempMatDens.dDens = _wtof(arrItems[i].Mid(arrItems[i].Find(L"(") + 1, nCount));
arrMatDens.Add(tempMatDens);
}
// 判断是否使用材料关联参数
BOOL bUsePara = FALSE;
CString strParaName;
if (checkRule.arrRuleContent.GetCount() >=2)
{
strParaName = checkRule.arrRuleContent[1];
if (strParaName.CompareNoCase(L"") != 0)
bUsePara = TRUE;
}
ProError status;
ErrorItem errItem;
// 获取当前材料名称、密度值和单位
CString strMatName;
double dScale, dDensity;
if (bUsePara)
{
ProModelitem mdlItem;
ProMdlToModelitem(pMdl, &mdlItem);
if (!GetSDParameter(&mdlItem, strParaName, strMatName, FALSE))
{
checkResult.nResultType = CHECK_RESULT_ITEM_NOT_FOUND;
return CHECK_RESULT_ITEM_NOT_FOUND;
}
ProParameter para;
GetSDParameter(&mdlItem, L"MP_DENSITY", para, NULL);
ProParamvalue paraValue;
ProParameterValueGet(¶, ¶Value);
ProUnititem unit;
ProParameterUnitsGet(¶, &unit);
ProPath expression;
ProUnitExpressionGet(&unit, expression);
dScale = GetConvertFactor(CString(expression));
dDensity = paraValue.value.d_val*dScale;
}
else
{
// 能否获取材料密度
ProMaterial mdlMat;
if (ProMaterialCurrentGet(ProMdlToSolid(pMdl), &mdlMat) != PRO_TK_NO_ERROR)
{
checkResult.nResultType = CHECK_RESULT_ITEM_NOT_FOUND;
return CHECK_RESULT_ITEM_NOT_FOUND;
}
strMatName = mdlMat.matl_name;
/*ProMaterialdata matdata;
ProMaterialDataGet(&mdlMat, &matdata);
double dDensity = matdata.mass_density;*/
ProMaterialItem matItem;
status = ProModelitemByNameInit(pMdl, PRO_RP_MATERIAL, mdlMat.matl_name, &matItem);
ProParamvalue val;
ProUnititem mdlUnit;
if (ProMaterialPropertyGet(&matItem, PRO_MATPROP_MASS_DENSITY, &val, &mdlUnit) != PRO_TK_NO_ERROR)
{
checkResult.nResultType = CHECK_RESULT_UNKNOWN_ERROR;
return CHECK_RESULT_UNKNOWN_ERROR;
}
ProPath expression;
ProUnitExpressionGet(&mdlUnit, expression);
dScale = GetConvertFactor(CString(expression));
dDensity = val.value.d_val*dScale;
}
checkResult.arrErrorItems.RemoveAll();
checkResult.nResultType = CHECK_RESULT_INVALID_VALUE;
errItem.strItemName = strMatName;
checkResult.arrErrorItems.Add(errItem);
errItem.strItemName.Format(L"%g", dDensity);
checkResult.arrErrorItems.Add(errItem);
errItem.strItemName.Format(L"%g", dScale);
checkResult.arrErrorItems.Add(errItem);
for (int i = 0; i< arrMatDens.GetCount(); ++i)
{
// 匹配材料名
if (strMatName.CompareNoCase(arrMatDens[i].strMatName) == 0)
{
errItem.strItemName.Format(L"%g", arrMatDens[i].dDens);
checkResult.arrErrorItems.Add(errItem);
// 检查密度值
if (ISDNEAR(arrMatDens[i].dDens, dDensity))
{
checkResult.nResultType = CHECK_RESULT_NO_ERROR;
}
else
{
checkResult.nResultType = CHECK_RESULT_ERROR_VALUE;
}
return checkResult.nResultType;
}
}
return CHECK_RESULT_INVALID_VALUE;
}
int CSD3DDrawingColorCheck::CheckAction(void *pData, const CheckRule &checkRule, CheckResult &checkResult)
{
ProMdl pMdl = (ProMdl)pData;
if (NULL == pMdl)
{
checkResult.nResultType = CHECK_RESULT_INVALID_MODEL;
return checkResult.nResultType;
}
if (!IsMdlTypeValid(pMdl, checkRule.dwMdlFilter))
{
checkResult.nResultType = CHECK_RESULT_INVALID_MODEL;
return checkResult.nResultType;
}
// 检查输入值有效性
if (checkRule.arrRuleContent.GetSize() < 3)
{
checkResult.nResultType = CHECK_RESULT_INVALID_INPUT;
return checkResult.nResultType;
}
for (int i = 0; i < 3; i++)
{
if (!IsNumber(checkRule.arrRuleContent.GetAt(i)))
{
checkResult.nResultType = CHECK_RESULT_INVALID_INPUT;
return CHECK_RESULT_INVALID_INPUT;
}
else if (!DEQUAL(_wtof(checkRule.arrRuleContent.GetAt(i)), 0.0) && !IsPoistive(checkRule.arrRuleContent.GetAt(i)))
{
checkResult.nResultType = CHECK_RESULT_INVALID_INPUT;
return CHECK_RESULT_INVALID_INPUT;
}
else if (_wtof(checkRule.arrRuleContent.GetAt(i)) > 255.0)
{
checkResult.nResultType = CHECK_RESULT_INVALID_INPUT;
return CHECK_RESULT_INVALID_INPUT;
}
}
Drw3DColorVisitData visitData;
visitData.dRed = _wtof(checkRule.arrRuleContent.GetAt(0));
visitData.dGreen = _wtof(checkRule.arrRuleContent.GetAt(1));
visitData.dBlue = _wtof(checkRule.arrRuleContent.GetAt(2));
// 注解
ProMdlNoteVisit(pMdl, Note3DVisitAciton, NULL, &visitData);
// 从动尺寸
ProSolidDimensionVisit(ProMdlToSolid(pMdl), PRO_B_FALSE, Dim3DVisitAciton, NULL, &visitData);
// 参考尺寸
ProSolidDimensionVisit(ProMdlToSolid(pMdl), PRO_B_TRUE, Dim3DVisitAciton, NULL, &visitData);
// 几何公差
ProMdlGtolVisit(pMdl, Gtol3DVisitAciton, NULL, &visitData);
// 符号（焊接符号、基准符号）
ProSolidDtlsyminstVisit(ProMdlToSolid(pMdl), Symbol3DVisitAciton, NULL, &visitData);
// 表面光洁度
ProSolidSurffinishVisit(ProMdlToSolid(pMdl), SurfFin3DVisitAciton, NULL, &visitData);
// 基准标签
ProSolidSetdatumtagVisit(ProMdlToSolid(pMdl), DatumTagVisitAciton, NULL, &visitData);
checkResult.arrErrorItems.RemoveAll();
if (visitData.arrErrors.GetCount() > 0)
{
checkResult.arrErrorItems.Copy(visitData.arrErrors);
checkResult.nResultType = CHECK_RESULT_ERROR_VALUE;
return CHECK_RESULT_ERROR_VALUE;
}
else
{
checkResult.nResultType = CHECK_RESULT_NO_ERROR;
return CHECK_RESULT_NO_ERROR;
}
}
// 检查开始，传出检查结果
int CSDMdl505PolarCheck::CheckAction(void *pData, const CheckRule &checkRule, CheckResult &checkResult)
{
checkRule;
ProMdl pMdl = (ProMdl)pData;
if (NULL == pMdl)
{
checkResult.nResultType = CHECK_RESULT_INVALID_MODEL;
return checkResult.nResultType;
}
if (!IsMdlTypeValid(pMdl, checkRule.dwMdlFilter))
{
checkResult.nResultType = CHECK_RESULT_INVALID_MODEL;
return checkResult.nResultType;
}
// 获取坐标系对
CsysPolarVisitData visitData;
visitData.pMdl = pMdl;
visitData.bCheck1 = TRUE;
ProSolidCsysVisit((ProSolid)pMdl,
CsyVisitAction,
NULL,
&visitData);
// 判断模型是否包含圆柱曲面
BOOL bFindCyl = FALSE;
PolarCylVisitData cyldata;
if (ProSolidSurfaceVisit(ProMdlToSolid(pMdl), SurfaceVisitAction, NULL, &cyldata) == PRO_TK_USER_ABORT)
{
bFindCyl = TRUE;
}
checkResult.arrErrorItems.RemoveAll();
ErrorItem item;
for (int i=0; i<visitData.arrID1.GetCount(); i++)
{
ProCsys pCsy1, pCsy2;
ProCsysInit(ProMdlToSolid(pMdl), visitData.arrID1[i], &pCsy1);
ProCsysInit(ProMdlToSolid(pMdl), visitData.arrID2[i], &pCsy2);
ProGeomitemdata* pcsyData1, *pcsyData2;
ProCsysDataGet(pCsy1, &pcsyData1);
ProCsysDataGet(pCsy2, &pcsyData2);
SVDOUBLE3 vec0, vec1, vec2, pt1, pt2;
vec0.x = pcsyData2->data.p_csys_data->origin[0]-pcsyData1->data.p_csys_data->origin[0];
vec0.y = pcsyData2->data.p_csys_data->origin[1]-pcsyData1->data.p_csys_data->origin[1];
vec0.z = pcsyData2->data.p_csys_data->origin[2]-pcsyData1->data.p_csys_data->origin[2];
vec1.x = pcsyData1->data.p_csys_data->z_vector[0];
vec1.y = pcsyData1->data.p_csys_data->z_vector[1];
vec1.z = pcsyData1->data.p_csys_data->z_vector[2];
vec2.x = pcsyData2->data.p_csys_data->z_vector[0];
vec2.y = pcsyData2->data.p_csys_data->z_vector[1];
vec2.z = pcsyData2->data.p_csys_data->z_vector[2];
pt1.x = pcsyData1->data.p_csys_data->origin[0];
pt1.y = pcsyData1->data.p_csys_data->origin[1];
pt1.z = pcsyData1->data.p_csys_data->origin[2];
pt2.x = pcsyData2->data.p_csys_data->origin[0];
pt2.y = pcsyData2->data.p_csys_data->origin[1];
pt2.z = pcsyData2->data.p_csys_data->origin[2];
ProGeomitemdataFree(&pcsyData1);
ProGeomitemdataFree(&pcsyData2);
BPVec3Normalize(&vec0, &vec0);
BPVec3Normalize(&vec1, &vec1);
BPVec3Normalize(&vec2, &vec2);
// 检查是否指向模型本体外
double dRadian = BPCalcArcCos(BPVec3Dot(vec0, vec1));
if (!ISDNEAR(dRadian, 1.5707964) && dRadian < 1.5707964)
{
item.nID = visitData.arrID1[i];
item.nType = PRO_CSYS;
item.pOwner = pMdl;
item.strItemName = visitData.arrCsysName[i] + L"1";
checkResult.arrErrorItems.Add(item);
}
else if (bFindCyl) // 检查是否同轴
{
if ((!IsVecSameDir(vec1, cyldata.line) && !IsVecReverseDir(vec1, cyldata.line)) ||
!IsPointOnLine(pt1, vec1, cyldata.pt))
{
item.nID = visitData.arrID1[i];
item.nType = PRO_CSYS;
item.pOwner = pMdl;
item.strItemName = visitData.arrCsysName[i] + L"1";
checkResult.arrErrorItems.Add(item);
}
}
dRadian = BPCalcArcCos(BPVec3Dot(vec0, vec2));
if (!ISDNEAR(dRadian, 1.5707964) && dRadian > 1.5707964)
{
item.nID = visitData.arrID2[i];
item.nType = PRO_CSYS;
item.pOwner = pMdl;
item.strItemName = visitData.arrCsysName[i] + L"2";
checkResult.arrErrorItems.Add(item);
}
else if (bFindCyl)
{
if ((!IsVecSameDir(vec2, cyldata.line) && !IsVecReverseDir(vec2, cyldata.line)) ||
!IsPointOnLine(pt2, vec2, cyldata.pt))
{
item.nID = visitData.arrID2[i];
item.nType = PRO_CSYS;
item.pOwner = pMdl;
item.strItemName = visitData.arrCsysName[i] + L"2";
checkResult.arrErrorItems.Add(item);
}
}
}
if (checkResult.arrErrorItems.GetCount() > 0)
checkResult.nResultType = CHECK_RESULT_INVALID_VALUE;
else
checkResult.nResultType = CHECK_RESULT_NO_ERROR;
return checkResult.nResultType;
}
