// 单侧放量
void OnOffsetSingleActFn()
{
/*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;
}
// 选择面
vector<ProSelection> arrSelQlt;
ShowMessageTip(L"Tips.选择要偏移的面...");
if (SelectObject(arrSelQlt, "surface"))
{
// 输入偏离值
double dOffset;
ShowMessageTip(L"输入偏移量，不能为0，但可以为负值：");
if (ProMessageDoubleRead(NULL, &dOffset) == PRO_TK_NO_ERROR)
{
// 判断面的方向
ProModelitem itemSurf;
ProSelectionModelitemGet(arrSelQlt[0], &itemSurf);
ProSurface surf;
ProGeomitemToSurface(&itemSurf, &surf);
ProGeomitemdata* psrfdata;
ProSurfaceDataGet(surf, &psrfdata);
if (psrfdata->data.p_surface_data->orient == PRO_SURF_ORIENT_IN)
dOffset = dOffset*(-1);
ProGeomitemdataFree(&psrfdata);
// 创建偏移特征
int nOffsetID = OffsetSurfaceWithSide(pMdl, arrSelQlt[0], dOffset);
if (nOffsetID > 0)
{
// 修改面颜色
ProFeature feat;
feat.id = nOffsetID;
feat.type = PRO_FEATURE;
feat.owner = pMdl;
vector<ProModelitem> arrQuilts;
ProFeatureGeomitemVisit(&feat, PRO_QUILT, FeatureGeomsGetAction, NULL, &arrQuilts);
for (int i=0; i<arrQuilts.size(); i++)
SetSurfColor(arrQuilts[i], 255, 215, 0);
}
}
}
InvalidateDrawing();
ProMessageClear();
}
ProError CSDMdlMachFlatBottomHoleCheck::HoleGeomitemVisitAction(ProGeomitem *pGeomitem, ProError status, ProAppData data)
{
CArray<ProSurface> &arrSurf = *(CArray<ProSurface>*)data;
ProSurface Surf;
ProSrftype SurfType;
status = ProGeomitemToSurface(pGeomitem, &Surf);
status = ProSurfaceTypeGet(Surf, &SurfType);
if (SurfType == PRO_SRF_CYL || SurfType == PRO_SRF_PLANE)
{
arrSurf.Add(Surf);
}
return PRO_TK_NO_ERROR;
}
ProError CSDMdlMachFlatBottomHoleCheck::SurfGeomitemVisitAction(ProGeomitem *pGeomitem, ProError status, ProAppData data)
{
int &nSurfCheckResult = *(int*)data;
ProSurface Surf;
ProSrftype SurfType;
status = ProGeomitemToSurface(pGeomitem, &Surf);
status = ProSurfaceTypeGet(Surf, &SurfType);
if (SurfType != PRO_SRF_PLANE && SurfType != PRO_SRF_CYL)
{
nSurfCheckResult = CHECK_RESULT_NO_ERROR;
}
return PRO_TK_NO_ERROR;
}
// 通过特征的面的UV值获得特征包围盒
ProError CSDMdlMachFeaMinSizeCheck::FeaMinSizeGeomitemVisitAction(ProGeomitem *p_Geomitem, ProError status, ProAppData data)
{
ProGeomitemdata *pGeomitemdata;
ProSurface Surf;
ProUvParam uvMin, uvMax;
ProVector xyzMin, xyzMax, normal, deriv1[2], deriv2[3];
status = ProGeomitemToSurface(p_Geomitem, &Surf);
status = ProGeomitemdataGet(p_Geomitem,&pGeomitemdata);
uvMin[0] = ((*pGeomitemdata).data.p_surface_data->uv_min)[0];
uvMin[1] = ((*pGeomitemdata).data.p_surface_data->uv_min)[1];
uvMax[0] = ((*pGeomitemdata).data.p_surface_data->uv_max)[0];
uvMax[1] = ((*pGeomitemdata).data.p_surface_data->uv_max)[1];
ProPoint3d xyzMinTemp, xyzMaxTemp;
xyzMinTemp[0] = ((*pGeomitemdata).data.p_surface_data->xyz_min)[0];
xyzMinTemp[1] = ((*pGeomitemdata).data.p_surface_data->xyz_min)[1];
xyzMinTemp[2] = ((*pGeomitemdata).data.p_surface_data->xyz_min)[2];
xyzMaxTemp[0] = ((*pGeomitemdata).data.p_surface_data->xyz_max)[0];
xyzMaxTemp[1] = ((*pGeomitemdata).data.p_surface_data->xyz_max)[1];
xyzMaxTemp[2] = ((*pGeomitemdata).data.p_surface_data->xyz_max)[2];
status = ProSurfaceXyzdataEval(Surf, uvMin, xyzMin, deriv1, deriv2, normal);
status = ProSurfaceXyzdataEval(Surf, uvMax, xyzMax, deriv1, deriv2, normal);
vector<double>arrTemp;
arrTemp.push_back(xyzMin[0]);
arrTemp.push_back(xyzMin[1]);
arrTemp.push_back(xyzMin[2]);
(*(vector<vector<double>>*)data).push_back(arrTemp);
vector<double>arrTemp1;
arrTemp1.push_back(xyzMax[0]);
arrTemp1.push_back(xyzMax[1]);
arrTemp1.push_back(xyzMax[2]);
(*(vector<vector<double>>*)data).push_back(arrTemp1);
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();
}
ProError CSDMdlMachDeepHoleCheck::DeepHoleGeomitemVisitAction(ProGeomitem *pGeomitem, ProError status, ProAppData data)
{
ProGeomitemdata *pGeomitemdata;
ProSurfacedata *Surdata;
ProSurfaceshapedata SufShapedata;
ProCylinderdata Cylindata;
ProSurface surf ;
ProSrftype SurfTyp;
status = ProGeomitemToSurface(pGeomitem, &surf);
status = ProSurfaceTypeGet(surf, &SurfTyp);
if (SurfTyp != PRO_SRF_CYL)
{
return PRO_TK_NO_ERROR;
}
status = ProGeomitemdataGet(pGeomitem,&pGeomitemdata);
Surdata = (*pGeomitemdata).data.p_surface_data;
SufShapedata = (*Surdata).srf_shape;
double DeepHole_umax = (*Surdata).uv_max[0];
double DeepHole_vmax = (*Surdata).uv_max[1];
//double DeepHole_umin = (*Surdata).uv_min[0];
double DeepHole_vmin = (*Surdata).uv_min[1];
Cylindata = SufShapedata.cylinder;
double cylin_origin[3];
double DeepHole_e1[3];
double DeepHole_e2[3];
double DeepHole_e3[3];
double DeepHole_radius;
for (int i = 0; i<3; i++)
{
cylin_origin[i] = Cylindata.origin[i];
DeepHole_e1[i] = Cylindata.e1[i];
DeepHole_e2[i] = Cylindata.e2[i];
DeepHole_e3[i] = Cylindata.e3[i];
}
DeepHole_radius = Cylindata.radius;
if (DEQUAL(DeepHole_radius, 0.0))
{
return PRO_TK_NO_ERROR;
}
double DeepHole_point1[3];
double DeepHole_point2[3];
for (int j = 0; j<3; j++)
{
DeepHole_point1[j] = DeepHole_radius*(cos(DeepHole_umax)*DeepHole_e1[j] + sin(DeepHole_umax)*DeepHole_e2[j]) +
DeepHole_vmax*DeepHole_e3[j] + cylin_origin[j];
DeepHole_point2[j] = DeepHole_radius*(cos(DeepHole_umax)*DeepHole_e1[j] + sin(DeepHole_umax)*DeepHole_e2[j]) +
DeepHole_vmin*DeepHole_e3[j] + cylin_origin[j];
}
double DeepHoleDepth;
DeepHoleDepth = sqrt((DeepHole_point1[0] - DeepHole_point2[0])*(DeepHole_point1[0] - DeepHole_point2[0]) +
(DeepHole_point1[1] - DeepHole_point2[1])*(DeepHole_point1[1] - DeepHole_point2[1]) +
(DeepHole_point1[2] - DeepHole_point2[2])*(DeepHole_point1[2] - DeepHole_point2[2]));
ProFeature DeepHoleErrorFeat;
int arrDeepHoleErrorSize = (int)(*(DeepHoleFeaVisitData*)data).arrDeepHoleErrorIDs.GetSize();
if ((DeepHoleDepth/DeepHole_radius)>(*(DeepHoleFeaVisitData*)data).dDeepHoleRatio)
{
(*(DeepHoleFeaVisitData*)data).nDeepHoleResultType = CHECK_RESULT_INVALID_VALUE;
status = ProGeomitemFeatureGet(pGeomitem,&DeepHoleErrorFeat);
if (0 != arrDeepHoleErrorSize)
{
for (int k=0; k<arrDeepHoleErrorSize; k++)
{
if ((*(DeepHoleFeaVisitData*)data).arrDeepHoleErrorIDs[k] == DeepHoleErrorFeat.id)
return PRO_TK_NO_ERROR;
}
}
(*(DeepHoleFeaVisitData*)data).arrDeepHoleErrorIDs.Add(DeepHoleErrorFeat.id);
}
return PRO_TK_NO_ERROR;
}
