occqt.cpp注释解析

// 引入occQt.h头文件，该文件可能包含了Open CASCADE Technology和Qt库的交互代码  
#include "occQt.h"  
  
// 引入occView.h头文件，该文件可能包含了用于3D视图处理的代码  
#include "occView.h"  
  
// 引入QToolBar头文件，这是Qt库的一部分，用于创建工具栏  
#include <QToolBar>  
  
// 引入QTreeView头文件，这是Qt库的一部分，用于创建树形视图  
#include <QTreeView>  
  
// 引入QMessageBox头文件，这是Qt库的一部分，用于创建消息框  
#include <QMessageBox>  
  
// 引入QDockWidget头文件，这是Qt库的一部分，用于创建可停靠窗口  
#include <QDockWidget>  
  
// 引入gp_Circ.hxx头文件，这是Open CASCADE Technology的一部分，用于处理圆  
#include <gp_Circ.hxx>  
  
// 引入gp_Elips.hxx头文件，这是Open CASCADE Technology的一部分，用于处理椭圆  
#include <gp_Elips.hxx>  
  
// 引入gp_Pln.hxx头文件，这是Open CASCADE Technology的一部分，用于处理平面  
#include <gp_Pln.hxx>  
  
// 引入gp_Lin2d.hxx头文件，这是Open CASCADE Technology的一部分，用于处理2D线  
#include <gp_Lin2d.hxx>  
  
// 引入Geom_ConicalSurface.hxx头文件，这是Open CASCADE Technology的一部分，用于处理圆锥面  
#include <Geom_ConicalSurface.hxx>  
  
// 引入Geom_ToroidalSurface.hxx头文件，这是Open CASCADE Technology的一部分，用于处理环面  
#include <Geom_ToroidalSurface.hxx>  
  
// 引入Geom_CylindricalSurface.hxx头文件，这是Open CASCADE Technology的一部分，用于处理圆柱面  
#include <Geom_CylindricalSurface.hxx>  
  
// 引入GCE2d_MakeSegment.hxx头文件，这是Open CASCADE Technology的一部分，用于创建2D线段  
#include <GCE2d_MakeSegment.hxx>  
  
// 引入TopoDS.hxx头文件，这是Open CASCADE Technology的一部分，用于处理拓扑形状数据结构  
#include <TopoDS.hxx>  
  
// 引入TopExp.hxx头文件，这是Open CASCADE Technology的一部分，用于处理拓扑形状的操作和算法  
#include <TopExp.hxx>  
  
// 引入TopExp_Explorer.hxx头文件，这是Open CASCADE Technology的一部分，用于探索拓扑形状的结构  
#include <TopExp_Explorer.hxx>  
  
// 引入TColgp_Array1OfPnt2d.hxx头文件，这是Open CASCADE Technology的一部分，用于处理2D点数组  
#include <TColgp_Array1OfPnt2d.hxx>  
  
// 引入BRepLib.hxx头文件，这是Open CASCADE Technology的一部分，用于处理边界表示库  
#include <BRepLib.hxx>  
  
// 引入BRepBuilderAPI_MakeVertex.hxx头文件，这是Open CASCADE Technology的一部分，用于创建顶点  
#include <BRepBuilderAPI_MakeVertex.hxx>  
  
// 引入BRepBuilderAPI_MakeEdge.hxx头文件，这是Open CASCADE Technology的一部分，用于创建边缘  
#include <BRepBuilderAPI_MakeEdge.hxx>  
  
// 引入BRepBuilderAPI_MakeWire.hxx头文件，这是Open CASCADE Technology的一部分，用于创建线框  
#include <BRepBuilderAPI_MakeWire.hxx>  
  
// 引入BRepBuilderAPI_MakeFace.hxx头文件，这是Open CASCADE Technology的一部分，用于创建面片  
#include <BRepBuilderAPI_MakeFace.hxx>  
  
// 引入BRepBuilderAPI_Transform.hxx头文件，这是Open CASCADE Technology的一部分，用于进行形状变换操作  
#include <BRepBuilderAPI_Transform.hxx>  
  
// 引入BRepBuilderAPI_MakePolygon.hxx头文件，这是Open CASCADE Technology的一部分，用于创建多边形  
#include <BRepBuilderAPI_MakePolygon.hxx>  
  
// 引入BRepPrimAPI_MakeBox.hxx头文件，这是Open CASCADE Technology的一部分，用于创建立方体  
#include <BRepPrimAPI_MakeBox.hxx>  
  
// 引入BRepPrimAPI_MakeCone.hxx头文件，这是Open CASCADE Technology的一部分，用于创建圆锥体  
#include <BRepPrimAPI_MakeCone.hxx>  
  
// 引入BRepPrimAPI_MakeSphere.hxx头文件，这是Open CASCADE Technology的一部分，用于创建球体  
#include <BRepPrimAPI_MakeSphere.hxx>  
  
// 引入BRepPrimAPI_MakeCylinder.hxx头文件，这是Open CASCADE Technology的一部分，用于创建圆柱体  
#include <BRepPrimAPI_MakeCylinder.hxx>  
  
// 引入BRepPrimAPI_MakeTorus.hxx头文件，这是Open CASCADE Technology的一部分，用于创建环体  
#include <BRepPrimAPI_MakeTorus.hxx>  
  
// 引入BRepPrimAPI_MakePrism.hxx头文件，这是Open CASCADE Technology的一部分，用于创建立体棱柱  
#include <BRepPrimAPI_MakePrism.hxx>  
  
// 引入BRepPrimAPI_MakeRevol.hxx头文件，这是Open CASCADE Technology的一部分，用于创建旋转体  
#include <BRepPrimAPI_MakeRevol.hxx>

// 引入BRepFilletAPI_MakeFillet.hxx头文件，该文件包含了用于创建圆角的类和方法  
#include <BRepFilletAPI_MakeFillet.hxx>  
  
// 引入BRepFilletAPI_MakeChamfer.hxx头文件，该文件包含了用于创建斜角的类和方法  
#include <BRepFilletAPI_MakeChamfer.hxx>  
  
// 引入BRepOffsetAPI_MakePipe.hxx头文件，该文件包含了用于创建管道形状的类和方法  
#include <BRepOffsetAPI_MakePipe.hxx>  
  
// 引入BRepOffsetAPI_ThruSections.hxx头文件，该文件包含了用于通过多个截面创建形状的类和方法  
#include <BRepOffsetAPI_ThruSections.hxx>  
  
// 引入BRepAlgoAPI_Cut.hxx头文件，该文件包含了用于进行布尔减运算的类和方法  
#include <BRepAlgoAPI_Cut.hxx>  
  
// 引入BRepAlgoAPI_Fuse.hxx头文件，该文件包含了用于进行布尔加运算的类和方法  
#include <BRepAlgoAPI_Fuse.hxx>  
  
// 引入BRepAlgoAPI_Common.hxx头文件，该文件包含了用于进行布尔交运算的类和方法  
#include <BRepAlgoAPI_Common.hxx>  
  
// 引入AIS_Shape.hxx头文件，该文件包含了用于处理3D形状的类和方法  
#include <AIS_Shape.hxx>  
  
// 定义occQt类的构造函数，该类继承自QMainWindow，是用于创建主窗口的类  
occQt::occQt(QWidget *parent)  
    : QMainWindow(parent) // 调用父类的构造函数，参数是parent，表示这个窗口的父窗口是parent指向的窗口  
{  
    ui.setupUi(this); // 调用ui对象的setupUi方法，初始化用户界面  
  
    myOccView = new OccView(this); // 创建新的OccView对象，参数是this，表示这个OccView的父窗口是this指向的窗口  
  
    setCentralWidget(myOccView); // 设置中央部件为myOccView指向的部件  
  
    createActions(); // 创建操作  
    createMenus(); // 创建菜单  
    createToolBars(); // 创建工具栏  
}  
  
// 定义occQt类的析构函数，用于在对象被删除时执行清理操作，此处没有具体实现  
occQt::~occQt()  
{  
  
}

void occQt::createActions( void ) // 定义一个名为createActions的成员函数，该函数没有返回值(void)和参数  
{  
    // File  
    connect(ui.actionExit, SIGNAL(triggered()), this, SLOT(close())); // 连接ui.actionExit的triggered信号到本类的close槽，当用户点击Exit按钮时，触发close函数  
  
    // View  
    connect(ui.actionZoom, SIGNAL(triggered()), myOccView, SLOT(zoom())); // 连接ui.actionZoom的triggered信号到myOccView的zoom槽，当用户点击Zoom按钮时，触发myOccView的zoom函数  
    connect(ui.actionPan, SIGNAL(triggered()), myOccView, SLOT(pan())); // 连接ui.actionPan的triggered信号到myOccView的pan槽，当用户点击Pan按钮时，触发myOccView的pan函数  
    connect(ui.actionRotate, SIGNAL(triggered()), myOccView, SLOT(rotate())); // 连接ui.actionRotate的triggered信号到myOccView的rotate槽，当用户点击Rotate按钮时，触发myOccView的rotate函数  
  
    connect(ui.actionReset, SIGNAL(triggered()), myOccView, SLOT(reset())); // 连接ui.actionReset的triggered信号到myOccView的reset槽，当用户点击Reset按钮时，触发myOccView的reset函数  
    connect(ui.actionFitAll, SIGNAL(triggered()), myOccView, SLOT(fitAll())); // 连接ui.actionFitAll的triggered信号到myOccView的fitAll槽，当用户点击Fit All按钮时，触发myOccView的fitAll函数  
  
    // Primitive  
    connect(ui.actionBox, SIGNAL(triggered()), this, SLOT(makeBox())); // 连接ui.actionBox的triggered信号到本类的makeBox槽，当用户点击Box按钮时，触发makeBox函数  
    connect(ui.actionCone, SIGNAL(triggered()), this, SLOT(makeCone())); // 连接ui.actionCone的triggered信号到本类的makeCone槽，当用户点击Cone按钮时，触发makeCone函数  
    connect(ui.actionSphere, SIGNAL(triggered()), this, SLOT(makeSphere())); // 连接ui.actionSphere的triggered信号到本类的makeSphere槽，当用户点击Sphere按钮时，触发makeSphere函数  
    connect(ui.actionCylinder, SIGNAL(triggered()), this, SLOT(makeCylinder())); // 连接ui.actionCylinder的triggered信号到本类的makeCylinder槽，当用户点击Cylinder按钮时，触发makeCylinder函数  
    connect(ui.actionTorus, SIGNAL(triggered()), this, SLOT(makeTorus())); // 连接ui.actionTorus的triggered信号到本类的makeTorus槽，当用户点击Torus按钮时，触发makeTorus函数  
  
    // Modeling  
    connect(ui.actionFillet, SIGNAL(triggered()), this, SLOT(makeFillet())); // 连接ui.actionFillet的triggered信号到本类的makeFillet槽，当用户点击Fillet按钮时，触发makeFillet函数  
    connect(ui.actionChamfer, SIGNAL(triggered()), this, SLOT(makeChamfer())); // 连接ui.actionChamfer的triggered信号到本类的makeChamfer槽，当用户点击Chamfer按钮时，触发makeChamfer函数  
    connect(ui.actionExtrude, SIGNAL(triggered()), this, SLOT(makeExtrude())); // 连接ui.actionExtrude的triggered信号到本类的makeExtrude槽，当用户点击Extrude按钮时，触发makeExtrude函数  
    connect(ui.actionRevolve, SIGNAL(triggered()), this, SLOT(makeRevol())); // 连接ui.actionRevolve的triggered信号到本类的makeRevol槽，当用户点击Revolve按钮时，触发makeRevol函数  
    connect(ui.actionLoft, SIGNAL(triggered()), this, SLOT(makeLoft())); // 连接ui.actionLoft的triggered信号到本类的makeLoft槽，当用户点击Loft按钮时，触发makeLoft函数  
  
    connect(ui.actionCut, SIGNAL(triggered()), this, SLOT(testCut())); // 连接ui.actionCut的triggered信号到本类的testCut槽，当用户点击Cut按钮时，触发testCut函数  
    connect(ui.actionFuse, SIGNAL(triggered()), this, SLOT(testFuse())); // 连接ui.actionFuse的triggered信号到本类的testFuse槽，当用户点击Fuse按钮时，
connect(ui.actionHelix, SIGNAL(triggered()), this, SLOT(testHelix())); // 连接ui.actionHelix的triggered信号到本类的testHelix槽，当用户点击Helix按钮时，触发testHelix函数  
  
// Help  
connect(ui.actionAbout, SIGNAL(triggered()), this, SLOT(about())); // 连接ui.actionAbout的triggered信号到本类的about槽，当用户点击About按钮时，触发about函数

void occQt::createToolBars( void ) // 定义一个名为createToolBars的成员函数，该函数没有返回值(void)和参数  
{  
    QToolBar* aToolBar = addToolBar(tr("&Navigate")); // 创建一个新的工具栏，并添加到窗口，工具栏的标题为"&Navigate"  
    aToolBar->addAction(ui.actionZoom); // 在工具栏上添加一个动作，该动作是ui.actionZoom，一般来说这是一个缩放操作  
    aToolBar->addAction(ui.actionPan); // 在工具栏上添加一个动作，该动作是ui.actionPan，一般来说这是一个平移操作  
    aToolBar->addAction(ui.actionRotate); // 在工具栏上添加一个动作，该动作是ui.actionRotate，一般来说这是一个旋转操作  
  
    aToolBar = addToolBar(tr("&View")); // 创建一个新的工具栏，并添加到窗口，工具栏的标题为"&View"  
    aToolBar->addAction(ui.actionReset); // 在工具栏上添加一个动作，该动作是ui.actionReset，一般来说这是一个重置视图操作  
    aToolBar->addAction(ui.actionFitAll); // 在工具栏上添加一个动作，该动作是ui.actionFitAll，一般来说这是一个适应所有视图操作  
  
    aToolBar = addToolBar(tr("&Primitive")); // 创建一个新的工具栏，并添加到窗口，工具栏的标题为"&Primitive"  
    aToolBar->addAction(ui.actionBox); // 在工具栏上添加一个动作，该动作是ui.actionBox，一般来说这是一个创建盒子操作  
    aToolBar->addAction(ui.actionCone); // 在工具栏上添加一个动作，该动作是ui.actionCone，一般来说这是一个创建锥体操作  
    aToolBar->addAction(ui.actionSphere); // 在工具栏上添加一个动作，该动作是ui.actionSphere，一般来说这是一个创建球体操作  
    aToolBar->addAction(ui.actionCylinder); // 在工具栏上添加一个动作，该动作是ui.actionCylinder，一般来说这是一个创建圆柱体操作  
    aToolBar->addAction(ui.actionTorus); // 在工具栏上添加一个动作，该动作是ui.actionTorus，一般来说这是一个创建圆环体操作  
  
    aToolBar = addToolBar(tr("&Modeling")); // 创建一个新的工具栏，并添加到窗口，工具栏的标题为"&Modeling"  
    aToolBar->addAction(ui.actionFillet); // 在工具栏上添加一个动作，该动作是ui.actionFillet，一般来说这是一个圆角操作  
    aToolBar->addAction(ui.actionChamfer); // 在工具栏上添加一个动作，该动作是ui.actionChamfer，一般来说这是一个斜角操作  
    aToolBar->addAction(ui.actionExtrude); // 在工具栏上添加一个动作，该动作是ui.actionExtrude，一般来说这是一个拉伸操作  
    aToolBar->addAction(ui.actionRevolve); // 在工具栏上添加一个动作，该动作是ui.actionRevolve，一般来说这是一个旋转操作  
    aToolBar->addAction(ui.actionLoft); // 在工具栏上添加一个动作，该动作是ui.actionLoft，一般来说这是一个放样操作  
    aToolBar->addSeparator(); // 在工具栏上添加一个分隔符  
    aToolBar->addAction(ui.actionCut); // 在工具栏上添加一个动作，该动作是ui.actionCut，一般来说这是一个剪切操作  
    aToolBar->addAction(ui.actionFuse); // 在工具栏上添加一个动作，该动作是ui.actionFuse，一般来说这是一个融合操作  
    aToolBar->addAction(ui.actionCommon); // 在工具栏上添加一个动作，该动作是ui.actionCommon，一般来说这是一个求交集操作  
    aToolBar->addSeparator(); // 在工具栏上添加一个分隔符  
    aToolBar->addAction(ui.actionHelix); // 在工具栏上添加一个动作，该动作是ui.actionHelix，一般来说这是一个创建螺旋操作  
  
    aToolBar = addToolBar(tr("Help")); // 创建一个新的工具栏，并添加到窗口，工具栏的标题为"Help"  
    aToolBar->addAction(ui.actionAbout); // 在工具栏上添加一个动作，该动作是ui.
}

// 定义一个关于occQt的说明函数，函数没有返回值（void）和参数  
void occQt::about()  
{  
    // 使用Qt的QMessageBox类的about方法弹出一个关于窗口，窗口的标题为"About occQt"，内容为occQt 2.0的版权信息  
    QMessageBox::about(this, tr("About occQt"),  
        tr("<h2>occQt 2.0</h2>"  
        "<p>Copyright &copy; 2014 eryar@163.com"  
        "<p>occQt is a demo applicaton about Qt and OpenCASCADE."));  
}  
  
// 定义一个关于occQt的创建盒子函数，函数没有返回值（void）和参数  
void occQt::makeBox()  
{  
    // 使用OpenCASCADE的BRepPrimAPI_MakeBox方法创建一个盒子，参数为盒子的长、宽、高，返回值为盒子的几何形状（TopoDS_Shape）  
    TopoDS_Shape aTopoBox = BRepPrimAPI_MakeBox(3.0, 4.0, 5.0).Shape();  
    // 创建一个新的AIS_Shape对象，参数为刚创建的盒子的几何形状  
    Handle(AIS_Shape) anAisBox = new AIS_Shape(aTopoBox);  
  
    // 设置盒子的颜色为Azure（天蓝色）  
    anAisBox->SetColor(Quantity_NOC_AZURE);  
  
    // 在myOccView的上下文中显示盒子  
    myOccView->getContext()->Display(anAisBox, Standard_True);  
}  
  
// 定义一个关于occQt的创建圆锥函数，函数没有返回值（void）和参数  
void occQt::makeCone()  
{  
    // 创建一个轴（gp_Ax2对象），并设置其位置（gp_Pnt对象），这里的位置是(0.0, 10.0, 0.0)  
    gp_Ax2 anAxis;  
    anAxis.SetLocation(gp_Pnt(0.0, 10.0, 0.0));  
  
    // 使用OpenCASCADE的BRepPrimAPI_MakeCone方法创建一个带有底部（即不是完全尖锐的）圆锥，参数为轴、底部半径、顶部半径和高，返回值为圆锥的几何形状（TopoDS_Shape）  
    TopoDS_Shape aTopoReducer = BRepPrimAPI_MakeCone(anAxis, 3.0, 1.5, 5.0).Shape();  
    // 创建一个新的AIS_Shape对象，参数为刚创建的圆锥的几何形状  
    Handle(AIS_Shape) anAisReducer = new AIS_Shape(aTopoReducer);  
  
    // 设置圆锥的颜色为Bisque（米色）  
    anAisReducer->SetColor(Quantity_NOC_BISQUE);  
  
    // 修改轴的位置为(8.0, 10.0, 0.0)  
    anAxis.SetLocation(gp_Pnt(8.0, 10.0, 0.0));  
    // 使用OpenCASCADE的BRepPrimAPI_MakeCone方法创建一个尖锐的圆锥（即底部半径为0），参数为轴、底部半径、顶部半径和高，返回值为圆锥的几何形状（TopoDS_Shape）  
    TopoDS_Shape aTopoCone = BRepPrimAPI_MakeCone(anAxis, 3.0, 0.0, 5.0).Shape();  
    // 创建一个新的AIS_Shape对象，参数为刚创建的圆锥的几何形状  
    Handle(AIS_Shape) anAisCone = new AIS_Shape(aTopoCone);  
  
    // 设置圆锥的颜色为Chocolate（巧克力色）  
    anAisCone->SetColor(Quantity_NOC_CHOCOLATE);  
  
    // 在myOccView的上下文中显示带有底部的圆锥和尖锐的圆锥  
    myOccView->getContext()->Display(anAisReducer, Standard_True);  
    myOccView->getContext()->Display(anAisCone, Standard_True);  
}

// 定义一个关于occQt的创建球体函数，函数没有返回值（void）和参数  
void occQt::makeSphere()  
{  
    // 创建一个轴（gp_Ax2对象），并设置其位置（gp_Pnt对象），这里的位置是(0.0, 20.0, 0.0)  
    gp_Ax2 anAxis;  
    anAxis.SetLocation(gp_Pnt(0.0, 20.0, 0.0));  
  
    // 使用OpenCASCADE的BRepPrimAPI_MakeSphere方法创建一个球体，参数为轴和半径，返回值为球体的几何形状（TopoDS_Shape）  
    TopoDS_Shape aTopoSphere = BRepPrimAPI_MakeSphere(anAxis, 3.0).Shape();  
    // 创建一个新的AIS_Shape对象，参数为刚创建的球体的几何形状  
    Handle(AIS_Shape) anAisSphere = new AIS_Shape(aTopoSphere);  
  
    // 设置球体的颜色为蓝色  
    anAisSphere->SetColor(Quantity_NOC_BLUE1);  
  
    // 在myOccView的上下文中显示球体  
    myOccView->getContext()->Display(anAisSphere, Standard_True);  
}  
  
// 定义一个关于occQt的创建圆柱体函数，函数没有返回值（void）和参数  
void occQt::makeCylinder()  
{  
    // 创建一个轴（gp_Ax2对象），并设置其位置（gp_Pnt对象），这里的位置是(0.0, 30.0, 0.0)  
    gp_Ax2 anAxis;  
    anAxis.SetLocation(gp_Pnt(0.0, 30.0, 0.0));  
  
    // 使用OpenCASCADE的BRepPrimAPI_MakeCylinder方法创建一个圆柱体，参数为轴、半径和高，返回值为圆柱体的几何形状（TopoDS_Shape）  
    TopoDS_Shape aTopoCylinder = BRepPrimAPI_MakeCylinder(anAxis, 3.0, 5.0).Shape();  
    // 创建一个新的AIS_Shape对象，参数为刚创建的圆柱体的几何形状  
    Handle(AIS_Shape) anAisCylinder = new AIS_Shape(aTopoCylinder);  
  
    // 设置圆柱体的颜色为红色  
    anAisCylinder->SetColor(Quantity_NOC_RED);  
  
    // 修改轴的位置为(8.0, 30.0, 0.0)  
    anAxis.SetLocation(gp_Pnt(8.0, 30.0, 0.0));  
    // 使用OpenCASCADE的BRepPrimAPI_MakeCylinder方法创建一个部分圆柱体（即只有一部分的圆柱体），参数为轴、半径、高和角度（这里的角度为1.5个π，即180度），返回值为部分圆柱体的几何形状（TopoDS_Shape）  
    TopoDS_Shape aTopoPie = BRepPrimAPI_MakeCylinder(anAxis, 3.0, 5.0, M_PI_2 * 3.0).Shape();  
    // 创建一个新的AIS_Shape对象，参数为刚创建的部分圆柱体的几何形状  
    Handle(AIS_Shape) anAisPie = new AIS_Shape(aTopoPie);  
  
    // 设置部分圆柱体的颜色为棕色  
    anAisPie->SetColor(Quantity_NOC_TAN);  
  
    // 在myOccView的上下文中显示圆柱体和部分圆柱体  
    myOccView->getContext()->Display(anAisCylinder, Standard_True);  
    myOccView->getContext()->Display(anAisPie, Standard_True);  
}

// 定义一个关于occQt的创建圆环函数，函数没有返回值（void）和参数  
void occQt::makeTorus()  
{  
    // 创建一个轴（gp_Ax2对象），并设置其位置（gp_Pnt对象），这里的位置是(0.0, 40.0, 0.0)  
    gp_Ax2 anAxis;  
    anAxis.SetLocation(gp_Pnt(0.0, 40.0, 0.0));  
  
    // 使用OpenCASCADE的BRepPrimAPI_MakeTorus方法创建一个圆环，参数为轴、主半径和次半径，返回值为圆环的几何形状（TopoDS_Shape）  
    TopoDS_Shape aTopoTorus = BRepPrimAPI_MakeTorus(anAxis, 3.0, 1.0).Shape();  
    // 创建一个新的AIS_Shape对象，参数为刚创建的圆环的几何形状  
    Handle(AIS_Shape) anAisTorus = new AIS_Shape(aTopoTorus);  
  
    // 设置圆环的颜色为黄色  
    anAisTorus->SetColor(Quantity_NOC_YELLOW);  
  
    // 修改轴的位置为(8.0, 40.0, 0.0)  
    anAxis.SetLocation(gp_Pnt(8.0, 40.0, 0.0));  
    // 使用OpenCASCADE的BRepPrimAPI_MakeTorus方法创建一个部分圆环（即只有一部分的圆环），参数为轴、主半径、次半径和角度（这里的角度为180度），返回值为部分圆环的几何形状（TopoDS_Shape）  
    TopoDS_Shape aTopoElbow = BRepPrimAPI_MakeTorus(anAxis, 3.0, 1.0, M_PI_2).Shape();  
    // 创建一个新的AIS_Shape对象，参数为刚创建的部分圆环的几何形状  
    Handle(AIS_Shape) anAisElbow = new AIS_Shape(aTopoElbow);  
  
    // 设置部分圆环的颜色为蓟色  
    anAisElbow->SetColor(Quantity_NOC_THISTLE);  
  
    // 在myOccView的上下文中显示圆环和部分圆环  
    myOccView->getContext()->Display(anAisTorus, Standard_True);  
    myOccView->getContext()->Display(anAisElbow, Standard_True);  
}  
  
// 定义一个关于occQt的创建圆角函数，函数没有返回值（void）和参数  
void occQt::makeFillet()  
{  
    // 创建一个轴（gp_Ax2对象），并设置其位置（gp_Pnt对象），这里的位置是(0.0, 50.0, 0.0)  
    gp_Ax2 anAxis;  
    anAxis.SetLocation(gp_Pnt(0.0, 50.0, 0.0));  
  
    // 使用OpenCASCADE的BRepPrimAPI_MakeBox方法创建一个长方体，参数为轴和长宽高，返回值为长方体的几何形状（TopoDS_Shape）  
    TopoDS_Shape aTopoBox = BRepPrimAPI_MakeBox(anAxis, 3.0, 4.0, 5.0).Shape();  
    // 使用OpenCASCADE的BRepFilletAPI_MakeFillet方法创建一个圆角，参数为刚创建的长方体  
    BRepFilletAPI_MakeFillet MF(aTopoBox);  
  
    // 将所有边添加到圆角中  
    // 使用OpenCASCADE的TopExp_Explorer类遍历长方体的所有边，并将它们添加到圆角中，圆角半径为1.0  
    // Add all the edges to fillet.  
    for (TopExp_Explorer ex(aTopoBox, TopAbs_EDGE); ex.More(); ex.Next())  
    {  
        MF.Add(1.0, TopoDS::Edge(ex.Current()));  
    }  
  
    // 创建一个新的AIS_Shape对象，参数为刚创建的圆角的几何形状  
    Handle(AIS_Shape) anAisShape = new AIS_Shape(MF.Shape());  
    // 设置圆角的颜色为紫色  
    anAisShape->SetColor(Quantity_NOC_VIOLET);  
  
    // 在myOccView的上下文中显示圆角  
    myOccView->getContext()->Display(anAisShape, Standard_True);  
}

// 定义一个关于occQt的创建倒角函数，函数没有返回值（void）和参数  
void occQt::makeChamfer()  
{  
    // 创建一个轴（gp_Ax2对象），并设置其位置（gp_Pnt对象），这里的位置是(8.0, 50.0, 0.0)  
    gp_Ax2 anAxis;  
    anAxis.SetLocation(gp_Pnt(8.0, 50.0, 0.0));  
  
    // 使用OpenCASCADE的BRepPrimAPI_MakeBox方法创建一个长方体，参数为轴和长宽高，返回值为长方体的几何形状（TopoDS_Shape）  
    TopoDS_Shape aTopoBox = BRepPrimAPI_MakeBox(anAxis, 3.0, 4.0, 5.0).Shape();  
    // 使用OpenCASCADE的BRepFilletAPI_MakeChamfer方法创建一个倒角，参数为刚创建的长方体  
    BRepFilletAPI_MakeChamfer MC(aTopoBox);  
    // 创建一个用于存储边和面映射的数据结构  
    TopTools_IndexedDataMapOfShapeListOfShape aEdgeFaceMap;  
  
    // 使用OpenCASCADE的TopExp::MapShapesAndAncestors方法，将长方体的边和它们所在的面进行映射，结果存储在aEdgeFaceMap中  
    TopExp::MapShapesAndAncestors(aTopoBox, TopAbs_EDGE, TopAbs_FACE, aEdgeFaceMap);  
  
    // 遍历aEdgeFaceMap中的所有边和面  
    for (Standard_Integer i = 1; i <= aEdgeFaceMap.Extent(); ++i)  
    {  
        // 获取当前边  
        TopoDS_Edge anEdge = TopoDS::Edge(aEdgeFaceMap.FindKey(i));  
        // 获取当前边所在的面  
        TopoDS_Face aFace = TopoDS::Face(aEdgeFaceMap.FindFromIndex(i).First());  
  
        // 在倒角中添加当前边和面的信息，倒角的两个半径均为0.6  
        MC.Add(0.6, 0.6, anEdge, aFace);  
    }  
  
    // 创建一个新的AIS_Shape对象，参数为刚创建的倒角的几何形状  
    Handle(AIS_Shape) anAisShape = new AIS_Shape(MC.Shape());  
    // 设置倒角的颜色为番茄色  
    anAisShape->SetColor(Quantity_NOC_TOMATO);  
  
    // 在myOccView的上下文中显示倒角  
    myOccView->getContext()->Display(anAisShape, Standard_True);  
}

// 定义一个属于occQt类的挤出函数，该函数没有返回值  
void occQt::makeExtrude() {  
  
    // 创建一个顶点（TopoDS_Vertex对象），该顶点由给定的3D坐标(0.0, 60.0, 0.0)确定  
    // BRepBuilderAPI_MakeVertex是一个创建顶点的函数  
    TopoDS_Vertex aVertex = BRepBuilderAPI_MakeVertex(gp_Pnt(0.0, 60.0, 0.0));  
  
    // 使用BRepPrimAPI_MakePrism方法创建一个棱柱，该棱柱由刚创建的顶点（aVertex）和一个高度向量(0.0, 0.0, 5.0)确定  
    // 返回棱柱的几何形状（TopoDS_Shape对象）  
    TopoDS_Shape aPrismVertex = BRepPrimAPI_MakePrism(aVertex, gp_Vec(0.0, 0.0, 5.0));  
  
    // 创建一个新的AIS_Shape对象，该对象与刚创建的棱柱的几何形状关联  
    Handle(AIS_Shape) anAisPrismVertex = new AIS_Shape(aPrismVertex);  
  
  
    // 创建一个边（TopoDS_Edge对象），该边由给定的两个3D点(5.0, 60.0, 0.0)和(10.0, 60.0, 0.0)确定  
    // BRepBuilderAPI_MakeEdge是一个创建边的函数  
    TopoDS_Edge anEdge = BRepBuilderAPI_MakeEdge(gp_Pnt(5.0, 60.0, 0.0), gp_Pnt(10.0, 60.0, 0.0));  
  
    // 使用BRepPrimAPI_MakePrism方法创建一个棱柱，该棱柱由刚创建的边（anEdge）和一个高度向量(0.0, 0.0, 5.0)确定  
    // 返回棱柱的几何形状（TopoDS_Shape对象）  
    TopoDS_Shape aPrismEdge = BRepPrimAPI_MakePrism(anEdge, gp_Vec(0.0, 0.0, 5.0));  
  
    // 创建一个新的AIS_Shape对象，该对象与刚创建的棱柱的几何形状关联  
    Handle(AIS_Shape) anAisPrismEdge = new AIS_Shape(aPrismEdge);  
  
  
    // 定义一个轴，并将其位置设置为给定的3D点(16.0, 60.0, 0.0)  
    gp_Ax2 anAxis;  
    anAxis.SetLocation(gp_Pnt(16.0, 60.0, 0.0));  
  
    // 创建一个圆（TopoDS_Edge对象），该圆心位于定义的轴上，半径为3.0  
    // BRepBuilderAPI_MakeEdge是一个创建圆的函数  
    TopoDS_Edge aCircleEdge = BRepBuilderAPI_MakeEdge(gp_Circ(anAxis, 3.0));  
  
    // 创建一个线（TopoDS_Wire对象），该线由刚创建的圆（aCircleEdge）构成  
    // BRepBuilderAPI_MakeWire是一个创建线的函数  
    TopoDS_Wire aCircleWire = BRepBuilderAPI_MakeWire(aCircleEdge);  
  
    // 使用BRepPrimAPI_MakePrism方法创建一个棱柱，该棱柱由刚创建的线（aCircleWire）和一个高度向量(0.0, 0.0, 5.0)确定  
    // 返回棱柱的几何形状（TopoDS_Shape对象）  
    TopoDS_Shape aPrismCircle = BRepPrimAPI_MakePrism(aCircleWire, gp_Vec(0.0, 0.0, 5.0));  
  
    // 创建一个新的AIS_Shape对象，该对象与刚创建的棱柱的几何形状关联  
    Handle(AIS_Shape) anAisPrismCircle = new AIS_Shape(aPrismCircle);  
  
    // 设置轴的位置为给定的3D点(24.0, 60.0, 0.0)  
anAxis.SetLocation(gp_Pnt(24.0, 60.0, 0.0));  
  
// 创建一个椭圆（TopoDS_Edge对象），该椭圆位于定义的轴上，半轴分别为3.0和2.0  
// BRepBuilderAPI_MakeEdge是一个创建椭圆的函数  
TopoDS_Edge aEllipseEdge = BRepBuilderAPI_MakeEdge(gp_Elips(anAxis, 3.0, 2.0));  
  
// 创建一个线（TopoDS_Wire对象），该线由刚创建的椭圆（aEllipseEdge）构成  
// BRepBuilderAPI_MakeWire是一个创建线的函数  
TopoDS_Wire aEllipseWire = BRepBuilderAPI_MakeWire(aEllipseEdge);  
  
// 创建一个面（TopoDS_Face对象），该面由给定的平面(gp::XOY())和刚创建的线（aEllipseWire）确定  
// BRepBuilderAPI_MakeFace是一个创建面的函数  
TopoDS_Face aEllipseFace = BRepBuilderAPI_MakeFace(gp_Pln(gp::XOY()), aEllipseWire);  
  
// 使用BRepPrimAPI_MakePrism方法创建一个棱柱，该棱柱由刚创建的面（aEllipseFace）和一个高度向量(0.0, 0.0, 5.0)确定  
// 返回棱柱的几何形状（TopoDS_Shape对象）  
TopoDS_Shape aPrismEllipse = BRepPrimAPI_MakePrism(aEllipseFace, gp_Vec(0.0, 0.0, 5.0));  
  
// 创建一个新的AIS_Shape对象，该对象与刚创建的棱柱的几何形状关联  
Handle(AIS_Shape) anAisPrismEllipse = new AIS_Shape(aPrismEllipse);
// 设置anAisPrismVertex的颜色为Quantity_NOC_PAPAYAWHIP。Quantity_NOC_PAPAYAWHIP是OpenCASCADE库中定义的一种颜色。  
anAisPrismVertex->SetColor(Quantity_NOC_PAPAYAWHIP);  
  
// 设置anAisPrismEdge的颜色为Quantity_NOC_PEACHPUFF。Quantity_NOC_PEACHPUFF是OpenCASCADE库中定义的一种颜色。  
anAisPrismEdge->SetColor(Quantity_NOC_PEACHPUFF);  
  
// 设置anAisPrismCircle的颜色为Quantity_NOC_PERU。Quantity_NOC_PERU是OpenCASCADE库中定义的一种颜色。  
anAisPrismCircle->SetColor(Quantity_NOC_PERU);  
  
// 设置anAisPrismEllipse的颜色为Quantity_NOC_PINK。Quantity_NOC_PINK是OpenCASCADE库中定义的一种颜色。  
anAisPrismEllipse->SetColor(Quantity_NOC_PINK);  
  
// 在myOccView的上下文中显示anAisPrismVertex，Standard_True表示显示方式为标准显示。  
myOccView->getContext()->Display(anAisPrismVertex, Standard_True);  
  
// 在myOccView的上下文中显示anAisPrismEdge，Standard_True表示显示方式为标准显示。  
myOccView->getContext()->Display(anAisPrismEdge, Standard_True);  
  
// 在myOccView的上下文中显示anAisPrismCircle，Standard_True表示显示方式为标准显示。  
myOccView->getContext()->Display(anAisPrismCircle, Standard_True);  
  
// 在myOccView的上下文中显示anAisPrismEllipse，Standard_True表示显示方式为标准显示。  
myOccView->getContext()->Display(anAisPrismEllipse, Standard_True);
}

void occQt::makeRevol()  
{  
    gp_Ax1 anAxis;  // 定义一个轴线对象  
  
    // 围绕一个顶点旋转的结果是一个边。  
    // 设置轴线的位置为(0.0, 70.0, 0.0)  
    anAxis.SetLocation(gp_Pnt(0.0, 70.0, 0.0));    
    // 创建一个顶点，位置为(2.0, 70.0, 0.0)  
    TopoDS_Vertex aVertex = BRepBuilderAPI_MakeVertex(gp_Pnt(2.0, 70.0, 0.0));    
    // 以anAxis为轴线，围绕aVertex旋转，得到旋转后的几何体  
    TopoDS_Shape aRevolVertex = BRepPrimAPI_MakeRevol(aVertex, anAxis);    
    // 创建一个与旋转后的几何体关联的AIS_Shape对象  
    Handle(AIS_Shape) anAisRevolVertex = new AIS_Shape(aRevolVertex);    
  
    // 围绕一个边旋转的结果是一个面。  
    // 设置轴线的位置为(8.0, 70.0, 0.0)  
    anAxis.SetLocation(gp_Pnt(8.0, 70.0, 0.0));    
    // 创建一个边，该边的两个顶点分别为(6.0, 70.0, 0.0)和(6.0, 70.0, 5.0)  
    TopoDS_Edge anEdge = BRepBuilderAPI_MakeEdge(gp_Pnt(6.0, 70.0, 0.0), gp_Pnt(6.0, 70.0, 5.0));    
    // 以anAxis为轴线，围绕anEdge旋转，得到旋转后的几何体  
    TopoDS_Shape aRevolEdge = BRepPrimAPI_MakeRevol(anEdge, anAxis);    
    // 创建一个与旋转后的几何体关联的AIS_Shape对象  
    Handle(AIS_Shape) anAisRevolEdge = new AIS_Shape(aRevolEdge);    
  
    // 围绕一个线旋转的结果是一个壳。  
    // 设置轴线的位置为(20.0, 70.0, 0.0)  
    anAxis.SetLocation(gp_Pnt(20.0, 70.0, 0.0));    
    // 设置轴线的方向为gp::DY()，即沿Y轴方向  
    anAxis.SetDirection(gp::DY());    
    // 创建一个圆边，该圆位于(15.0, 70.0, 0.0)，半径为1.5，法线方向为gp::DZ()  
    TopoDS_Edge aCircleEdge = BRepBuilderAPI_MakeEdge(gp_Circ(gp_Ax2(gp_Pnt(15.0, 70.0, 0.0), gp::DZ()), 1.5));    
    // 以aCircleEdge为线，创建线对象aCircleWire  
    TopoDS_Wire aCircleWire = BRepBuilderAPI_MakeWire(aCircleEdge);    
    // 以anAxis为轴线，围绕aCircleWire旋转M_PI_2弧度（即90度），得到旋转后的几何体  
    TopoDS_Shape aRevolCircle = BRepPrimAPI_MakeRevol(aCircleWire, anAxis, M_PI_2);    
    // 创建一个与旋转后的几何体关联的AIS_Shape对象  
    Handle(AIS_Shape) anAisRevolCircle = new AIS_Shape(aRevolCircle);    
  
    // 围绕一个面旋转的结果是一个实体。  
    // 设置轴线的位置为(30.0, 70.0, 0.0)  
    anAxis.SetLocation(gp_Pnt(30.0, 70.0, 0.0));    
    // 设置轴线的方向为gp::DY()，即沿Y轴方向逐行注释这段代码到此结束  
    anAxis.SetDirection(gp::DY());    
// 创建一个椭圆边缘，该椭圆在(25.0, 70.0, 0.0)位置，沿Z轴方向，长轴为3.0，短轴为2.0  
TopoDS_Edge aEllipseEdge = BRepBuilderAPI_MakeEdge(gp_Elips(gp_Ax2(gp_Pnt(25.0, 70.0, 0.0), gp::DZ()), 3.0, 2.0));  
  
// 以aEllipseEdge为边缘，创建一个线对象aEllipseWire  
TopoDS_Wire aEllipseWire = BRepBuilderAPI_MakeWire(aEllipseEdge);  
  
// 以aEllipseWire为轮廓，创建一个面对象aEllipseFace，该面位于XOY平面上  
TopoDS_Face aEllipseFace = BRepBuilderAPI_MakeFace(gp_Pln(gp::XOY()), aEllipseWire);  
  
// 以aEllipseFace为面，围绕anAxis旋转M_PI_4弧度（即45度），得到一个旋转后的几何体aRevolEllipse  
TopoDS_Shape aRevolEllipse = BRepPrimAPI_MakeRevol(aEllipseFace, anAxis, M_PI_4);  
  
// 创建一个与旋转后的几何体aRevolEllipse关联的AIS_Shape对象anAisRevolEllipse  
Handle(AIS_Shape) anAisRevolEllipse = new AIS_Shape(aRevolEllipse);  
  
// 设置anAisRevolVertex的颜色为Quantity_NOC_LIMEGREEN，这是OpenCASCADE库中定义的一种颜色  
anAisRevolVertex->SetColor(Quantity_NOC_LIMEGREEN);  
  
// 设置anAisRevolEdge的颜色为Quantity_NOC_LINEN，这是OpenCASCADE库中定义的一种颜色  
anAisRevolEdge->SetColor(Quantity_NOC_LINEN);  
  
// 设置anAisRevolCircle的颜色为Quantity_NOC_MAGENTA1，这是OpenCASCADE库中定义的一种颜色  
anAisRevolCircle->SetColor(Quantity_NOC_MAGENTA1);  
  
// 设置anAisRevolEllipse的颜色为Quantity_NOC_MAROON，这是OpenCASCADE库中定义的一种颜色  
anAisRevolEllipse->SetColor(Quantity_NOC_MAROON);  
  
// 在myOccView的上下文中显示anAisRevolVertex，Standard_True表示显示方式为标准显示  
myOccView->getContext()->Display(anAisRevolVertex, Standard_True);  
  
// 在myOccView的上下文中显示anAisRevolEdge，Standard_True表示显示方式为标准显示  
myOccView->getContext()->Display(anAisRevolEdge, Standard_True);  
  
// 在myOccView的上下文中显示anAisRevolCircle，Standard_True表示显示方式为标准显示  
myOccView->getContext()->Display(anAisRevolCircle, Standard_True);  
  
// 在myOccView的上下文中显示anAisRevolEllipse，Standard_True表示显示方式为标准显示  
myOccView->getContext()->Display(anAisRevolEllipse, Standard_True);
}

void occQt::makeLoft()  
{  
    // 创建一个圆形边缘，该圆形位于(0.0, 80.0, 0.0)，沿Z轴方向，半径为1.5  
    // bottom wire.  
    TopoDS_Edge aCircleEdge = BRepBuilderAPI_MakeEdge(gp_Circ(gp_Ax2(gp_Pnt(0.0, 80.0, 0.0), gp::DZ()), 1.5));  
    // 以aCircleEdge为边缘，创建一个线对象aCircleWire  
    TopoDS_Wire aCircleWire = BRepBuilderAPI_MakeWire(aCircleEdge);  
  
    // 创建一个多边形，该多边形由四个点构成，这些点分别为(-3.0, 77.0, 6.0)，(3.0, 77.0, 6.0)，(3.0, 83.0, 6.0)，(-3.0, 83.0, 6.0)  
    // top wire.  
    BRepBuilderAPI_MakePolygon aPolygon;  
    aPolygon.Add(gp_Pnt(-3.0, 77.0, 6.0));  
    aPolygon.Add(gp_Pnt(3.0, 77.0, 6.0));  
    aPolygon.Add(gp_Pnt(3.0, 83.0, 6.0));  
    aPolygon.Add(gp_Pnt(-3.0, 83.0, 6.0));  
    // 关闭多边形，使其形成一个封闭的多边形线  
    aPolygon.Close();  
  
    // 创建两个生成器对象，一个用于生成壳，一个用于生成实体  
    BRepOffsetAPI_ThruSections aShellGenerator;  
    BRepOffsetAPI_ThruSections aSolidGenerator(true);  
  
    // 将圆形线和多边形线添加到壳生成器和实体生成器中  
    aShellGenerator.AddWire(aCircleWire);  
    aShellGenerator.AddWire(aPolygon.Wire());  
    aSolidGenerator.AddWire(aCircleWire);  
    aSolidGenerator.AddWire(aPolygon.Wire());  
  
    // 创建一个平移变换，将实体沿X轴方向平移18个单位  
    // translate the solid.  
    gp_Trsf aTrsf;  
    aTrsf.SetTranslation(gp_Vec(18.0, 0.0, 0.0));  
    // 应用平移变换到实体生成器的形状上，得到平移后的形状  
    BRepBuilderAPI_Transform aTransform(aSolidGenerator.Shape(), aTrsf);  
  
    // 创建两个与壳和实体形状关联的AIS_Shape对象，用于显示和颜色设置  
    Handle(AIS_Shape) anAisShell = new AIS_Shape(aShellGenerator.Shape());  
    Handle(AIS_Shape) anAisSolid = new AIS_Shape(aTransform.Shape());  
  
    // 设置壳的颜色为Quantity_NOC_OLIVEDRAB，这是OpenCASCADE库中定义的一种颜色  
    anAisShell->SetColor(Quantity_NOC_OLIVEDRAB);  
    // 设置实体的颜色为Quantity_NOC_PEACHPUFF，这是OpenCASCADE库中定义的一种颜色  
    anAisSolid->SetColor(Quantity_NOC_PEACHPUFF);  
  
    // 在myOccView的上下文中显示壳和实体，Standard_True表示显示方式为标准显示  
    myOccView->getContext()->Display(anAisShell, Standard_True);  
    myOccView->getContext()->Display(anAisSolid, Standard_True);  
}

void occQt::testCut()  
{  
    // 定义一个轴对象anAxis，并设置其位置为(0.0, 90.0, 0.0)  
    gp_Ax2 anAxis;  
    anAxis.SetLocation(gp_Pnt(0.0, 90.0, 0.0));  
  
    // 使用BRepPrimAPI_MakeBox函数创建一个立方体，立方体的中心在anAxis上，三个边长分别为3.0, 4.0, 5.0，然后获取这个立方体的形状  
    TopoDS_Shape aTopoBox = BRepPrimAPI_MakeBox(anAxis, 3.0, 4.0, 5.0).Shape();  
      
    // 使用BRepPrimAPI_MakeSphere函数创建一个球体，球体的中心在anAxis上，半径为2.5，然后获取这个球体的形状  
    TopoDS_Shape aTopoSphere = BRepPrimAPI_MakeSphere(anAxis, 2.5).Shape();  
      
    // 使用BRepAlgoAPI_Cut函数对aTopoBox和aTopoSphere进行差集运算，即从aTopoBox中减去aTopoSphere，然后得到运算后的形状  
    TopoDS_Shape aCuttedShape1 = BRepAlgoAPI_Cut(aTopoBox, aTopoSphere);  
      
    // 同样使用BRepAlgoAPI_Cut函数对aTopoSphere和aTopoBox进行差集运算，即从aTopoSphere中减去aTopoBox，然后得到运算后的形状  
    TopoDS_Shape aCuttedShape2 = BRepAlgoAPI_Cut(aTopoSphere, aTopoBox);  
  
    // 定义一个变换对象aTrsf，并设置其平移向量为(8.0, 0.0, 0.0)  
    gp_Trsf aTrsf;  
    aTrsf.SetTranslation(gp_Vec(8.0, 0.0, 0.0));  
      
    // 使用BRepBuilderAPI_Transform函数对aCuttedShape1应用变换aTrsf，然后得到变换后的形状  
    BRepBuilderAPI_Transform aTransform1(aCuttedShape1, aTrsf);  
  
    // 修改变换对象aTrsf的平移向量为(16.0, 0.0, 0.0)  
    aTrsf.SetTranslation(gp_Vec(16.0, 0.0, 0.0));  
      
    // 使用BRepBuilderAPI_Transform函数对aCuttedShape2应用变换aTrsf，然后得到变换后的形状  
    BRepBuilderAPI_Transform aTransform2(aCuttedShape2, aTrsf);  
  
    // 创建四个AIS_Shape对象，它们分别关联四个形状：aTopoBox、aTopoSphere、aTransform1.Shape()和aTransform2.Shape()  
    Handle(AIS_Shape) anAisBox = new AIS_Shape(aTopoBox);  
    Handle(AIS_Shape) anAisSphere = new AIS_Shape(aTopoSphere);  
    Handle(AIS_Shape) anAisCuttedShape1 = new AIS_Shape(aTransform1.Shape());  
    Handle(AIS_Shape) anAisCuttedShape2 = new AIS_Shape(aTransform2.Shape());  
  
    // 设置这些AIS_Shape对象的颜色分别为SpringGreen、SteelBlue、Tan和Salmon  
    anAisBox->SetColor(Quantity_NOC_SPRINGGREEN);  
    anAisSphere->SetColor(Quantity_NOC_STEELBLUE);  
    anAisCuttedShape1->SetColor(Quantity_NOC_TAN);  
    anAisCuttedShape2->SetColor(Quantity_NOC_SALMON);  
  
    // 在myOccView的上下文中显示这些形状  
    myOccView->getContext()->Display(anAisBox, Standard_True);  
    myOccView->getContext()->Display(anAisSphere, Standard_True);  
    myOccView->getContext()->Display(anAisCuttedShape1, Standard_True);  
    myOccView->getContext()->Display(anAisCuttedShape2, Standard_True);  
}

void occQt::testFuse()  // 定义一个名为testFuse的函数，这个函数属于occQt类  
{  
    gp_Ax2 anAxis;  // 定义一个轴对象anAxis  
    anAxis.SetLocation(gp_Pnt(0.0, 100.0, 0.0));  // 设置这个轴的位置为(0.0, 100.0, 0.0)  
  
    TopoDS_Shape aTopoBox = BRepPrimAPI_MakeBox(anAxis, 3.0, 4.0, 5.0).Shape();  // 使用BRepPrimAPI_MakeBox函数创建一个立方体，立方体的中心在anAxis上，三个边长分别为3.0, 4.0, 5.0，然后获取这个立方体的形状  
    TopoDS_Shape aTopoSphere = BRepPrimAPI_MakeSphere(anAxis, 2.5).Shape();  // 使用BRepPrimAPI_MakeSphere函数创建一个球体，球体的中心在anAxis上，半径为2.5，然后获取这个球体的形状  
    TopoDS_Shape aFusedShape = BRepAlgoAPI_Fuse(aTopoBox, aTopoSphere);  // 使用BRepAlgoAPI_Fuse函数对aTopoBox和aTopoSphere进行融合操作，然后得到融合后的形状  
  
    gp_Trsf aTrsf;  // 定义一个变换对象aTrsf  
    aTrsf.SetTranslation(gp_Vec(8.0, 0.0, 0.0));  // 设置这个变换的平移向量为(8.0, 0.0, 0.0)  
    BRepBuilderAPI_Transform aTransform(aFusedShape, aTrsf);  // 使用BRepBuilderAPI_Transform函数对aFusedShape应用变换aTrsf，然后得到变换后的形状  
  
    Handle(AIS_Shape) anAisBox = new AIS_Shape(aTopoBox);  // 创建一个AIS_Shape对象anAisBox，这个对象关联了形状aTopoBox  
    Handle(AIS_Shape) anAisSphere = new AIS_Shape(aTopoSphere);  // 创建一个AIS_Shape对象anAisSphere，这个对象关联了形状aTopoSphere  
    Handle(AIS_Shape) anAisFusedShape = new AIS_Shape(aTransform.Shape());  // 创建一个AIS_Shape对象anAisFusedShape，这个对象关联了形状aTransform.Shape()  
  
    anAisBox->SetColor(Quantity_NOC_SPRINGGREEN);  // 设置anAisBox的颜色为SpringGreen  
    anAisSphere->SetColor(Quantity_NOC_STEELBLUE);  // 设置anAisSphere的颜色为SteelBlue  
    anAisFusedShape->SetColor(Quantity_NOC_ROSYBROWN);  // 设置anAisFusedShape的颜色为RosyBrown  
  
    myOccView->getContext()->Display(anAisBox, Standard_True);  // 在myOccView的上下文中显示anAisBox  
    myOccView->getContext()->Display(anAisSphere, Standard_True);  // 在myOccView的上下文中显示anAisSphere  
    myOccView->getContext()->Display(anAisFusedShape, Standard_True);  // 在myOccView的上下文中显示anAisFusedShape  
}

void occQt::testCommon()  // 定义一个名为testCommon的函数，这个函数属于occQt类  
{  
    // 创建一个轴对象，初始位置为(0.0, 110.0, 0.0)  
    gp_Ax2 anAxis;  
    anAxis.SetLocation(gp_Pnt(0.0, 110.0, 0.0));  
  
    // 使用BRepPrimAPI_MakeBox函数创建一个立方体，立方体的中心在anAxis上，三个边长分别为3.0, 4.0, 5.0，然后获取这个立方体的形状  
    TopoDS_Shape aTopoBox = BRepPrimAPI_MakeBox(anAxis, 3.0, 4.0, 5.0).Shape();  
      
    // 使用BRepPrimAPI_MakeSphere函数创建一个球体，球体的中心在anAxis上，半径为2.5，然后获取这个球体的形状  
    TopoDS_Shape aTopoSphere = BRepPrimAPI_MakeSphere(anAxis, 2.5).Shape();  
  
    // 使用BRepAlgoAPI_Common函数计算立方体和球体的公共部分（交集），然后获取这个公共部分的形状  
    TopoDS_Shape aCommonShape = BRepAlgoAPI_Common(aTopoBox, aTopoSphere);  
  
    // 创建一个变换对象，并将变换平移向量设置为(8.0, 0.0, 0.0)  
    gp_Trsf aTrsf;  
    aTrsf.SetTranslation(gp_Vec(8.0, 0.0, 0.0));  
  
    // 使用BRepBuilderAPI_Transform函数对公共部分应用前面创建的变换，然后获取变换后的形状  
    BRepBuilderAPI_Transform aTransform(aCommonShape, aTrsf);  
  
    // 创建一个AIS_Shape对象，这个对象关联了形状aTopoBox  
    Handle(AIS_Shape) anAisBox = new AIS_Shape(aTopoBox);  
  
    // 创建一个AIS_Shape对象，这个对象关联了形状aTopoSphere  
    Handle(AIS_Shape) anAisSphere = new AIS_Shape(aTopoSphere);  
  
    // 创建一个AIS_Shape对象，这个对象关联了形状变换后的公共部分  
    Handle(AIS_Shape) anAisCommonShape = new AIS_Shape(aTransform.Shape());  
  
    // 设置anAisBox的颜色为SpringGreen  
    anAisBox->SetColor(Quantity_NOC_SPRINGGREEN);  
  
    // 设置anAisSphere的颜色为SteelBlue  
    anAisSphere->SetColor(Quantity_NOC_STEELBLUE);  
  
    // 设置anAisCommonShape的颜色为RoyalBlue  
    anAisCommonShape->SetColor(Quantity_NOC_ROYALBLUE);  
  
    // 在myOccView的上下文中显示anAisBox  
    myOccView->getContext()->Display(anAisBox, Standard_True);  
  
    // 在myOccView的上下文中显示anAisSphere  
    myOccView->getContext()->Display(anAisSphere, Standard_True);  
  
    // 在myOccView的上下文中显示anAisCommonShape  
    myOccView->getContext()->Display(anAisCommonShape, Standard_True);  
}

// 定义一个名为occQt的类或者命名空间中的函数testHelix  
void occQt::testHelix()  
{  
    // 调用函数makeCylindricalHelix，该函数可能用于生成一个圆柱形螺旋，具体实现未在此处给出  
    makeCylindricalHelix();  
  
    // 调用函数makeConicalHelix，该函数可能用于生成一个圆锥形螺旋，具体实现未在此处给出  
    makeConicalHelix();  
  
    // 调用函数makeToroidalHelix，该函数可能用于生成一个环形螺旋，具体实现未在此处给出  
    makeToroidalHelix();  
}

// 定义一个名为occQt的类或者命名空间中的函数makeCylindricalHelix()  
void occQt::makeCylindricalHelix()  
{  
    // 定义两个实数变量，分别表示圆柱螺旋的半径和螺距  
    Standard_Real aRadius = 3.0;  
    Standard_Real aPitch = 1.0;  
  
    // 在参数空间中创建一个2D线段，也就是圆柱螺旋的一条边线  
    // the pcurve is a 2d line in the parametric space.  
    gp_Lin2d aLine2d(gp_Pnt2d(0.0, 0.0), gp_Dir2d(aRadius, aPitch));  
  
    // 使用2D线段创建一条2D曲线  
    Handle(Geom2d_TrimmedCurve) aSegment = GCE2d_MakeSegment(aLine2d, 0.0, M_PI * 2.0).Value();  
  
    // 创建一个圆柱表面，其中心轴为X轴，半径为前面定义的aRadius  
    Handle(Geom_CylindricalSurface) aCylinder = new Geom_CylindricalSurface(gp::XOY(), aRadius);  
  
    // 使用圆柱表面和2D曲线创建一条3D螺旋边  
    TopoDS_Edge aHelixEdge = BRepBuilderAPI_MakeEdge(aSegment, aCylinder, 0.0, 6.0 * M_PI).Edge();  
  
    // 创建一个变换对象，将螺旋边平移一定的距离  
    gp_Trsf aTrsf;  
    aTrsf.SetTranslation(gp_Vec(0.0, 120.0, 0.0));  
    BRepBuilderAPI_Transform aTransform(aHelixEdge, aTrsf);  
  
    // 使用变换后的螺旋边创建AIS中的螺旋曲线对象，并显示出来  
    Handle(AIS_Shape) anAisHelixCurve = new AIS_Shape(aTransform.Shape());  
  
    myOccView->getContext()->Display(anAisHelixCurve, Standard_True);  
  
    // 由于在pcurve中没有3D曲线，所以需要手动创建一个3D曲线  
    // sweep a circle profile along the helix curve.  
    // there is no curve3d in the pcurve edge, so approx one.  
    BRepLib::BuildCurve3d(aHelixEdge);  
  
    // 创建一个坐标轴对象，其方向为X轴正向，原点位于圆柱螺旋的底部圆心处  
    gp_Ax2 anAxis;  
    anAxis.SetDirection(gp_Dir(0.0, 4.0, 1.0));  
    anAxis.SetLocation(gp_Pnt(aRadius, 0.0, 0.0));  
  
    // 创建一个圆轮廓，其中心位于坐标轴的原点处，半径为0.3  
    gp_Circ aProfileCircle(anAxis, 0.3);  
  
    // 使用圆轮廓创建一条3D边  
    TopoDS_Edge aProfileEdge = BRepBuilderAPI_MakeEdge(aProfileCircle).Edge();  
    // 将边转化为线段  
    TopoDS_Wire aProfileWire = BRepBuilderAPI_MakeWire(aProfileEdge).Wire();  
    // 将线段转化为面  
    TopoDS_Face aProfileFace = BRepBuilderAPI_MakeFace(aProfileWire).Face();  
  
    // 将螺旋边转化为线段  
    TopoDS_Wire aHelixWire = BRepBuilderAPI_MakeWire(aHelixEdge).Wire();  
  
    // 创建一个管道制造器对象，其管道的轮廓为前面创建的面，螺旋边为填充路径  
    BRepOffsetAPI_MakePipe aPipeMaker(aHelixWire, aProfileFace);  
  
    // 如果管道制造完成，则进行下面的操作  
    if (aPipeMaker.IsDone())  
    {  
        // 将管道的面平移一定的距离  
        aTrsf.SetTranslation(gp_Vec(8.0, 120.0, 0.0));  
        BRepBuilderAPI_Transform aPipeTransform(aPipeMaker.Shape(), aTrsf);  
  
     // 使用管道制造器对象的Shape()方法获取管道的形状，并创建一个新的AIS_Shape对象  
Handle(AIS_Shape) anAisPipe = new AIS_Shape(aPipeTransform.Shape());  
// 设置管道的颜色为珊瑚色  
anAisPipe->SetColor(Quantity_NOC_CORAL);  
// 在myOccView的上下文中显示管道  
myOccView->getContext()->Display(anAisPipe, Standard_True);
}
}

// 定义一个名为occQt的类或者命名空间中的函数makeConicalHelix()  
void occQt::makeConicalHelix()  
{  
    // 定义两个实数变量，分别表示圆锥螺旋的半径和螺距  
    Standard_Real aRadius = 3.0;  
    Standard_Real aPitch = 1.0;  
  
    // 在参数空间中创建一个2D线段，这就是圆锥螺旋的一条边线  
    // the pcurve is a 2d line in the parametric space.  
    gp_Lin2d aLine2d(gp_Pnt2d(0.0, 0.0), gp_Dir2d(aRadius, aPitch));  
  
    // 使用2D线段创建一条2D曲线  
    Handle(Geom2d_TrimmedCurve) aSegment = GCE2d_MakeSegment(aLine2d, 0.0, M_PI * 2.0).Value();  
  
    // 创建一个圆锥表面，其中心轴为X轴，角度为π/6（30度），半径为前面定义的aRadius  
    Handle(Geom_ConicalSurface) aCylinder = new Geom_ConicalSurface(gp::XOY(), M_PI / 6.0, aRadius);  
  
    // 使用圆锥表面和2D曲线创建一条3D螺旋边  
    TopoDS_Edge aHelixEdge = BRepBuilderAPI_MakeEdge(aSegment, aCylinder, 0.0, 6.0 * M_PI).Edge();  
  
    // 创建一个变换对象，将螺旋边平移一定的距离  
    gp_Trsf aTrsf;  
    aTrsf.SetTranslation(gp_Vec(18.0, 120.0, 0.0));  
    BRepBuilderAPI_Transform aTransform(aHelixEdge, aTrsf);  
  
    // 使用变换后的螺旋边创建AIS中的螺旋曲线对象，并显示出来  
    Handle(AIS_Shape) anAisHelixCurve = new AIS_Shape(aTransform.Shape());  
  
    myOccView->getContext()->Display(anAisHelixCurve, Standard_True);  
  
    // 由于在pcurve中没有3D曲线，所以需要手动创建一个3D曲线  
    // sweep a circle profile along the helix curve.  
    // there is no curve3d in the pcurve edge, so approx one.  
    BRepLib::BuildCurve3d(aHelixEdge);  
  
    // 创建一个坐标轴对象，其方向为X轴正向，原点位于圆锥螺旋的底部圆心处  
    gp_Ax2 anAxis;  
    anAxis.SetDirection(gp_Dir(0.0, 4.0, 1.0));  
    anAxis.SetLocation(gp_Pnt(aRadius, 0.0, 0.0));  
  
    // 创建一个圆轮廓，其中心位于坐标轴的原点处，半径为0.3  
    gp_Circ aProfileCircle(anAxis, 0.3);  
  
    // 使用圆轮廓创建一条3D边  
    TopoDS_Edge aProfileEdge = BRepBuilderAPI_MakeEdge(aProfileCircle).Edge();  
    // 将边转化为线段  
    TopoDS_Wire aProfileWire = BRepBuilderAPI_MakeWire(aProfileEdge).Wire();  
    // 将线段转化为面  
    TopoDS_Face aProfileFace = BRepBuilderAPI_MakeFace(aProfileWire).Face();  
  
    // 将螺旋边转化为线段  
    TopoDS_Wire aHelixWire = BRepBuilderAPI_MakeWire(aHelixEdge).Wire();  
  
    // 创建一个管道制造器对象，其管道的轮廓为前面创建的面，螺旋边为填充路径  
    BRepOffsetAPI_MakePipe aPipeMaker(aHelixWire, aProfileFace);  
  
    // 如果管道制造完成，则执行下面的代码块  
    if (aPipeMaker.IsDone())  
    {  
        // 将管道的面平移一定的距离  
        aTrsf.SetTranslation(gp_Vec(28.0, 120.0, 0.0));  
        BRepBuilderAPI_Transform aPipeTransform(aPipeMaker.Shape(), aTrsf);  
  // 创建一个新的AIS_Shape对象，该对象使用aPipeTransform中的形状信息  
Handle(AIS_Shape) anAisPipe = new AIS_Shape(aPipeTransform.Shape());  
// 将管道的颜色设置为金色  
anAisPipe->SetColor(Quantity_NOC_GOLD);  
// 在myOccView的上下文中显示这个管道  
myOccView->getContext()->Display(anAisPipe, Standard_True);
}

// 定义一个名为occQt的类或者命名空间中的函数makeToroidalHelix()  
void occQt::makeToroidalHelix()  
{  
    // 定义两个实数变量，分别表示环面螺旋的半径和斜率  
    Standard_Real aRadius = 1.0;  
    Standard_Real aSlope = 0.05;  
  
    // 在参数空间中创建一个2D线段，这就是环面螺旋的一条边线  
    // the pcurve is a 2d line in the parametric space.  
    gp_Lin2d aLine2d(gp_Pnt2d(0.0, 0.0), gp_Dir2d(aSlope, 1.0));  
  
    // 使用2D线段创建一条2D曲线  
    Handle(Geom2d_TrimmedCurve) aSegment = GCE2d_MakeSegment(aLine2d, 0.0, M_PI * 2.0).Value();  
  
    // 创建一个环面表面对象，其中心轴为X轴，半径为5倍的aRadius  
    Handle(Geom_ToroidalSurface) aCylinder = new Geom_ToroidalSurface(gp::XOY(), aRadius * 5.0, aRadius);  
  
    // 使用2D曲线和环面表面创建一条3D螺旋边  
    TopoDS_Edge aHelixEdge = BRepBuilderAPI_MakeEdge(aSegment, aCylinder, 0.0, 2.0 * M_PI / aSlope).Edge();  
  
    // 创建一个变换对象，将螺旋边平移一定的距离  
    gp_Trsf aTrsf;  
    aTrsf.SetTranslation(gp_Vec(45.0, 120.0, 0.0));  
    BRepBuilderAPI_Transform aTransform(aHelixEdge, aTrsf);  
  
    // 使用变换后的螺旋边创建AIS中的螺旋曲线对象，并显示出来  
    Handle(AIS_Shape) anAisHelixCurve = new AIS_Shape(aTransform.Shape());  
  
    myOccView->getContext()->Display(anAisHelixCurve, Standard_True);  
  
    // 由于在pcurve中没有3D曲线，所以需要手动创建一个3D曲线  
    // sweep a circle profile along the helix curve.  
    // there is no curve3d in the pcurve edge, so approx one.  
    BRepLib::BuildCurve3d(aHelixEdge);  
  
    // 创建一个坐标轴对象，其方向为Z轴正向，原点位于环面螺旋的中心处  
    gp_Ax2 anAxis;  
    anAxis.SetDirection(gp_Dir(0.0, 0.0, 1.0));  
    anAxis.SetLocation(gp_Pnt(aRadius * 6.0, 0.0, 0.0));  
  
    // 创建一个圆轮廓，其中心位于坐标轴的原点处，半径为0.3  
    gp_Circ aProfileCircle(anAxis, 0.3);  
  
    // 使用圆轮廓创建一条3D边  
    TopoDS_Edge aProfileEdge = BRepBuilderAPI_MakeEdge(aProfileCircle).Edge();  
    // 将边转化为线段  
    TopoDS_Wire aProfileWire = BRepBuilderAPI_MakeWire(aProfileEdge).Wire();  
    // 将线段转化为面  
    TopoDS_Face aProfileFace = BRepBuilderAPI_MakeFace(aProfileWire).Face();  
  
    // 将螺旋边转化为线段  
    TopoDS_Wire aHelixWire = BRepBuilderAPI_MakeWire(aHelixEdge).Wire();  
  
    // 创建一个管道制造器对象，其管道的轮廓为前面创建的面，螺旋边为填充路径  
    BRepOffsetAPI_MakePipe aPipeMaker(aHelixWire, aProfileFace);  
  
    // 如果管道制造完成，则执行下面的代码块  
    if (aPipeMaker.IsDone())  
    {  
        // 将管道的面平移一定的距离  
        aTrsf.SetTranslation(gp_Vec(60.0, 120.0, 0.0));  
        BRepBuilderAPI_Transform aPipeTransform(aPipeMaker.Shape(), aTrsf);  
  
      // 使用变换后的管道面创建AIS中的管道对象，并设置其颜色为奶油色（Cornsilk1）  
Handle(AIS_Shape) anAisPipe = new AIS_Shape(aPipeTransform.Shape());  
anAisPipe->SetColor(Quantity_NOC_CORNSILK1);  
myOccView->getContext()->Display(anAisPipe, Standard_True);
}
}