介绍

建模算法模块汇集了广泛的拓扑算法用于建模。除了这些工具，你还会发现几何算法。

几何工具

Open CASCADE Technology几何工具提供以下算法:

• 计算两个2D曲线、曲面的交点，或一个3D曲线与一个曲面的交点;
• 将点投射到2D和3D曲线上，点投射到表面上，3D曲线投射到曲面上;
• 根据约束构造直线和圆;
• 根据约束构造曲线和曲面;
• 通过插值构造曲线和曲面。

相交

交集组件用于计算二维或三维几何对象之间的交集:

• 两条二维曲线的交点;
• 二维曲线的自交;
• 三维曲线与曲面的交点;
• 两个平面的交点。

类Geom2dAPI_InterCurveCurve评估两个几何曲线Geom2d_Curve的交点gp_Pnt2d，也可以计算一个曲线自相交的交点。

在这两种情况下，算法都要求一个两点共同的容差值(Standard_Real)。所有构造函数中使用的默认容差值为1.0e-6。

该算法在相交的情况下返回一个点，在相切相交的情况下返回一个段。

两曲线相交

Geom2dApi_Intercurecurve类可以实例化曲线C1和C2的交集。

Geom2dAPI_InterCurveCurve Intersector(C1,C2,tolerance); 

或自相交曲线C3

Geom2dAPI_InterCurveCurve Intersector(C3,tolerance); 
Standard_Integer N = Intersector.NbPoints(); 

调用交点的个数

若要选择所需的交点，请在参数中传递整数索引值。

gp_Pnt2d P = Intersector.Point(Index); 

要调用交集段的个数，使用

Standard_Integer M = Intersector.NbSegments(); 

要选择所需的相交段，请在参数中传递整数索引值。

Handle(Geom2d_Curve) Seg1, Seg2; 
Intersector.Segment(Index,Seg1,Seg2); 
// if intersection of 2 curves 
Intersector.Segment(Index,Seg1); 
// if self-intersection of a curve 

如果您需要访问更广泛的功能，以下方法将返回用于计算交叉点的算法对象:

Geom2dInt_GInter& TheIntersector = Intersector.Intersector(); 

曲线曲面相交

GeomAPI_IntCS类用于计算曲线和曲面之间的交点。

这个类的实例化如下:

GeomAPI_IntCS Intersector(C, S); 

要调用交点的个数，使用:

Standard_Integer nb = Intersector.NbPoints(); 
gp_Pnt& P = Intersector.Point(Index); 	

其中Index是1到nb之间的整数，称为交点。

两曲面相交

GeomAPI_IntSS类用于根据给定的公差从Geom_Surface计算两个曲面的相交。

这个类的实例化如下:

GeomAPI_IntSS Intersector(S1, S2, Tolerance); 

一旦创建了GeomAPI_IntSS对象，就可以解释它了。

Standard_Integer nb = Intersector. NbLines(); 

调用交点曲线的个数。

Handle(Geom_Curve) C = Intersector.Line(Index) 

其中Index是1到nb之间的整数，称为交点曲线。

插值

插值定律组件提供了函数的定义:y=f(x)。它特别提供了以下定义:

• 一个线性函数，
• 一个S函数，
• 以及一个值范围的插值函数。

这样的函数可以用来定义，例如，沿形状边缘的圆角的演化规律。

所构建函数的有效性永远不会检查：Law包不知道该函数将用于什么应用程序或用于什么目的。特别是，如果用函数作为圆角的演化规律，重要的是函数总是正的。用户必须对此进行检查。

Geom2dAPI_Interpolate

这个类用于插值一个通过点数组的BSplineCurve。如果在插值点不要求切线，则连续性为C2。如果在该点处要求切线，则连续性为C1。如果要求周期性，曲线是闭合的，连接点将是给出的第一个点。曲线只有C1的连续性。这个类可以实例化如下:

Geom2dAPI_Interpolate 
(const  Handle_TColgp_HArray1OfPnt2d& Points, 
const  Standard_Boolean PeriodicFlag, 
const Standard_Real  Tolerance); 
Geom2dAPI_Interpolate Interp(Points, Standard_False, Precision::Confusion()); 

可以从上面定义的对象调用b样条曲线。

Handle(Geom2d_BSplineCurve) C = Interp.Curve(); 

注意Handle(Geom2d_BSplineCurve)操作符已经被方法Curve()重新定义。因此，不需要传递Geom2dAPI_Interpolate类型的中间对象的构造，并且下面的语法是正确的。

Handle(Geom2d_BSplineCurve) C =  Geom2dAPI_Interpolate(Points,  Standard_False, Precision::Confusion()); 

GeomAPI_Interpolate

这个类可以实例化如下:

GeomAPI_Interpolate 
(const  Handle_TColgp_HArray1OfPnt& Points, 
const  Standard_Boolean PeriodicFlag, 
const Standard_Real  Tolerance); 
GeomAPI_Interpolate Interp(Points, Standard_False, Precision::Confusion()); 

可以从上面定义的对象调用b样条曲线。

Handle(Geom_BSplineCurve) C = Interp.Curve(); 

注意Handle(Geom_BSplineCurve)操作符已经被Curve()方法重新定义。因此，不需要传递GeomAPI_Interpolate类型的中间对象的构造，并且下面的语法是正确的。

Handle(Geom_BSplineCurve) C = GeomAPI_Interpolate(Points，Standard_False 1.0 e);

边界条件可以用Load方法施加。

GeomAPI_Interpolate AnInterpolator 
(Points, Standard_False, 1.0e-5); 
AnInterpolator.Load (StartingTangent, EndingTangent); 

约束的直线和圆

约束类型

构建二维圆或直线的算法可以用与其他曲线相关的数值或几何约束来描述。

这些约束如下:

• 圆的半径；
• 一条直线与另一条直线的夹角；
• 一条直线或圆与曲线的切线；
• 一条直线或圆穿过一点；
• 圆心在一点或曲线上的圆；

例如，这些算法可以很容易地构造一个半径给定的圆，以直线为中心，与另一个圆相切。

实现的算法比直接构造组件提供的用于构建2D圆或线的算法更复杂。

根据解与表示相切约束的圆或直线的相对位置，切线问题的表达式通常会导致几个结果。

例如，考虑以下一个给定半径的圆(一个小圆)与两个割线圆C1和C2相切的情况:

这张图清楚地表明有8种可能的解决方案。

为了限制解的数量，我们可以尝试表示所需解相对于它所相切的圆的相对位置。例如，如果我们指定解决方案在圆圈C1内，在圆圈C2外，则图上只有两个参考3和4的解决方案响应所提出的问题。

这些定义很容易在圆上解释，在圆上很容易识别内部和外部。事实上，对于任何一种曲线，内部都被定义为曲线的左边相对于它的方向。

根据与之相切的曲线来确定解的这种技术，可用于所有通过几何约束构造圆或直线的算法中。使用了四个限定词:

• 封闭-解决方案必须包含参数;
• 封闭-解决方案必须包含在参数中;
• 外部——解和参数必须是彼此外部的;
• 不合格-相对位置不合格，即所有解决方案都应用。

可以使用限定符创建表达式，例如:

GccAna_Circ2d2TanRad Solver(GccEnt::Outside(C1), GccEnt::Enclosing(C2),Rad,Tolerance); 

这个表达式找到了所有半径为Rad的圆，它们同时与圆C1和圆C2相切，而C1在外面，C2在里面。

可用的线和圆的类型

以下使用值处理实体创建具有几何约束的二维直线或圆的分析算法是可用的:

• 与三个元素(线、圆、曲线、点)相切的圆，
• 与两个元素相切并有半径的圆，
• 与两个元素相切，以第三个元素为中心的圆，
• 与两个元素相切并以一点为圆心的圆，
• 与一个元素相切，以另一个元素为圆心的圆，
• 两点的平分线，
• 两条线的平分线，
• 两个圆的平分线，
• 一条线和一点的平分线，
• 一个圆和一点的平分线，
• 一条线和一个圆的平分线，
• 直线与两个要素(点、圆、曲线)相切，
• 直线与一个要素相切而平行于一条直线，
• 直线与一个要素相切而垂直于一条直线，
• 直线与一个要素相切而与一条直线形成夹角。

外部/内部

定义一个圆的内部和外部并不难。如下图所示，外部是用双法线的意义来表示的，也就是说，根据穿过圆的意义来表示右边。因此，左侧是内部(或“材料”)。

推而广之，将直线或任意开口曲线的内部根据通过方向定义为左侧，如下图所示:

直线的方向

有时有必要事先定义沿着要创建的路线旅行的方向。这种方向将从第一个点到第二个点。

两个圆相切

以下四个图说明了在创建一行时使用限定符的四种情况。第五个显示了如果没有给出限定符的情况下的解决方案。

案例1

约束：与C1相切和外部。C2的切线和外部。

GccAna_Lin2d2Tan Solver(GccEnt::Outside(C1), GccEnt::Outside(C2), Tolerance); 

案例2

约束:相切且包含C1,相切且包含C2。

GccAna_Lin2d2Tan 
    Solver(GccEnt::Enclosing(C1), 
        GccEnt::Enclosing(C2), 
        Tolerance); 

案例3

约束:相切且包含C1。C2的正切和外切。

GccAna_Lin2d2Tan 
    Solver(GccEnt::Enclosing(C1), 
        GccEnt::Outside(C2), 
        Tolerance); 

案例4

约束:与C1相切且在C1外部，相切且包含C2。

GccAna_Lin2d2Tan 
    Solver(GccEnt::Outside(C1), 
        GccEnt::Enclosing(C2), 
        Tolerance); 

案例5

约束条件:与C1相切且未定义。关于C2的正切且未定义。

GccAna_Lin2d2Tan 
    Solver(GccEnt::Unqualified(C1), 
        GccEnt::Unqualified(C2), 
        Tolerance); 

给定半径的圆与两个圆相切

下面的四张图显示了在创建圆时使用限定词的四种情况。

案例1

约束:与C1相切且在C1外部。C2的正切和外切。

GccAna_Circ2d2TanRad 
    Solver(GccEnt::Outside(C1), 
    GccEnt::Outside(C2),  Rad, Tolerance); 

案例2

约束:与C1相切且在C1外部。正切并包含在C2中。

GccAna_Circ2d2TanRad 
    Solver(GccEnt::Outside(C1), 
        GccEnt::Enclosed(C2),  Rad, Tolerance); 

案例3

约束:与C1相切且在C1外部。相切且包含C2。

GccAna_Circ2d2TanRad 
    Solver(GccEnt::Outside(C1), 
        GccEnt::Enclosing(C2),  Rad, Tolerance); 

案例4

约束:切线和封闭C1。正切和封闭C2。

GccAna_Circ2d2TanRad 
    Solver(GccEnt::Enclosing(C1), 
        GccEnt::Enclosing(C2),  Rad, Tolerance); 

案例5

下面的语法将给出所有半径为Rad的圆，它们与C1和C2相切，而不受相对位置的影响:

GccAna_Circ2d2TanRad  Solver(GccEnt::Unqualified(C1), 
                            GccEnt::Unqualified(C2), 
                            Rad,Tolerance); 

算法的类型

OCCT实现了几类算法:

• 解析算法是通过解析方程获得解的算法，当处理的几何图形(切线参数、中心位置等)是点、线或圆时使用这种算法;
• 几何算法，通常通过计算由几何参数建立的平行或平分曲线的相交来获得解;
• 迭代算法，通过一个迭代过程得到解。

对于每一种受约束的直线或圆的几何结构，OCCT提供了两种类型的访问:

• Geom2dGcc包中的算法自动选择最适合问题的算法，无论是在一般情况下还是在所有类型的特定情况下;使用的参数是Geom2d对象，而计算的解决方案是gp对象;
• 封装gcca中的算法可以解析地解决问题，并且只能在要处理的几何形状是直线或圆时使用;使用的参数和计算的解决方案都是gp对象。

所提供的算法计算，对应于与所述几何问题的所有解，除非解是通过迭代算法找到的。

迭代算法只计算一个最接近初始位置的解。它们可以在以下情况下使用:

• 当参数比直线或圆更复杂，且半径不知道或难以确定时，即与三个几何元素相切的圆，或与两个几何元素相切并以曲线为中心的圆;
• 当切线参数比直线或圆更复杂时，构建一条线。

合格曲线(用于切线参数)由以下方式提供:

• GccEnt包，用于GccAna算法的直接使用，或
• Geom2dGcc包，用于Geom2dGcc算法的一般使用。

GccEnt和Geom2dGcc包也提供了简单的功能，以非常有效的方式构建合格的曲线。

GccAna包还提供了在圆、线或点之间构造等分轨迹的算法。两个几何物体之间的等分轨迹使得它们的每个点与两个几何物体的距离相同。它们通常是曲线，例如GccAna算法中的圆、线或圆锥。每个初等解作为一个初等等分轨迹对象给出(直线，圆，椭圆，双曲线，抛物线)，由GccInt包描述。

注:GccAna算法用来定义要求解的几何问题的曲线，是gp包中的二维直线或圆，没有显式参数化。然而，这些线或圆保留隐式参数化，对应于它们在等效的Geom2d对象上的参数化。这种参数化是在这样的曲线上返回参数值时使用的，例如使用函数Tangency1, Tangency2, Tangency3, Intersection2和CenterOn3，这些函数由GccAna或Geom2dGcc包中的构造算法提供。

约束的曲线和曲面

来自约束的曲线和曲面组件将2D和3D几何中使用的高级函数组合在一起，用于:

• 平滑和极小变化的2D曲线的创建
• 直纹面的构建
• 管状面的创建
• 曲面填充
• 平直面的创建
• 三维曲线或曲面超出其原始边界的延伸

OPEN CASCADE公司还提供了一种名为Surfaces from Scattered Points的产品，该产品允许从分散的点构建表面。该算法接受或构造一个初始b样条曲面，并寻找其满足约束条件的变形(有限元法)。通过优化的计算方法，该算法可以由超过50万个点构建一个曲面。

SSP产品不随Open CASCADE Technology一起提供，但可以单独购买。

平滑、极小变化的2D曲线

弹性梁曲线起源于造船中应用的传统建模方法，在这种方法中，一根细长的木头，一个车床，被迫在两组钉子之间通过，这样，根据两点，施加在这两点上的力的方向，以及木制车床本身的特性，采取曲线的形式。

保持这些约束要求纵向和横向力都施加到梁上，以补偿其内部弹性。纵向力可以是推或拉，梁可以或可以不允许在这些固定点上滑动。

Batten曲线

类FairCurve_Batten允许生成基于两个参考点上的一个或多个约束定义的平滑曲线。这些包括点，切线角和曲率设置。以下约束顺序可用:

• 曲线必须经过一点
• 曲线必须经过一个点并且有一个给定的切线
• 曲线必须经过一个点，有一个给定的切线和曲率。

只使用0和1个约束顺序。函数Curve返回结果为2D b样条曲线。

极小变化的曲线

类FairCurve_MinimalVariation允许在每个参考点生成曲率变化最小的曲线。以下约束顺序可用:

• 曲线必须经过一点
• 曲线必须经过一个点并且有一个给定的切线
• 曲线必须经过一个点，有一个给定的切线和曲率。

约束顺序为0、1和2。该算法最大限度地减少张力，下垂和抽搐能量。

函数Curve返回结果为2D b样条曲线。

如果你想给一条Batten曲线一个特定的长度，使用:

b.SetSlidingFactor(L / b.SlidingOfReference()) 

其中b是Batten曲线对象的名称

自由滑动通常比受限滑动更美观。然而，当角度大于p/2时，计算可能会失败，因为在这种情况下，长度理论上是无限的。

在其他情况下，当施加滑动且滑动系数过大时，板条可能会坍塌。

构造函数参数Tolerance和NbIterations控制了计算的精确程度和所需的时间。

直纹面

直纹曲面是沿两条曲线的长度绘制一条直线而形成的。

贝塞尔曲面的创建

类GeomFill_BezierCurves允许从连续的Bezier曲线生成一个Bezier曲面。注意，有理贝塞尔曲线可能会出现问题。

B样条曲面的创建

类GeomFill_BSplineCurves允许从连续的b样条曲线生成一个b样条曲面。注意，有理b样条可能会出现问题。

管状曲面的创建

类GeomFill_Pipe允许通过沿着另一条曲线(路径)扫描曲线(截面)来生成管道。结果是一个b样条曲面。

以下类型的结构是可用的:

• 具有恒定半径的圆形截面的管道，
• 具有恒定截面的管道，
• 具有在两个给定曲线之间演变的截面的管道。

填充一个轮廓

从一些曲线中创建一个曲面通常很方便，这些曲线将形成定义新曲面的边界。这是通过类GeomFill_ConstrainedFilling完成的，它允许填充由三条或四条曲线以及切线约束定义的轮廓。得到的曲面是一个b样条。

一个恰当的例子是两个圆角的交点。如果一个边缘上的圆角半径与另一个边缘上的圆角半径不同，则不可能将所得表面的所有边缘缝合在一起。这会在你正在构建的物体的整体表面留下一个缺口。

这些算法允许你从两条、三条或四条曲线中填补这个空白。这可以在有约束或没有约束的情况下完成，生成的曲面将是一系列填充样式之一的贝塞尔曲面或b样条曲面。

创建边界

类GeomFill_SimpleBound允许你为要构造的表面定义一个边界。

通过邻面创建边界

类GeomFill_BoundWithSurf允许定义要构造的表面的边界。这个边界已经连接到另一个表面。

填充类型

枚举FillingStyle指定用于构建表面的样式。这些包括:

• Stretch-补面最平整的样式
• Coons-圆角的风格，比弧形的深度小
• Curved-有最圆润补丁的样式。

Plate曲面

在CAD中，经常需要生成没有精确数学定义的曲面，但这些曲面是由各自的约束定义的。这些可以是数学的、技术的或美学的顺序。

从本质上讲，Plate表面是通过变形表面来构造的，使其符合给定数量的曲线或点约束。在下图中，可以看到平面轮廓的四段，以及一个分别作为曲线约束和点约束的点。生成的曲面可以通过使用MakeApprox函数转换为BSpline曲面。

使用变分样条算法构建曲面。它利用薄板在局部机械力作用下变形的原理。如果输入中没有给出，则计算初始曲面。这对应于变形前的板块。然后调用算法计算最终曲面。它寻找满足约束条件并使能量输入最小的解。

GeomPlate包提供以下服务，用于创建符合曲线和点约束的表面.

定义线框

BuildPlateSurface类允许创建一个框架，根据曲线和点的约束以及公差设置来构建曲面。结果与Surface函数一起返回。

请注意，您不必在构造时指定初始表面。它可以稍后添加，或者，如果没有加载，曲面将自动计算。

定义曲线约束

类CurveConstraint 允许定义曲线作为你想要构建的曲面的约束。

定义点约束

类PointConstraint允许将点定义为您想要构建的曲面的约束

应用Geom_Surface到plate曲面

类Surface允许使用Geom_Surface的方法描述buildplatessurface::Surface返回的Plate曲面对象的特征

拟合Plate曲面为B样条

MakeApprox类允许将一个GeomPlate表面转换为一个Geom_BSplineSurface。

让我们创建一个板表面，并从折线近似为曲线约束和点约束

Standard_Integer NbCurFront=4, 
NbPointConstraint=1; 
gp_Pnt P1(0.,0.,0.); 
gp_Pnt P2(0.,10.,0.); 
gp_Pnt P3(0.,10.,10.); 
gp_Pnt P4(0.,0.,10.); 
gp_Pnt P5(5.,5.,5.); 
BRepBuilderAPI_MakePolygon W; 
W.Add(P1); 
W.Add(P2); 
W.Add(P3); 
W.Add(P4); 
W.Add(P1); 
// Initialize a BuildPlateSurface 
GeomPlate_BuildPlateSurface BPSurf(3,15,2); 
// Create the curve constraints 
BRepTools_WireExplorer anExp; 
for(anExp.Init(W); anExp.More(); anExp.Next()) 
{ 
TopoDS_Edge E = anExp.Current(); 
Handle(BRepAdaptor_HCurve) C = new 
BRepAdaptor_HCurve(); 
C-ChangeCurve().Initialize(E); 
Handle(BRepFill_CurveConstraint) Cont= new 
BRepFill_CurveConstraint(C,0); 
BPSurf.Add(Cont); 
} 
// Point constraint 
Handle(GeomPlate_PointConstraint) PCont= new 
GeomPlate_PointConstraint(P5,0); 
BPSurf.Add(PCont); 
// Compute the Plate surface 
BPSurf.Perform(); 
// Approximation of the Plate surface 
Standard_Integer MaxSeg=9; 
Standard_Integer MaxDegree=8; 
Standard_Integer CritOrder=0; 
Standard_Real dmax,Tol; 
Handle(GeomPlate_Surface) PSurf = BPSurf.Surface(); 
dmax = Max(0.0001,10*BPSurf.G0Error()); 
Tol=0.0001; 
GeomPlate_MakeApprox 
Mapp(PSurf,Tol,MaxSeg,MaxDegree,dmax,CritOrder); 
Handle (Geom_Surface) Surf (Mapp.Surface()); 
// create a face corresponding to the approximated Plate 
Surface 
Standard_Real Umin, Umax, Vmin, Vmax; 
PSurf->Bounds( Umin, Umax, Vmin, Vmax); 
BRepBuilderAPI_MakeFace MF(Surf,Umin, Umax, Vmin, Vmax); 

投影

投影提供下列计算:

• 2D点到2D曲线上的投影
• 3D点到3D曲线或曲面上的投影
• 3D曲线到曲面上的投影。
• 平面曲线从三维到二维参数空间的变换。
• 二维gp对象在三维几何空间中的定位。

–2D点在曲线上的投影

Geom2dAPI_ProjectPointOnCurve允许计算从一个点(gp_Pnt2d)投射到几何曲线(Geom2d_Curve)上的所有法线。计算可能被限制在给定的域内。

曲线不必是Geom2d_TrimmedCurve。该算法将与继承Geom2d_Curve的任何类一起工作。

类Geom2dAPI_ProjectPointOnCurve可以像下面的例子那样实例化:

gp_Pnt2d P; 
Handle(Geom2d_BezierCurve) C = 
    new  Geom2d_BezierCurve(args); 
Geom2dAPI_ProjectPointOnCurve Projector (P, C);

要将法线的搜索限制在给定域[U1,U2]，使用以下构造函数:

Geom2dAPI_ProjectPointOnCurve Projector (P, C, U1, U2); 

这样创建了Geom2dAPI_ProjectPointOnCurve对象之后，我们现在可以查询它了。

调用解的点个数

Standard_Integer NumSolutions = Projector.NbPoints(); 

调用局部解的点

解的索引范围从1到project . nbpoints()。可以找到与给定索引对应的点:

gp_Pnt2d Pn = Projector.Point(Index); 

调用参数解的点

对于对应于给定索引的给定点:

Standard_Real U = Projector.Parameter(Index); 

这也可以编程为:

Standard_Real U; 
Projector.Parameter(Index,U);

调用起止点的距离

我们可以求出初始点到某点的距离，对应给定的Index:

Standard_Real D = Projector.Distance(Index); 

调用最近解的点

这个类提供了一个方法来返回离起点最近的解点。该解决方案的访问方式如下:

gp_Pnt2d P1 = Projector.NearestPoint(); 

调用参数最近解的点

Standard_Real U = Projector.LowerDistanceParameter(); 

调用点到曲线最小距离

Standard_Real D = Projector.LowerDistance(); 

重定义操作符

为了找到最接近的解决方案，一些操作已经被重新定义。

Standard_Real()返回从点到曲线的最小距离。

Standard_Real D = Geom2dAPI_ProjectPointOnCurve (P,C); 

Standard_Integer()返回解的个数。

Standard_Integer N = 
Geom2dAPI_ProjectPointOnCurve (P,C); 

gp_Pnt2d()返回最近的解点。

gp_Pnt2d P1 = Geom2dAPI_ProjectPointOnCurve (P,C); 

当您只需要最近的点时，使用这些操作符可以使编码更容易。因此:

Geom2dAPI_ProjectPointOnCurve Projector (P, C); 
gp_Pnt2d P1 = Projector.NearestPoint(); 

可以更简洁地写为:

gp_Pnt2d P1 = Geom2dAPI_ProjectPointOnCurve (P,C); 

然而，请注意，在第二种情况下，没有创建中间的Geom2dAPI_ProjectPointOnCurve对象，因此不可能访问其他解的点。

访问较底层的函数

如果希望使用Extrema包提供的更广泛的功能，则调用Extrema()方法将返回用于计算极值的算法对象。例如:

Extrema_ExtPC2d& TheExtrema = Projector.Extrema(); 

–3D点在曲线上的投影

类GeomAPI_ProjectPointOnCurve的实例化如下面的例子:

gp_Pnt P; 
Handle(Geom_BezierCurve) C = 
    new  Geom_BezierCurve(args); 
GeomAPI_ProjectPointOnCurve Projector (P, C); 

如果您希望将法线的搜索限制在给定域[U1,U2]，请使用以下构造函数:

GeomAPI_ProjectPointOnCurve Projector (P, C, U1, U2); 

这样创建了GeomAPI_ProjectPointOnCurve对象之后，您现在可以查询它了。

调用解的点数量

Standard_Integer NumSolutions = Projector.NbPoints(); 

调用局部解的点

解的索引范围从1到project . nbpoints()。可以找到对应于给定索引的点:

gp_Pnt Pn = Projector.Point(Index); 

调用参数解的点

对于对应于给定索引的给定点:

Standard_Real U = Projector.Parameter(Index); 

这也可以编程为:

Standard_Real U; 
Projector.Parameter(Index,U); 

调用起止点的距离

对应于给定索引的起始点到某点的距离为:

Standard_Real D = Projector.Distance(Index); 

调用最近解的点

这个类提供了一个方法来返回离起点最近的解点。该解决方案的访问方式如下:

gp_Pnt P1 = Projector.NearestPoint(); 

调用参数最近解的点

Standard_Real U = Projector.LowerDistanceParameter(); 

调用点到曲线的最小距离

Standard_Real D =  Projector.LowerDistance();

重定义操作符

一些作业者已经被重新定义，以寻找最接近的解决方案。

Standard_Real()返回从点到曲线的最小距离。

Standard_Real D = GeomAPI_ProjectPointOnCurve (P,C); 

Standard_Integer()返回解决方案的个数。

Standard_Integer N =  GeomAPI_ProjectPointOnCurve (P,C); 

gp_Pnt2d()返回最近的解点。

gp_Pnt P1 = GeomAPI_ProjectPointOnCurve (P,C); 

当您只需要最近的点时，使用这些操作符可以使编码更容易。这样，

GeomAPI_ProjectPointOnCurve Projector (P, C); 
gp_Pnt P1 = Projector.NearestPoint(); 

可以更简洁地写为:

gp_Pnt P1 = GeomAPI_ProjectPointOnCurve (P,C); 

然而，在第二种情况下，没有创建中间的GeomAPI_ProjectPointOnCurve对象，并且不可能访问其他解决方案点。

访问较底层的函数

如果希望使用Extrema包提供的更广泛的功能，则调用Extrema()方法将返回用于计算极值的算法对象。例如:

Extrema_ExtPC& TheExtrema = Projector.Extrema(); 

–点在曲面上的投影

类GeomAPI_ProjectPointOnSurf允许计算从gp_Pnt的一个点投射到Geom_Surface的几何表面的所有法线。

注意，表面不必是Geom_RectangularTrimmedSurface类型。

该算法将适用于继承了Geom_Surface的任何类。

GeomAPI_ProjectPointOnSurf的实例化如下:

gp_Pnt P; 
Handle (Geom_Surface) S = new Geom_BezierSurface(args); 
GeomAPI_ProjectPointOnSurf Proj (P, S); 

要限制在给定矩形域内搜索法线[U1, U2, V1, V2]，使用构造函数GeomAPI_ProjectPointOnSurf Proj (P, S, U1, U2, V1, V2)

U1、U2、V1、V2的值均在最大值和最小值范围内，即:

Umin <=  U1 < U2 <= Umax 
Vmin <=  V1 < V2 <= Vmax 

这样创建了GeomAPI_ProjectPointOnSurf对象之后，您就可以查询它了。

调用解的点数量

Standard_Integer NumSolutions = Proj.NbPoints(); 

调用局部解的点

解决方案的索引范围从1到project . nbpoints()。可以找到与给定索引对应的点:

gp_Pnt Pn = Proj.Point(Index); 

调用参数解的点

对于对应于给定索引的给定点:

Standard_Real U,V; 
Proj.Parameters(Index, U, V); 

调用起止点的距离

初始点与给定索引对应点之间的距离为:

Standard_Real D = Projector.Distance(Index); 

调用最近距离点

该类提供了一个方法，该方法返回离起始点最近的解决方案点。该解决方案的访问方式如下:

gp_Pnt P1 = Proj.NearestPoint(); 

调用参数最近解的点

Standard_Real U,V; 
Proj.LowerDistanceParameters (U, V); 

调用点到曲面的最小距离

Standard_Real D = Proj.LowerDistance(); 

重定义操作符

有些操作符已经被重新定义，以帮助您找到最近的解决方案。

Standard_Real()返回从点到表面的最小距离。

Standard_Real D = GeomAPI_ProjectPointOnSurf (P,S); 

Standard_Integer()返回解的个数。

Standard_Integer N = GeomAPI_ProjectPointOnSurf (P,S); 

gp_Pnt2d()返回最近的解点。

gp_Pnt P1 = GeomAPI_ProjectPointOnSurf (P,S); 

当您只需要最近的点时，使用这些操作符可以使编码更容易。这样，

GeomAPI_ProjectPointOnSurface Proj (P, S); 
gp_Pnt P1 = Proj.NearestPoint(); 

可以更简洁地写为:

gp_Pnt P1 = GeomAPI_ProjectPointOnSurface (P,S); 

访问较底层函数

然而，在第二种情况下，没有创建中间的GeomAPI_ProjectPointOnSurf对象，并且不可能访问其他解决方案点。

如果你想使用Extrema包提供的更广泛的功能，调用Extrema()方法将返回用于计算极值的算法对象，如下所示:

Extrema_ExtPS& TheExtrema = Proj.Extrema(); 

2d和3d曲线切换

To2d和To3d方法用于;

从位于gp_Pln平面上的3d Geom_Curve构建2d曲线，从Geom2d_Curve和gp_Pln平面构建3d曲线。

这些方法的调用方式如下:

Handle(Geom2d_Curve) C2d = GeomAPI::To2d(C3d, Pln); 
Handle(Geom_Curve) C3d = GeomAPI::To3d(C2d, Pln); 

标准拓扑对象

可以创建如下标准拓扑对象:

• 顶点;
• 边;
• 面;
• 线;
• 多边形线;
• 壳;
• 实体。

它们的构造和修改有两个根类:

• 延迟类BRepBuilderAPI_MakeShape是所有构建形状的BRepBuilderAPI类的根。它继承了类BRepBuilderAPI_Command，并提供了一个字段来存储构造的形状。
• 延迟类Brepbuilderapi_modifshape被用作形状修改的根。它继承了BRepBuilderAPI_MakeShape，并实现了用于跟踪所有子形状历史的方法。

点

BRepBuilderAPI_MakeVertex从gp的3D点创建一个新的顶点。

gp_Pnt P(0,0,10); 
TopoDS_Vertex V = BRepBuilderAPI_MakeVertex(P); 

这个类总是创建一个新的顶点，没有其他的方法。

边

基本边缘构造法

使用BRepBuilderAPI_MakeEdge从曲线和顶点创建。基本方法由一条曲线、两个顶点和两个参数构造一条边。

Handle(Geom_Curve) C = ...; // a curve 
TopoDS_Vertex V1 = ...,V2 = ...;// two Vertices 
Standard_Real p1 = ..., p2 = ..;// two parameters 
TopoDS_Edge E = BRepBuilderAPI_MakeEdge(C,V1,V2,p1,p2); 

其中C为边的定义域;V1是第一个面向FORWARD的顶点;V2是第二个顶点方向反转;p1和p2是曲线上顶点V1和V2的参数。默认容差与此边相关联。

以下规则适用于参数:

曲线

• 不能是空句柄。
• 如果曲线是修剪过的曲线，则使用基曲线。

顶点

• 可以是空形状。当V1或V2为Null时，沿相应方向打开，对应的参数p1或p2必须是无限大的(即p1是RealFirst()， p2是Realast())。
• 如果它们具有不同的3d位置，则必须是不同的顶点，如果它们具有相同的3d位置，则必须是相同的顶点(当曲线闭合时使用相同的顶点)。

参数

必须递增且在曲线范围内，即:

C->FirstParameter() <=  p1 < p2 <= C->LastParameter() 

• 如果参数减小，则切换顶点，即V2变为V1, V1变为V2。
• 在周期曲线上，通过加减周期来调整参数p1和p2，得到曲线范围内的p1和p1 < p2 <= p1+Period范围内的p2。所以在参数曲线上，p2可以大于第二个参数，见下图。
• 可以是无限的，但是对应的顶点必须是Null(见上文)。
• 顶点3d位置与曲线上使用该参数计算的点之间的距离必须低于默认精度。

补充边缘构造方法

在基本边缘构造方法的基础上，还存在补充边缘构造方法。

BRepBuilderAPI_MakeEdge类提供了方法，这些方法都是前一个的简化调用:

• 参数可以省略。它们是通过在曲线上投影顶点来计算的。
• 3d点(Pnt from gp)可以代替顶点。顶点是由点创建的。在创建连接顶点时，给出顶点是很有用的。
• 如果给出了参数，则可以省略顶点或点。这些点是通过计算曲线上的参数来计算的。
• 顶点或点和参数可以省略。使用曲线的第一个和最后一个参数。

因此，从基本结构中衍生出以下五种方法:

Handle(Geom_Curve) C = ...; // a curve 
TopoDS_Vertex V1 = ...,V2 = ...;// two Vertices 
Standard_Real p1 = ..., p2 = ..;// two parameters 
gp_Pnt P1 = ..., P2 = ...;// two points 
TopoDS_Edge E; 
// project the vertices on the curve 
E = BRepBuilderAPI_MakeEdge(C,V1,V2); 
// Make vertices from points 
E = BRepBuilderAPI_MakeEdge(C,P1,P2,p1,p2); 
// Make vertices from points and project them 
E = BRepBuilderAPI_MakeEdge(C,P1,P2); 
// Computes the points from the parameters 
E = BRepBuilderAPI_MakeEdge(C,p1,p2); 
// Make an edge from the whole curve 
E = BRepBuilderAPI_MakeEdge(C); 

还为gp包中的曲线提供了六种方法(上述五种方法和基本方法)，以取代来自Geom的曲线。这些方法从Geom中创建相应的曲线，并为以下类实现:

gp_Lin创建了一个Geom_Line, gp_Circ创建了一个Geom_Circle, gp_Elips创建了一个Geom_Ellipse, gp_Hypr创建了一个geom_Hyperbola，gp_Parab创建了一个geom_Parabola。

还有两种方法可以从两个顶点或两个点构造边。这些方法假设曲线是一条直线;顶点或点必须有不同的位置。

TopoDS_Vertex V1 = ...,V2 = ...;// two Vertices 
gp_Pnt P1 = ..., P2 = ...;// two points 
TopoDS_Edge E; 
 
// linear edge from two vertices 
E = BRepBuilderAPI_MakeEdge(V1,V2); 
 
// linear edge from two points 
E = BRepBuilderAPI_MakeEdge(P1,P2);

另一些信息和错误状态

类BRepBuilderAPI_MakeEdge可以提供额外的信息并返回一个错误状态。

如果BRepBuilderAPI_MakeEdge被用作一个类，它可以提供两个顶点。当顶点没有作为参数提供时，这很有用，例如，当从曲线和参数构造边缘时。两个方法Vertex1和Vertex2返回顶点。注意，如果沿相应方向打开，则返回的顶点可以为空。

Error方法返回BRepBuilderAPI_EdgeError枚举的一个项。它可以用来分析IsDone方法返回False时的错误。这些项是:

• EdgeDone：没有错误发生，IsDone返回True。
• PointProjectionFailed：没有给出参数，但是3D点在曲线上的投影失败了。如果点到曲线的距离大于精度，就会发生这种情况。
• Parameteroutorange：给定的参数不在C->FirstParameter()， C->LastParameter()范围内
• DifferentPointsOnClosedCurve ：这两个顶点或点有不同的位置，但它们是封闭曲线的端点。
• PointWithInfiniteParameter -一个有限坐标点与一个无限参数相关联(参见Precision包中的无限值定义)。
• DifferentsPointAndParameter -使用参数在曲线上评估的3D点和点的距离大于精度。
• LineThroughIdenticPoints -给出两个相同的点来定义一条线(构造没有曲线的边缘)，gp::Resolution用于测试混淆。

下面的示例创建一个以维度H、L为中心的矩形，圆角半径为r。边和顶点存储在数组theEdges和theVertices中。我们使用类Array1OfShape(即不是边或顶点的数组)。请看下面的图片。

#include <BRepBuilderAPI_MakeEdge.hxx> 
#include <TopoDS_Shape.hxx> 
#include <gp_Circ.hxx> 
#include <gp.hxx> 
#include <TopoDS_Wire.hxx> 
#include <TopTools_Array1OfShape.hxx> 
#include <BRepBuilderAPI_MakeWire.hxx> 
 
// Use MakeArc method to make an edge and two vertices 
void MakeArc(Standard_Real x,Standard_Real y, 
Standard_Real R, 
Standard_Real ang, 
TopoDS_Shape& E, 
TopoDS_Shape& V1, 
TopoDS_Shape& V2) 
{ 
gp_Ax2 Origin = gp::XOY(); 
gp_Vec Offset(x, y, 0.); 
Origin.Translate(Offset); 
BRepBuilderAPI_MakeEdge 
ME(gp_Circ(Origin,R),  ang, ang+PI/2); 
E = ME; 
V1 = ME.Vertex1(); 
V2 = ME.Vertex2(); 
} 
 
TopoDS_Wire MakeFilletedRectangle(const Standard_Real H, 
const Standard_Real L, 
const Standard_Real  R) 
{ 
TopTools_Array1OfShape theEdges(1,8); 
TopTools_Array1OfShape theVertices(1,8); 
 
// First create the circular edges and the vertices 
// using the MakeArc function described above. 
void MakeArc(Standard_Real, Standard_Real, 
Standard_Real, Standard_Real, 
TopoDS_Shape&, TopoDS_Shape&,  TopoDS_Shape&); 
 
Standard_Real x = L/2 - R, y = H/2 - R; 
MakeArc(x,-y,R,3.*PI/2.,theEdges(2),theVertices(2), 
theVertices(3)); 
MakeArc(x,y,R,0.,theEdges(4),theVertices(4), 
theVertices(5)); 
MakeArc(-x,y,R,PI/2.,theEdges(6),theVertices(6), 
theVertices(7)); 
MakeArc(-x,-y,R,PI,theEdges(8),theVertices(8), 
theVertices(1)); 
// Create the linear edges 
for (Standard_Integer i = 1; i <= 7; i += 2) 
{ 
theEdges(i) = BRepBuilderAPI_MakeEdge 
(TopoDS::Vertex(theVertices(i)),TopoDS::Vertex 
(theVertices(i+1))); 
} 
// Create the wire using the BRepBuilderAPI_MakeWire 
BRepBuilderAPI_MakeWire MW; 
for (i = 1; i <= 8; i++) 
{ 
MW.Add(TopoDS::Edge(theEdges(i))); 
} 
return MW.Wire(); 
} 

2D边

使用BRepBuilderAPI_MakeEdge2d类从2d曲线在工作平面上制作边缘。工作平面是BRepBuilderAPI包的默认值(参见plane方法)。

BRepBuilderAPI_MakeEdge2d类严格类似于BRepBuilderAPI_MakeEdge，但它使用gp和Geom2d的2D几何形状，而不是3D几何形状。

多边形

BRepBuilderAPI_MakePolygon类用于从顶点或点构建多边形线。点自动更改为顶点在BRepBuilderAPI_MakeEdge。

BRepBuilderAPI_MakePolygon的基本用法是通过使用Add方法添加顶点或点来创建线。在任何时刻，线都可以被提取出来。闭合方法可用于闭合线。在下面的示例中，从点的数组创建一个封闭的线。

#include <TopoDS_Wire.hxx> 
#include <BRepBuilderAPI_MakePolygon.hxx> 
#include <TColgp_Array1OfPnt.hxx> 
 
TopoDS_Wire ClosedPolygon(const TColgp_Array1OfPnt&  Points) 
{ 
BRepBuilderAPI_MakePolygon MP; 
for(Standard_Integer i=Points.Lower();i=Points.Upper();i++) 
{ 
MP.Add(Points(i)); 
} 
MP.Close(); 
return MP; 
} 

为2,3或4个点或顶点提供了快捷方式。这些方法的最后一个参数是布尔值，用来判断多边形是否闭合。默认值为False。

两个例子:

一个由三个顶点组成的封闭三角形的例子:

TopoDS_Wire W =  BRepBuilderAPI_MakePolygon(V1,V2,V3,Standard_True); 

一个由四个点组成的开放多边形的例子:

TopoDS_Wire W = BRepBuilderAPI_MakePolygon(P1,P2,P3,P4); 

BRepBuilderAPI_MakePolygon类维护当前连线。目前的线可以随时抽出，并可以进行处理更长的线。在每个点插入之后，类维护最后创建的边和顶点，它们由Edge、FirstVertex和LastVertex方法返回。

当添加的点或顶点与前一个位置相同时，它不会添加到当前线中，但最近创建的边变为Null。add方法可用于测试此条件。MakePolygon类永远不会引发错误。如果没有添加顶点，则Wire为Null。如果两个顶点在同一位置，则不会创建任何边。

面

使用BRepBuilderAPI_MakeFace类从表面和线创建一个面。底层曲面由曲面和可选参数值构造而成。线可以添加到曲面上。一个平面可以由线构成。面构建后可返回错误状态。

基础面的构造方法

一个面可以由一个表面和四个参数来确定紫外空间的限制。参数是可选的，如果省略它们，则使用表面的自然边界。最多可以用导线创建四个边和顶点。当参数为无穷大时，不会创建任何边。

Handle(Geom_Surface) S = ...; // a surface 
Standard_Real umin,umax,vmin,vmax; // parameters 
TopoDS_Face F =  BRepBuilderAPI_MakeFace(S,umin,umax,vmin,vmax); 

要从曲面的自然边界制作一个面，不需要以下参数:

Handle(Geom_Surface) S = ...; // a surface 
TopoDS_Face F = BRepBuilderAPI_MakeFace(S); 

参数的约束类似于BRepBuilderAPI_MakeEdge中的约束。

• Umin,umax (vmin,vmax)必须在曲面范围内，且必须是递增的。
• 在U (V)周期曲面上调整umin和umax (vmin,vmax)。
• Umin, umax, vmin, vmax可以是无穷大。在相应的方向上没有边。

附加面的构造方法

这两种基本构造(从曲面和从曲面和参数)实现了所有gp包表面，它们在相应的Surface中从Geom转换。

gp package surface		Geom package surface
gp_Pln		Geom_Plane
gp_Cylinder		Geom_CylindricalSurface
gp_Cone	creates a	Geom_ConicalSurface
gp_Sphere		Geom_SphericalSurface
gp_Torus		Geom_ToroidalSurface

一旦创建了一个面，就可以使用Add方法添加一条线。例如，下面的代码创建一个圆柱形表面并添加一条线。

gp_Cylinder C = ..; // a cylinder 
TopoDS_Wire W = ...;// a wire 
BRepBuilderAPI_MakeFace MF(C); 
MF.Add(W); 
TopoDS_Face F = MF; 

在一个曲面上可以添加一条以上的线，只要它们不相互交叉并且它们只定义曲面上的一个区域。(请注意，此选项未勾选)。

对于一根线，提供了一个简单的语法来从曲面和线构造面。以上几行可以写成:

TopoDS_Face F = BRepBuilderAPI_MakeFace(C,W); 

面上的边缘必须有参数化曲线描述。如果线的某条边在曲面上没有参数曲线，则采用投影法计算，而且只能对平面表面进行计算。

只要线定义了平面，就可以仅用线创建平面。例如，要从一组点创建一个平面面，你可以使用BRepBuilderAPI_MakePolygon和BRepBuilderAPI_MakeFace。

#include <TopoDS_Face.hxx> 
#include <TColgp_Array1OfPnt.hxx> 
#include <BRepBuilderAPI_MakePolygon.hxx> 
#include <BRepBuilderAPI_MakeFace.hxx> 
 
TopoDS_Face PolygonalFace(const TColgp_Array1OfPnt&  thePnts) 
{ 
BRepBuilderAPI_MakePolygon MP; 
for(Standard_Integer i=thePnts.Lower(); 
i<=thePnts.Upper(); i++) 
{ 
MP.Add(thePnts(i)); 
} 
MP.Close(); 
TopoDS_Face F = BRepBuilderAPI_MakeFace(MP.Wire()); 
return F; 
} 

MakeFace的最后一个用途是复制一个现有的面来添加新的线。例如，下面的代码将一个新的线添加到一个面:

TopoDS_Face F = ...; // a face 
TopoDS_Wire W = ...; // a wire 
F = BRepBuilderAPI_MakeFace(F,W); 

要添加多个线，可以创建一个BRepBuilderAPI_MakeFace类的实例，并使用add方法插入面和第一条线以及新线。

错误状态

Error方法返回一个错误状态，这是来自BRepBuilderAPI_FaceError枚举的一个术语。

FaceDone ：没有错误发生。

NoFace ：不初始化算法;使用了空构造函数。

NotPlanar ：没有给出曲面，导线也不是平面的。

CurveProjectionFailed：在曲面的参数空间中没有找到边缘的曲线。

Parametersoutorange：参数umin, umax, vmin, vmax都不在曲面中。

线

线是一个复合形状，不是由一个几何形状，而是由边缘的组装。BRepBuilderAPI_MakeWire类可以从一个或多个边构建一个线，或者将新边连接到现有的线。

最多可直接使用四条边，例如:

TopoDS_Wire W = BRepBuilderAPI_MakeWire(E1,E2,E3,E4); 

对于更高或未知数量的边，必须使用Add方法;例如，从一组形状(作为边)构建一条线。

TopTools_Array1OfShapes theEdges; 
BRepBuilderAPI_MakeWire MW; 
for (Standard_Integer i = theEdge.Lower(); 
i <= theEdges.Upper(); i++) 
MW.Add(TopoDS::Edge(theEdges(i)); 
TopoDS_Wire W = MW; 

类可以用线构造。也可以加一根线。在这种情况下，所有的线的边缘被添加。例如合并两条线:

#include <TopoDS_Wire.hxx> 
#include <BRepBuilderAPI_MakeWire.hxx> 
 
TopoDS_Wire MergeWires (const TopoDS_Wire& W1, 
const  TopoDS_Wire& W2) 
{ 
BRepBuilderAPI_MakeWire MW(W1); 
MW.Add(W2); 
return MW; 
} 

BRepBuilderAPI_MakeWire类将边缘连接到线上。当添加一条新边时，如果它的一个顶点与线共享，则认为它与导线。如果没有共享顶点，则算法搜索位于相同位置的边的顶点和线的顶点(顶点的公差用于测试它们是否具有相同的位置)。如果找到了这样一对顶点，则用线的顶点代替原始顶点复制边缘。边的所有顶点都可以交换为线上的顶点。

BRepBuilderAPI_MakeWire类可以返回添加到连线的最后一条边(edge方法)。如果复制了这条边，它可能与原始边不同。

Error方法返回BRepBuilderAPI_WireError枚举的一个项:

• WireDone：没有错误发生。
• EmptyWire：没有初始化算法，使用了一个空的构造函数。
• DisconnectedWire：最后添加的边缘没有连接到线上。
• NonManifoldWire：有一些奇点的线。

壳

壳是一个复合形状，不是由几何形状，而是由面组装而成。使用BRepBuilderAPI_MakeShell类从一组Faces构建Shell。重要的是，每一个面都应该有必要的连续性。这就是为什么最初的表面被分解成面。

实体

实体是一种复合形状，不是由几何形状构成的，而是由壳的组装而成的。使用BRepBuilderAPI_MakeSolid类从一组shell构建一个Solid。它的使用类似于MakeWire类的使用:将壳添加到实体中，就像在MakeWire中将边缘添加到线中一样。

基础对象

BRepPrimAPI包为构造基础对象提供了一个API(应用程序编程接口)，例如:

• 盒子;
• 圆台;
• 柱体;
• 棱镜;

创建基础对象

盒子

类BRepPrimAPI_MakeBox允许构建一个平行六面体盒子。结果要么是Shell，要么是Solid。有四种方法可以构建一个盒子:

• 从三维的dx dy dz。盒子平行于坐标轴并延伸为[0,dx] [0,dy] [0,dz]。
• 从一个点到三维。和上面一样，但是这个点是新的原点。
• 从两点开始，盒子平行于坐标轴，并在两点坐标定义的间隔上延伸。
• 从gp_Ax2轴和三维坐标系出发。和第一种方法一样，但是盒子平行于给定的轴系。

如果使用默认精度，该框在任何维度上都是平坦的，则会引发错误。下面的代码展示了如何创建一个框:

TopoDS_Solid theBox = BRepPrimAPI_MakeBox(10.,20.,30.); 

构建方框的四种方法如图所示:

锥体

BRepPrimAPI_MakeWedge类允许构建一个楔形，这是一个倾斜的盒子，即一个有角度的盒子。楔形的构造方式与盒子的构造方式大致相同，即由三维dx,dy,dz加上参数，或由轴系，三维和参数构成。

下图显示了构建楔形的两种方法。一种是增加一个维度ltx，这是脸在x点的长度，第二种是增加xmin, xmax, zmin和zmax来描述面在dy点的长度。

第一个方法是第二个方法的特殊情况，其中xmin = 0, xmax = ltx, zmin = 0, zmax = dz。要制作居中金字塔，可以使用xmin = xmax = dx / 2, zmin = zmax = dz / 2。

旋转体

BRepPrimAPI_MakeOneAxis是一个延迟的类，用于所有构造旋转的基础对象的类的根类。旋转基元是通过绕轴旋转曲线来创建的。它们包括圆柱、圆锥、球面、环面和提供所有其他曲线的旋转。

描述了这些基础对象的特定结构，但它们都有一些共同的参数，它们是:

• 一个坐标系，其中Z轴是旋转轴。
• 在[0,2*PI]范围内的角度。
• 一个vmin、vmax参数范围的曲线。

OneAxis构造的结果是一个实体、一个壳或一个面。面是覆盖旋转表面的面。请记住，您不会直接使用OneAxis，而是使用一个派生类，它提供了改进的结构。下图展示了OneAxis参数。

柱体

Breprimapi_MakeCylder类允许创建圆柱形基础对象。圆柱体可以在默认坐标系中创建，也可以在给定坐标系gp_Ax2中创建。有两种结构:

• 半径和高度，来构建一个完整的圆柱体。
• 半径，高度和角度，以建立一个圆柱体的一部分。

下面的代码构建图形的圆柱面，它是沿Y轴的圆柱面的四分之一，原点为X,Y,Z，长度为DY，半径为R。

Standard_Real X = 20, Y = 10, Z = 15, R = 10, DY = 30; 
// Make the system of coordinates 
gp_Ax2 axes = gp::ZOX(); 
axes.Translate(gp_Vec(X,Y,Z)); 
TopoDS_Face F = 
BRepPrimAPI_MakeCylinder(axes,R,DY,PI/2.);

圆台

BRepPrimAPI_MakeCone类允许创建圆锥形基础对象。与圆柱体一样，锥体可以在默认坐标系中创建，也可以在给定坐标系(gp_Ax2)中创建。有两种结构:

• 两个半径和高度，构建一个完整的圆锥体。其中一个半径可以为零，以形成一个尖锐的锥体。
• 半径，高度和角度，以建立一个截锥形。

下面的代码构建图形的实心锥体，它位于默认系统中，半径为R1和R2，高度为H。

Standard_Real R1 = 30, R2 = 10, H = 15; 
TopoDS_Solid S = BRepPrimAPI_MakeCone(R1,R2,H); 

球

BRepPrimAPI_MakeSphere类允许创建球形原语。与圆柱体一样，球体可以在默认坐标系中创建，也可以在给定坐标系gp_Ax2中创建。有四种结构:

• 从半径-建立一个完整的球体。
• 从半径和角度-建立一个月形。
• 从一个半径和两个角度-在两个纬度之间建立一个环绕球面段。角a1和a2必须符合这样的关系:PI/2 <= a1 < a2 <= PI/2。
• 从一个半径和三个角度-前两种方法的组合建立一个球形段的一部分。

下面的代码从一个半径和三个角度构建了四个球体。

Standard_Real R = 30, ang = 
    PI/2, a1 = -PI/2.3,  a2 = PI/4; 
TopoDS_Solid S1 = BRepPrimAPI_MakeSphere(R); 
TopoDS_Solid S2 = BRepPrimAPI_MakeSphere(R,ang); 
TopoDS_Solid S3 = BRepPrimAPI_MakeSphere(R,a1,a2); 
TopoDS_Solid S4 = BRepPrimAPI_MakeSphere(R,a1,a2,ang); 

注意，我们同样可以选择创建shell而不是solid。

圆环面

Breprrimapi_MakeTorus类允许创建环面基元。与其他基元一样，环面是在默认坐标系或给定坐标系gp_Ax2中创建的。与球体结构类似的结构有四种:

• 两个半径-构建一个完整的环面。
• 两个半径和一个角-建立一个角环面段。
• 两个半径和两个角度-在两个径向平面之间建立一个环绕环面段。角a1、a2必须符合0 < a2 - a1 < 2*PI的关系。
• 两个半径和三个角度——前两种方法的组合构建了环面形状的一部分

下面的代码从两个半径和三个角度构建四个环面壳。

Standard_Real R1 = 30, R2 = 10, ang = PI, a1 = 0, 
    a2 = PI/2; 
TopoDS_Shell S1 = BRepPrimAPI_MakeTorus(R1,R2); 
TopoDS_Shell S2 = BRepPrimAPI_MakeTorus(R1,R2,ang); 
TopoDS_Shell S3 = BRepPrimAPI_MakeTorus(R1,R2,a1,a2); 
TopoDS_Shell S4 = 
    BRepPrimAPI_MakeTorus(R1,R2,a1,a2,ang); 

注意，我们同样可以选择创建实体而不是壳。

旋转

Breprrimapi_MakeRevolution类允许从曲线构建单轴原语。与其他单轴原语一样，它可以在默认坐标系或给定坐标系中创建。

曲线可以是任意的Geom_Curve，只要它是平面的，并且与本地坐标系的z轴在同一平面上。有四种结构模式:

• 从一个曲线，使用完整的曲线，使一个完整的旋转。
• 从一条曲线和一个旋转角度。
• 从一条曲线和两个参数来裁剪曲线。这两个参数必须是递增的，且在曲线范围内。
• 从一条曲线，两个参数和一个角度。这两个参数必须是递增的，且在曲线范围内。

扫掠：棱镜，旋转和管道

扫掠

扫描是通过沿着路径扫描轮廓获得的对象。该轮廓可以是任何拓扑结构。路径通常是一条曲线或一条线。轮廓根据以下规则生成对象:

• 顶点生成边
• 边生成面。
• 线生成shell。
• 面生成实体。
• 壳生成复合实体

禁止扫略实体和复合实体。一个复合对象生成一个复合对象，并扫描它的所有元素。

棱镜

BRepPrimAPI_MakeSweep类是一个延迟的类，用作以下扫描类的根:

• Breprrimapi_MakePrism—生成线性扫描
• Breprrimapi_MakeRevol —产生一个旋转扫描
• BRepPrimAPI_MakePipe—生成一个常规扫描。

BRepPrimAPI_MakePrism类允许从形状和矢量或方向创建线性棱镜。

• 矢量允许创建有限棱镜;
• 一个方向允许创建无限或半无限棱镜。半无限或无限棱镜是通过布尔参数切换的。所有构造函数都有一个布尔参数来复制原始形状或共享它(默认情况下)。

下面的代码使用面、方向和长度创建有限、无限和半无限的实体。

TopoDS_Face F = ..; // The swept face 
gp_Dir direc(0,0,1); 
Standard_Real l = 10; 
// create a vector from the direction and the length 
gp_Vec v = direc; 
v *= l; 
TopoDS_Solid P1 = BRepPrimAPI_MakePrism(F,v); 
// finite 
TopoDS_Solid P2 = BRepPrimAPI_MakePrism(F,direc); 
// infinite 
TopoDS_Solid P3 =  BRepPrimAPI_MakePrism(F,direc,Standard_False); 
// semi-infinite 

旋转

BRepPrimAPI_MakeRevol类允许从形状、轴(gp_Ax1)和角度创建旋转扫描。这个角度的默认值是2*PI，这意味着一个封闭的公转。

Breprrimapi_MakeRevol构造函数有最后一个参数来复制或共享原始形状。下面的代码使用一个面、一个轴和一个角度创建一个完全旋转和一个部分旋转。

TopoDS_Face F = ...; // the profile 
gp_Ax1 axis(gp_Pnt(0,0,0),gp_Dir(0,0,1)); 
Standard_Real ang = PI/3; 
TopoDS_Solid R1 = BRepPrimAPI_MakeRevol(F,axis); 
// Full revol 
TopoDS_Solid R2 = BRepPrimAPI_MakeRevol(F,axis,ang); 

布尔运算

布尔运算用于从两组形状的组合中创建新形状。

Operation	Result
Fuse	在S1或S2中的所有点
Common	在S1和S2中的所有点
Cut S1 by S2	所有在S1中、而不在S2中的点

从拓扑学的角度来看，这些是拓扑操作之后的混合(将圆角放在拓扑操作后创建的边缘上)。

拓扑操作是创建真实工业部件最方便的方法。由于大多数工业零件由几个简单的元素组成，如齿轮，臂，孔，肋，管和管道。通常很容易分别创建这些元素，然后在整个最后部分通过布尔运算将它们组合起来。

输入和结果参数

布尔运算具有以下类型的参数，并产生以下结果:

• 对于具有相同形状类型的参数(例如SOLID / SOLID)，生成的形状类型将是一个COMPOUND，包含这种类型的形状;
• 对于具有不同形状类型的参数(例如SHELL / SOLID)，结果形状的类型将是一个COMPOUND，包含与参数的low类型相同的类型的形状。示例:对于SHELL/SOLID，结果是SHELL的COMPOUND。
• 对于具有不同形状类型的参数，由于结果的非流形类型，一些布尔运算不能使用默认实现来完成。例如:不能执行SHELL和SOLID的FUSE操作，但可以执行CUT操作，其中SHELL是对象，SOLID是工具。
• 可以对COMPOUND形状类型的参数执行布尔运算。在这种情况下，每个复合对象不能是异质的，即它必须包含等维形状(边或/和线，面或/和壳，固体)。复合对象内的实体不得相互接触(相交或接触)。壳或面、线或边也应遵守同样的条件。
• 不支持COMPSOLID形状类型的布尔运算。

执行

BRepAlgoAPI_BooleanOperation类是布尔操作的延迟根类。

Fuse

BRepAlgoAPI_Fuse执行Fuse操作。

TopoDS_Shape A = ..., B = ...; 
TopoDS_Shape S = BRepAlgoAPI_Fuse(A,B); 

Common

BRepAlgoAPI_Common执行普通操作。

TopoDS_Shape A = ..., B = ...; 
TopoDS_Shape S = BRepAlgoAPI_Common(A,B); 

Cut

BRepAlgoAPI_Cut执行Cut操作。

TopoDS_Shape A = ..., B = ...; 
TopoDS_Shape S = BRepAlgoAPI_Cut(A,B); 

Section

BRepAlgoAPI_Section执行该section，描述为由TopoDS_Edge组成的TopoDS_Compound。

TopoDS_Shape A = ...,  TopoDS_ShapeB = ...; 
TopoDS_Shape S =  BRepAlgoAPI_Section(A,B); 

拓扑工具

OCCT提供算法：

从边缘创建线;

用线创造出面孔;

计算该形状相对于其他形状的状态;

在容器中定位形状;

从现有的形状中创建新的形状;

在面上建立边缘的p曲线;

检查形状的有效性;

获取面上的点;

获取面上的法线方向。

从线框模型中创建面

可以从三维空间中随机设置的任意平面边集创建平面面。这个功能可能是有用的，如果你需要从线框模型中恢复形状:

为了从边缘制作面，首先需要从给定的边缘创建平面线，然后从每条线创建平面面。静态方法BOPAlgo_Tools::EdgesToWires和BOPAlgo_Tools::WiresToFaces可以用于此:

TopoDS_Shape anEdges = ...; /* The input edges */
Standard_Real anAngTol = 1.e-8; /* The angular tolerance for distinguishing the planes in which the wires are located */
Standard_Boolean bShared = Standard_False; /* Defines whether the edges are shared or not */
//
TopoDS_Shape aWires; /* resulting wires */
Standard_Integer iErr = BOPAlgo_Tools::EdgesToWires(anEdges, aWires, bShared, anAngTol);
if (iErr) {
  cout << "Error: Unable to build wires from given edges\n";
  return;
}
//
TopoDS_Shape aFaces; /* resulting faces */
Standard_Boolean bDone = BOPAlgo_Tools::WiresToFaces(aWires, aFaces, anAngTol);
if (!bDone) {
  cout << "Error: Unable to build faces from wires\n";
  return;
}

这些方法也可以单独使用:

• BOPAlgo_Tools::EdgesToWires允许从边缘创建平面线。输入边可能不共享，但输出线将共享重合的顶点和边。为此，执行了边的相交。但是，通过将相应的标志传递到方法中，可以跳过相交阶段(如果输入边已经被共享)。输入边应该是平面的，但是该方法不检查它。因此，如果输入边不是平面的，输出线也将不是平面的。一般来说，输出线是非流形的，可能包含自由顶点，也可能包含多连接顶点。
• BOPAlgo_Tools::WiresToFaces允许从平面连线创建平面面。一般情况下，输入线是非流形的，可以不闭合，但应该共用重合部分。位于同一平面的导线完全包含在其他导线中，将在由外部导线构建的表面上产生孔:

形状的分类

以下方法可以将不同形状相对于其他形状进行分类:

• BOPTools_AlgoTools::ComputState方法的多样性分类顶点/边缘/面相对固体;
• BOPTools_AlgoTools::IsHole对线材进行相对面分类;
• IntTools_Tools::ClassifyPointByFace对点进行相对面分类。

容器中形状的方向

以下方法允许重新定向容器中的形状:

• BOPTools_AlgoTools::OrientEdgesOnWire正确定向线上的边缘;
• BOPTools_AlgoTools::OrientFacesOnShell正确定向外壳上的面。

创建新形状

以下方法允许从现有形状创建新形状:

• BOPTools_AlgoTools::MakeNewVertex的变化从其他顶点和边创建新的顶点;
• BOPTools_AlgoTools::MakeSplitEdge按给定的参数分割边缘。

创建P曲线

下面的方法允许在面上建立边缘的p曲线:

BOPTools_AlgoTools::BuildPCurveForEdgeOnFace计算面部边缘的PCurve;

• BOPTools_AlgoTools::BuildPCurveForEdgeOnPlane和BOPTools_AlgoTools::BuildPCurveForEdgesOnPlane允许在平面上为边缘构建PCurves;
• BOPTools_AlgoTools::AttachExistingPCurve从一个边缘取面上的PCurve，并将此PCurve附加到与第一个重合的另一个边缘上。

检查形状的有效性

以下方法允许检查形状的有效性:

• BOPTools_AlgoTools::IsMicroEdge检测小边缘;
• BOPTools_AlgoTools::ComputeTolerance计算端面上边缘的正确公差;
• BOPTools_AlgoTools::CorrectShapeTolerances和BOPTools_AlgoTools::CorrectTolerances允许修正子形状的公差。
• BRepLib::FindValidRange查找未被顶点公差球覆盖的边缘的3d曲线范围。

获取面上的点

以下方法可以在面部内部取点:

• BOPTools_AlgoTools3D::PointNearEdge的变化允许在靠近边缘的面部内部获得一个点;
• BOPTools_AlgoTools3D::PointInFace允许在面部内部获得一个点。

获取面上的法线

以下方法允许获得面/表面的法线方向:

• BOPTools_AlgoTools3D::GetNormalToSurface计算由UV参数定义的给定点上表面的法线方向;
• BOPTools_AlgoTools3D::GetNormalToFaceOnEdge在面边缘的点上计算面的法线方向;
• BOPTools_AlgoTools3D::GetApproxNormalToFaceOnEdge在靠近面边缘的点上计算面的法线方向。

Topology API

开放级联技术(OCCT)的拓扑API包括以下六个包:

• BRepAlgoAPI
• BRepBuilderAPI
• BRepFilletAPI
• BRepFeat
• BRepOffsetAPI
• BRepPrimAPI

API提供的类具有以下特性:

• 类的构造函数提供了不同的构造方法;
• 类保留了用于将对象构建为字段的不同工具;
• 该类提供了一个强制转换方法，通过类似函数的调用自动获得结果。

让我们使用类BRepBuilderAPI_MakeEdge从两点创建一条线性边。

gp_Pnt P1(10,0,0), P2(20,0,0); 
TopoDS_Edge E = BRepBuilderAPI_MakeEdge(P1,P2);

这是从两点P1和P2创建边E的最简单方法，但开发人员可以在对数据不像前一个示例那样有信心时测试错误。

#include <gp_Pnt.hxx> 
#include <TopoDS_Edge.hxx> 
#include <BRepBuilderAPI_MakeEdge.hxx> 
void EdgeTest() 
{ 
gp_Pnt P1; 
gp_Pnt P2; 
BRepBuilderAPI_MakeEdge ME(P1,P2); 
if (!ME.IsDone()) 
{ 
// doing ME.Edge() or E = ME here 
// would raise StdFail_NotDone 
Standard_DomainError::Raise 
(“ProcessPoints::Failed to createan edge”); 
} 
TopoDS_Edge E = ME; 
} 

在这个例子中，引入了一个中间对象ME。可以在访问结果之前测试函数是否完成。关于拓扑编程接口中的错误处理的更多信息可以在下一节中找到。

BRepBuilderAPI_MakeEdge提供了有价值的信息。例如，当从两个点创建一条边时，必须从这些点创建两个顶点。有时，您可能对快速获得这些顶点而不探索新边感兴趣。这样的信息可以在使用类时提供。下面的例子展示了一个从两个点创建一条边和两个顶点的函数。

void MakeEdgeAndVertices(const gp_Pnt& P1, 
const gp_Pnt& P2, 
TopoDS_Edge& E, 
TopoDS_Vertex& V1, 
TopoDS_Vertex& V2) 
{ 
BRepBuilderAPI_MakeEdge ME(P1,P2); 
if (!ME.IsDone()) { 
Standard_DomainError::Raise 
(“MakeEdgeAndVerices::Failed  to create an edge”); 
} 
E = ME; 
V1 = ME.Vextex1(); 
V2 = ME.Vertex2(); 

类BRepBuilderAPI_MakeEdge提供了两个方法Vertex1和Vertex2，它们返回用于创建边缘的两个顶点。

BRepBuilderAPI_MakeEdge如何既是一个函数又是一个类?它可以做到这一点，因为它使用了c++的强制转换功能。BRepBuilderAPI_MakeEdge类有一个叫做Edge的方法;在前面的示例中，可以这样写E = ME行。

E = ME.Edge(); 

该指令告诉c++编译器，使用Edge方法将BRepBuilderAPI_MakeEdge隐式转换为TopoDS_Edge。这意味着当在需要TopoDS_Edge的地方找到BRepBuilderAPI_MakeEdge时，会自动调用此方法。

这个特性允许您提供类，这些类在需要时具有函数调用的简单性，在需要高级处理时具有类的强大功能。在描述拓扑编程接口类时解释了这种方法的所有优点。

历史记录支持

所有拓扑API算法都支持其参数的形状修改历史(或仅仅是历史)。通常，历史记录可用于以下类型的输入形状的子形状:

• Vertex
• Edge
• Face

有些算法还支持solid的历史记录。

历史信息包括以下信息:

• 关于已删除形状的信息;
• 关于修改形状的信息;
• 关于生成形状的信息。

History是根据操作结果填充的。历史记录不能返回结果中不包含的任何形状。如果操作的结果是空形状，则所有输入形状都将被认为是已删除的，并且没有任何形状具有已修改和已生成的形状。

历史信息可以通过API方法访问:

• Standard_Boolean IsDeleted(const TopoDS_Shape& theS) -检查形状是否在操作期间被删除;
• const TopTools_ListOfShape& Modified(const TopoDS_Shape& theS) -从给定的形状中获得修改的形状;
• const TopTools_ListOfShape& Generated(const TopoDS_Shape& theS) -获取从给定形状生成的形状。

删除形状

在操作过程中，如果满足以下所有条件，则认为该形状已删除:

• 形状是运算参数形状的一部分;
• 结果形状不包含形状本身;
• 结果形状不包含形状的任何分割。

例如，在两个相交实体之间的CUT操作中，位于工具实体内部的所有顶点/边/面将在操作期间被删除。

修改形状

如果结果形状包含形状的分割，而不是形状本身，则该形状在操作期间被认为是已修改的。该形状只能修改为具有相同尺寸的形状。结果形状中包含的形状的分割是从该形状修改的。修改后的形状是从输入形状的子形状创建的，并且通常重复其几何形状。

Modified元素列表将只包含对操作结果有贡献的元素。如果列表为空，则表示该形状未被修改，需要检查它是否已被删除。

例如，形状在任何方向上翻译后，其所有子形状将被修改为其翻译副本。

生成形状

如果结果形状中包含的形状是在操作期间生成的，并且与创建它们的形状具有不同的维度，则认为它们是从输入形状生成的。

生成的元素列表将只包含那些包含在操作结果中的元素。如果列表为空，则表示没有从该形状生成新的形状。

例如，在某个方向上挤压边缘将创建一个面。这个面将从边缘生成。

BRepTools_History

BRepTools_History是通用的历史工具，用于统一不同算法的历史。

BRepTools_History可以从任何支持标准历史方法的算法中创建*(IsDeleted()， Modified()*和Generated()):

// The arguments of the operation
TopoDS_Shape aS = ...;
 
// Perform transformation on the shape
gp_Trsf aTrsf;
aTrsf.SetTranslationPart(gp_Vec(0, 0, 1));
BRepBuilderAPI_Transform aTransformer(aS, aTrsf); // Transformation API algorithm
const TopoDS_Shape& aRes = aTransformer.Shape();
 
// Create the translation history object
TopTools_ListOfShape anArguments;
anArguments.Append(aS);
BRepTools_History aHistory(anArguments, aTransformer);

BRepTools_History也允许合并历史。因此，如果你有两个或多个后续操作，你可以从这些操作的历史记录中获得一个最终的历史记录:

Handle(BRepTools_History) aHist1 = ...; // History of first operation
Handle(BRepTools_History) aHist2 = ...; // History of second operation

可以将第二个历史合并到第一个历史中:

aHist1->Merge(aHist2);

或者创建新的历史记录，保持两个历史记录不变:

Handle(BRepTools_History) aResHistory = new BRepTools_History;
aResHistory->Merge(aHist1);
aResHistory->Merge(aHist2);

合并历史和从API算法创建历史的可能性允许为新算法提供简单的历史支持。

绘制历史记录

DRAW History对算法的支持由三个基本命令提供:

• 删除的我;
• 修改的;
• 生成的。

有关绘制历史记录机制的更多信息，请参阅绘制用户指南-历史记录命令中的相应章节。

倒角和切削

这个库提供了在形状边缘上制作圆角和倒角的算法。处理以下情况:

• 具有不同半径的角和尖;
• 具有不同凹凸度的角和顶点。

如果存在凹面，则需要扩展的表面和不需要扩展的表面都进行处理。

形状倒角

圆角是用光滑的表面代替锋利的边缘。

BRepFilletAPI_MakeFillet类允许对形状进行切片。

要生成圆角，必须在类的构造中定义圆角形状，并使用add方法添加圆角描述。

圆角描述包含一条边和一条半径。这条边必须由两个面共用。圆角自动扩展到与原始边缘平滑连续的所有边缘。添加两次圆角不是错误，最后一个描述成立。

在下面的示例中，创建一个尺寸为a,b,c，半径为r的圆角盒。

常半径

#include <TopoDS_Shape.hxx> 
#include <TopoDS.hxx> 
#include <BRepPrimAPI_MakeBox.hxx> 
#include <TopoDS_Solid.hxx> 
#include <BRepFilletAPI_MakeFillet.hxx> 
#include <TopExp_Explorer.hxx> 
 
TopoDS_Shape FilletedBox(const Standard_Real a, 
                        const Standard_Real  b, 
                        const Standard_Real  c, 
                        const Standard_Real  r) 
{ 
    TopoDS_Solid Box =  BRepPrimAPI_MakeBox(a,b,c); 
    BRepFilletAPI_MakeFillet  MF(Box); 
 
    // add all the edges  to fillet 
    TopExp_Explorer  ex(Box,TopAbs_EDGE); 
    while (ex.More()) 
    { 
    MF.Add(r,TopoDS::Edge(ex.Current())); 
    ex.Next(); 
    } 
    return MF.Shape(); 
    } 

改变半径

#include <TopoDS_Shape.hxx> 
#include <TopoDS.hxx> 
#include <BRepPrimAPI_MakeBox.hxx> 
#include <TopoDS_Solid.hxx> 
#include <BRepFilletAPI_MakeFillet.hxx> 
#include <TopExp_Explorer.hxx> 
 
TopoDS_Shape FilletedBox(const Standard_Real a, 
                        const Standard_Real  b, 
                        const Standard_Real  c, 
                        const Standard_Real  r) 
{ 
    TopoDS_Solid Box =  BRepPrimAPI_MakeBox(a,b,c); 
    BRepFilletAPI_MakeFillet  MF(Box); 
 
    // add all the edges  to fillet 
    TopExp_Explorer  ex(Box,TopAbs_EDGE); 
    while (ex.More()) 
    { 
    MF.Add(r,TopoDS::Edge(ex.Current())); 
    ex.Next(); 
    } 
    return MF.Shape(); 
    } 

切削

倒角是代替面的尖顶点的直线边缘。

BRepFilletAPI_MakeChamfer类的使用类似于BRepFilletAPI_MakeFillet类的使用，除了以下不同:

• 创造的表面是有规则的，不光滑。
• 用于选择边缘的Add语法需要一个或两个距离，一个边缘和一个面(与边缘相邻)。

Add(dist,  E, F) 
Add(d1,  d2, E, F) with d1 on the face F. 

平面倒角

BRepFilletAPI_MakeFillet2d类允许在平面上构造圆角和倒角。在平面上创建圆角:定义圆角，指定要删除的顶点，并使用AddFillet方法给出圆角半径。

可以使用AddChamfer方法计算倒角。它可以用

• 两条边和两个距离
• 一条边，一个顶点，一个距离和一个角。圆角和倒角在加法完成时计算。

如果面F2是由2D圆角和倒角生成器从面F1创建的，则生成器可以重建(生成器恢复其删除之前的状态)

BRepFilletAPI_MakeFillet2d builder; 
builder.Init(F1,F2); 

面倒角

#include “BRepPrimAPI_MakeBox.hxx” 
#include “TopoDS_Shape.hxx” 
#include “TopExp_Explorer.hxx” 
#include “BRepFilletAPI_MakeFillet2d.hxx” 
#include “TopoDS.hxx” 
#include “TopoDS_Solid.hxx” 
 
TopoDS_Shape FilletFace(const Standard_Real a, 
                        const Standard_Real  b, 
                        const Standard_Real c, 
                        const Standard_Real  r) 
 
{ 
    TopoDS_Solid Box =  BRepPrimAPI_MakeBox (a,b,c); 
    TopExp_Explorer  ex1(Box,TopAbs_FACE); 
 
    const  TopoDS_Face& F = TopoDS::Face(ex1.Current()); 
    BRepFilletAPI_MakeFillet2d  MF(F); 
    TopExp_Explorer  ex2(F, TopAbs_VERTEX); 
    while (ex2.More()) 
    { 
    MF.AddFillet(TopoDS::Vertex(ex2.Current()),r); 
    ex2.Next(); 
    } 
    // while... 
    return MF.Shape(); 
} 

Offsets, Drafts, Pipes and Evolved形状

这些类提供以下服务:

• 创建偏移形状及其变体，例如:
  • 挖空;
  • 抽面;
  • 放样;
• 使用拔模角创造锥形;
• 创建扫掠。

偏移计算

偏移量计算可以使用BRepOffsetAPI_MakeOffsetShape来执行。这个类为两种不同的偏移算法提供API:

基于解析延拓计算的偏移算法。参数含义请参见BRepOffsetAPI_MakeOffsetShape::PerformByJoin方法描述。下面的列表展示了该算法的主要方案:

• 第一步，计算偏移量。
• 之后，计算每个偏移量的解析延拓。
• 根据原始拓扑信息(共享、邻居数等)计算两两相交。
• 偏移形状装配。

第二种算法是，即没有连续的单个面总是可以建立偏移计算。下面的列表显示了简单的偏移算法:

• 每个表面都映射到其几何偏移表面。
• 对于每条边，p曲线被映射到偏移曲面上相同的p曲线。
• 对于每条边，通过在第一个偏移面上重新逼近pcurve来构造三维曲线。
• 结果壳中每个顶点的位置计算为共享该顶点的所有边的端点的平均值。
• 根据生成的几何形状更新公差。简单算法可能存在的缺点是，在一般情况下，它会导致容差增加。为了覆盖输出中相邻面之间的间隙，公差必须增大。应该注意的是，实际公差增长取决于输入面之间的偏移距离和连接质量。无论如何，良好的输入壳(相邻面之间的平滑连接)将导致良好的结果。

下面的代码片段展示了用法示例:

BRepOffsetAPI_MakeOffsetShape OffsetMaker1;
// Computes offset shape using analytical continuation mechanism.
OffsetMaker1.PerformByJoin(Shape, OffsetValue, Tolerance);
if (OffsetMaker1.IsDone())
  NewShape = OffsetMaker1.Shape();
 
BRepOffsetAPI_MakeOffsetShape OffsetMaker2;
// Computes offset shape using simple algorithm.
OffsetMaker2.PerformBySimple(Shape, OffsetValue);
if (OffsetMaker2.IsDone())
  NewShape = OffsetMaker2.Shape();

抽壳

抽壳用于将实体的给定面偏移一个特定的值。根据边缘的凹凸度，它沿其边缘使相邻的面圆或相交。BRepOffsetAPI_MakeThickSolid的MakeThickSolidByJoin方法接受实体、要删除的面列表和偏移量值作为输入。

TopoDS_Solid SolidInitial = ...;
 
Standard_Real           Of      = ...;
TopTools_ListOfShape    LCF;
TopoDS_Shape            Result;
Standard_Real           Tol = Precision::Confusion();
 
for (Standard_Integer i = 1 ;i <= n; i++) {
    TopoDS_Face SF = ...; // a face from SolidInitial
    LCF.Append(SF);
}
 
BRepOffsetAPI_MakeThickSolid SolidMaker;
SolidMaker.MakeThickSolidByJoin(SolidInitial,
                                LCF,
                                Of,
                                Tol);
if (SolidMaker.IsDone())
  Result = SolidMaker.Shape();

也可以创建实体之间的壳，偏移壳。这个功能可以使用BRepOffsetAPI_MakeThickSolid::MakeThickSolidBySimple方法调用。下面的代码显示了使用示例:

BRepOffsetAPI_MakeThickSolid SolidMaker;
SolidMaker.MakeThickSolidBySimple(Shell, OffsetValue);
if (myDone.IsDone())
  Solid = SolidMaker.Shape();

拔模角度

BRepOffsetAPI_DraftAngle类允许通过对其平面，圆柱形和圆锥形面应用拔模角度来修改形状。

类是从一个形状创建或初始化的，然后添加要修改的面;对于每个face，使用三个参数:

• 方向:测量的拔模角度的方向
• 角度:角度的值
• 中性面:面与中性面的交点是不变的。

下面的代码在一个形状的几个面上放置一个拔模角;每个面使用相同的方向、角度和中性面:

TopoDS_Shape myShape = ... 
// The original shape 
TopTools_ListOfShape ListOfFace; 
// Creation of the list of faces to be modified 
... 
 
gp_Dir Direc(0.,0.,1.); 
// Z direction 
Standard_Real Angle = 5.*PI/180.; 
// 5 degree angle 
gp_Pln Neutral(gp_Pnt(0.,0.,5.), Direc); 
// Neutral plane Z=5 
BRepOffsetAPI_DraftAngle theDraft(myShape); 
TopTools_ListIteratorOfListOfShape itl; 
for (itl.Initialize(ListOfFace); itl.More(); itl.Next())  { 
    theDraft.Add(TopoDS::Face(itl.Value()),Direc,Angle,Neutral); 
    if  (!theDraft.AddDone()) { 
        // An error has occurred. The faulty face is given by //  ProblematicShape 
        break; 
        } 
} 
if (!theDraft.AddDone()) { 
    // An error has  occurred 
    TopoDS_Face guilty =  theDraft.ProblematicShape(); 
    ... 
} 
theDraft.Build(); 
if (!theDraft.IsDone()) { 
    // Problem  encountered during reconstruction 
    ... 
} 
else { 
    TopoDS_Shape  myResult = theDraft.Shape(); 
    ... 
} 

管状构建

BRepOffsetAPI_MakePipe类允许从Spine(一个Wire)和Profile(一个Shape)创建管道。此实现仅限于具有平滑过渡的脊线，锐利过渡由BRepOffsetAPI_MakePipeShell处理。更精确地说，连续性必须是G1，这意味着切线在相邻的边缘上必须有相同的方向，尽管不一定是相同的大小。

脊柱和轮廓之间的角度在整个管道中保持不变。

TopoDS_Wire Spine = ...; 
TopoDS_Shape Profile = ...; 
TopoDS_Shape Pipe =  BRepOffsetAPI_MakePipe(Spine,Profile); 

旋转实体

BRepOffsetAPI_MakeEvolved类允许从Spine(平面面或线)和profile(线)创建一个进化的实体。

进化的实体是由脊柱和轮廓产生的无环扫描。

通过在脊柱上扫描轮廓的参考轴来创建提升的实体。坐标轴的原点移动到脊柱，X轴和局部切线重合，Z轴垂直于面。

轮廓线的参考轴可以定义为以下两种不同的模式:

• 轮廓线的参考轴是原点轴。

• 轮廓的参考轴计算如下:

  • 原点是由脊柱上最接近轮廓的点给出的
  • X轴由上面定义的点与脊柱的切线给出
  • Z轴是包含脊柱的平面的法线。

  TopoDS_Face Spine = ...; 
  TopoDS_Wire Profile = ...; 
  TopoDS_Shape Evol = 
  BRepOffsetAPI_MakeEvolved(Spine,Profile); 
  

对象修改

变换

BRepBuilderAPI_Transform类可用于对形状应用转换(参见类gp_Trsf)。这些方法有一个布尔参数，用于复制或共享原始形状，只要转换允许(只可能进行直接等距转换)。默认情况下，共享原始形状。

下面的示例处理形状的旋转。

TopoDS_Shape myShape1 = ...; 
// The original shape 1 
TopoDS_Shape myShape2 = ...; 
// The original shape2 
gp_Trsf T; 
T.SetRotation(gp_Ax1(gp_Pnt(0.,0.,0.),gp_Vec(0.,0.,1.)), 
2.*PI/5.); 
BRepBuilderAPI_Transformation theTrsf(T); 
theTrsf.Perform(myShape1); 
TopoDS_Shape myNewShape1 = theTrsf.Shape() 
theTrsf.Perform(myShape2,Standard_True); 
// Here duplication is forced 
TopoDS_Shape myNewShape2 = theTrsf.Shape() 

复制

使用BRepBuilderAPI_Copy类复制一个形状。这样就形成了一个新的形状。下面以复制实体为例:

TopoDS Solid MySolid; 
....// Creates a solid 
 
TopoDS_Solid myCopy = BRepBuilderAPI_Copy(mySolid); 

TopologyAPI的错误句柄

方法可以在以下两种情况下报告错误:

• 方法的数据或参数不正确，即它们不尊重其规范中方法指定的限制。典型的例子:从两个相同的点创建一个线性边缘，在计算线的方向时很可能导致零除。
• 意想不到的事情发生了。这种情况涵盖了第一类之外的所有错误。包括:中断，方法中的编程错误或由第一个方法调用的另一个方法中的编程错误，参数的不良规范(即一组不预计会失败的参数)。

第二种情况应该随着系统的调试和异常机制的处理而变得越来越异常。使用异常可以避免在调用方法时处理错误状态:这是一种非常繁琐的编程风格。

在第一种情况下，还应该引发异常，因为调用方法应该已经验证了参数，如果它没有这样做，则存在错误。例如，如果在调用MakeEdge之前，您不确定两点是否相同，则必须对这种情况进行测试。

对参数进行这些有效性检查对于编程来说可能是乏味的，并且令人沮丧，因为您可能已经正确地推测该方法将执行两次测试。它不信任你。由于该测试涉及大量计算，因此执行两次也很耗时。

因此，您可能会倾向于采用以下示例中所示的极不可取的编程风格:

#include <Standard_ErrorHandler.hxx> 
try { 
TopoDS_Edge E = BRepBuilderAPI_MakeEdge(P1,P2); 
// go on with the edge 
} 
catch { 
// process the error. 
} 

为了帮助用户，Topology API类只引发异常StdFail_NotDone。任何其他异常都意味着在这个API的设计中发生了无法预料的事情。

只有当用户试图访问计算结果并且原始数据已损坏时，才会引发NotDone异常。在构造类实例时，如果不能完成算法，则设置内部标志NotDone。可以测试此标志，并且在某些情况下可以查询更完整的错误描述。如果用户忽略NotDone状态并尝试访问结果，则会引发异常。

BRepBuilderAPI_MakeEdge ME(P1,P2); 
if (!ME.IsDone()) { 
// doing ME.Edge() or E = ME here 
// would raise StdFail_NotDone 
Standard_DomainError::Raise 
(“ProcessPoints::Failed to create an edge”); 
} 
TopoDS_Edge E = ME; 

缝合

介绍

缝纫允许从一组独立的拓扑元素(面和边)创建连接的拓扑(壳和线)。例如，缝纫可以用来从一个单独的面复合创建一个壳。

区分缝合和其他修改几何形状的程序是很重要的，例如填充孔或间隙、粘合、弯曲曲线和表面等。

缝合不会改变形状的几何表示。缝合适用于没有连接但可以连接的拓扑元素(面，边)，因为它们在几何上是一致的:它增加了拓扑连通性的信息。已经连接的元件在流形缝合的情况下保持不变。

让我们定义几个术语:

• 浮边不属于任何面;
• 自由边界只属于一个面;
• 共享边属于多个面(即流形拓扑中的两个面)。
• 缝合面应该有彼此共享的边缘。
• 缝合边应该有彼此共享的顶点。

缝合算法

缝制算法是形状加工的基本算法之一，缝制算法的质量非常重要。

缝纫算法在类BRepBuilder_Sewing中实现。这个类提供了以下方法:

• 加载全局或局部缝合的初始数据;
• 设置定制参数，如特殊操作方式、公差和输出结果;
• 应用可用于获取外部算法所需的连通性数据的分析方法;
• 加载形状的缝合;

缝合支持大值公差的工作方式。不需要一步一步地重复缝合，同时平稳地增加公差。

也可以将边缘缝到金属丝上，也可以将局部分离的面和边缘缝到形状上。

缝合算法可以细分为几个独立的阶段，其中一些可以使用布尔或其他标志打开或关闭。

简而言之，该算法需要为每个自由边界找到一组合并候选者，并根据一定的标准对其进行筛选，最后将发现的候选者合并并构建最终的缝合形状。

算法的每个阶段或整个算法都可以通过以下参数进行调整:

• 工作公差定义了拓扑元素之间可以缝合的最大距离。这些因素实际上并不是最终的，因为许多其他标准被应用于做出最终决定。
• 最小公差定义了最终形状中最小元素(边)的尺寸。声明缝合后不会创建尺寸小于此值的边。如果遇到这种情况，这种拓扑就会退化。
• 非流形模式允许缝合非流形拓扑。

示例

要连接一组n个连续但独立的面，请执行以下操作:

BRepBuilderAPI_Sewing Sew;
Sew.Add(Face1); 
Sew.Add(Face2); 
...
Sew.Add(Facen); 
Sew.Perform();
TopoDS_Shape result= Sew.SewedShape();

如果所有的面都缝对了，结果就是一个壳。否则，它就是一个复合对象。在一次成功的缝合操作后，所有的面都有一个一致的方向。

容差管理

为了生产一个封闭的外壳，缝纫允许指定工作公差值，超过属于形状的小面尺寸。

然而，如果我们生产一个开壳，如果工作公差值太大(即超过了位于开放边界上的面的尺寸)，则可能会得到不正确的缝纫结果。

以下建议可用于调整缝纫过程:

• 使用尽可能小的工作公差。这将减少缝纫时间，因此，不正确缝制边缘的壳与自由边界的数量。
• 使用尽可能大的最小公差。这将减少形状中的小几何形状的数量，无论是原始的还是切割后出现的。
• 如果期望通过缝纫得到有孔(自由边界)的壳体，则应将工作公差设置为不大于最小单元(边)的尺寸或该自由边界的单元之间的最小距离的值。否则，自由边界只能部分地缝合。
• 需要指出的是，缝制算法无法理解应该保留哪个小(小于工作公差)的自由边界，应该缝制哪个边界。

流形和非流形

为了从一组面中创建一个或多个壳，缝纫将属于不同面或一个封闭面的边合并在一起。

面缝支持多种和非多种模式。流形模式只能产生一个流形外壳。缝纫应在非流形模式下使用，以创建非流形外壳。

面形缝只将属于不同面或一个封闭面的最近的两条边合并在一起。面的非流形缝将所有边以小于规定公差的距离合并。

对于复杂的拓扑结构，建议先应用歧管缝，然后应用非歧管缝，以尽可能减小工作公差。但是，对于简单的拓扑来说，这不是必需的。

给非流形缝合一个大的公差值将导致很多不正确，因为所有附近的几何形状将被缝合。

局部缝合

如果一个形状在缝制后仍有一些未缝制的面或边缘，则可以使用更大公差的局部缝制。

局部缝纫尤其适用于开壳。它允许在形状的一部分缝一个不需要的孔，并保持一个所需的孔，这比在形状的另一部分为局部缝制指定的工作公差小。局部缝制比整体缝制要快得多。

所有预先存在的整体形状的连接都在局部缝制后保留。

例如，如果你想用局部缝线缝合两个有重合自由边的开壳，有必要从两个壳中创建一个复合，然后使用方法BRepBuilderAPI_Sewing:: load()加载完整的复合。之后需要添加局部子形状，应该使用方法BRepBuilderAPI_Sewing:: add()来缝制。缝纫的结果可以使用方法BRepBuilderAPI_Sewing::SewedShape()获得。

看一个示例

//initial sewn shapes
TopoDS_Shape aS1, aS2;  // these shapes are expected to be well sewn shells
TopoDS_Shape aComp;
BRep_Builder aB;
aB.MakeCompound(aComp);
aB.Add(aComp, aS1);
aB.Add(aComp, aS2);
................................
aSewing.Load(aComp);
 
//sub shapes which should be locally sewed
aSewing.Add(aF1);
aSewing.Add(aF2);
//performing sewing
aSewing.Perform();
//result shape
TopoDS_Shape aRes = aSewing.SewedShape();

特征

BRepFeat包中包含的这个库对于创建和操作超越经典形状边界表示的形式和机械特征是必要的。从这个意义上说，BRepFeat是BRepBuilderAPI包的扩展。

形状特征

形状特征是凹陷或突出，包括以下类型:

• 柱体;
• 拔模棱镜;
• 棱镜;
• 旋转特性;
• 管道。

根据你是想做一个凹陷还是突出，你可以选择移除物质(布尔剪切:熔合等于0)或添加物质(布尔融合:融合等于1)。

形状特征创建的语义基于形状的构造:

• 在一定的长度，在一定的方向;
• 直至限位面;
• 从某一高度的限制面;
• 在平面之上或之下的

定义特征结构的形状既可以是支撑边，也可以是面部的相关区域。

在有支撑边的情况下，该轮廓可以通过绑定附着在基形的一个面上。当轮廓被绑定到该面上时，轮廓将在该面上滑动的信息将提供给相关的类方法。例如，对于面的相关区域，您可以将其切割出来并在不同的高度移动，这定义了突出或凹陷的限制面。

具有这种局部操作的拓扑定义使计算比全局操作更简单、更快。后者将需要第二阶段去除不需要的物质以获得相同的结果。

Form来自 BRepFeat包是一个延迟的类，用作表单特性的根。它继承了来自BRepBuilderAPI的MakeShape，并提供了跟踪所有子形状的方法的实现。

棱镜

类BRepFeat_MakePrism用于构建与形状交互的棱镜。它被创建或初始化

• 形状(基本形状)、
• 棱柱的基底、
• 面(已在其上定义基底并用于确定基底是否已在基本形状上定义的草图面)、
• 一个方向，
• 一个布尔值表示对基本形状的操作类型(融合=突出或切割=凹陷)，
• 另一个布尔值表示是否必须找到自交(并非在每种情况下都使用)。

有六种Perform方法:

Method	Description
Perform(Height)	所得到的棱镜具有给定的长度。
Perform(Until)	棱镜在基座的位置和给定的表面之间定义
Perform(From, Until)	棱镜被定义在两个面之间From和Until。
PerformUntilEnd()	棱镜是半无限的，受限于基座的实际位置。
PerformFromEnd(Until)	棱镜是半无限的，受限于面直到。
PerformThruAll()	棱镜是无限的。在凹陷的情况下，结果类似于用无限棱镜切割。在凸出的情况下，结果中不保留无限部分。

请注意，Add方法可以在Perform方法之前使用，以指示由边缘生成的面滑入基本形状的面。

在以下顺序中，执行突出，即将形状的一个面更改为棱镜。

TopoDS_Shape Sbase = ...;  // an initial shape 
TopoDS_Face Fbase = ....; // a base of prism 
 
gp_Dir Extrusion (.,.,.); 
 
// An empty face is given as the sketch face 
 
BRepFeat_MakePrism thePrism(Sbase, Fbase, TopoDS_Face(),  Extrusion, Standard_True, Standard_True); 
 
thePrism, Perform(100.); 
if (thePrism.IsDone()) { 
    TopoDS_Shape  theResult = thePrism; 
    ... 
} 

拔模棱镜

类BRepFeat_MakeDPrism用于构建与基本形状交互的草稿棱镜拓扑。这些可能是凹陷或突出。创建或初始化一个类对象:

• 一个形状(基本形状)，
• 棱镜的底部，
• 一个面(在草图的面上定义了基础，并用于确定基础是否已在基本形状上定义)，
• 一个角度，
• 一个布尔值，表示基本形状上的操作类型(融合=突出或切割=凹陷)，
• 另一个布尔值表示是否必须找到自交(并非在每种情况下都使用)。

显然，MakeDPrism的输入数据与MakePrism相同，除了增加了一个参数Angle和缺少了一个参数Direction:棱镜生成的方向是自动确定为棱镜基部的法线。拔模棱镜特征创建的语义是基于形状的构造:

• 沿长度
• 直至极限面，
• 从极限面至高度。

所述拔模棱镜特征的形状定义结构可以是支撑边或面的有关区域。

在支撑边的情况下，该轮廓可以通过绑定附着在基形的一个面上。当轮廓被绑定到该面上时，轮廓将在该面上滑动的信息将提供给相关的类方法。对于面部的相关区域，可以将其切割出来并移动到不同的高度，这将定义一个突出或凹陷方向的限制面部。

Perform方法与MakePrism的方法相同。

TopoDS_Shape S = BRepPrimAPI_MakeBox(400.,250.,300.); 
TopExp_Explorer Ex; 
Ex.Init(S,TopAbs_FACE); 
Ex.Next(); 
Ex.Next(); 
Ex.Next(); 
Ex.Next(); 
Ex.Next(); 
TopoDS_Face F = TopoDS::Face(Ex.Current()); 
Handle(Geom_Surface) surf = BRep_Tool::Surface(F); 
gp_Circ2d 
c(gp_Ax2d(gp_Pnt2d(200.,130.),gp_Dir2d(1.,0.)),50.); 
BRepBuilderAPI_MakeWire MW; 
Handle(Geom2d_Curve) aline = new Geom2d_Circle(c); 
MW.Add(BRepBuilderAPI_MakeEdge(aline,surf,0.,PI)); 
MW.Add(BRepBuilderAPI_MakeEdge(aline,surf,PI,2.*PI)); 
BRepBuilderAPI_MakeFace MKF; 
MKF.Init(surf,Standard_False); 
MKF.Add(MW.Wire()); 
TopoDS_Face FP = MKF.Face(); 
BRepLib::BuildCurves3d(FP); 
BRepFeat_MakeDPrism MKDP (S,FP,F,10*PI180,Standard_True, 
                            Standard_True); 
MKDP.Perform(200); 
TopoDS_Shape res1 = MKDP.Shape(); 

旋转

类BRepFeat_MakeRevol用于构建与形状交互的旋转。它被创建或初始化从:

• 一个形状(基本形状)，
• 旋转的基础，
• 一个面(已经定义了基础并用于确定基础是否已经定义在基本形状上的草图的面)，
• 一个旋转轴，
• 一个布尔值表示基本形状上的操作类型(融合=突出或切割=凹陷)，
• 另一个布尔值表示是否必须找到自交(并非在每种情况下都使用)。

有四种Perform方法:

Method	Description
Perform(Angle)	由此产生的公转具有给定的量级。
Perform(Until)	旋转是在基座的实际位置和给定的面之间定义的。
Perform(From, Until)	旋转是在两个面之间定义的，From 和 Until.
PerformThruAll()	结果类似于Perform(2*PI)

请注意，Add方法可以在Perform方法之前使用，以指示由边缘生成的面滑入基本形状的面。

在下面的序列中，一个面被旋转，并且旋转被一个基本形状的面所限制。

TopoDS_Shape Sbase = ...;  // an initial shape 
TopoDS_Face Frevol = ....; // a base of prism 
TopoDS_Face FUntil = ....; // face limiting the revol 
 
gp_Dir RevolDir (.,.,.); 
gp_Ax1 RevolAx(gp_Pnt(.,.,.), RevolDir); 
 
// An empty face is given as the sketch face 
 
BRepFeat_MakeRevol theRevol(Sbase, Frevol, TopoDS_Face(), RevolAx,  Standard_True, Standard_True); 
 
theRevol.Perform(FUntil); 
if (theRevol.IsDone()) { 
    TopoDS_Shape  theResult = theRevol; 
    ... 
} 

管道

类BRepFeat_MakePipe构造具有管道特征的复合形状:凹陷或突出。创建或初始化一个类对象:

• 一个形状(基本形状)，
• 一个基础面(管道的轮廓)
• 一个面(在其上定义了基础并用于确定基础是否在基本形状上定义了基础的草图的面)，
• 一个脊柱线
• 一个布尔值，表示基本形状上的操作类型(融合=突出或切割=凹陷)，
• 另一个布尔值表示是否必须找到自交(并非在每种情况下都使用)。

有三种Perform方法:

Method	Description
Perform()	管道沿着整个路径定义(脊线)
Perform(Until)	管道沿着路径定义，直到给定的面
Perform(From, Until)	管道是在From和Until两个面之间定义的

让我们来看看这个例子:

TopoDS_Shape S = BRepPrimAPI_MakeBox(400.,250.,300.); 
TopExp_Explorer Ex; 
Ex.Init(S,TopAbs_FACE); 
Ex.Next(); 
Ex.Next(); 
TopoDS_Face F1 = TopoDS::Face(Ex.Current()); 
Handle(Geom_Surface) surf = BRep_Tool::Surface(F1); 
BRepBuilderAPI_MakeWire MW1; 
gp_Pnt2d p1,p2; 
p1 = gp_Pnt2d(100.,100.); 
p2 = gp_Pnt2d(200.,100.); 
Handle(Geom2d_Line) aline = GCE2d_MakeLine(p1,p2).Value(); 
 
MW1.Add(BRepBuilderAPI_MakeEdge(aline,surf,0.,p1.Distance(p2))); 
p1 = p2; 
p2 = gp_Pnt2d(150.,200.); 
aline = GCE2d_MakeLine(p1,p2).Value(); 
 
MW1.Add(BRepBuilderAPI_MakeEdge(aline,surf,0.,p1.Distance(p2))); 
p1 = p2; 
p2 = gp_Pnt2d(100.,100.); 
aline = GCE2d_MakeLine(p1,p2).Value(); 
 
MW1.Add(BRepBuilderAPI_MakeEdge(aline,surf,0.,p1.Distance(p2))); 
BRepBuilderAPI_MakeFace MKF1; 
MKF1.Init(surf,Standard_False); 
MKF1.Add(MW1.Wire()); 
TopoDS_Face FP = MKF1.Face(); 
BRepLib::BuildCurves3d(FP); 
TColgp_Array1OfPnt CurvePoles(1,3); 
gp_Pnt pt = gp_Pnt(150.,0.,150.); 
CurvePoles(1) = pt; 
pt = gp_Pnt(200.,100.,150.); 
CurvePoles(2) = pt; 
pt = gp_Pnt(150.,200.,150.); 
CurvePoles(3) = pt; 
Handle(Geom_BezierCurve) curve = new Geom_BezierCurve 
(CurvePoles); 
TopoDS_Edge E = BRepBuilderAPI_MakeEdge(curve); 
TopoDS_Wire W = BRepBuilderAPI_MakeWire(E); 
BRepFeat_MakePipe MKPipe (S,FP,F1,W,Standard_False, 
Standard_True); 
MKPipe.Perform(); 
TopoDS_Shape res1 = MKPipe.Shape(); 

机械特征

机械特征包括沿平面(线性)表面或旋转表面的肋、突起和凹槽(或槽)、凹陷。

机械特征的语义是围绕给轮廓赋予厚度而建立的。这种厚度可以是对称的(在轮廓的一侧)，也可以是不对称的(在两侧)。在形状特征的语义中，厚度是由特定上下文中的形状构造来定义的。

然而，在机械特性的情况下，开发背景有所不同。这里包括挤压:

• 到基形的极限面;
• 到达或从一个极限平面;
• 到一个高度。

创建或初始化一个类对象

• 形状(基本形状);
• 金属丝(肋骨或凹槽的底部);
• 平面(电线的平面);
• 方向1(沿其建立厚度的矢量);
• 方向2(与之前的矢量相反，厚度将沿其建立，可能为null);
• 一个布尔值指示基本形状上的操作类型(融合=肋条或切割=凹槽);
• 另一个布尔值，指示是否必须找到自交集(并非在所有情况下都使用)。

线性形式

线性形式是在MakeLinearForm类中实现的，它沿着平面创建一个肋骨或凹槽。有一个Perform()方法，它沿着与基形Sbase交互的direction1和direction2从导线执行棱镜。棱镜的高度为Magnitude(Direction1)+Magnitude(direction2)。

BRepBuilderAPI_MakeWire mkw; 
gp_Pnt p1 = gp_Pnt(0.,0.,0.); 
gp_Pnt p2 = gp_Pnt(200.,0.,0.); 
mkw.Add(BRepBuilderAPI_MakeEdge(p1,p2)); 
p1 = p2; 
p2 = gp_Pnt(200.,0.,50.); 
mkw.Add(BRepBuilderAPI_MakeEdge(p1,p2)); 
p1 = p2; 
p2 = gp_Pnt(50.,0.,50.); 
mkw.Add(BRepBuilderAPI_MakeEdge(p1,p2)); 
p1 = p2; 
p2 = gp_Pnt(50.,0.,200.); 
mkw.Add(BRepBuilderAPI_MakeEdge(p1,p2)); 
p1 = p2; 
p2 = gp_Pnt(0.,0.,200.); 
mkw.Add(BRepBuilderAPI_MakeEdge(p1,p2)); 
p1 = p2; 
mkw.Add(BRepBuilderAPI_MakeEdge(p2,gp_Pnt(0.,0.,0.))); 
TopoDS_Shape S = BRepBuilderAPI_MakePrism(BRepBuilderAPI_MakeFace 
    (mkw.Wire()),gp_Vec(gp_Pnt(0.,0.,0.),gp_P 
     nt(0.,100.,0.))); 
TopoDS_Wire W = BRepBuilderAPI_MakeWire(BRepBuilderAPI_MakeEdge(gp_Pnt 
    (50.,45.,100.), 
gp_Pnt(100.,45.,50.))); 
Handle(Geom_Plane) aplane = 
    new Geom_Plane(gp_Pnt(0.,45.,0.),  gp_Vec(0.,1.,0.)); 
BRepFeat_MakeLinearForm aform(S, W, aplane, gp_Dir 
    (0.,5.,0.), gp_Dir(0.,-3.,0.),  1, Standard_True); 
aform.Perform(); 
TopoDS_Shape res = aform.Shape(); 

胶粘

类BRepFeat_Gluer允许沿面粘合两个实体。胶合成型的接触面不得在基本成型的接触面外有零件。完成后，该算法给出粘合形状，并在形状内切割出部分面。

类是从两个形状创建或初始化的:“粘合”形状和基本形状(另一个形状粘在其上)。使用两种绑定方法将粘合形状的面绑定到基本形状的面，将粘合形状的边缘绑定到基本形状的边缘。

注意，每个面和边都必须有界，如果两个粘合面的两个边是一致的，它们必须明确有界。

TopoDS_Shape Sbase = ...; // the basic shape 
TopoDS_Shape Sglued = ...; // the glued shape 
 
TopTools_ListOfShape Lfbase; 
TopTools_ListOfShape Lfglued; 
// Determination of the glued faces 
... 
 
BRepFeat_Gluer theGlue(Sglue, Sbase); 
TopTools_ListIteratorOfListOfShape itlb(Lfbase); 
TopTools_ListIteratorOfListOfShape itlg(Lfglued); 
for (; itlb.More(); itlb.Next(), itlg(Next()) { 
const TopoDS_Face& f1 = TopoDS::Face(itlg.Value()); 
const TopoDS_Face& f2 = TopoDS::Face(itlb.Value()); 
theGlue.Bind(f1,f2); 
// for example, use the class FindEdges from LocOpe to 
// determine coincident edges 
LocOpe_FindEdge fined(f1,f2); 
for (fined.InitIterator(); fined.More(); fined.Next()) { 
theGlue.Bind(fined.EdgeFrom(),fined.EdgeTo()); 
} 
} 
theGlue.Build(); 
if (theGlue.IsDone() { 
TopoDS_Shape  theResult = theGlue; 
... 
} 

分割形状

类BRepFeat_SplitShape用于将形状的面分割成线或边。包含新实体的形状被重建，共享未修改的实体。

类是从一个形状(基本形状)创建或初始化的。Add方法有三种:

• Add(Wire, Face)-在基本形状的面上添加新的线。
• Add(Edge, Face)-在基本形状的面上添加一条新边。
• Add(EdgeNew, EdgeOld) -在现有边上添加新边(旧边必须包含新边)。

注:添加的线和边必须定义面上的闭合线或位于两个现有边之间的线。现有的边不能相交。

TopoDS_Shape Sbase = ...; // basic shape 
TopoDS_Face Fsplit = ...; // face of Sbase 
TopoDS_Wire Wsplit = ...; // new wire contained in Fsplit 
BRepFeat_SplitShape Spls(Sbase); 
Spls.Add(Wsplit, Fsplit); 
TopoDS_Shape theResult = Spls; 
...

3D 模型 特征

OCCT特征化算法旨在从模型中去除不需要的部分或特征。这些零件可以是孔、突起、间隙、倒角、圆角等。

不执行特征检测，所有要删除的特征都应该由用户定义。在特征化过程中不修改输入形状，结果中构建新的形状。

在API级别上，特征算法是在BRepAlgoAPI_Defeaturing类中实现的。在输入时，算法接受要从中去除的形状和要从形状中去除的特征(一个或多个)。目前，输入形状应该是SOLID、COMPSOLID或COMPOUND of SOLIDs。要删除的特征是由形成它们的面孔集定义的。如何给出特征面并不重要:作为单独的面还是它们的集合。这些面应该属于初始形状，否则它们将被忽略。

实际的特征移除是由底层的BOPAlgo_RemoveFeatures算法执行的。在API级别，所有输入都被传递到工具中，并调用方法BOPAlgo_RemoveFeatures::Perform()。

在删除特征之前，所有要从形状中删除的面都被分类到连接的块中-每个块代表一个要删除的特征。特征一个接一个地从形状中移除，这允许删除所有可能的特征，即使它们的移除存在一些问题(例如，由于不正确的输入数据)。

被移除的特征被相邻的面的扩展填充。一般来说，从形状中去除单个特征的算法如下:

• 找出与特征相邻的面;
• 扩展相邻的面以覆盖特征;
• 按原面的边界(与特征共有的边界除外)修剪扩展面，使它们只覆盖特征;
• 用重建的相邻面重建实体，避免特征面。

如果单个特征去除成功，则结果形状被新形状覆盖，否则结果不保留，并给出警告。无论哪种方式，该过程都将继续进行下一个功能。

defaturing算法有以下选项:

• 历史上的支持;

以及基类(BOPAlgo_Options)中可用的选项:

• 错误/警告报告系统;
• 并行处理模式。

注意，这里不支持基类的其他选项，也不会产生任何影响。

历史记录支持允许根据Modified、IsDeleted和Generated跟踪输入形状的修改。默认情况下，收集历史记录，但是可以使用SetToFillHistory(false)方法禁用它。在底层，历史信息由历史工具BRepTools_History收集，该工具可以通过BOPAlgo_RemoveFeatures:: history()方法访问。

错误/警告报告系统允许获得在操作期间发生的错误/警告的扩展概述。一旦出现任何错误，算法就会停止工作。警告允许继续作业，并通知用户出错了。该算法返回以下错误/警告:

• BOPAlgo_AlertUnsupportedType -如果输入形状不包含任何实体，警报将作为错误给出，如果输入形状不仅包含实体，还包含其他形状，则作为警告;
• BOPAlgo_AlertNoFacesToRemove-如果没有要从形状中删除的面(什么都不做)，则给出错误警报;
• BOPAlgo_AlertUnableToRemoveTheFeature -给出警告警报，告知用户不可能删除该功能。该算法仍将尝试去除其他特征;
• BOPAlgo_AlertRemoveFeaturesFailed -如果操作失败，则给出错误警报

有关错误/警告报告系统的更多信息，请参见布尔操作用户指南中的错误和警告报告系统一章。

并行处理模式-允许在并行模式下运行算法，更快地获得结果。

该算法有一定的局限性:

• 与特征相邻的连通面的曲面交点不应为空。它的意思是，这些面不应该彼此相切。如果相邻面的交点为空，则算法将无法正确地修剪面，并且很可能不会删除特征。
• 该算法不处理实体的内部部分，它们在重建过程中被简单地移除。

请注意，为了成功地移除特征，与特征相邻的扩展面应完全覆盖特征，否则将无法重建实体。看看下面这个简单的形状:

去除间隙的所有三个面是行不通的，因为没有面来填补横向部分的步骤。虽然，只去除两个面，保留一个横向面，将填补空白与保留的面:

用法

下面是在c++级别使用BrepAlgoApi_Feataturing算法的示例:

TopoDS_Shape aSolid = ...;               // Input shape to remove the features from
TopTools_ListOfShape aFeatures = ...;    // Features to remove from the shape
Standard_Boolean bRunParallel = ...;     // Parallel processing mode
Standard_Boolean isHistoryNeeded = ...;  // History support
 
BRepAlgoAPI_Defeaturing aDF;             // Defeaturing algorithm
aDF.SetShape(aSolid);                    // Set the shape
aDF.AddFacesToRemove(aFaces);            // Add faces to remove
aDF.SetRunParallel(bRunParallel);        // Define the processing mode (parallel or single)
aDF.SetToFillHistory(isHistoryNeeded);   // Define whether to track the shapes modifications
aDF.Build();                             // Perform the operation
if (!aDF.IsDone())                       // Check for the errors
{
  // error treatment
  Standard_SStream aSStream;
  aDF.DumpErrors(aSStream);
  return;
}
if (aDF.HasWarnings())                   // Check for the warnings
{
  // warnings treatment
  Standard_SStream aSStream;
  aDF.DumpWarnings(aSStream);
}
const TopoDS_Shape& aResult = aDF.Shape(); // Result shape

使用API history方法来跟踪形状的历史:

// Obtain modification of the shape
const TopTools_ListOfShape& BRepAlgoAPI_Defeaturing::Modified(const TopoDS_Shape& theS);
 
// Obtain shapes generated from the shape
const TopTools_ListOfShape& BRepAlgoAPI_Defeaturing::Generated(const TopoDS_Shape& theS);
 
// Check if the shape is removed or not
Standard_Boolean BRepAlgoAPI_Defeaturing::IsDeleted(const TopoDS_Shape& theS);

命令removefeatures允许在绘制级别上使用特征化算法。

标准历史命令可用于跟踪特征化过程中形状修改的历史。

有关上述命令的更多详细信息，请参阅绘制测试线束用户指南的Defeatiring commands。

示例

以下是ANC101模型特征的例子:

以下是包含混合盒的模型特征的几个例子:

3D 模型周期性

Open CASCADE技术提供了在指定方向的3D空间中制作任意3D模型(或只是形状)周期的工具。

形状的周期性意味着形状可以在任何周期性方向上重复任意次数，而不会产生新的几何形状或分裂。这个算法的思想是使形状在相反的边或者在周期方向的周期边界上看起来相似。这并不意味着该形状的相对侧面将被镜像。它只是意味着形状的对边应该被彼此分开，在对边得到相同的几何形状。这种方法将允许重复形状，即在周期上翻译形状的副本，而不创建新的几何形状，因为不会有不同维度的重合部分。

为了更好地理解周期性的含义，让我们制作一个简单的棱镜，让它具有周期性。下面的绘制脚本创建扩展为10x5x10的l形棱镜:

polyline p 0 0 0 0 0 10 5 0 10 5 0 5 10 0 5 10 0 0 0 0 0
mkplane f p
prism s f 0 5 0

使这个形状在X, Y和Z方向上具有周期性，并且周期与形状的延伸相匹配，应该会使形状的负X和负Z边分裂。形状在Y方向的相对两侧已经相似，因此预计不会有新的分裂。这是把它做成周期性后的形状:

这是形状在X和Z方向上的重复:

OCCT形状周期性工具还允许在周期与形状的扩展不匹配时使形状具有周期性。让这个形状以11 6 11为周期分别对应X, Y, Z周期。这样的周期值意味着在重复的形状之间会有一个间隙，因为在重复的过程中，相反的两边不接触，所以形状根本不会分裂。这是形状在X和Z方向上的重复:

正如预期的那样，形状没有分裂，重复的元素也没有接触。

如果有必要，算法将通过将其与限制形状请求周期的平面分开来修剪形状以适应请求周期。例如，让l形周期仅在X方向上，周期2从X参数4开始:

如何使形状具有周期性

为了使形状在一定方向上具有周期性，算法执行以下步骤:

• 创建形状的副本，并将其在周期上移动到请求方向的负侧;
• 通过移动副本拆分形状的负侧，确保几何形状从正侧复制到负侧;
• 创建形状的副本(已经分裂的负侧)，并将其移动到请求方向的正侧;
• 通过移动副本拆分形状的正侧，确保几何形状从负侧复制到正侧。

几何形状的重复复制确保周期形状的角边缘在所有周期方向的相对侧具有相同的几何形状。

因此，在周期形状中，形状正侧的几何形状总是复制到周期方向的负侧。

相反形状关联

该算法还将位于周期形状相对两侧的相同(或双胞胎)形状联系起来。通过构造，两个形状应该始终具有相同的几何形状，并且在周期上彼此保持距离。有可能这个形状没有任何双胞胎。这意味着当重复这个形状时，不会碰到形状的另一边。在此示例中，当形状的周期大于其扩展时，子形状中没有一个具有双胞胎。

周期性形状重复

该算法还提供了在周期方向上重复周期形状的方法。为了重复形状，该算法制作所需数量的形状副本，并在time * period值上逐个转换它们。在所有的副本被制作和翻译后，它们被粘在一起，使其具有有效的形状。随后的重复是在重复的形状上进行的，因此，例如，在任何周期方向上重复该形状两次将产生包含三个形状的结果(原始形状加两个副本)。任何方向的单次重复都会产生6个形状。

重复的动作可以清除并重新开始。

历史记录支持

该算法支持形状修改的历史记录，因此可以跟踪形状是如何被周期性地改变的，以及在重复过程中创建了哪些新形状。分裂历史和周期性形状重复历史在这里都是可用的。注意，所有重复的形状都按照生成到历史记录中的方式存储。

BRepTools_History用于历史支持。

错误/警告

该算法支持错误/警告报告系统，该系统允许获得操作过程中发生的错误和警告的扩展概述。一旦出现任何错误，算法就会停止工作。警告允许继续作业，通知用户出错了。该算法返回以下警报:

• BOPAlgo_AlertNoPeriodicityRequired -如果在任何方向上没有请求周期性，则给出错误警报;
• BOPAlgo_AlertUnableToTrim -如果将形状调整到请求的周期失败，则给出错误警报;
• BopAlgo_AlertUnableToMakeSame -如果通过其移动副本分割形状失败，则给出错误警报;
• BOPAlgo_AlertUnableToRepeat -如果重复形状的粘合失败，则给出警告警报。

有关错误/警告报告系统的更多信息，请参阅布尔操作用户指南中的错误和警告报告系统一章。

用法

该算法在类BOPAlgo_MakePeriodic中实现。下面是它在API级别使用的示例:

TopoDS_Shape aShape = ...;                 // The shape to make periodic
Standard_Boolean bMakeXPeriodic = ...;     // Flag for making or not the shape periodic in X direction
Standard_Real aXPeriod = ...;              // X period for the shape
Standard_Boolean isXTrimmed = ...;         // Flag defining whether it is necessary to trimming
                                           // the shape to fit to X period
Standard_Real aXFirst = ...;               // Start of the X period
                                           // (really necessary only if the trimming is requested)
Standard_Boolean bRunParallel = ...;       // Parallel processing mode or single
 
BOPAlgo_MakePeriodic aPeriodicityMaker;                   // Periodicity maker
aPeriodicityMaker.SetShape(aShape);                       // Set the shape
aPeriodicityMaker.MakeXPeriodic(bMakePeriodic, aXPeriod); // Making the shape periodic in X direction
aPeriodicityMaker.SetTrimmed(isXTrimmed, aXFirst);        // Trim the shape to fit X period
aPeriodicityMaker.SetRunParallel(bRunParallel);           // Set the parallel processing mode
aPeriodicityMaker.Perform();                              // Performing the operation
 
if (aPeriodicityMaker.HasErrors())                        // Check for the errors
{
  // errors treatment
  Standard_SStream aSStream;
  aPeriodicityMaker.DumpErrors(aSStream);
  return;
}
if (aPeriodicityMaker.HasWarnings())                      // Check for the warnings
{
  // warnings treatment
  Standard_SStream aSStream;
  aPeriodicityMaker.DumpWarnings(aSStream);
}
const TopoDS_Shape& aPeriodicShape = aPeriodicityMaker.Shape(); // Result periodic shape
 
aPeriodicityMaker.XRepeat(2);                                    // Making repetitions
const TopoDS_Shape& aRepeat = aPeriodicityMaker.RepeatedShape(); // Getting the repeated shape
aPeriodicityMaker.ClearRepetitions();                            // Clearing the repetitions

请注意，这个类是基于选项类BOPAlgo_Options，它为算法提供了以下选项:

• 错误/警告报告系统;
• 并行处理模式。这里不支持基类的其他选项，也不会产生任何影响。

操作过程中获得的所有历史信息存储在BRepTools_History对象中，通过history()方法可用:

// Get the history object
const Handle(BRepTools_History)& BOPAlgo_MakePeriodic::History();

对于在Draw级别使用MakePeriodic算法，已经实现了以下命令:

• 使周期性
• 重复形状
• 周期性双胞胎
• 清除重复

有关周期性命令的更多详细信息，请参阅绘制测试线束用户指南中的周期性命令。

要在MakePeriodic操作期间跟踪形状修改的历史记录，可以使用标准历史记录命令。

为了能够在运行算法之前访问操作的错误/警告形状，请使用bdrawwarnshapes命令(参见布尔操作的错误和警告报告系统用户指南中的命令用法)。

示例

想象一下，你需要在盘子上的钻头彼此之间保持相同的距离。为了模拟这一过程，有必要制作许多圆柱体(模拟钻头)并从板上切割这些圆柱体。使用周期性工具，过程看起来非常简单:

# create plate 100 x 100
box plate -50 -50 0 100 100 1
# create a single drill with radius 1
pcylinder drill 1 1
# locate the drill in the left corner
ttranslate drill -48 -48 0
# make the drill periodic with 4 as X and Y periods, so the distance between drills will be 2
makeperiodic drill drill -x 4 -trim -50 -y 4 -trim -50
# repeat the drill to fill the plate, in result we get net of 25 x 25 drills
repeatshape drills -x 24 -y 24
# cut the drills from the plate
bcut result plate drills

隐线消除

为了提供工业设计所需的精度，图纸需要提供去除隐藏在给定投影中的线条的可能性。

为此，隐线移除组件提供了两种算法:HLRBRep_Algo和HLRBRep_PolyAlgo。

这些算法是基于将要可视化的形状的每个边缘与其每个面进行比较，并计算每个边缘的可见部分和隐藏部分的原理。请注意，这些不是用于生成阴影的算法，阴影算法通过将形状中的每个面部与相同形状的其他面部进行比较来计算形状中每个面部的可见和隐藏部分。这些算法对一个形状进行操作，并去除或显示被面隐藏的边缘。对于给定的投影，他们计算一组被表示对象的特征线。它们还与提取工具一起使用，提取工具从计算结果的选择中重建新的简化形状。这个新形状由边缘组成，代表了投影中可视化的形状。

HLRBRep_Algo允许使用形状本身，而HLRBRep_PolyAlgo使用形状的多面体简化。当你使用HLRBRep_Algo时，你获得了一个精确的结果，然而，当你使用HLRBRep_PolyAlgo时，你减少了计算时间，但获得了多边形段。

没有提供平滑算法。因此，多面体将被视为多面体，算法将以符合多面体数学定义的线段形式给出结果。HLRBRep_PolyAlgo总是这样。

HLRBRep_Algo和HLRBRep_PolyAlgo可以处理任何类型的对象，例如，体，面和线的集合，只要其中没有未完成的对象或点。

然而，在使用HLR时有一些限制:

• 不处理点;
• 不处理无限的面或线。

以下服务与删除隐藏线有关:

加载形状

要将TopoDS_Shape传递给HLRBRep_Algo对象，请使用HLRBRep_Algo::Add。对于HLRBRep_PolyAlgo对象，使用HLRBRep_PolyAlgo::Load。如果您希望添加多个形状，请根据需要经常使用add或Load。

设置视图参数

HLRBRep_Algo::Projector和HLRBRep_PolyAlgo::Projector设置了一个投影仪对象，它定义了视图的参数。这个对象是HLRAlgo_Projector。

计算投影

HLRBRep_PolyAlgo::Update启动HLRBRep_PolyAlgo框架可视化的形状轮廓的计算。

对于HLRBRep_Algo，使用HLRBRep_Algo::Update。使用此算法，还必须调用方法HLRBRep_Algo::Hide来计算要可视化的形状的可见和隐藏线。对于HLRBRep_PolyAlgo对象，由HLRBRep_PolyHLRToShape计算可见和隐藏线。

提取边

类HLRBRep_HLRToShape和HLRBRep_PolyHLRToShape分别为HLRBRep_Algo对象和HLRBRep_PolyAlgo对象提供了一系列提取过滤器。它们从算法计算的结果中突出显示边缘的类型。使用这两个提取类，你可以突出显示以下类型的输出:

• 可见/隐藏的锐利边缘;
• 可见/隐藏平滑边缘;
• 可见/隐藏缝边;
• 可见/隐藏轮廓边缘。

要对HLRBRep_PolyHLRToShape对象执行提取，请使用HLRBRep_PolyHLRToShape::Update函数。

对于由HLRBRepAlgo对象构建的HLRBRep_HLRToShape 对象，您还可以突出显示:

• 可见等参数和
• 隐藏等参数。

示例

HLRBRep_Algo

// Build The algorithm object 
myAlgo = new HLRBRep_Algo(); 
 
// Add Shapes into the algorithm 
TopTools_ListIteratorOfListOfShape anIterator(myListOfShape); 
for (;anIterator.More();anIterator.Next()) 
myAlgo-Add(anIterator.Value(),myNbIsos); 
 
// Set The Projector (myProjector is a 
HLRAlgo_Projector) 
myAlgo-Projector(myProjector); 
 
// Build HLR 
myAlgo->Update(); 
 
// Set The Edge Status 
myAlgo->Hide(); 
 
// Build the extraction object : 
HLRBRep_HLRToShape aHLRToShape(myAlgo); 
 
// extract the results : 
TopoDS_Shape VCompound           = aHLRToShape.VCompound(); 
TopoDS_Shape Rg1LineVCompound                            = 
aHLRToShape.Rg1LineVCompound(); 
TopoDS_Shape RgNLineVCompound                            = 
aHLRToShape.RgNLineVCompound(); 
TopoDS_Shape OutLineVCompound                            = 
aHLRToShape.OutLineVCompound(); 
TopoDS_Shape IsoLineVCompound                            = 
aHLRToShape.IsoLineVCompound(); 
TopoDS_Shape HCompound           = aHLRToShape.HCompound(); 
TopoDS_Shape Rg1LineHCompound                            = 
aHLRToShape.Rg1LineHCompound(); 
TopoDS_Shape RgNLineHCompound                            = 
aHLRToShape.RgNLineHCompound(); 
TopoDS_Shape OutLineHCompound                            = 
aHLRToShape.OutLineHCompound(); 
TopoDS_Shape IsoLineHCompound                            = 
aHLRToShape.IsoLineHCompound(); 

HLRBRep_PolyAlgo

// Build The algorithm object 
myPolyAlgo = new HLRBRep_PolyAlgo(); 
 
// Add Shapes into the algorithm 
TopTools_ListIteratorOfListOfShape 
anIterator(myListOfShape); 
for (;anIterator.More();anIterator.Next()) 
myPolyAlgo-Load(anIterator.Value()); 
 
// Set The Projector (myProjector is a 
HLRAlgo_Projector) 
myPolyAlgo->Projector(myProjector); 
 
// Build HLR 
myPolyAlgo->Update(); 
 
// Build the extraction object : 
HLRBRep_PolyHLRToShape aPolyHLRToShape; 
aPolyHLRToShape.Update(myPolyAlgo); 
 
// extract the results : 
TopoDS_Shape VCompound = 
aPolyHLRToShape.VCompound(); 
TopoDS_Shape Rg1LineVCompound = 
aPolyHLRToShape.Rg1LineVCompound(); 
TopoDS_Shape RgNLineVCompound = 
aPolyHLRToShape.RgNLineVCompound(); 
TopoDS_Shape OutLineVCompound = 
aPolyHLRToShape.OutLineVCompound(); 
TopoDS_Shape HCompound = 
aPolyHLRToShape.HCompound(); 
TopoDS_Shape Rg1LineHCompound = 
aPolyHLRToShape.Rg1LineHCompound(); 
TopoDS_Shape RgNLineHCompound = 
aPolyHLRToShape.RgNLineHCompound(); 
TopoDS_Shape OutLineHCompound = 
aPolyHLRToShape.OutLineHCompound(); 

形状连接

Open CASCADE技术提供了使相同维度的触摸形状连接(或粘合)的工具，即使形状之间在拓扑上共享一致的几何形状。为了使形状连接起来，使用通用熔丝算法将它们粘合在一起。使用选项BOPAlgo_GlueShift，因此如果输入形状受到干扰，算法将无法识别这一点。

使一组形状连接起来是有用的，例如，在划分组之前。它将允许生成的网格共形。

使形状连接的算法在类s BOPAlgo_MakeConnected中实现。

材料关联

在这个工具的框架中，输入形状被称为材料，每个输入形状都有一个独特的材料。

连接形状后，输入形状的边界元素与它们所属的形状相关联。这样，就考虑了形状中边界元素的方向。这些关联适用于以下类型:

• 对于输入实体，生成的人脸与输入实体相关联;
• 对于输入面，生成的EDGES与输入面相关联;
• 对于输入边，结果顶点与输入边相关联。这种联想过程称为物质联想。它允许找到相反输入形状的重合元素。这些元素将与至少两种材料相关联(一种在形状的正侧，另一种在负侧)。

获取材料信息应采用以下方法

• MaterialsOnPositiveSide() -返回位于给定形状正侧的原始形状(材料)(即FORWARD方向);
• MaterialsOnNegativeSide() -返回位于给定形状的负侧的原始形状(材料)(即反向方向);

// Returns the original shapes which images contain the given shape with FORWARD orientation.
const TopTools_ListOfShape& BOPAlgo_MakeConnected::MaterialsOnPositiveSide(const TopoDS_Shape& theS)
 
// Returns the original shapes which images contain the given shape with REVERSED orientation.
const TopTools_ListOfShape& BOPAlgo_MakeConnected::MaterialsOnNegativeSide(const TopoDS_Shape& theS)

使连通形状具有周期性

该工具提供了使连接形状周期性的可能性。因为通过使形状周期性，它确保了相反边的重合形状的几何形状将是相同的，它允许为其周期性双胞胎重用形状的网格。

在使形状周期性之后，更新材料关联以对应于结果形状的实际状态。周期形状的重复从这里也是可能的。材料联系不会消失。

历史记录支持

该算法支持操作过程中形状修改的历史记录。除了BRepTools_History提供的标准历史方法(这里用作历史工具)之外，该算法还提供了跟踪反向连接的方法——从生成的形状到输入的形状。这个方法叫做GetOrigins():

// Returns the list of original shapes from which the current shape has been created.
const TopTools_ListOfShape& BOPAlgo_MakeConnected::GetOrigins(const TopoDS_Shape& theS);

这里提供了粘合历史和使形状周期性和周期性形状重复的历史。注意，所有重复的形状都按照生成到历史记录中的方式存储。

错误/警告

该算法支持错误/警告报告系统，该系统允许获得操作过程中发生的错误和警告的扩展概述。一旦出现任何错误，算法就会停止工作。警告允许继续作业，通知用户出错了。该算法返回以下警报:

• BOPAlgo_AlertTooFewArguments-尝试在没有参数的情况下运行算法时会发出错误警报；

• BOPAlgo_AlertMultiDimensionalArguments-尝试在多维参数上运行算法时会发出错误警报；

• BOPAlgo_AlertEnableToGlue-如果gluer算法无法粘合给定的参数，则会发出错误警报；

• BOPAlgo_AlertEnableToMakePeriodic-如果周期生成器无法使用给定选项使连接的形状具有周期性，则会发出警告警报；

• BOPAlgo_AlertShapeIsNotPeriodic-在使形状具有周期性之前，尝试重复形状时会发出警告警报。

有关错误/警告报告系统的更多信息，请参阅布尔运算的错误和警告报告系统用户指南一章。

使用语法

以下是BOPAlgo_MakePeriodic算法在API级别上的使用示例：

TopTools_ListOfShape anArguments = ...;  // Shapes to make connected
Standard_Boolean bRunParallel = ...;     // Parallel processing mode
 
BOPAlgo_MakeConnected aMC;               // Tool for making the shapes connected
aMC.SetArguments(anArguments);           // Set the shapes
aMC.SetRunParallel(bRunParallel);        // Set parallel processing mode
aMC.Perform();                           // Perform the operation
 
if (aMC.HasErrors())                     // Check for the errors
{
  // errors treatment
  Standard_SStream aSStream;
  aMC.DumpErrors(aSStream);
  return;
}
if (aMC.HasWarnings())                   // Check for the warnings
{
  // warnings treatment
  Standard_SStream aSStream;
  aMC.DumpWarnings(aSStream);
}
 
const TopoDS_Shape& aGluedShape = aMC.Shape(); // Connected shape
 
// Checking material associations
TopAbs_ShapeEnum anElemType = ...;       // Type of border element
TopExp_Explorer anExp(anArguments.First(), anElemType);
for (; anExp.More(); anExp.Next())
{
  const TopoDS_Shape& anElement = anExp.Current();
  const TopTools_ListOfShape& aNegativeM = aMC.MaterialsOnNegativeSide(anElement);
  const TopTools_ListOfShape& aPositiveM = aMC.MaterialsOnPositiveSide(anElement);
}
 
// Making the connected shape periodic
BOPAlgo_MakePeriodic::PeriodicityParams aParams = ...; // Options for periodicity of the connected shape
aMC.MakePeriodic(aParams);
 
// Shape repetition after making it periodic
// Check if the shape has been made periodic successfully
if (aMC.PeriodicityTool().HasErrors())
{
  // Periodicity maker error treatment
}
 
// Shape repetition in periodic directions
aMC.RepeatShape(0, 2);
 
const TopoDS_Shape& aShape = aMC.PeriodicShape(); // Periodic and repeated shape

请注意，该类基于选项类BOPAlgo_options，它为算法提供了以下选项：

• 错误/警告报告系统；

• 并行处理模式。基类的其他选项在此不受支持，也不会有任何效果。

操作过程中获得的所有历史信息都存储在BRpTools_history对象中，并可通过history()方法获得：

// Get the history object
const Handle(BRepTools_History)& BOPAlgo_MakeConnected::History();

为了在绘图级别上使用MakeConnected算法，已经实现了以下命令：

• makeconnected
• cmaterialson
• cmakeperiodic
• crepeatshape
• cperiodictwins
• cclearrepetitions

有关连接命令的更多详细信息，请参阅《绘制测试线束用户指南》中的MakeConnected命令。

要在MakeConnected操作期间跟踪形状修改的历史，可以使用标准历史命令。

要有可能访问操作的错误/警告形状，请在运行算法之前使用bdrawwarnshapes命令（请参阅布尔操作的错误和警告报告系统用户指南中的命令用法）。