OCCT 基础2

刺骨的言语ヽ痛彻心扉 2021-12-11 03:51 257阅读 0赞

#### OpenCASCADE 基础 ####

一直在用OCC作项目，但这方面的中文资料很少，看来OCC在中国还不是十分普及；

后来，项目中使用OCC和DirectX结合使用，取得了很好的效果；

随着OCC6.3版本的推出，Open CASCADE在速度方面已有了很大的改变。以下为一些OCC的基础知识，愿与各位OCC爱好者共同学习；

**一：****OCC****中的基础类：**

**gp\_Pnt**

在OCC中，gp\_Pnt表示一个顶点，gp\_Vec表示一个向量，可以用两个顶点来生成一个向量。

比如：

gp\_Pnt P1(0,0,0);

gp\_Pnt P2(5,0,0);

gp\_Vec V1 (P1,P2);

向量有一个方法.IsOpposite（），可以用来测试两个向量的方向是相对还是平行;

比如：

gp\_Pnt P3(-5,0,2);

gp\_Vec V2 (P1,P3);

Standard\_Boolean result =V1.IsOpposite(V2,Precision::Angular());

另外向量还有一些重要方法：

\--Standard\_Real Magnitude() const;计算向量的大小；

\--Standard\_Real SquareMagnitude() const;计算向量的平方；

\--向量的加减乘除操作；

\--向量的单位化；

\--通过一个点，线，面得出其镜像的向量；

\--向量的旋转，平移，缩放；

具体的函数名称可以看OCC的头文件说明；

有时需要决定一组空间点是位于一个点;一条直线,或一个平面,或一个空间:

OCC中提供了相应的算法；

比如：

TColgp\_Array1OfPnt array (1,5); // sizing array

array.SetValue(1,gp\_Pnt(0,0,1));

array.SetValue(2,gp\_Pnt(1,2,2));

array.SetValue(3,gp\_Pnt(2,3,3));

array.SetValue(4,gp\_Pnt(4,4,4));

array.SetValue(5,gp\_Pnt(5,5,5));

GProp\_PEquation PE (array,1.5 );

if (PE.IsPoint())\{ \} //是否是同一个点

gp\_Lin L;

if (PE.IsLinear()) \{ L = PE.Line(); \} //是否位于一条直线上；

if (PE.IsPlanar())\{ \} //是否在一个平面内；

if (PE.IsSpace()) \{ \}

**gp\_Dir****类：**

此类用来描述3D空间中的一个单位向量;

常用方法:

(1):IsEqual(const gp\_Dir& Other,const Standard\_Real AngularTolerance) const;两个单位向量是否相等;

(2):IsNormal(const gp\_Dir& Other,const Standard\_Real AngularTolerance) const;两个单位向量的夹角是否是PI/2;

(3):IsOpposite(const gp\_Dir& Other,const Standard\_Real AngularTolerance) const;两个单位向量是否方向相反;

(4):IsParallel(const gp\_Dir& Other,const Standard\_Real AngularTolerance) const;两个单位向量夹角O或PI;

(5):Angle(const gp\_Dir& Other) const;求两个向量之间的夹角;

(6):void CrossCross(const gp\_Dir& V1,const gp\_Dir& V2) ;计算三个向量之间的叉积；

(7)：Standard\_Real Dot(const gp\_Dir& Other) const;计算点积；

(8)：Standard\_Real DotCross(const gp\_Dir& V1,const gp\_Dir& V2) const;计算叉积再点积；

(9):gp\_Dir Reversed() const;得到反方向，

在OCC中用 gp\_Lin2d 类，来生成一个二维空间的直线，有它的原点和单位向量；

**gp\_Ax2d****类：**

通过原点和X方向单位和Y方向单位建立一个二维坐标系；利用sense参数可以决定是右手系还是左手系；

可以利用平移、旋转、缩放、镜像来更改坐标系；

类似地，gp\_Ax3类：

用来描述一个3D空间的坐标系。而gp\_Ax2类用来表示一个二维空间坐标系；可以为右手系，也可以是左手系；

**二、曲线类**

**GeomAPI****和****GeomConvert****包：**

GeomAPI开发包提供了一个几何体的可编程应用程序接口；

比如：

求点P和曲线C的距离D：

D = GeomAPI\_ProjectPointOnCurve(P,C);

或者

GeomAPI\_ProjectPointOnCurve PonC(P,C);

D = PonC.LowerDistance();

GeomConvert包提供了一些全局函数，可以用来实现转化一个Geom曲线为BSpline曲线等；

比如：

Handle(Geom\_BSplineSurface) aPipeSurface =

Handle(Geom\_BSplineSurface)::DownCast(aPipe.Surface());

Handle(Geom\_BSplineSurface) anotherBSplineSurface =

GeomConvert::SplitBSplineSurface(aPipeSurface,1,2,3,6);

OCC中三维几何曲线的类型有：

\--线

\--园

\--椭圆

\--二次曲线

\--抛物线

\--Bezier曲线

\--BSpline曲线

可以将一个二维的几何曲线转化为某个平面内的一个三维曲线：

比如：

Standard\_Real radius = 5;

gp\_Ax2d ax2d(gp\_Pnt2d(2,3),gp\_Dir2d(1,0));

//生成一个二维园

Handle(Geom2d\_Circle) circ2d = new Geom2d\_Circle(ax2d,radius);

gp\_Ax2d circ2dXAxis = circ2d->XAxis();

// 然后，在这个平面里转化为三维曲线；

Handle(Geom\_Curve) C3D = GeomAPI::To3d(circ2d,gp\_Pln(gp\_Ax3(gp::XOY())));

Handle(Geom\_Circle) C3DCircle = Handle(Geom\_Circle)::DownCast(C3D);

gp\_Ax1 C3DCircleXAxis = C3DCircle->XAxis();

另外，可以以将一个三维曲线，投影到一个平面内，从而生成一个二维曲线

gp\_Pln ProjectionPlane(gp\_Pnt(1,1,0),gp\_Dir( 1,1,1 ));

Handle(Geom2d\_Curve) C2D = GeomAPI::To2d(C3D,ProjectionPlane);

Handle(Geom2d\_Circle) C2DCircle =Handle(Geom2d\_Circle)::DownCast(C2D);

gp\_Ax2d C2DCircleXAxis = C2DCircle->XAxis();

将一个基本几何图形进行空间变换可以使用它自带的函数:

比如：

Handle(Geom\_Geometry) aRotatedEntity = circle->Rotated(gp::OZ(),PI/4);

如果想获取图形的类型名称:

Standard\_CString aRotatedEntityTypeName = aRotatedEntity->DynamicType()->Name();

**gp\_Parab2d****类：**

描述一个平面内的抛物线；

示例：

gp\_Pnt2d P(2,3);

gp\_Dir2d D(4,5);

gp\_Ax22d A(P,D);

gp\_Parab2d Para(A,6);

**GCE2d\_MakeParabola****类：**

生成一个抛物线图形；

**Geom2d\_BSplineCurve****类：**

描述样条曲线；

**Geom2dAPI\_Interpolate****类：**

通过一组点来修改一个样条曲线；

**FairCurve\_Batten****类：**

用一个常量或线性增加的值来构造曲线；可以用来设计木纹或塑料板条；图形为二维的，可以模拟物理样条或板条.

**Geom2d\_TrimmedCurve****类：**

此类通过两个值，定义曲线的一部分，

\--可以用来计算曲线的参数值和点坐标；

\--可以得到曲线的一般特征，比如连续的等级，封闭特点，周期性，边界参数；

\--当用一个矩阵应用于曲线或原始曲线转化后进行相应参数的改变；

所有的曲线必须几何连续，曲线至少一阶可导。一般来说，在生成一个曲线时，要先检查一下所应用的参数是否可以生成一个光滑曲线；否则会出现错误；

另外注意一点：不可以构造空长度的曲线或自相交的曲线；

此类的基类是Geom2d\_BoundedCurve类：

它是一个抽象类；描述二维空间中的边界曲线的一般行为；除了Geom2d\_TrimmedCurve是它的一个派生类外，它还有二个派生类：

\- Geom2d\_BezierCurve

\- Geom2d\_BSplineCurve

Geom2d\_BoundedCurve类的基类是Geom2d\_Curve类：

Geom2d\_Curve:抽象类；此抽象类描述了2D空间的曲线的一般特征；派生出的类有多个：包括直线，园，二次曲线，Bizier,BSpline曲线等；这些曲线的特点是可以参数化；

Geom2d\_Curve类的基类是Geom2d\_Geometry类；

此抽象类主要定义了曲线的变换，平移，旋转，缩放及拷贝等方法；

Geom2d\_Geometry类的基类是MMgt\_TShared类；

此抽象类为管理对象的基类，可以引用计数，及删除方法；

Standard\_Transient：此抽象类为所有类共同的基类；

Geom2dAPI\_InterCurveCurve类：

此类用来实现二维曲线的相交；

一种情况是曲线与曲线的相交，另外一种情况是曲线自身的相交；

主要方法有：

\--Standard\_Integer NbPoints() const;相交点数；

\--Standard\_Integer NbSegments() const;切线相交数；

\--void Segment(const Standard\_Integer Index,Handle(Geom2d\_Curve)& Curve1,Handle(Geom2d\_Curve)& Curve2)

const;返回其中一个线段；

下面的示例是两个曲线相交的例子：

首先，生成第一个曲线，在这里，应用点数组来生成一个曲线；

\--定义数组

Handle(TColgp\_HArray1OfPnt2d) harray = new TColgp\_HArray1OfPnt2d (1,5); // sizing harray

\--输入点数组的值

harray->SetValue(1,gp\_Pnt2d (0,0));

harray->SetValue(2,gp\_Pnt2d (-3,1));

harray->SetValue(3,gp\_Pnt2d (-2,5));

harray->SetValue(4,gp\_Pnt2d (2,9));

harray->SetValue(5,gp\_Pnt2d (-4,14));

\--检测一下点与点之间是否为同一点；0.01为公差值，依实际需要可以更改此参数；

Geom2dAPI\_Interpolate anInterpolation(harray,Standard\_False,0.01);

\--生成曲线

anInterpolation.Perform();

Handle(Geom2d\_BSplineCurve) SPL = anInterpolation.Curve();

\--第二个曲线用两点来生成

gp\_Pnt2d P1(-1,-2);gp\_Pnt2d P2(0,15);gp\_Dir2d V1 = gp::DY2d();

Handle(Geom2d\_TrimmedCurve) TC1= GCE2d\_MakeSegment(P1,V1,P2);

\--下面进行曲线的求交

Standard\_Real tolerance = Precision::Confusion();

Geom2dAPI\_InterCurveCurve ICC (SPL,TC1,tolerance);

\--得到交点

Standard\_Integer NbPoints =ICC.NbPoints();

gp\_Pnt2d PK;

for (Standard\_Integer k = 1;k<=NbPoints;k++)

PK = ICC.Point(k);

// 针对每个交点，进行相应处理；

Geom2d\_OffsetCurve类:

此类用来实现偏移曲线；

比如：

\--生成一个曲线

TColgp\_Array1OfPnt2d array (1,5); // sizing array

array.SetValue(1,gp\_Pnt2d (-4,0)); array.SetValue(2,gp\_Pnt2d (-7,2));

array.SetValue(3,gp\_Pnt2d (-6,3)); array.SetValue(4,gp\_Pnt2d (-4,3));

array.SetValue(5,gp\_Pnt2d (-3,5));

Handle(Geom2d\_BSplineCurve) SPL1 = Geom2dAPI\_PointsToBSpline(array);

\--生成一个偏移曲线

Standard\_Real dist = 1;

Handle(Geom2d\_OffsetCurve) OC =

new Geom2d\_OffsetCurve(SPL1,dist);

Standard\_Boolean result = OC->IsCN(2);

GccAna\_Pnt2dBisec类

此类实现两点之间的等分线.

示例:

gp\_Pnt2d P1(1,2);

gp\_Pnt2d P2(4,5);

gp\_Lin2d L;

GccAna\_Pnt2dBisec B(P1,P2);

if (B.IsDone())

\{ L = B.ThisSolution(); \}

因为所生成的为直线,所以显示时要转化为线段:

if (B.IsDone())

Handle(Geom2d\_TrimmedCurve) aLine = GCE2d\_MakeSegment(L,-8,8);

Handle(ISession2D\_Curve) aCurve = new ISession2D\_Curve(aLine);

aDoc->GetISessionContext()->Display(aCurve, Standard\_False);

gce\_MakeCirc2d类

用来创建园:创建园的方法很多，主要构造方法有：

\--园心和通过的一点;

\--通过一个园和一个距离值,创建一个同心园;

\--三点决定一个园;

\--园心和半径;

gp\_Elips2d类：

可以生成一个椭园,也可以生成椭园上的一段园弧;

比如：

Standard\_Real major = 12;

Standard\_Real minor = 4;

gp\_Ax2d axis = gp::OX2d();

gp\_Elips2d EE(axis,major,minor);;

Handle(Geom2d\_TrimmedCurve) arc = GCE2d\_MakeArcOfEllipse(EE,0.0,PI/4);  
上面是利用长短轴的方法构造椭圆,也可以用二次方程的方式来构造椭园;

其中椭园类中方法可以求出焦点1和焦点2的位置,两焦点之间的位置,离心率;旋转,平移,缩放等操作.

**三、关于面的类**

**gp\_Pln****类****:**

定义一个平面,构造的方法可以是点法式,或通过ABCD系数;

另外，还提供了一些常用的方法，比如：

\--求点到平面,线到平面,平面与平面的距离及平方距离;

\--点是否在平面内,线是否在平面内;

\--通过一个点,一个轴的镜像平面;

\--平面的旋转,缩放与平移;

**Geom\_ElementarySurface****类：**

此类用来描述一个表面，此类的派生类有：

平面；园柱面；锥面；球面；园环面；

它的基类是Geom\_Surface，是一个抽象类；

Geom\_Surface类的基类是Geom\_Geometry类；

**Geom\_RectangularTrimmedSurface****类：**

用来生成一个有边界的平面；

比如：

Handle(Geom\_Plane) aProjectionPlane = GC\_MakePlane(ProjectionPlane).Value();

Handle(Geom\_RectangularTrimmedSurface) aProjectionPlaneSurface=

new Geom\_RectangularTrimmedSurface(aProjectionPlane,-8.,8.,-12.,12.);

DisplaySurface(aDoc,aProjectionPlaneSurface);

此类的基类是Geom\_BoundedSurface类；

此类的兄弟类还有

\- Geom\_BezierSurface,

\- Geom\_BSplineSurface

**ConicalSurface****类：用来创建一个园锥表面****;**

构造表面的方法有：

\--已知一个园锥表面,和空间一点,过此点的平行于已知园锥表面;

\--已知一个园锥表面,和一个距离,创建一个平行于已知园锥表面的园锥表面;

\--通过四个点构造一个园锥表面;

\--通过一个轴和两个点;

\--通过两个点和两个半径;

GeomAPI\_IntCS类：

此类用来计算一个园弧和和一个表面的交点或相交线段;

GeomFill\_BSplineCurves类:

此类用来构造一个可以填充的BSpline表面,构造它可以用两个三个或四个BSpline曲线作为边界;

填充类型有三种:

enum GeomFill\_FillingStyle \{

GeomFill\_StretchStyle,

GeomFill\_CoonsStyle,

GeomFill\_CurvedStyle

\};

以下示例为用两个样条曲线生成一个表面:

GeomFill\_FillingStyle Type = GeomFill\_StretchStyle;

GeomFill\_BSplineCurves aGeomFill1(SPL1,SPL2,Type);

Handle(Geom\_BSplineSurface) aBSplineSurface1 = aGeomFill1.Surface();

GeomFill\_Pipe类：

此类用来构造一个pipe,沿着一个路径sweep一个截面，这两个都是曲线类型；一般来说，结果是一个BSpline表面；

常见的有几种方法：

\--给定一个路径和一个半径，截面是个园，位置是路径的第一个点，

比如：

GeomFill\_Pipe aPipe(SPL1,1);

aPipe.Perform();

Handle(Geom\_Surface) aSurface= aPipe.Surface();

Standard\_CString aSurfaceEntityTypeName="Not Computed";

if (!aSurface.IsNull())

aSurfaceEntityTypeName = aSurface->DynamicType()->Name();

\--给定一个路径和一个截面。

比如：

Handle(Geom\_Ellipse) E = GC\_MakeEllipse( gp::XOY() ,3,1).Value();

GeomFill\_Pipe aPipe2(SPL1,E);

aPipe2.Perform();

Handle(Geom\_Surface) aSurface2= aPipe2.Surface();

Standard\_CString aSurfaceEntityTypeName2="Not Computed";

if (!aSurface2.IsNull()) \{

aSurfaceEntityTypeName2 = aSurface2->DynamicType()->Name();

aSurface2->Translate(gp\_Vec(5,0,0)); \}

\--给定一个路径和两个截面，中间截面为过度线；

示例：

Handle(Geom\_TrimmedCurve) TC1 =

GC\_MakeSegment(gp\_Pnt(1,1,1),gp\_Pnt(5,5,5));

Handle(Geom\_TrimmedCurve) TC2 =

GC\_MakeSegment(gp\_Pnt(1,1,0),gp\_Pnt(4,5,6));

GeomFill\_Pipe aPipe3(SPL1,TC1,TC2);

aPipe3.Perform();

Handle(Geom\_Surface) aSurface3 = aPipe3.Surface();

Standard\_CString aSurfaceEntityTypeName3="Not Computed";

if (!aSurface3.IsNull())

aSurfaceEntityTypeName3 = aSurface3->DynamicType()->Name();

aSurface3->Translate(gp\_Vec(10,0,0));

\--给定一个路径和N个截面，中间为过渡线；

一般情况下，所生结果为：NURBS，但是，在一些特殊的情况下，可以生成平面，园柱，球，园锥等；

参数，U，沿着截面的方向，V沿着路径方向；

Geom\_BezierSurface类：

生成一个Bezier表面；

Geom\_OffsetSurface类：

用来偏移一个表面；

比如：

Standard\_Real offset = 1;

Handle(Geom\_OffsetSurface) GOS = new Geom\_OffsetSurface(aGeomSurface, offset);

Geom\_SweptSurface类：

有两个派生类，分别用来生成一个回转体表面和一个延展体表面；

Geom\_SurfaceOfLinearExtrusion：用来描述一个线性延展表面；

它的基类是：Geom\_Surface类

比如：

Handle(Geom\_BSplineCurve) aCurve =GeomAPI\_PointsToBSpline(array).Curve();

gp\_Dir aDir(1,2,3);

Handle(Geom\_SurfaceOfLinearExtrusion) SOLE =new Geom\_SurfaceOfLinearExtrusion(aCurve,aDir);

Handle(Geom\_RectangularTrimmedSurface) aTrimmedSurface =new Geom\_RectangularTrimmedSurface(SOLE,-10,10,false);

Geom\_SurfaceOfRevolution类，表示一个回转体表面；

比如：

Handle(Geom\_BSplineCurve) aCurve = GeomAPI\_PointsToBSpline(array).Curve();

Handle(Geom\_SurfaceOfRevolution) SOR =new Geom\_SurfaceOfRevolution(aCurve,gp::OX());

1:利用一个二维数组来生成曲面的方法:

TColgp\_Array2OfPnt array3 (1,5,1,5);

array3.SetValue(1,1,gp\_Pnt (-4,-4,5));

...

array3.SetValue(2,1,gp\_Pnt (-2,-4,4));

...

Handle(Geom\_BSplineSurface) aSurf2 =GeomAPI\_PointsToBSplineSurface(array3).Surface();

2:GeomAPI\_ExtremaSurfaceSurface类:

计算两个表面之间的极值点;

主要方法:

(1):Quantity\_Length LowerDistance() const;计算两个表面的最短距离;

(2):Standard\_EXPORT void LowerDistanceParameters(Quantity\_Parameter& U1,Quantity\_Parameter& V1,Quantity\_Parameter& U2,Quantity\_Parameter& V2) const;

得到第一个表面上的极值点的UV参数和第二个表面上的极值点的UV参数;

(3):void NearestPoints(gp\_Pnt& P1,gp\_Pnt& P2) const;得到第一个表面上的极值点和第二个表面上的极值点;

(4): Quantity\_Length Distance(const Standard\_Integer Index) const;得到第N个极值点的距离;

(5):Standard\_Integer NbExtrema() const;极值的数目;

......

示例:

GeomAPI\_ExtremaSurfaceSurface ESS(aSurf1,aSurf2);

Quantity\_Length dist = ESS.LowerDistance();

gp\_Pnt P1,P2;

ESS.NearestPoints(P1,P2);

gp\_Pnt P3,P4;

Handle(Geom\_Curve) aCurve;

Standard\_Integer NbExtrema = ESS.NbExtrema();

for(Standard\_Integer k=1;k<=NbExtrema;k++)\{

ESS.Points(k,P3,P4);

aCurve= GC\_MakeSegment(P3,P4).Value();

DisplayCurve(aDoc,aCurve,Quantity\_NOC\_YELLOW3,false);

一些OCC的基础知识，愿与各位OCC爱好者共同学习；mail:tongabcd@yeah.net

**一：关于体的类**

**BRepBuilderAPI\_MakeVertex****类**

创建点；

**BRepBuilderAPI\_MakeEdge****类**

此类用来创建边；

比如，由直线生成边：

gp\_Lin line(gp\_Ax1(gp\_Pnt(10,10,10),gp\_Dir(1,0,0)));

WhiteEdge = BRepBuilderAPI\_MakeEdge(line,-20,10);

下面为生成四分之一园边：

gp\_Elips Elips(gp\_Ax2(gp\_Pnt(10,0,0),gp\_Dir(1,1,1)),60,30);

RedEdge = BRepBuilderAPI\_MakeEdge(Elips,0,PI/2);

下面是由曲线生成边：

Handle (Geom\_BezierCurve) curve = new Geom\_BezierCurve(array);

BRepBuilderAPI\_MakeEdge ME (curve);

GreenEdge = ME;

V3 = ME.Vertex1();

V4 = ME.Vertex2();

**BRepBuilderAPI\_MakeWire****类**

用来创建一个Wire类；

用一个Wire和一个边来生成一个新的Wire：

ExistingWire = BRepBuilderAPI\_MakeWire(Edge2);

Edge3 = BRepBuilderAPI\_MakeEdge(gp\_Pnt(-300,0,-80),gp\_Pnt(-90,20,-30));

BRepBuilderAPI\_MakeWire MW1(ExistingWire,Edge3);

if (MW1.IsDone()) \{YellowWire = MW1;\}

用一个Wire和添加边的方法来生成Wire：

BRepBuilderAPI\_MakeWire MW;

MW.Add(ExistingWire2);

MW.Add(Edge5);

MW.Add(Edge6);

MW.Add(Edge7);

if (MW.IsDone()) \{

WhiteWire = MW.Wire();

LastEdge = MW.Edge();

LastVertex = MW.Vertex();

**BRepBuilderAPI\_MakeFace****类**

生成一个面；有多种生成面的方法；

\--通过一个封闭曲线生成面：

BRepBuilderAPI\_MakeFace(curve);

\--通过一个Wire生成面：

BrownFace = BRepBuilderAPI\_MakeFace(YellowWire);

**Bnd\_Box2d****类****:**

定义一个二维空间的边界盒,可以得出边界盒各个点的值，有时，在某个方向是无限大,这种情况下，称为在此方向上是开放的;

示例:

Bnd\_Box2d aCBox;

Geom2dAdaptor\_Curve GACC (C);

BndLib\_Add2dCurve::Add (GACC,Precision::Approximation(),aCBox);

**Bnd\_Box****类****:**

定义一个三维空间的边界盒,可以扩大或缩小边界盒,也可以合并两个轴对齐边界盒;

**BRepPrimAPI\_MakeBox****类**

用来生成一个立方体;

构造一个立方体可以是两个对角点,一个角点及三个方向长度,可以是非轴对称的:

TopoDS\_Shape B2 = BRepPrimAPI\_MakeBox (gp\_Ax2(gp\_Pnt(-200.,-80.,-70.), gp\_Dir(1.,2.,1.)), 80.,90.,120.);

使用方法

TopoDS\_Face& BottomFace() ;.可以得到立方体的底面;同样，用其它类似的方法可以获得顶面等；

方法TopoDS\_Solid& Solid() ;可以将box转化为一个Solid;

方法TopoDS\_Shell& Shell() ;可以将box转化为一个shell;

**BRepPrimAPI\_MakeCylinder****类**

用来生成一个园柱体或园柱体的一部分；

比如：

TopoDS\_Shape C2 = BRepPrimAPI\_MakeCylinder (gp\_Ax2(gp\_Pnt(200.,0.,200.), gp\_Dir(0.,1.,0.)),40.,110.,210.\*PI180);

**BRepPrimAPI\_MakeCone****类**

生成一个园锥或园锥的一部分；

**BRepPrimAPI\_MakeSphere****类**

生成球体或球体的一部分，可以是U方向切一部分或V方向切一部分；

**BRepPrimAPI\_MakeTorus****类**

生成环或环的一部分；

**BRepPrimAPI\_MakeWedge****类**

生成一个楔块或楔块的一部分；

**BRepPrimAPI\_MakePrism****类**

生成一个线性的swept,称为Prisms;它的基类是BRepPrimAPI\_MakeSweep类；BRepPrimAPI\_MakeSweep类的基类是

BRepBuilderAPI\_MakeShape类

注意，原始基本图形不可以包含任何实体：

应用此类时：

\--顶点“推移”成边：

TopoDS\_Vertex V1 = BRepBuilderAPI\_MakeVertex(gp\_Pnt(-200.,-200.,0.));

Handle(AIS\_Shape) ais1 = new AIS\_Shape(V1);

TopoDS\_Shape S1 = BRepPrimAPI\_MakePrism(V1,gp\_Vec(0.,0.,100.));

Handle(AIS\_Shape) ais2 = new AIS\_Shape(S1);

\--边“推移”成面：.

TopoDS\_Edge E = BRepBuilderAPI\_MakeEdge(gp\_Pnt(-150.,-150,0.), gp\_Pnt(-50.,-50,0.));

Handle(AIS\_Shape) ais3 = new AIS\_Shape(E);

myAISContext->Display(ais3,Standard\_False);

TopoDS\_Shape S2 = BRepPrimAPI\_MakePrism(E,gp\_Vec(0.,0.,100.));

\--Wires “推移”成Shells.

TopoDS\_Edge E1 = BRepBuilderAPI\_MakeEdge(gp\_Pnt(0.,0.,0.), gp\_Pnt(50.,0.,0.));

TopoDS\_Edge E2 = BRepBuilderAPI\_MakeEdge(gp\_Pnt(50.,0.,0.), gp\_Pnt(50.,50.,0.));

TopoDS\_Edge E3 = BRepBuilderAPI\_MakeEdge(gp\_Pnt(50.,50.,0.), gp\_Pnt(0.,0.,0.));

TopoDS\_Wire W = BRepBuilderAPI\_MakeWire(E1,E2,E3);

TopoDS\_Shape S3 = BRepPrimAPI\_MakePrism(W,gp\_Vec(0.,0.,100.));

\--Faces “推移”成Solids.

TopoDS\_Face F = BRepBuilderAPI\_MakeFace(gp\_Pln(gp::XOY()),Wc);

Handle(AIS\_Shape) ais7 = new AIS\_Shape(F);

myAISContext->Display(ais7,Standard\_False);

TopoDS\_Shape S4 = BRepPrimAPI\_MakePrism(F,gp\_Vec(0.,0.,100.));

\--Shells “推移”成复合实体

**BRepPrimAPI\_MakeRevol****类**

一个回转sweep体；

类继承关系和前面类似：BRepBuilderAPI\_MakeShape--〉BRepPrimAPI\_MakeSweep-->BRepPrimAPI\_MakeRevol

，对于角度而言，范围是\[0，2PI\]，默认值是2PI，生成规则：

\- Vertex -> Edge.

\- Edge -> Face.

\- Wire -> Shell.

\- Face-> Solid.

\- Shell-> CompSolid.

**BRepOffsetAPI\_MakePipe****类**

可以生成一个管道

类继承关系是：BRepBuilderAPI\_MakeShape--〉BRepPrimAPI\_MakeSweep-->BRepOffsetAPI\_MakePipe

以下为生成一个管道的示例过程：

\--利用生成一个WIRE，作为管道的路径:

Handle(Geom\_BezierCurve) curve = new Geom\_BezierCurve(CurvePoles);

TopoDS\_Edge E = BRepBuilderAPI\_MakeEdge(curve);

TopoDS\_Wire W = BRepBuilderAPI\_MakeWire(E);

\--生成一个面，作为生成管道的截面：

gp\_Circ c = gp\_Circ(gp\_Ax2(gp\_Pnt(0.,0.,0.),gp\_Dir(0.,1.,0.)),10.);

TopoDS\_Edge Ec = BRepBuilderAPI\_MakeEdge(c);

TopoDS\_Wire Wc = BRepBuilderAPI\_MakeWire(Ec);

TopoDS\_Face F = BRepBuilderAPI\_MakeFace(gp\_Pln(gp::ZOX()),Wc);

\--利用前两步生成的路径和截面来生成pipe:

TopoDS\_Shape S = BRepOffsetAPI\_MakePipe(W,F);

Handle(AIS\_Shape) ais2 = new AIS\_Shape(S);

**BRepOffsetAPI\_ThruSections****类**

此类继承自BRepBuilderAPI\_MakeShape：创建一个loft,通过一组给定的sections，生成一个shell或一个solid;通常，section是wire;但是第一个和最后一个section可以是

vertices;

比如：

BRepOffsetAPI\_ThruSections generator(Standard\_False,Standard\_True);

generator.AddWire(W1);

generator.AddWire(W2);

generator.AddWire(W3);

generator.AddWire(W4);

generator.Build();

TopoDS\_Shape S1 = generator.Shape();

Handle(AIS\_Shape) ais1 = new AIS\_Shape(S1);

**BRepBuilderAPI\_MakePolygon****类**

创建一个polygonal wires，可以通过一组点或向量生成，也可以先生成一个空的对象，再添加点。

示例1：

BRepBuilderAPI\_MakePolygon P;

P.Add(gp\_Pnt(0.,0.,0.));

P.Add(gp\_Pnt(200.,0.,0.));

P.Add(gp\_Pnt(200.,200.,0.));

P.Add(gp\_Pnt(0.,200.,0.));

P.Add(gp\_Pnt(0.,0.,0.));

TopoDS\_Wire W = P.Wire();

示例2：

TopoDS\_Wire wprof = BRepBuilderAPI\_MakePolygon(gp\_Pnt(0.,0.,0.),gp\_Pnt(-60.,-60.,-200.));

**BRepOffsetAPI\_MakeEvolved****类**

创建一个可展图形，它是通过一个planar spine (face or wire)和一个rofile (wire)来生成的，它是一个非循环的sweep (pipe),用profile沿着spline;自相交点将被移除；

比如：

\--沿着一个spline，sweep一个profile;

Standard\_EXPORT BRepOffsetAPI\_MakeEvolved(const TopoDS\_Face& Spine,const TopoDS\_Wire& Profil,const GeomAbs\_JoinType Join = GeomAbs\_Arc,const Standard\_Boolean

AxeProf = Standard\_True,const Standard\_Boolean Solid = Standard\_False,const Standard\_Boolean ProfOnSpine = Standard\_False,const Standard\_Real Tol = 0.0000001);

AxeProf参数如果为true,R是0,X,Y,Z;如果solid为真，结果为一个solid或复合的solids;

示例：

TopoDS\_Shape

S = BRepOffsetAPI\_MakeEvolved(W,wprof,GeomAbs\_Arc,Standard\_True,Standard\_False,Standard\_True,0.0001);

**BRepBuilderAPI\_ModifyShape****类**

当使用BRepTools来创建一个修改类，主要有以下派生类：

\--BRepBuilderAPI\_Copy:处理一个图形的拷贝；

\--BRepBuilderAPI\_Transform 和BRepBuilderAPI\_GTransform：用来对一个图形应用几何变形；

\--BRepBuilderAPI\_NurbsConvert:用来将一个图形转化为NURBS几何体；

\--BRepOffsetAPI\_DraftAngle：创建一个tapered图形；

**BRepOffsetAPI\_DraftAngle****类**

创建一个tapered图形；一般过程是：

\--初始化构造算法；

\--输入要taper的特征面；

\--实现算法；

\--生成结果；

示例：

TopoDS\_Shape S = BRepPrimAPI\_MakeBox(200.,300.,150.);

BRepOffsetAPI\_DraftAngle adraft(S);

TopExp\_Explorer Ex;

for (Ex.Init(S,TopAbs\_FACE); Ex.More(); Ex.Next()) \{

TopoDS\_Face F = TopoDS::Face(Ex.Current());

Handle(Geom\_Plane) surf = Handle(Geom\_Plane)::DownCast(BRep\_Tool::Surface(F));

gp\_Pln apln = surf->Pln();

gp\_Dir dirF = apln.Axis().Direction();

if (dirF.IsNormal(gp\_Dir(0.,0.,1.),Precision::Angular()))

adraft.Add(F, gp\_Dir(0.,0.,1.), 15.\*PI180, gp\_Pln(gp::XOY()));

ais1->Set(adraft.Shape());

**二：关于布尔等实体修改操作相关**

**BRepAlgoAPI\_BooleanOperation****类**

此类的基类是BRepBuilderAPI\_MakeShape类，它是一个抽象类；

可以应用的操作有：BOP\_SECTION 、BOP\_COMMON、BOP\_FUSE、BOP\_CUT、BOP\_CUT21

有时会产生错误，无法达到想要的结果，根据返回值，可以得到错误信息，含义是：

0：OK

1： 对象创建完成，但结果为空；

2：源图形为空；

3：参数类型检查错误；

4：不能为DSFiller分配内存；

5：此种类型参数的Builder无法工作；

6：不允许的操作；

7：不能为Builder分配内存；

>100 参见Builder错误信息；

相关的方法介绍：

\--TopTools\_ListOfShape& SectionEdges()方法：返回一组截面的边，它们在布尔操作过程中生成；

\--Standard\_Boolean HasDeleted()方法：如果至少一个图形对象被删除了，返回为真；

\--Standard\_Boolean HasGenerated()方法：如果至少生成了一个图形，返回为真；

\--Standard\_Boolean HasModified()方法：如果至少一个图形被修改了，返回为真；

\--TopTools\_ListOfShape& Generated(const TopoDS\_Shape& S) 方法：返回生成以后的图形的集合；

\--TopTools\_ListOfShape& Modified2(const TopoDS\_Shape& aS)方法：返回修改后的图形的集合；

\--Standard\_Boolean IsDeleted(const TopoDS\_Shape& aS)方法：如果图形S已经被删除，返回为真，即结果图形中不包括图形S；

\-BOP\_Operation Operation()方法：返回布尔操作的类型；

**布尔操作类**

包括有BRepAlgoAPI\_Cut类， BRepAlgoAPI\_Fuse类，BRepAlgoAPI\_Common类：布尔交集；

**BRepAlgoAPI\_Section****类**

计算两个图形或几何体的截面，几何对象可以是平面的表面，转化为face.

示例：

给定两个图形S1和S2，计算在S1和S2上的边，在新曲线上生成近似值，结果在第一部分上而不在第二部分上：

Standard\_Boolean PerformNow = Standard\_False;

BRepBoolAPI\_Section S(S1,S2,PerformNow);

S.ComputePCurveOn1(Standard\_True);

S.Approximation(Standard\_True);

S.Build();

TopoDS\_Shape R = S.Shape();

如果结果为空，调用NotDone()；

常见方法：

\--BRepAlgoAPI\_Section(const Handle(Geom\_Surface)& Sf1,const Handle(Geom\_Surface)& Sf2,const Standard\_Boolean

PerformNow = Standard\_True);

用来生成线：

\--两个图形SH1和SH2；

\--图形SH和平面P1；

\--表面SF和图形SH；

\--两个表面SF1和SF2；

参数PerformNow如果为真，将直接计算结果，如果为假，表示后面将通过Build（）这个函数来计算结果；

生成后的图形是由方法Shape（）得出的；

这些相交的边是独立的，不在一个链表上，也不在一个wire上，如果不存在一个相交边，返回结果为空；

示例：

\--计算相交的基本边--利用这些基本边创建一个相交线--决定相交线在两个图形的哪个图形的参数空间；

TopoDS\_Shape S1 = ... , S2 = ... ;

Standard\_Boolean PerformNow = Standard\_False;

BRepAlgoAPI\_Section S ( S1, S2, PerformNow );

S.ComputePCurveOn1 (Standard\_True);

S.Approximation (Standard\_True);

S.Build();

TopoDS\_Shape R = S.Shape();

**BRepFilletAPI\_LocalOperation****类**

基类是BRepBuilderAPI\_MakeShape；

构造在一个shell的边的园角；常用方法有

\--void Add(const TopoDS\_Edge& E) = 0;在builder上添加一个轮廓线；

\--void ResetContour(const Standard\_Integer IC) = 0;重置索引为IC的轮廓线；

\--Standard\_Integer NbContours() const = 0;返回轮廓线的数目；

\--Standard\_Integer Contour(const TopoDS\_Edge& E) const = 0;返回边E的轮廓线的索引，如果边E不在轮廓线内，返回为O；

\--Standard\_Integer NbEdges(const Standard\_Integer I) const = 0;返回在轮廓线I中的边数；

\--void Remove(const TopoDS\_Edge& E) = 0;移除一个边；

\--Standard\_Real Length(const Standard\_Integer IC) const = 0;得到某个轮廓线的长度；

\--TopoDS\_Vertex FirstVertex(const Standard\_Integer IC) const = 0;返回某个轮廓线的第一个顶点；LastVertex方法返回最后一个顶点；

\--Abscissa方法，返回某个顶点的横坐标；

\--Standard\_Boolean ClosedAndTangent(const Standard\_Integer IC) const如果某个轮廓线是封闭切线，返回为真；

\--Standard\_Boolean Closed(const Standard\_Integer IC) const = 0;如果某个轮廓线是封闭，返回为真；

\--Reset() = 0;重置所有；

**BRepFilletAPI\_MakeFillet****类**

创建一个园角；

示例一：

对一个BOX园角：

BRepFilletAPI\_MakeFillet fillet(Box);

for (TopExp\_Explorer ex(Box,TopAbs\_EDGE); ex.More(); ex.Next()) \{

TopoDS\_Edge Edge =TopoDS::Edge(ex.Current());

fillet.Add(20,Edge);

示例二：

两个BOX，合并后园角；

TopoDS\_Shape fusedShape = BRepAlgoAPI\_Fuse(S1,S2);

BRepFilletAPI\_MakeFillet fill(fusedShape);

for (TopExp\_Explorer ex1(fusedShape,TopAbs\_EDGE); ex1.More(); ex1.Next()) \{

TopoDS\_Edge E =TopoDS::Edge(ex1.Current());

fill.Add(E);

for (Standard\_Integer i = 1;i<=fill.NbContours();i++) \{

Standard\_Real longueur(fill.Length(i));

Standard\_Real Rad(0.15\*longueur);

fill.SetRadius(Rad,i, 1);

TopoDS\_Shape blendedFusedSolids = fill.Shape();

Handle(AIS\_Shape) aBlend = new AIS\_Shape(blendedFusedSolids);

示例三：

只园角其中一条边：

BRepFilletAPI\_MakeFillet Rake(theBox);

TopExp\_Explorer ex(theBox,TopAbs\_EDGE);

ex.Next();

Rake.Add(8,50,TopoDS::Edge(ex.Current()));

Rake.Build();

if (Rake.IsDone() )\{

TopoDS\_Shape evolvedBox = Rake.Shape();

ais1->Set(evolvedBox);

示例四：

园角一个园柱：

BRepFilletAPI\_MakeFillet fillet(theCylinder);

TColgp\_Array1OfPnt2d TabPoint2(1,20);

for (Standard\_Integer i=0; i<=19; i++) \{

gp\_Pnt2d Point2d(i\*2\*PI/19,60\*cos(i\*PI/19-PI/2)+10);

TabPoint2.SetValue(i+1,Point2d);

TopExp\_Explorer exp2(theCylinder,TopAbs\_EDGE);

fillet.Add(TabPoint2,TopoDS::Edge(exp2.Current()));

fillet.Build();

if (fillet.IsDone() )\{

TopoDS\_Shape LawEvolvedCylinder = fillet.Shape();

ais3->Set(LawEvolvedCylinder);

myAISContext->Redisplay(ais3,Standard\_False);

myAISContext->SetCurrentObject(ais3,Standard\_False);

**BRepFilletAPI\_MakeChamfer****类**

创建一个倒角；

基类：BRepFilletAPI\_LocalOperation；

可以设置相关参数，比如倒角两个距离，角度等参数；

示例：

BRepFilletAPI\_MakeChamfer MC(theBox);

// add all the edges to chamfer

TopTools\_IndexedDataMapOfShapeListOfShape M;

TopExp::MapShapesAndAncestors(theBox,TopAbs\_EDGE,TopAbs\_FACE,M);

for (Standard\_Integer i = 1;i<=M.Extent();i++) \{

TopoDS\_Edge E = TopoDS::Edge(M.FindKey(i));

TopoDS\_Face F = TopoDS::Face(M.FindFromIndex(i).First());

MC.Add(5,5,E,F);

**BRepBuilderAPI\_MakeShell****类**

生成一个表面的外壳，注意，一个图形的外壳，不是一个由表面和厚度定义的实体模型，如果想要创建这种壳，需要使用BRepOffsetAPI\_MakeOffsetShape，一个外壳是由一系列相互通过普通的边连接起来的面；如果表面是C2连续的，外壳将只有一个面；如果表面不是C2连续的，将把一些面细分成所有的面都是C2连续的，结果是外壳包含所有这些面；通过一个非C2连续的表面来生成一个外壳，一般过程是：--构造一个外壳对象--实现算法--生成结果；

注意：表面分解的这些C2面并没有缝合在一起，需要使用BRepOffsetAPI\_Sewing，如果想实现带厚度的外壳，需要使用BRepOffsetAPI\_MakeOffsetShape类；

**BRepBuilderAPI\_Sewing****类**

将多个邻近图形“缝合”成为一个图形；同时有多个边的情况下无法缝合；

一般操作过程是：

\--创建一个空对象；

缺省的公差是1.E-06；

面分析；

缝合操作；

根据需要作剪操作；

\--定义公差；

\--添加要缝合的对象；

\--计算生成；

\--输出结果图形；

\--如果需要可以输出自由边；

\--如果需要可以输出多个边；

\--输出其它问题；

主要方法：

\--构造函数：

option1 如果为假表示只控制；

option2：分析退化的图形；

option3：为自由边的剪操作；

option4：未复制处理；

BRepBuilderAPI\_Sewing(const Standard\_Real tolerance = 1.0e-06,const Standard\_Boolean option1 = Standard\_True,const Standard\_Boolean option2 = Standard\_True,const Standard\_Boolean option3 = Standard\_True,const Standard\_Boolean option4 = Standard\_False);

如果必要，可以初始化参数；

void Init(const Standard\_Real tolerance = 1.0e-06,const Standard\_Boolean option1 = Standard\_True,const Standard\_Boolean option2 = Standard\_True,const Standard\_Boolean option3 = Standard\_True,const Standard\_Boolean option4 = Standard\_False) ;

\--添加一个要缝合的图形的方法是；

void Add(const TopoDS\_Shape& shape) ;

\--生成图形方法是：

void Perform() ;

\--得到缝合后的图形方法是：

TopoDS\_Shape& SewedShape() const;

\--得到自由边（只被一个面共享的边）的数量方法是：

Standard\_Integer NbFreeEdges() const;

\--得到一个自由边的方法是：

const TopoDS\_Edge& FreeEdge(const Standard\_Integer index) const;

\--得到复合边（被两个及以上面共享的边）的数量：

Standard\_Integer NbMultipleEdges() const;

\--得到其中的一个复合边：

const TopoDS\_Edge& MultipleEdge(const Standard\_Integer index) const;

\--得到邻近边的数量：

Standard\_Integer NbContigousEdges() const;

\--得到其中一个邻近边：

const TopoDS\_Edge& ContigousEdge(const Standard\_Integer index) const;

\--得到有一个邻近边的边的集合（截面）；

const TopTools\_ListOfShape& ContigousEdgeCouple(const Standard\_Integer index) const;

\--一个截面是否是有边界的（使用SectionToBoundary方法之前）：

Standard\_Boolean IsSectionBound(const TopoDS\_Edge& section) const;

\--得到成为截面的原始边。记住，截面是由普通边所组成的，这个信息对于控制来说是很重要的，因为通过原始边可以找到被附加的截面的表面；

const TopoDS\_Edge& SectionToBoundary(const TopoDS\_Edge& section) const;

\--得到每一个退化的图形：

const TopoDS\_Shape& DegeneratedShape(const Standard\_Integer index) const;

\--此图形是否是退化的图形：

Standard\_Boolean IsDegenerated(const TopoDS\_Shape& shape) const;

\--此图形是否已被修改过：

Standard\_Boolean IsModified(const TopoDS\_Shape& shape) const;

\--得到一个修改后的图形：

const TopoDS\_Shape& Modified(const TopoDS\_Shape& shape) const;

\--子图形是否被修改过：

Standard\_Boolean IsModifiedSubShape(const TopoDS\_Shape& shape) const;

\--得到一个修改过的子图形：

TopoDS\_Shape ModifiedSubShape(const TopoDS\_Shape& shape) const;

\--得到每一个被删除的面：

const TopoDS\_Face& DeletedFace(const Standard\_Integer index) const;

\--void Dump() const;打印相关信息；

\--得到一个修改后的图形：

TopoDS\_Face WhichFace(const TopoDS\_Edge& theEdg,const Standard\_Integer index = 1) const;

示例：

BRepOffsetAPI\_Sewing aMethod;

aMethod.Add(FirstShape);

aMethod.Add(SecondShape);

aMethod.Perform();

TopoDS\_Shape sewedShape = aMethod.SewedShape();

Handle(AIS\_Shape) result = new AIS\_Shape(sewedShape);

**BRep\_Tool****类**

提供了处理BRep图形几何对象的一些方法；

如果S是一个Solid,Shell,或Compound.返回为真；

Standard\_Boolean IsClosed(const TopoDS\_Shape& S) ;

返回在位置L处的几何表面：

Handle\_Geom\_Surface& Surface(const TopoDS\_Face& F,TopLoc\_Location& L) ;

返回面的几何表面，如果有一个位置可以是一个拷贝；

Handle\_Geom\_Surface Surface(const TopoDS\_Face& F) ;

返回面的多边三角形，如果没有三角形返回一个空句柄：

const Handle\_Poly\_Triangulation& Triangulation(const TopoDS\_Face& F,TopLoc\_Location& L) ;

返加面的公差值：

Standard\_Real Tolerance(const TopoDS\_Face& F) ;

返回面的自然约束标志：

Standard\_Boolean NaturalRestriction(const TopoDS\_Face& F) ;

如果E是一个3D曲线或表面上的一个曲线，返回为真；

Standard\_Boolean IsGeometric(const TopoDS\_Edge& E) ;

返回边的3D曲线，可以是NULL，返回L位置，及参数范围；

Handle\_Geom\_Curve& Curve(const TopoDS\_Edge& E,TopLoc\_Location& L,Standard\_Real& First,Standard\_Real& Last) ;

返回边的3D多边形，返回多边形的位置L；

Handle\_Poly\_Polygon3D& Polygon3D(const TopoDS\_Edge& E,TopLoc\_Location& L)

**TopLoc\_Location****类**

一个Location 是一个复合的平移；对象类型是TopLoc\_Datum3D；

常见方法：

\--TopLoc\_Location();

构造一个空的局部坐标系统对象；注意，这种被构造的缺省的数据为空；、

\--TopLoc\_Location(const gp\_Trsf& T);

通过T构造一个局部坐标系统；

\--TopLoc\_Location(const Handle(TopLoc\_Datum3D)& D);

通过3D datum D来构造一个局部坐标系统，如果平移T不能表达一个局部坐标系统，会引发构造异常；

\--Standard\_Boolean IsIdentity() const;如果此位置等于一个单位化平移，返回为真；

\-- void Identity() ;设置位置为单位化平移；

\--Handle\_TopLoc\_Datum3D& FirstDatum() 得到位置的第一个基础数据；

\-- const TopLoc\_Location& NextLocation() const;

另外，具有加减乘除，是否相等方法；

示例：

炸开一个立方体的六个面：

for (TopExp\_Explorer exp (aBox,TopAbs\_FACE);exp.More();exp.Next()) \{

TopoDS\_Face aCurrentFace = TopoDS::Face(exp.Current());

//测试当前面的方向

TopAbs\_Orientation orient = aCurrentFace.Orientation();

//重新生成几何平面

TopLoc\_Location location;

Handle (Geom\_Surface) aGeometricSurface = BRep\_Tool::Surface(aCurrentFace,location);

Handle (Geom\_Plane) aPlane = Handle (Geom\_Plane)::DownCast(aGeometricSurface);

//Build an AIS\_Shape with a new color

//创建一个新的AIS\_Shape

Handle(AIS\_Shape) theMovingFace = new AIS\_Shape(aCurrentFace);

Quantity\_NameOfColor aCurrentColor = (Quantity\_NameOfColor)j;

myAISContext->SetColor(theMovingFace,aCurrentColor,Standard\_False);

myAISContext->SetMaterial(theMovingFace,Graphic3d\_NOM\_PLASTIC,Standard\_False);

//查找每个面的法向量

gp\_Pln agpPlane = aPlane->Pln();

gp\_Ax1 norm = agpPlane.Axis();

gp\_Dir dir = norm.Direction();

gp\_Vec move(dir);

TopLoc\_Location aLocation;

Handle (AIS\_ConnectedInteractive) theTransformedDisplay = new AIS\_ConnectedInteractive();

theTransformedDisplay->Connect(theMovingFace, aLocation);

// = myAISContext->Location(theMovingFace);

Handle (Geom\_Transformation) theMove = new Geom\_Transformation(aLocation.Transformation());

for (Standard\_Integer i=1;i<=30;i++) \{

theMove->SetTranslation(move\*i);

if (orient==TopAbs\_FORWARD) myAISContext->SetLocation(theTransformedDisplay,TopLoc\_Location(theMove->Trsf()));

else myAISContext->SetLocation(theTransformedDisplay,TopLoc\_Location(theMove->Inverted()->Trsf()));

myAISContext->Redisplay(theTransformedDisplay,Standard\_False);

j+=15;

**BRepAlgo****类**

BRepAlgo提供了一些布尔操作的服务；

注意，在BrepAlgoAPI包中提供了新的布尔操作，代替了旧的布尔操作；

方法：

\--static Standard\_Boolean IsValid(const TopoDS\_Shape& S) ;检测图形是否合法；

\--Standard\_EXPORT static Standard\_Boolean IsValid(const TopTools\_ListOfShape& theArgs,const TopoDS\_Shape&

theResult,const Standard\_Boolean closedSolid = Standard\_False,const Standard\_Boolean GeomCtrl = Standard\_True) ;

检查在结果图形中所生成和修改后的面是否合法，参数theArgs可以为空，表示所有的面都被检查；如果closedSolid 为真，表示只有封闭的图形合法，如果参数GeomCtrl为假，几何体的顶点和边不检查，自相交的新的wire也不检查；

\--Standard\_Boolean IsTopologicallyValid(const TopoDS\_Shape& S) ;

也是检查图形是否合法，和前一个不同的是，检查 no geometric contols (intersection of wires, pcurve validity) are

performed.

**GProp\_GProps****类**

计算图元的属性；

**gp\_Trsf****类**

定义一个矩阵变换的类

\--可以定义平移、旋转、缩放的矩阵；

\--可以对称于一个点，一条线，一个平面；

示例一：

对称于一个点：

gp\_Trsf theTransformation;

gp\_Pnt PntCenterOfTheTransformation(110,60,60);

theTransformation.SetMirror(PntCenterOfTheTransformation);

示例二：

绕一个轴旋转：

gp\_Trsf theTransformation;

gp\_Ax1 axe = gp\_Ax1(gp\_Pnt(200,60,60),gp\_Dir(0.,1.,0.));

theTransformation.SetRotation(axe,30\*PI/180);

示例三：

缩放：

gp\_Trsf theTransformation;

gp\_Pnt theCenterOfScale(200,60,60);

theTransformation.SetScale(theCenterOfScale,0.5);

示例四：

平移：

gp\_Trsf theTransformation;

gp\_Vec theVectorOfTranslation(-6,-6,6);

theTransformation.SetTranslation(theVectorOfTranslation);

示例五：

Displacement：

TopoDS\_Shape S = BRepPrimAPI\_MakeWedge(60.,100.,80.,20.);

gp\_Trsf theTransformation;

gp\_Ax3 ax3\_1(gp\_Pnt(0,0,0),gp\_Dir(0,0,1));

gp\_Ax3 ax3\_2(gp\_Pnt(60,60,60),gp\_Dir(1,1,1));

theTransformation.SetDisplacement(ax3\_1,ax3\_2);

BRepBuilderAPI\_Transform myBRepTransformation(S,theTransformation);

TopoDS\_Shape TransformedShape = myBRepTransformation.Shape();

示例六：

变形

gp\_GTrsf theTransformation;

gp\_Mat rot(1, 0, 0, 0, 0.5, 0, 0, 0, 1.5);

theTransformation.SetVectorialPart(rot);

theTransformation.SetTranslationPart(gp\_XYZ(5,5,5));

BRepBuilderAPI\_GTransform myBRepTransformation(S,theTransformation);

TopoDS\_Shape S2 = myBRepTransformation.Shape();

**BuilderAPI\_MakeEdge****类**

定义一生成一个边；此类有多个构造函数，现举其中一个介绍如下：

Standard\_EXPORT BRepBuilderAPI\_MakeEdge(const Handle(Geom2d\_Curve)& L,const Handle(Geom\_Surface)& S,const TopoDS\_Vertex& V1,const TopoDS\_Vertex& V2,const Standard\_Real p1,const Standard\_Real p2);

其参数含义是：

顶点V1和V2用来限制曲线（定义边的约束），值p1和p2为顶点的参数；

曲线可以定义成在一个表面的2D曲线，应用缺省的公差；

参数规则：

对于曲线来说：

\--句柄不能为空；

\--如果曲线是一个trimmed曲线，使用基础曲线；

对于顶点来说：

\--可以为空，表示此参数为无限大；静态方法 Precision::Infinite()用来定义一个无限大的数；

\--两个顶点如果位于同一位置，必须一样，当曲线是封闭时使用相同的顶点；

对于参数来说：

\--参数为必须在曲线参数范围内，如果曲线是trimmed,使用基础曲线；如果边的条件不满足，返回BRepAPI\_ParameterOutOfRange错误；

\--参数值不能相等，如果条件不满足，边无法创建，返回BRepAPI\_LineThroughIdenticPoints错误；

\--参数值可以这样给出C->FirstParameter()

\--如果参数值需要切换，比如第一个顶点的参数为P2，第二个顶点的参数为P1，边的方向可以“reversed”；

\--对于一个周期曲线，值P1和P2可以通过加或减周期来得到；

\--参数值可以无限大，在对应的方向上边是开放的。然而，对应的顶点必须是空图形，如果条件不满足，边无法创建，返回BRepAPI\_PointWithInfiniteParameter错误；

\--参数值可以被忽略，将通过曲线上的投影进行计算；

\--可以给定空间三维点；

**BRepFeat\_MakePipe****类**

基类为：BRepFeat\_Form；

通过基本图形生成一个Pipe;

**BRepFeat\_MakeLinearForm** **类**

基类为：BRepFeat\_RibSlot

在一个平面表面上建一个肋或开凹槽；

**BRepFeat\_Gluer****类**

粘合两个实体为一个实体；

示例：

（1）：创建两个BOX，并找到要粘合的面；

（2）：创建要粘合的对象：

BRepFeat\_Gluer glue2(S4,S3);

（3）：用两个面粘合对象；

glue2.Bind(F4,F3);

（4）：重新生成对象：

LocOpe\_FindEdges CommonEdges(F4,F3);

for (CommonEdges.InitIterator(); CommonEdges.More(); CommonEdges.Next())

glue2.Bind(CommonEdges.EdgeFrom(),CommonEdges.EdgeTo());

TopoDS\_Shape res2 = glue2.Shape();

myAISContext->Erase(ais3,Standard\_False,Standard\_False);

ais4->Set(res2);

myAISContext->Redisplay(ais4,Standard\_False);

**Graphic2d\_Polyline****类**

创建一个多边形．

常见方法：

\--Length()得到线的点数；

\--void Values(const Standard\_Integer aRank,Quantity\_Length& X,Quantity\_Length& Y) const;得到序号为aRank的点；

\--void DrawElement(const Handle(Graphic2d\_Drawer)& aDrawer,const Standard\_Integer anIndex) ;绘制多边形的一条边；

\--void DrawVertex(const Handle(Graphic2d\_Drawer)& aDrawer,const Standard\_Integer anIndex) ;绘制多边形的一个顶点；

\--Standard\_Boolean Pick(const Standard\_ShortReal X,const Standard\_ShortReal Y,const Standard\_ShortReal aPrecision,const Handle(Graphic2d\_Drawer)& aDrawer) ;得到此多边形是否被拾取，注意：PickIndex()方法得到的是最后拾取的点，如果拾取点在线的内部，返回０；

**Graphic2d\_Line****类**

是Polyline, Circle ... 等图元的基类；

常见方法：

\--SetWidthIndex(const Standard\_Integer anIndex) ;得到在width map中的宽度的索引；设定对应的线宽值；

\--SetTypeIndex(const Standard\_Integer anIndex) ;设置线型；

\--SetInteriorColorIndex(const Standard\_Integer anIndex) ;设置颜色；

\--void SetDrawEdge(const Standard\_Boolean aDraw) ;设置边是否绘出，注意，这种情况下，polygon的类型必须为：

Graphic2d\_TOPF\_FILLED 或者 Graphic2d\_TOPF\_PATTERNED；

\--SetInteriorPattern(const Standard\_Integer anIndex) ;定义封闭线的内部图案，polygon的填充类型必须是：Graphic2d\_TOPF\_PATTERNED；

\--SetTypeOfPolygonFilling(const Graphic2d\_TypeOfPolygonFilling aType) ;定义封闭线的图案，TypeOfPolygonFilling可选类型有：

\- Graphic2d\_TOPF\_EMPTY - Graphic2d\_TOPF\_FILLED - Graphic2d\_TOPF\_PATTERNED ；

\--Standard\_Integer InteriorColorIndex() const;得到颜色索引；

\--Standard\_Integer InteriorPattern() const;得到所使用的图案索引；

\--Graphic2d\_TypeOfPolygonFilling TypeOfPolygonFilling() const;得到多边形填充模式；

**Graphic2d\_Primitive****类**

是Graphic2d\_Line类的基类，

常见方法：

\--得到及获取颜色索引；

\--得到图元元素的数量和顶点的数量：

Standard\_Integer NumOfElemIndices() const;

Standard\_Integer NumOfVertIndices() const;

\--Standard\_Integer PickedIndex() const;得到最后拾取的图元元素的索引值；

\--void Highlight(const Standard\_Integer anIndex = 0) ;高亮显示图元或图元的一部分，当anIndex＝０表示所有的图元高亮显示，>0为当所要求的图元元素高亮显示时，<0为所要求的顶点高亮显示时；

\--void Unhighlight() ;禁止图元高亮显示；

\-- Standard\_Boolean IsHighlighted() const;图元是否高亮显示；

\--Handle\_TColStd\_HSequenceOfInteger HighlightIndices() const;得到图元高亮显示的索引序列；

\--void SetDisplayMode(const Standard\_Integer aMode) ;设置图元显示的模式；

\--Standard\_Integer DisplayMode() const;得到图元显示的模式；

\--Standard\_Boolean Graphic2d\_GraphicObject::Pick(const Standard\_Real X,const Standard\_Real Y,const Standard\_Real aPrecision,const Handle(Graphic2d\_Drawer)& aDrawer) ;

用一个矩形框拾取图形对象，如果图形对象被拾取，返回为真，通过方法Graphic2d\_View::Pick调用；

\--Standard\_Boolean Graphic2d\_GraphicObject::PickByCircle(const Standard\_Real X,const Standard\_Real Y,const Standard\_Real Radius,const Handle(Graphic2d\_Drawer)& aDrawer) ;

用一个园来拾取图形对象，如果图形对象被拾取，返回为真，通过方法Graphic2d\_View::PickByCircle调用；

\--Standard\_Boolean Graphic2d\_GraphicObject::Pick(const Standard\_Real Xmin,const Standard\_Real Ymin,const Standard\_Real Xmax,const Standard\_Real Ymax,const Handle(Graphic2d\_Drawer)& aDrawer,const Graphic2d\_PickMode aPickMode) ;

以下情况下返回值为真：

包括在矩形内：included in rectangle (),

不在矩形内：excluded from rectangle (),

相交于矩形框：intersected by rectangle (),

通过 Xmin, Ymin, Xmax, Ymax定义矩形框。

\--得到所有在图元内的markers的最小最大值，注意，如果me为空，或未显示，或没有markers返回为假，

Minx = Miny = RealFirst () ；Maxx = Maxy = RealLast ()

Standard\_EXPORT Standard\_Boolean Graphic2d\_GraphicObject::MarkerMinMax(Quantity\_Length& Minx,Quantity\_Length& Maxx,Quantity\_Length& Miny,Quantity\_Length& Maxy) const;

\--移除图元；Standard\_EXPORT void Graphic2d\_GraphicObject::RemovePrimitive(const Handle(Graphic2d\_Primitive)& aPrimitive) ;

\--绘制图元，以默认的图元属性绘制；void Graphic2d\_TransientManager::Draw(const Handle(Graphic2d\_Primitive)& aPrimitive) ;

**AIS2D\_InteractiveObject****类**

使用显示和选择服务，来可视化和选择机制，交互式对象常用来显示数据，曲线，图形，markers,尺寸标注等。

常用方法：

\--获取及设置属性

Handle\_Prs2d\_Drawer Attributes() const;

void SetAttributes(const Handle(Prs2d\_Drawer)& aDrawer) ;

\--通过Aspect设置属性，到所有图元分配这个Aspect.

Standard\_EXPORT void SetAspect(const Handle(Prs2d\_AspectRoot)& anAspect) ;

\--通过Aspect设置属性,到所有通过InteractiveContext被链接的图元对象；

Standard\_EXPORT void SetAspect(const Handle(Prs2d\_AspectRoot)& anAspect,const Handle(Graphic2d\_Primitive)& aPrimitive) ;

\--得到图元的Aspect;

Standard\_EXPORT Handle\_Prs2d\_AspectRoot GetAspect(const Handle(Graphic2d\_Primitive)& aPrimitive) const;

\--如果图元用一个aspect链接的话返回为真；

Standard\_EXPORT Standard\_Boolean HasAspect(const Handle(Graphic2d\_Primitive)& aPrimitive) const;

\--指出交互对象是否有一个交互上下文设备；

Standard\_EXPORT Standard\_Boolean HasInteractiveContext() const;

\--得到交互对象的上下文设备；

Standard\_EXPORT Handle\_AIS2D\_InteractiveContext GetContext() const;

**Graphic2d\_GraphicObject****类**

是AIS2D\_InteractiveObject类的基类；在一个view内创建一个图形对象，一个图形对象管理一系列图元；默认值为：空，可输出，可绘制，可拾取，不显示，不高亮，优先权为０；

主要方法：

设置视图，设置一个变形，设置获取图层，设置获取优先权，禁用/使用输出，是否可输出，禁用/使用Draw.是否可显示，Erase，高亮显示，颜色，拾取等；

**Graphic2d\_ImageFile****类**

定义一个图像，以图像的中心位置作为插入点，Ｘ，Ｙ定义在模型空间的位置，adx,ady 定义在设备空间的偏移量.ascale定义一个缩放系数；

**Aspect\_WidthMap****类**

定义一个WidthMap集合对象；

主要方法有，

\--添加一个入口：

Standard\_Integer AddEntry(const Aspect\_WidthOfLine aStyle) ;

void AddEntry(const Aspect\_WidthMapEntry& AnEntry) ;

Standard\_Integer AddEntry(const Quantity\_Length aStyle) ;

\--根据索引得到一个入口：

Aspect\_WidthMapEntry Entry(const Standard\_Integer AnIndex) const;

示例：

\--定义private :

Handle(Aspect\_WidthMap) myWidthMap;

\--遍历：

for(int i =1;i<=myWidthMap->Size();i++)

Aspect\_WidthMapEntry aWidthMapEntry = myWidthMap->Entry(i);

\--得到一个入口： Aspect\_WidthMapEntry aWidthMapEntry = myWidthMap->Entry(CurrentSelectionIndex);

**Aspect\_TypeMap****类**

定义一个线型集合对象：

**Aspect\_MarkMap****类**

定义一个MarkMap集合对象；

**Aspect\_FontMap****类**

定义一个字体集合对象；

**Aspect\_ColorMap****类**

定义一个颜色集合对象；

**GGraphic2d\_SetOfCurves****类**

基类是：Graphic2d\_Line；

定义一图元为由多个curves 的集合；主要方法有添加一个curves, 得到curves的数量，得到其中一个curves等；只绘制其中一个元素，是否为拾取状态；

示例：

Handle(Prs2d\_AspectLine) aLineAspect = new Prs2d\_AspectLine;

aLineAspect->SetTypeOfFill(Graphic2d\_TOPF\_EMPTY);

aLineAspect->SetTypeIndex(...);

aLineAspect->SetColorIndex(...);

aLineAspect->SetWidthIndex(...);

Handle(Graphic2d\_SetOfCurves) segment;

segment = new Graphic2d\_SetOfCurves(this);

segment->Add(myGeom2dCurve);

将此曲线集合应用所定义的线型线宽等；

SetAspect(aLineAspect, segment);

**创建交互式对象相关的类介绍**

**AIS\_Line**

此类的继承关系是：

Standard\_Transient->MMgt\_TShared->PrsMgr\_PresentableObject-->SelectMgr\_SelectableObject-->AIS\_InteractiveObject－>AIS\_Line

Standard\_Transient:抽象类，主要定义分配空间，得到类型，引用计数等；

MMgt\_TShared：抽象类，主要用来管理对象的内存；

PrsMgr\_PresentableObject类：表示一个可表达的二维或三维图形对象；主要方法有设置位置，更新，图形类型等；

此类的派生类类型有：

\-AIS\_InteractiveObject

\-AIS\_ConnectedInteractive

\-AIS\_MultipleConnectedInteractive

\-AIS\_Shape

SelectMgr\_SelectableObject类：表示一个可选择的对象；

**AIS\_Line****，****AIS\_Circle****等类**

定义一个直线，园等；主要方法有，返回对象的类型，设置线宽，线型，颜色等；

示例：

GC\_MakeCircle C(gp\_Pnt(-100.,-300.,0.),gp\_Pnt(-50.,-200.,0.),gp\_Pnt(-10.,-250.,0.));

Handle(AIS\_Circle) anAISCirc = new AIS\_Circle(C.Value());

myAISContext->Display(anAISCirc);

**AIS\_InteractiveContext****类**

交互式设备类，可以用它来管理交互式图形对象，可以在一个或多个视图中。如果图形对象已经装入交互式设备，可以直接调用交互式对象的方法。

使用设备时必须区分两种状态：

－没有打开本地设备。也称为不确定点；

－打开了一个或多个设备；

有的方法可以使用在打开的设备中，有的方法用在关闭的设备中，有的方法与设备状态无关；

\--当想工作在一个入口类型上，应设置选项UseDisplayedObjects为假，可显示对象可以重新可视化交互对象；

\--当使用缺省的选项来打开一个设备时，注意：

：可视化的交互对象在缺省选择模式下是活动的，必须分离那些不想使用的对象；

：交互式对象可以自动分解为子图形；

：“临时的”交互对象不会自动计入总数，，如果想使用它，必须手动装载它；

使用过程是：

－－用正确的选项打开设备；

－－装载／显示对象；

－－如果需要，激活标准模式；

－－创建一个过滤器，添加到设备中；

－－查找／选择／重置所需的入口；

－－根据索引关闭设备；

－－创建一个交互设备编辑器很有用，可以设置不同的设备用不用的选择／表达方式；

常见方法：

\--如果没有设备打开，交互对象没有显示模式，缺省的显示模式是０，如果一个设备是打开的并且更新为假，对象不会更新显示。

void Display(const Handle(AIS\_InteractiveObject)& anIobj,const Standard\_Integer amode,const Standard\_Integer

aSelectionMode,const Standard\_Boolean updateviewer = Standard\_True,const Standard\_Boolean allowdecomposition =

Standard\_True) ;

\--使用给定的选择模式载入一个交互对象：

void Load(const Handle(AIS\_InteractiveObject)& aniobj,const Standard\_Integer SelectionMode = -1,const Standard\_Boolean

AllowDecomp = Standard\_False) ;

\--擦除一个对象：如果putinCollector为假，对象被擦除但不放入集合中；

void Erase(const Handle(AIS\_InteractiveObject)& aniobj,const Standard\_Boolean updateviewer = Standard\_True,const

Standard\_Boolean PutInCollector = Standard\_True) ;

\--擦除视图集合中的每个对象；

void EraseAll(const Standard\_Boolean PutInCollector = Standard\_True,const Standard\_Boolean updateviewer = Standard\_True) ；

\--从集合中显示所有对象；

void DisplayAll(const Standard\_Boolean OnlyFromCollector = Standard\_True,const Standard\_Boolean updateviewer =

Standard\_True) ;

\--从集合中显示一个对象；

void DisplayFromCollector(const Handle(AIS\_InteractiveObject)& anIObj,const Standard\_Boolean updateviewer = Standard\_True)

\--擦除选择的对象；

void EraseSelected(const Standard\_Boolean PutInCollector = Standard\_True,const Standard\_Boolean updateviewer =

Standard\_True) ;

\--改变临时对象的状态，

Standard\_Boolean KeepTemporary(const Handle(AIS\_InteractiveObject)& anIObj,const Standard\_Integer InWhichLocal = -1) ;

\--从所有的视图中移除交互对象；

void Clear(const Handle(AIS\_InteractiveObject)& aniobj,const Standard\_Boolean updateviewer = Standard\_True) ;

\--从每个视图中移除对象；

void Remove(const Handle(AIS\_InteractiveObject)& aniobj,const Standard\_Boolean updateviewer = Standard\_True) ;

\--从所有打开的设备中移除所有对象；

void RemoveAll(const Standard\_Boolean updateviewer = Standard\_True) ;

\--通过鼠标动态检测，感知的图元被高亮显示。缺省的鼠标移过时的颜色为白色。

void Hilight(const Handle(AIS\_InteractiveObject)& aniobj,const Standard\_Boolean updateviewer = Standard\_True) ;

\--改变视图中线的颜色；

void HilightWithColor(const Handle(AIS\_InteractiveObject)& aniobj,const Quantity\_NameOfColor aCol,const Standard\_Boolean updateviewer = Standard\_True) ;

\--从入口对象中移除高亮；更新视图；

void Unhilight(const Handle(AIS\_InteractiveObject)& aniobj,const Standard\_Boolean updateviewer = Standard\_True) ;

\--设置显示的优先权；

void SetDisplayPriority(const Handle(AIS\_InteractiveObject)& anIobj,const Standard\_Integer aPriority) ;

\--设置所看到的交互对象的显示模式；

void SetDisplayMode(const Handle(AIS\_InteractiveObject)& aniobj,const Standard\_Integer aMode,const Standard\_Boolean

updateviewer = Standard\_True) ;

\--设置/移除交互对象的选择模式：

void SetSelectionMode(const Handle(AIS\_InteractiveObject)& aniobj,const Standard\_Integer aMode) ;

void UnsetSelectionMode(const Handle(AIS\_InteractiveObject)& aniobj) ;

\--设置感知的精度：

void SetSensitivity(const Standard\_Real aPrecision) ;

\--定义当前选择感知的像素：

void SetSensitivity(const Standard\_Integer aPrecision = 4) ;

\--设置/重置初始图形的位置；如果有一个位置返回为真；

void SetLocation(const Handle(AIS\_InteractiveObject)& aniobj,const TopLoc\_Location& aLocation) ;

void ResetLocation(const Handle(AIS\_InteractiveObject)& aniobj) ;

Standard\_Boolean HasLocation(const Handle(AIS\_InteractiveObject)& aniobj) const;

得到实体对象的位置；

const TopLoc\_Location& Location(const Handle(AIS\_InteractiveObject)& aniobj) const;

\--改变当前面的模式；缺省模式是Aspect\_TOFM\_TWO\_SIDE。意味着属性在前面和后面都应用；

void SetCurrentFacingModel(const Handle(AIS\_InteractiveObject)& aniobj,const Aspect\_TypeOfFacingModel aModel =

Aspect\_TOFM\_BOTH\_SIDE) ;

\--设置／获得三角形的尺寸，缺省值是１００mm.

void SetTrihedronSize(const Standard\_Real aSize,const Standard\_Boolean updateviewer = Standard\_True) ;

Standard\_Real TrihedronSize() const;

\--设置／获取平面的尺寸：

Standard\_EXPORT void SetPlaneSize(const Standard\_Real aSizeX,const Standard\_Real aSizeY,const Standard\_Boolean

updateviewer = Standard\_True) ;

\--得到实体对象的显示状态；

AIS\_DisplayStatus DisplayStatus(const Handle(AIS\_InteractiveObject)& anIobj) const;

\--得到实体对象的显示模式的列表：

const TColStd\_ListOfInteger& DisplayedModes(const Handle(AIS\_InteractiveObject)& aniobj) const;

\--关于绘制隐藏线相关的一些函数，通过名称就可以知道函数的意思；

EnableDrawHiddenLine（）；

DisableDrawHiddenLine（）；

Standard\_Boolean DrawHiddenLine()；

\--设置／得到ＵＶ等高参数；等高参数是否可用；

Standard\_Integer IsoNumber(const AIS\_TypeOfIso WhichIsos = AIS\_TOI\_Both) ;

\--设置／添加／移除当前对象.....

InitCurrent() ;MoreCurrent();NextCurrent();

Standard\_Boolean IsCurrent(const Handle(AIS\_InteractiveObject)& aniobj) const;

Handle\_AIS\_InteractiveObject Current() const;

Handle\_AIS\_InteractiveObject FirstCurrentObject() ;

void HilightCurrents(const Standard\_Boolean updateviewer = Standard\_True) ;

void UnhilightCurrents(const Standard\_Boolean updateviewer = Standard\_True) ;

void ClearCurrents(const Standard\_Boolean updateviewer = Standard\_True) ;

转载于:https://www.cnblogs.com/xyb617/p/10795042.html

OCCT 基础2

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 OpenCASCADE：OCCT应用框架OCAF之TObj模型对象

相关 OpenCASCADE：OCCT应用框架OCAF之TObj 模型

相关 OpenCASCADE：OCCT应用框架OCAF之XML支持

相关 OpenCASCADE：OCCT应用框架OCAF之功能服务

相关 OpenCASCADE：OCCT应用框架OCAF之可视化属性

相关 OpenCASCADE：OCCT应用框架OCAF之标准属性

相关 OpenCASCADE：OCCT应用框架OCAF之形状属性

相关 OpenCASCADE：OCCT应用框架OCAF之标准文件服务

相关 OpenCASCADE：OCCT应用框架OCAF之数据框架

相关 OCCT 基础2