OpenCasCade官方开发文档翻译(4)–occt建模算法

介绍

本手册解释了如何使用建模算法。它提供了有关建模算法的基本文档。

建模算法模块汇集了建模中使用的各种拓扑算法。除了这些工具,您还会发现它们所称的几何算法。

几何工具

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

  • 计算两条 2D 曲线、曲面或 3D 曲线与曲面的交点;
  • 将点投影到 2D 和 3D 曲线上,将点投影到曲面上,将 3D 曲线投影到曲面上;
  • 从约束构造线和圆;
  • 从约束构造曲线和曲面;
  • 通过插值构造曲线和曲面。

相交

Intersections 组件用于计算 2D 或 3D 几何对象之间的交点:

  • 两条二维曲线的交点;
  • 二维曲线的自相交;
  • 3D 曲线和曲面之间的交点;
  • 两个曲面之间的交点。

Geom2dAPI_InterCurveCurve类允许评估两条几何曲线 ( Geom2d_Curve ) 之间交点( gp_Pnt2d ) 以及评估曲线的自交点。

图片[1]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

曲线的交点和自交点

在这两种情况下,该算法都需要一个容差值 (Standard_Real) 用于两点之间的混淆。所有构造函数中使用的默认容差值为1.0e-6。

图片[2]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

相交和相切相交

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

两条曲线的交点

Geom2dAPI_InterCurveCurve类可以被实例化为曲线C1C2的交点。

Geom2dAPI_InterCurveCurve相交(C1,C2,公差);

或曲线C3的自相交。

Geom2dAPI_InterCurveCurve相交(C3,公差);
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 = 相交。NbLines();

调用相交曲线的数量。

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

其中Index是 1 和nb之间的整数,称为相交曲线。

插值

插值定律组件提供了函数的定义:y=f(x)

特别是,它提供了以下定义:

  • 一个线性函数,
  • S函数,和
  • 一系列值的插值函数。

例如,此类函数可用于定义圆角沿形状边缘的演变规律。

从未检查过所构建函数的有效性:Law包不知道该函数将用于什么应用程序或用于什么目的。特别是,如果将函数用作圆角的演化规律,则函数始终为正很重要。用户必须检查这一点。

Geom2dAPI_Interpolate

此类用于对通过点数组的 BSplineCurve 进行插值。如果在插值点未请求相切,则连续性将为C2。如果在该点请求相切,则连续性将为C1。如果要求周期性,则曲线将闭合,交点将是第一个给出的点。然后曲线将仅具有C1的连续性。此类可以按如下方式实例化:

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

可以从上面定义的对象调用 BSpline 曲线。

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

请注意,Handle(Geom2d_BSplineCurve)运算符已由Curve()方法重新定义。因此,不需要通过Geom2dAPI_Interpolate类型的中间对象的构造,并且以下语法是正确的。

GeomAPI_Interpolate

此类可以按如下方式实例化:

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

可以从上面定义的对象调用 BSpline 曲线。

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

请注意,Handle(Geom_BSplineCurve)运算符已由Curve()方法重新定义。因此,没有必要通过GeomAPI_Interpolate类型的中间对象的构造,并且以下语法是正确的。

Handle(Geom_BSplineCurve) C = GeomAPI_Interpolate (Points,
Standard_False, 1.0e-7);

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

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

约束中的线和圆

约束类型

可以使用与其他曲线相关的数字或几何约束来描述构建 2D 圆或线的算法。

这些约束可以强加以下内容:

  • 圆的半径,
  • 一条直线与另一条直线所成的角度,
  • 直线或圆相对于曲线的相切,
  • 一条直线或圆通过一个点,
  • 以点或曲线为中心的圆。

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

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

根据解的相对位置以及表达相切约束的圆或直线,相切问题的表达通常会导致几个结果。例如,考虑以下情况,一个给定半径的圆(一个小圆)与两个正割圆 C1 和 C2 相切:

图片[3]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

相切约束示例

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

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

这些定义很容易在一个圆圈上解释,在那里很容易识别内部和外部。事实上,对于任何类型的曲线,内部都定义为曲线相对于其方向的左侧。

这种解决方案的限定技术,与它相切的曲线有关,可用于通过几何约束构造圆或直线的所有算法中。使用了四个限定符:

  • 封闭——解决方案必须封闭论点;
  • 封闭——解决方案必须被参数封闭;
  • 外部——解决方案和论点必须彼此外部;
  • 不合格– 相对位置不合格,即所有解决方案都适用。

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

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

此表达式查找半径为Rad的所有圆,这些圆与圆C1C2均相切​​,而C1在外部,C2在内部。

可用的线和圆类型

以下分析算法使用值处理实体来创建具有几何约束的 2D 线或圆:

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

外部/内部

定义圆的内部和外部并不难。如下图所示,外部用副法线的方向表示,也就是按照遍历圆的方向表示右边。因此左侧是内部(或“材料”)。

图片[4]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

圆的外部/内部

引申,一条线或任何开放曲线的内部根据经过的方向定义为左侧,如下图所示:

图片[5]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

线和曲线的外部/内部

线的方向

有时需要预先定义沿要创建的线的行进感。这种意义将是从第一个论点到第二个论点。

下图显示了一条直线,它首先与直线内部的圆 C1 相切,然后通过点 P1。

图片[6]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

定向线

与两个圆相切的线

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

示例 1 案例 1

图片[7]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

外面的两个圆圈

约束:与 C1 相切和外部。与 C2 相切和外部。

句法:

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

示例 1 案例 2

图片[8]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

两个圆圈都围起来

约束:相切并包括 C1。切线并包括 C2。

句法:

示例 1 案例 3

图片[9]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

C1封闭,C2外

约束:相切并包括 C1。与 C2 相切和外部。

句法:

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

示例 1 案例 4

图片[10]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

C1 外部和 C2 封闭

约束:与 C1 相切和外部。切线并包括 C2。

句法:

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

示例 1 案例 5

图片[11]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

没有限定词

约束:关于 C1 的切线和未定义。与 C2 相切且未定义。

句法:

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

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

示例 2 案例 1

图片[12]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

两种解决方案都在外面

约束:与 C1 相切和外部。与 C2 相切和外部。

句法:

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

示例 2 案例 2

图片[13]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

C2 包含 C1

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

句法:

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

示例 2 案例 3

图片[14]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

解决方案包含 C2

约束:与 C1 相切和外部。切线并包括 C2。

句法:

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

示例 2 案例 4

图片[15]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

解决方案附上 C1

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

句法:

Solver( GccEnt::Enclosure (C1),
GccEnt::Enclosure (C2), Rad, Tolerance);

示例 2 案例 5

以下语法将给出半径为Rad的所有圆,它们与C1C2相切,不区分相对位置:

算法类型

OCCT 实现了几类算法:

  • 解析算法,通过求解方程获得解,当所处理的几何形状(切线参数、中心位置等)是点、线或圆时,使用此类算法;
  • 几何算法,通常通过计算由几何参数构建的平行或二等分曲线的交点来获得解决方案;
  • 迭代算法,通过迭代过程获得解决方案。

对于约束线或圆的每种几何构造,OCCT 提供两种访问方式:

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

所提供的算法计算与所述几何问题相对应的所有解决方案,除非通过迭代算法找到解决方案。

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

  • 构建一个圆,当参数比直线或圆更复杂,并且半径未知或难以确定时:与三个几何元素相切的圆,或与两个几何元素相切的圆就是这种情况,并且以曲线为中心;
  • 当相切参数比线或圆更复杂时,构建一条线。

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

GccEnt和Geom2dGcc包还提供了简单的函数以非常有效的方式构建合格的曲线。

GccAna包还提供了用于在圆、线或点之间构造二等分轨迹的算法。两个几何对象之间的二等分轨迹使得它们的每个点与两个几何对象的距离相同。它们通常是曲线,例如GccAna算法的圆、直线或圆锥曲线。每个基本解都以基本二等分轨迹对象(直线、圆、椭圆、双曲线、抛物线)的形式给出,由GccInt包描述。

注意:GccAna算法用于定义要解决的几何问题的曲线是gp包中的 2D 线或圆:它们没有显式参数化。但是,这些线或圆保留了隐式参数化,对应于它们在等效 Geom2d 对象上诱导的参数化。这种诱导参数化是在此类曲线上返回参数值时使用的参数化,例如使用GccAnaGeom2dGcc包中的构造算法提供的函数Tangency1、Tangency2、Tangency3 、Intersection2CenterOn3

来自约束的曲线和曲面

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

  • 创建流线型和最小变化的 2D 曲线
  • 规则面的构造
  • 管道表面的构造
  • 表面填充
  • 板面的构造
  • 超出其原始边界的 3D 曲线或曲面的延伸。

OPEN CASCADE 公司还提供了一种名为Surfaces from Scattered Points的产品,它允许从散点构建曲面。该算法接受或构造一个初始 B 样条曲面并寻找其满足约束条件的变形(有限元法)。使用优化的计算方法,该算法能够从超过 500 000 个点构建一个曲面。

SSP 产品不提供 Open CASCADE 技术,但可以单独购买。

流线型和最小变化 2D 曲线

弹性梁曲线起源于传统的造船建模方法,其中一块长而薄的木头,车床,被迫穿过两组钉子,以这种方式,采用基于曲线的曲线形式这两个点,施加在这些点上的力的方向,以及木车床本身的特性。

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

板条曲线

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

  • 0 曲线必须经过一个点
  • 1 曲线必须通过一个点并且有一个给定的切线
  • 2 曲线必须经过一个点,具有给定的切线和给定的曲率。

仅使用 0 和 1 约束顺序。函数 Curve 将结果作为 2D BSpline 曲线返回。

最小变化曲线

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

  • 0 曲线必须经过一个点
  • 1 曲线必须通过一个点并且有一个给定的切线
  • 2 曲线必须经过一个点,具有给定的切线和给定的曲率。

可以使用 0、1 和 2 的约束顺序。该算法最大限度地减少了张力、下垂和冲击能量。

函数Curve将结果作为 2D BSpline 曲线返回。

如果要为板条曲线指定特定长度,请使用:

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

其中b是板条曲线对象的名称

自由滑动通常比受限滑动更美观。但是,如果角度值大于p/2 ,则计算可能会失败,因为在这种情况下,长度理论上是无限的。

在其他情况下,当施加滑动并且滑动系数太大时,板条可能会倒塌。

构造函数参数ToleranceNbIterations控制计算的精确度以及需要多长时间。

直纹表面

直纹面是通过沿着两条曲线的长度划线来构建的。

贝塞尔曲面的创建

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

创建 BSpline 曲面

GeomFill_BSplineCurves类允许从连续的 BSpline 曲线生成 BSpline 曲面。请注意,有理 BSplines 可能会出现问题。

管道表面

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

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

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

填充轮廓

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

一个典型的例子是两个圆角在拐角处的交点。如果一个边上的圆角半径与另一边上的圆角半径不同,则无法将生成的曲面的所有边缝合在一起。这会在您正在构建的对象的整个表面上留下一个间隙。

图片[16]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

具有不同半径的相交圆角边

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

创建边界

GeomFill_SimpleBound类允许您定义要构造的表面的边界。

创建具有相邻曲面的边界

GeomFill_BoundWithSurf类允许为要构造的表面定义边界。此边界将已连接到另一个曲面。

填充样式

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

  • Stretch – 贴片最平整的款式
  • Coons – 一种比Curved深度更小的圆形风格
  • 弯曲的 – 具有最圆润补丁的样式。

图片[17]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

具有不同半径的相交圆角边留下由表面填充的间隙

板面

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

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

该曲面是使用变分样条算法构建的。它利用局部机械力使薄板变形的原理。如果输入中尚未给出,则计算初始表面。这对应于变形前的板。然后,调用该算法来计算最终表面。它寻找满足约束和最小化能量输入的解决方案。

图片[18]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

由两条曲线和一个点生成的曲面

GeomPlate包提供以下服务,用于创建尊重曲线和点约束的曲面:

框架的定义

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

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

曲线约束的定义

CurveConstraint类允许将曲线定义为对要构建的曲面的约束。

点约束的定义

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

将 Geom_Surface 应用到板曲面

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

将板曲面逼近到 BSpline

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

图片[19]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

由四条曲线和一个点生成的曲面

让我们创建一个板曲面并从多段线将其近似为曲线约束和点约束

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.);
W.Add(P1);
W.Add(P2);
W.Add(P3);
W.Add(P4);
W.Add(P1);
// Initialize a BuildPlateSurface
// Create the curve constraints
for(anExp.Init(W); anExp.More(); anExp.Next())
{
TopoDS_Edge E = anExp.Current();
Handle(BRepAdaptor_HCurve) C = new
BRepAdaptor_HCurve();
C-ChangeCurve().Initialize(E);
BPSurf.Add(Cont);
}
// Point constraint
BPSurf.Add(PCont);
// Compute the Plate surface
BPSurf.Perform();
// Approximation of the Plate surface
Standard_Integer MaxDegree=8;
Standard_Integer CritOrder=0;
Handle(GeomPlate_Surface) PSurf = BPSurf.Surface();
dmax = Max(0.0001,10*BPSurf.G0Error());
Tol=0.0001;
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 曲线投影到曲面上。
  • 从底层平面的 3D 到 2D 参数空间的平面曲线转置和 vs
  • 2D gp 对象在 3D 几何空间中的定位。

二维点在曲线上的投影

Geom2dAPI_ProjectPointOnCurve允许计算从一个点 ( gp_Pnt2d ) 投影到几何曲线 ( Geom2d_Curve ) 上的所有法线。计算可能仅限于给定域。

图片[20]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

从点到曲线的法线

曲线不必是Geom2d_TrimmedCurve。该算法将适用于任何继承Geom2d_Curve的类。

Geom2dAPI_ProjectPointOnCurve类可以被实例化,如下例所示:

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

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

这样创建了Geom2dAPI_ProjectPointOnCurve对象后,我们现在可以询问它。

调用解点数

Standard_Integer NumSolutions = Projector.NbPoints();

调用解点的位置

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

gp_Pnt2d Pn = Projector.Point(Index);

调用解点的参数

对于与给定Index对应的给定点:

Standard_Real U = Projector.Parameter(Index);

这也可以编程为:

Projector.Parameter(Index,U);

调用起点和终点之间的距离

我们可以找到初始点和一个点之间的距离,它对应于给定的Index

Standard_Real D = Projector.Distance(Index);

调用最近的解点

This class offers a method to return the closest solution point to the starting point. This solution is accessed as follows:

gp_Pnt2d P1 = Projector.NearestPoint();

调用最近解点的参数

Standard_Real U = Projector.LowerDistanceParameter();

调用点到曲线的最小距离

Standard_Real D = Projector.LowerDistance();

重新定义运算符

重新定义了一些运算符以找到最接近的解决方案。

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

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

gp_Pnt2d() 返回最近的解点。

当您只需要最近的点时,使用这些运算符可以更轻松地进行编码。 因此:

gp_Pnt2d P1 = Projector.NearestPoint();

可以更简洁地写成:

但是请注意,在第二种情况下,没有创建中间 Geom2dAPI_ProjectPointOnCurve 对象,因此无法访问其他解决方案点。

访问较低级别的功能

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

Extrema_ExtPC2d & TheExtrema = Projector.Extrema();

3D 点在曲线上的投影

GeomAPI_ProjectPointOnCurve类被实例化,如下例所示:

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

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

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

调用解点数

Standard_Integer NumSolutions = Projector.NbPoints();

调用解点的位置

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

gp_Pnt Pn = Projector.Point(Index);

调用解点的参数

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

Standard_Real U = Projector.Parameter(Index);

这也可以编程为:

Proj.Parameters(Index, U, V);

调用起点和终点之间的距离

可以找到初始点和对应于给定索引的点之间的距离:

Standard_Real D = Projector.Distance(Index);

调用最近的解点

此类提供了一种将最近的解点返回到起点的方法。该解决方案的访问方式如下:

gp_Pnt P1 = Projector.NearestPoint();

调用最近解点的参数

Standard_Real U = Projector.LowerDistanceParameter();

调用点到曲线的最小距离

Standard_Real D = Projector.LowerDistance();

重新定义运算符

一些运算符已被重新定义以找到最近的解决方案。

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

Standard_Integer() returns the number of solutions.

gp_Pnt2d() returns the nearest solution point.

当您只需要最近的点时,使用这些运算符可以更轻松地进行编码。 这样,

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

可以更简洁地写成:

然而,在第二种情况下,没有创建中间GeomAPI_ProjectPointOnCurve对象,并且无法访问其他解点。

访问较低级别的功能

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

Extrema_ExtPC & TheExtrema = Projector.Extrema();

点在曲面上的投影

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

图片[21]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

从点到曲面的法线投影

请注意,曲面不必是Geom_RectangularTrimmedSurface类型。
该算法将适用于任何继承Geom_Surface的类。

GeomAPI_ProjectPointOnSurf的实例化如下例所示:

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

U1、U2、V1V2的值处于或处于其最大和最小限制之内,即:

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

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

调用解点数

Standard_Integer NumSolutions = Proj.NbPoints();

调用解点的位置

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

gp_Pnt Pn = Proj.Point(Index);

调用解点的参数

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

Proj.Parameters(Index, U, V);

调用起点和终点之间的距离

可以找到初始点和对应于给定索引的点之间的距离:

Standard_Real D = Projector.Distance(Index);

调用最近的解点

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

gp_Pnt P1 = Proj.NearestPoint();

调用最近解点的参数

Proj.LowerDistanceParameters (U, V);

调用点到曲面的最小距离

Standard_Real D = Proj.LowerDistance();

重新定义运算符

一些运算符已重新定义,以帮助您找到最近的解决方案。

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

Standard_Integer()返回解的数量。

gp_Pnt2d()返回最近的解点。

当您只需要最近的点时,使用这些运算符可以更轻松地进行编码。这样,

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方法用于

这些方法调用如下:

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

标准拓扑对象

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

  • 点;
  • 边;
  • 面;
  • 线;
  • 多段线;
  • 壳;
  • 实体。

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

顶点

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

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

基本边构造方法

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

Handle( Geom_Curve ) C = …; // 一条曲线
TopoDS_Vertex V1 = …,V2 = …; // 两个顶点
Standard_Real p1 = …, p2 = ..; // 两个参数

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

图片[22]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

基本边缘构造

以下规则适用于参数:

曲线

  • 不得为空Handle。
  • 如果曲线是修整曲线,则使用基础曲线。

顶点

  • 可以是空形状。当 V1 或 V2 为 Null 时,边缘在相应方向上是开放的,并且相应的参数 p1 或 p2 必须是无限的(即 p1 是RealFirst(), p2 是RealLast())。
  • 如果它们具有不同的 3d 位置,则必须是不同的顶点;如果它们具有相同的 3d 位置,则必须是相同的顶点(当曲线闭合时使用相同的顶点)。

参数

  • 必须增加并且在曲线的范围内,即:
C->FirstParameter() <= p1 < p2 <= C->LastParameter()
  • 如果参数减少,则顶点切换,即V2变为V1,V1变为V2。
  • 在周期曲线上,通过增加或减去周期来调整参数 p1 和 p2,以获得曲线范围内的 p1 和 p1 < p2 <= p1+ 周期范围内的 p2。所以在一条参数曲线上p2可以大于第二个参数,见下图。
  • 可以是无限的,但对应的顶点必须为 Null(见上文)。
  • Vertex 3d 位置与使用参数在曲线上评估的点之间的距离必须低于默认精度。

下图说明了两种特殊情况,半无限边和周期曲线上的边。

图片[23]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

无限和周期性边

补充边构造方法

存在从基本方法派生的补充边缘构造方法。

BRepBuilderAPI_MakeEdge类提供了方法,都是上一个的简化调用:

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

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

Handle( Geom_Curve ) C = …; // 一条曲线
TopoDS_Vertex V1 = …,V2 = …; // 两个顶点
Standard_Real p1 = …, p2 = ..; // 两个参数
gp_Pnt P1 = …, P2 = …; // 两点
// 将顶点投影到曲线上
// 从点创建顶点
E = BRepBuilderAPI_MakeEdge (C,P1,P2,p1,p2);
// 从点创建顶点并投影它们
// 根据参数计算点
// 从整条曲线中创建一条边

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

gp_Lin创建Geom_Line gp_Circ创建Geom_Circle gp_Elips创建Geom_Ellipse gp_Hypr创建Geom_Hyperbola gp_Parab创建Geom_Parabola

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

TopoDS_Vertex V1 = …,V2 = …; // 两个顶点
gp_Pnt P1 = …, P2 = …; // 两点
// 来自两个顶点的线性边
// 两点的线性边

其他信息和错误状态

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

如果使用BRepBuilderAPI_MakeEdge作为类,它可以提供两个顶点。当顶点没有作为参数提供时,这很有用,例如当边缘是从曲线和参数构造时。Vertex1Vertex2两个方法返回顶点。请注意,如果边在相应方向上打开,则返回的顶点可以为空。

Error方法返回BRepBuilderAPI_EdgeError枚举的项。可用于分析IsDone方法返回 False 时的错误。条款是:

  • EdgeDone – 未发生错误,IsDone返回 True。
  • PointProjectionFailed – No parameters were given, but the projection of the 3D points on the curve failed. This happens if the point distance to the curve is greater than the precision.
  • ParameterOutOfRange – The given parameters are not in the range C->FirstParameter()C->LastParameter()
  • DifferentPointsOnClosedCurve – The two vertices or points have different locations but they are the extremities of a closed curve.
  • PointWithInfiniteParameter – A finite coordinate point was associated with an infinite parameter (see the Precision package for a definition of infinite values).
  • DifferentsPointAndParameter – 3D 点与带参数在曲线上评估的点的距离大于精度。
  • LineThroughIdenticPoints – 给出了两个相同的点来定义一条线(没有曲线的边缘构造),gp::Resolution用于测试混淆。

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

图片[24]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

创建线
#include < TopoDS_Shape.hxx >
#include < gp_Circ.hxx >
#include < gp.hxx >
#include < TopoDS_Wire.hxx >
// 使用 MakeArc 方法制作一条边和两个顶点
{
gp_Ax2 Origin = gp::XOY();
gp_Vec Offset(x, y, 0.);
Origin.Translate(Offset);
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);
// 首先创建圆形边和顶点
// 使用上述 MakeArc 函数。
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));
// 创建线性边
for (Standard_Integer i = 1; i <= 7; i += 2)
{
(theVertices(i+1)));
}
// 使用 BRepBuilderAPI_MakeWire 创建连线
for (i = 1; i <= 8; i++)
{
MW.Add(TopoDS::Edge(theEdges(i)));
}
return MW.Wire();
}

边缘 2D

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

BRepBuilderAPI_MakeEdge2d类与BRepBuilderAPI_MakeEdge严格相似,但它使用来自 gp 和 Geom2d 的 2D 几何而不是 3D 几何。

多边形

BRepBuilderAPI_MakePolygon类用于从顶点或点构建多边形线。点会自动更改为顶点,如BRepBuilderAPI_MakeEdge中一样。

BRepBuilderAPI_MakePolygon的基本用法是通过使用 Add 方法添加顶点或点来创建连线。随时都可以拔出当前的线。close 方法可用于关闭当前导线。在以下示例中,从点数组创建闭合线。

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

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

两个例子:

三个顶点的闭合三角形示例:

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

来自四个点的开放多边形示例:

BRepBuilderAPI_MakePolygon类维护当前的连线。可以随时拔出当前的线,并可以继续建造更长的线。每次插入点后,该类都会维护最后创建的边和顶点,这些边和顶点由Edge、FirstVertexLastVertex方法返回。

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

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

基本面构造方法

可以从一个表面和四个参数构造一个面,以确定 UV 空间的限制。这些参数是可选的,如果省略它们,则使用表面的自然边界。使用连线最多可创建四个边和顶点。当参数为无穷大时,不会创建边。

Handle( Geom_Surface ) S = …; // 一个表面
Standard_Real umin,umax,vmin,vmax; // 参数
TopoDS_Face F = BRepBuilderAPI_MakeFace (S,umin,umax,vmin,vmax);

图片[25]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

基本面构造

要从曲面的自然边界生成面,不需要以下参数:

Handle( Geom_Surface ) S = …; // 一个表面

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

  • umin,umax (vmin,vmax)必须在表面范围内并且必须增加。
  • U (V)周期表面上调整uminumax (vmin,vmax)
  • umin, umax, vmin, vmax可以是无限的。对应方向不会有边。

补充面构造方法

对所有gp封装表面都实现了两个基本构造(来自表面和来自表面和参数),这些表面在 Geom 的相应 Surface 中进行了转换。

gp封装面 Geom封装面
gp_Pln Geom_Plane
gp_Cylinder Geom_CylindricalSurface
gp_Cone 创建一个 Geom_ConicalSurface
gp_Sphere Geom_SphericalSurface
gp_Torus Geom_ToroidalSurface

创建面后,可以使用Add方法添加线。例如,以下代码创建一个圆柱面并添加一条线。

gp_Cylinder C = ..; // 一个圆柱体
TopoDS_Wire W = …;// a wire
MF.Add(W);
TopoDS_Face F = MF;

一个面可以添加多根线,前提是它们不相互交叉,并且只在曲面上定义一个区域。 (请注意,未选中此项)。对于一根线,提供了一种简单的语法来从表面和线构造面。 上面几行可以写成:

面上的边必须具有参数化曲线描述。 如果表面上没有线材边缘的参数曲线,则通过投影计算,此外,只能对平面进行计算。

一个平面可以仅由一根线创建,前提是该线定义了一个平面。例如,要从一组点创建平面,您可以使用BRepBuilderAPI_MakePolygonBRepBuilderAPI_MakeFace

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

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

TopoDS_Face F = …; // 一张面
TopoDS_Wire W = …; // 一条线

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

错误状态

Error方法返回一个错误状态,它是BRepBuilderAPI_FaceError枚举中的一个术语。

  • FaceDone – 没有发生错误。
  • NoFace——算法没有初始化;使用了一个空的构造函数。
  • NotPlanar – 没有给出表面并且导线不是平面的。
  • CurveProjectionFailed – 在曲面的参数空间中未找到边缘的曲线。
  • ParametersOutOfRange – 参数umin, umax, vmin, vmax超出表面。

线

线是一种复合形状,它不是由几何形状构建的,而是由边的组装而成。BRepBuilderAPI_MakeWire类可以从一条或多条边构建线或将新边连接到现有线。

最多可以直接使用四个边,例如:

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

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

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

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

BRepBuilderAPI_MakeWire 类将边连接到线。当添加一条新边时,如果它的一个顶点与导线共享,则它被视为已连接到线。如果没有共享顶点,则算法搜索位于同一位置的边的顶点和线的顶点(顶点的容差用于测试它们是否具有相同的位置)。如果找到这样的一对顶点,则使用线的顶点代替原始顶点复制边。边的所有顶点都可以换成线的顶点。如果未找到连接,则认为线已断开。这是一个错误。

BRepBuilderAPI_MakeWire 类可以返回添加到连线上的最后一条边(Edge 方法)。如果它被复制,此边缘可能与原始边缘不同。

Error 方法返回 BRepBuilderAPI_WireError 枚举项:WireDone – 未发生错误。 EmptyWire——没有初始化算法,使用了一个空的构造函数。 DisconnectedWire – 最后添加的边未连接到线。 NonManifoldWire – 具有一些奇点的线。

壳是一种复合形状,它不是由几何形状构建的,而是由面的组合构建的。使用BRepBuilderAPI_MakeShell类从一组 Faces 构建一个 Shell。可能重要的是每个面都应具有所需的连续性。这就是为什么初始表面被分解成面的原因。

实体

实体是一种复合形状,它不是由几何形状构建的,而是由壳的组装而成。使用BRepBuilderAPI_MakeSolid类从一组壳构建一个实体。它的使用类似于 MakeWire 类的使用:将壳添加到实体中的方式与在 MakeWire 中将边添加到线的方式相同。

基本体

BRepPrimAPI包提供一个 API(应用程序编程接口)用于构造原语,例如:

  • 盒子;
  • 锥体;
  • 圆柱;
  • 棱柱。

可以创建部分实体,例如受经度限制的球体。在实际模型中,可以使用基元来轻松创建特定的子部分。

  • 沿轮廓扫掠构造:
    • 线性;
    • 旋转(通过旋转角度)。

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

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

不允许扫掠固体和复合固体。BRepOffsetAPI包中也提供了沿复杂轮廓(例如 BSpline 曲线)的扫掠构造。此 API 为最常见的操作提供简单的高级调用。

制作基本体

盒子

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

  • 从三个维度dx、dydz。该框平行于轴并延伸[0,dx] [0,dy] [0,dz]
  • 从一个点和三个维度。与上面相同,但重点是新的原点。
  • 从两点开始,长方体平行于轴,并在两点坐标定义的间隔上延伸。
  • 来自轴gp_Ax2和三个维度的系统。与第一种方式相同,但盒子平行于给定的轴系统。

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

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

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

图片[26]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

制作盒子

BRepPrimAPI_MakeWedge类允许构建一个楔形,它是一个倾斜的盒子,即一个有角度的盒子。楔的构造方式与盒子的构造方式非常相似,即从三个维度 dx、dy、dz 加上参数或从一个轴系、三个维度和参数。

下图显示了构建楔形的两种方法。一种是添加一个维度ltx ,它是dy处面的x长度。第二种是在dy处添加xmin、xmax、zminzmax来描述面。

第一种方法是第二种方法的特例,其中xmin = 0, xmax = ltx, zmin = 0, zmax = dz。要制作中心金字塔,您可以使用xmin = xmax = dx / 2, zmin = zmax = dz / 2

图片[27]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

制作楔子

旋转对象

BRepPrimAPI_MakeOneAxis是一个延迟类,用作构建旋转图元的所有类的根类。旋转图元是通过围绕轴旋转曲线来创建的。它们涵盖了圆柱体、圆锥体、球体、圆环体和旋转体,它提供了所有其他曲线。

描述了这些原语的特定结构,但它们都有一些共同的论点,它们是:

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

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

图片[28]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

MakeOneAxis 参数

圆柱

BRepPrimAPI_MakeCylinder类允许创建圆柱形基元。在默认坐标系或给定坐标系gp_Ax2中创建圆柱体。有两种构造:

  • 半径和高度,构建一个完整的圆柱体。
  • 构建圆柱体一部分的半径、高度和角度。

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

Standard_Real X = 20, Y = 10, Z = 15, R = 10, DY = 30;
// 制作坐标系
gp_Ax2 axes = gp::ZOX();
axes.Translate(gp_Vec(X,Y,Z));
BRepPrimAPI_MakeCylinder(axes,R,DY,PI/2.);

图片[29]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

圆柱

锥体

BRepPrimAPI_MakeCone类允许创建锥形图元。像圆柱体一样,圆锥体在默认坐标系或给定坐标系 ( gp_Ax2 ) 中创建。有两种构造:

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

以下代码构建了图形的实心圆锥体,它位于默认系统中,半径为R1R2,高度为H

Standard_Real R1 = 30,R2 = 10,H = 15;

图片[30]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

锥体

球形

BRepPrimAPI_MakeSphere类允许创建球形图元。像圆柱体一样,球体在默认坐标系或给定坐标系gp_Ax2中创建。有四种结构:

  • 从一个半径 – 构建一个完整的球体。
  • 从一个半径和一个角度——构建一个月形(digon)。
  • 从一个半径和两个角度——在两个纬度之间建立一个环绕的球面。角度a1a2必须遵循以下关系:PI/2 <= a1 < a2 <= PI/2
  • 从一个半径和三个角度——结合以前的两种方法来构建球面的一部分。

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

Standard_Real R = 30, =
PI/2,a1 = -PI/2.3,a2 = PI/4;

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

图片[31]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

球体的例子

环面

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

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

图片[32]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

托里的例子

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

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

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

革命

BRepPrimAPI_MakeRevolution类允许从曲线构建单轴基元。与其他单轴基元一样,它可以在默认坐标系或给定坐标系中创建。

曲线可以是任何Geom_Curve,只要它是平面的并且与局部坐标系的 Z 轴位于同一平面内。建设模式有四种:

  • 从曲线开始,使用完整曲线并进行完整旋转。
  • 从曲线和旋转角度。
  • 从一条曲线和两个参数来修剪曲线。这两个参数必须在增长并且在曲线范围内。
  • 从一条曲线、两个参数和一个角度。这两个参数必须在增长并且在曲线范围内。

扫掠:拉伸体、旋转和管道

扫掠

扫描是通过沿路径扫描轮廓获得的对象。配置文件可以是任何拓扑。路径通常是曲线或线。配置文件根据以下规则生成对象:

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

禁止清扫固体和复合固体。一个 Compound 生成一个包含所有元素的 Compound。

图片[33]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

生成扫描

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

拉伸

BRepPrimAPI_MakePrism类允许从形状和矢量或方向创建线性拉伸

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

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

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

图片[34]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

“有限、无限和半无限拉伸”,420

旋转扫描

BRepPrimAPI_MakeRevol类允许从形状、轴 ( gp_Ax1 ) 和角度创建旋转扫描该角度的默认值为 2*PI,表示闭合旋转。

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

TopoDS_Face F = …; // the profile
gp_Ax1 axis(gp_Pnt(0,0,0),gp_Dir(0,0,1));
Standard_Real ang = PI/3;
// Full revol

图片[35]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

完全和部分旋转

布尔运算

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

Operation Result
S1 或 S2 中的所有点
S1 和 S2 中的所有点
S1 中的所有点,而不是 S2 中的所有点

图片[36]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

布尔运算

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

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

有关详细文档,请参阅布尔运算

输入和结果参数

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

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

执行

BRepAlgoAPI_BooleanOperation类是布尔运算的延迟根类。

BRepAlgoAPI_Fuse执行熔断操作。

TopoDS_Shape A = …, B = …;

BRepAlgoAPI_Common执行 Common 操作。

TopoDS_Shape A = …, B = …;

BRepAlgoAPI_Cut执行剪切操作。

TopoDS_Shape A = …, B = …;

部分

BRepAlgoAPI_Section执行部分,描述为由 TopoDS_Edge组成的TopoDS_Compound

图片[37]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

分段操作
TopoDS_Shape A = …,TopoDS_ShapeB = …;

拓扑工具

Open CASCADE Technology 拓扑工具提供算法

  • 从边缘创建线;
  • 从线创建面;
  • 计算形状相对于其他形状的状态;
  • 在容器中定位形状;
  • 从现有形状创建新形状;
  • 建立面上边的 PCurves;
  • 检查形状的有效性;
  • 取点在面上;
  • 获取面部的法线方向。

从线框模型创建面

可以从随机位于 3D 空间中的任意一组平面边创建平面。例如,如果您需要从线框模型中恢复形状,此功能可能会很有用:

图片[38]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

线框模型

图片[39]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

模型的面

要从边创建面,首先需要从给定的边创建平面线,然后从每条线创建平面。静态方法BOPAlgo_Tools::EdgesToWiresBOPAlgo_Tools::WiresToFaces可用于:

TopoDS_Shape anEdges = …; /* 输入边 */
Standard_Real anAngTol = 1.e-8; /* 区分导线所在平面的角度公差 */
Standard_Boolean bShared = Standard_False ; /* 定义边是否共享 */
//
TopoDS_Shape aWires;/* 产生的线 */
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;/* 结果面 */
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允许从平面线创建平面。一般来说,输入线是非歧管的,可以不封闭,但应共用重合部分。位于同一平面并完全包含在其他线中的线将在由外部线构建的面中产生孔:

图片[40]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

线框模型

图片[41]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

两张面(红面有洞)

形状的分类

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

容器中形状的方向

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

制作新形状

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

构建 PCurves

以下方法允许在面上构建边的 PCurves:

  • BOPTools_AlgoTools::BuildPCurveForEdgeOnFace计算面部边缘的 PCurve;
  • BOPTools_AlgoTools::BuildPCurveForEdgeOnPlaneBOPTools_AlgoTools::BuildPCurveForEdgesOnPlane允许为平面上的边构建 PCurve;
  • BOPTools_AlgoTools::AttachExistingPCurve从一个边缘获取面上的 PCurve 并将此 PCurve 附加到与第一个边缘重合的其他边缘。

检查形状的有效性

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

取一个点在面上

以下方法允许获取位于面部内部的点:

面变得正常

以下方法允许获取面/曲面的法线方向:

拓扑 API

Open CASCADE Technology ( OCCT ) 的 Topology API 包括以下六个包:

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

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

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

gp_Pnt P1(10,0,0), P2(20,0,0);

这是从两点 P1、P2 创建边 E 的最简单方法,但是当开发人员对数据没有前面示例中的信心时,可以测试错误。

#include <gp_Pnt.hxx>
#include <TopoDS_Edge.hxx>
void EdgeTest()
{
gp_Pnt P1;
gp_Pnt 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,
{
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 时会自动调用此方法。

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

History support

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

  • 点;
  • 边;
  • 面。

一些算法还支持实体的历史。

历史信息由以下信息组成:

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

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

历史信息可以通过 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 元素列表将仅包含那些对操作结果有贡献的元素。如果列表为空,则说明形状没有被修改,需要检查是否已删除。

例如,在向任何方向平移形状后,其所有子形状都将被修改为其翻译后的副本。

生成的形状

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

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

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

BRepTools_History

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

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

// 操作的参数
TopoDS_Shape aS = …;
// 对形状进行变换
gp_Trsf aTrsf;
aTrsf.SetTranslationPart ( gp_Vec ( 0 , 0 , 1 ));
BRepBuilderAPI_Transform aTransformer(aS, aTrsf); // 转换 API 算法
const TopoDS_Shape & aRes = aTransformer.Shape();
// 创建翻译历史对象
anArguments.Append(aS);
BRepTools_History aHistory(anArguments, aTransformer);

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

Handle( BRepTools_History ) aHist1 = …; // 第一次操作的历史
Handle( BRepTools_History ) aHist2 = …; // 第二次操作的历史

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

aHist1->Merge(aHist2);

或者创建新的历史,保持两个历史不变:

aResHistory->Merge(aHist1);
aResHistory->Merge(aHist2);

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

绘制历史支持

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

  • 已删除
  • 修改;
  • 生成.

有关Draw History 机制的更多信息,请参阅Draw用户指南 –历史命令中的相应章节。

圆角和倒角

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

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

如果存在凹面,则处理需要延伸的表面和不需要延伸的表面。

圆角

圆角形状

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

BRepFilletAPI_MakeFillet类允许对形状进行圆角处理。

要生成圆角,需要在构造类时定义圆角形状,并使用Add方法添加圆角描述。

圆角描述包含边和半径。边必须由两个面共享。圆角会自动延伸到与原始边缘平滑连续的所有边缘。两次添加圆角不是错误,最后的描述成立。

图片[42]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

使用半径 r1 和 r2 对两条边进行圆角化。

在以下示例中,将创建一个尺寸为 a、b、c 和半径为 r 的圆角框。

恒定半径

#include < TopoDS_Shape.hxx >
#include < TopoDS.hxx >
#include < TopoDS_Solid.hxx >
#include < TopExp_Explorer.hxx >
const Standard_Real c,
{
// 将所有边添加到圆角
TopExp_Explorer ex(Box,TopAbs_EDGE);
while (ex.More())
{
MF.Add(r,TopoDS::Edge(ex.Current()));
ex.Next();
}
return MF.Shape();
}

图片[43]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

具有恒定半径的圆角

改变半径

void CSampleTopologicalOperationsDoc::OnEvolvedblend1()
{
TopoDS_Shape theBox = BRepPrimAPI_MakeBox(200,200,200);
Rake.SetFilletShape(FSh);
TColgp_Array1OfPnt2d ParAndRad(1, 6);
ParAndRad(1).SetCoord(0., 10.);
ParAndRad(1).SetCoord(50., 20.);
ParAndRad(1).SetCoord(70., 20.);
ParAndRad(1).SetCoord(130., 60.);
ParAndRad(1).SetCoord(160., 30.);
ParAndRad(1).SetCoord(200., 20.);
TopExp_Explorer ex(theBox,TopAbs_EDGE);
Rake.Add(ParAndRad, TopoDS::Edge(ex.Current()));
TopoDS_Shape evolvedBox = Rake.Shape();
}

图片[44]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

半径变化的圆角

倒角

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

BRepFilletAPI_MakeChamfer类的使用类似于 BRepFilletAPI_MakeFillet 的使用,除了以下几点:

  • 创建的表面是直纹的且不光滑。
  • 用于选择边缘的添加语法需要一个或两个距离,一个边缘和一个面(与边缘相邻)。
Add(dist, E, F)
Add(d1, d2, E, F) with d1 on the face F.

图片[45]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

倒角

平面上的圆角

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

可以使用AddChamfer方法计算倒角。可以描述为

  • 两条边和两条距离
  • 一个边,一个顶点,一个距离,一个角度。添加完成后计算圆角和倒角。

如果面 F2 是由面 F1 的 2D 圆角和倒角构建器创建的,则可以重建构建器(构建器恢复其删除前的状态)。为此,请使用以下语法:

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 c,
{
TopExp_Explorer ex1(Box,TopAbs_FACE);
const TopoDS_Face& F = TopoDS::Face(ex1.Current());
TopExp_Explorer ex2(F, TopAbs_VERTEX);
while (ex2.More())
{
MF.AddFillet(TopoDS::Vertex(ex2.Current()),r);
ex2.Next();
}
// while…
return MF.Shape();
}

偏移、拔模、管道和演变的形状

这些类提供以下服务:

  • 创建偏移形状及其变体,例如:
    • 镂空;
    • 脱壳;
    • Lofting;
  • 使用拔模角创建锥形形状;
  • 创建扫描。

偏移量计算

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

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

  • 第一步,计算偏移量。
  • 在此之后,为每个偏移量计算分析延拓。
  • 根据原始拓扑信息(共享、邻居数量等)计算成对交集。
  • 偏移形状已组装。

第二种算法基于这样一个事实,即始终可以构建没有延续的单个面的偏移计算。下面的列表显示了简单的偏移算法:

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

下面的片段显示了使用示例:

// Computes offset shape using analytical continuation mechanism.
OffsetMaker1.PerformByJoin(Shape, OffsetValue, Tolerance);
if (OffsetMaker1.IsDone())
NewShape = OffsetMaker1.Shape();
// 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 = …;
TopoDS_Shape Result;
for (Standard_Integer i = 1 ;i <= n; i++) {
TopoDS_Face SF = …; // a face from SolidInitial
LCF.Append(SF);
}
SolidMaker.MakeThickSolidByJoin(SolidInitial,
LCF,
Of,
Tol);
if (SolidMaker.IsDone())
Result = SolidMaker.Shape();

图片[46]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

脱壳

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

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

拔模角

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

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

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

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

TopoDS_Shape myShape = …
// The original shape
// 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);
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();
}

图片[47]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

拔模斜度

管道构造器

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

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

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

图片[48]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

管道示例

进化实体

BRepOffsetAPI_MakeEvolved 类允许从 Spine(平面或线)和轮廓(线)创建进化实体。

演化实体是由脊椎和轮廓生成的未循环扫描。

演化实体是通过在脊椎上扫描轮廓的参考轴来创建的。 轴的原点移动到脊椎,X 轴和局部切线重合,Z 轴垂直于面。

轮廓的参考轴可以按照两种不同的模式定义:

轮廓的参考轴是原点轴。
轮廓的参考轴计算如下:
原点由脊椎上最接近轮廓的点给出
X 轴由上面定义的点与脊柱的切线给出
Z 轴是包含脊柱的平面的法线。

TopoDS_Face Spine = …;
TopoDS_Wire Profile = …;
BRepOffsetAPI_MakeEvolved(脊柱,轮廓);

对象修改

转型

BRepBuilderAPI_Transform类可用于对形状应用变换(参见类gp_Trsf)。只要转换允许,这些方法都有一个布尔参数来复制或共享原始形状(仅适用于直接等距转换)。默认情况下,原始形状是共享的。

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

TopoDS_Shape myShape1 = …;
// 原来的形状 1
TopoDS_Shape myShape2 = …;
//原来的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);
// 这里强制复制
TopoDS_Shape myNewShape2 = theTrsf.Shape()

复制

使用BRepBuilderAPI_Copy类复制形状。因此创建了一个新的形状。在以下示例中,复制了一个实体:

TopoDS Solid MySolid;
….// Creates a solid

拓扑 API 中的错误处理

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

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

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

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

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

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

try {
// go on with the edge
}
catch {
// process the error.
}

To help the user, the Topology API classes only raise the exception StdFail_NotDone. Any other exception means that something happened which was unforeseen in the design of this API.

The NotDone exception is only raised when the user tries to access the result of the computation and the original data is corrupted. At the construction of the class instance, if the algorithm cannot be completed, the internal flag NotDone is set. This flag can be tested and in some situations a more complete description of the error can be queried. If the user ignores the NotDone status and tries to access the result, an exception is raised.

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;

缝纫

介绍

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

图片[49]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

具有部分共享边的形状

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

缝纫不会改变形状的几何表示。缝纫适用于未连接但可以连接的拓扑元素(面、边),因为它们在几何上是重合的:它添加了有关拓扑连接的信息。在多路缝合的情况下,已经连接的元素保持不变。

让我们定义几个术语:

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

缝纫算法

缝纫算法是用于形状加工的基本算法之一,因此其质量非常重要。

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

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

缝纫支持大数值公差的工作模式。无需逐步重复缝制,同时平滑地增加公差。

也可以将边线缝合到线,并从形状中缝合局部分离的面和边线。

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

简而言之,算法应该为每个自由边界找到一组合并候选,根据一定的标准对其进行过滤,最后将找到的候选合并并构建生成的缝合形状。

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

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

例子

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

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

如果所有面都已正确缝合,则结果是一个壳。否则,它是一个化合物。成功的缝纫操作后,所有面都具有一致的方向。

公差管理

为了产生一个封闭的外壳,Sewing 允许指定工作公差的值,超过属于该形状的小面的大小。

然而,如果我们生产一个开放的外壳,如果工作公差的值太大(即它超过位于开放边界上的面的大小),就有可能得到不正确的缝纫结果。

对于缝纫过程的调整,可以提出以下建议:

  • 使用尽可能小的工作公差。这将减少缝合时间,从而减少带有自由边界的外壳的错误缝合边缘的数量。
  • 使用尽可能大的最小公差。这将减少形状中的小几何图形的数量,包括原始几何图形和切割后出现的几何图形。
  • 如果预期通过缝合获得带孔(自由边界)的壳,则工作公差应设置为不大于最小元素(边缘)的大小或该自由边界元素之间的最小距离的值. 否则,可能仅部分缝合自由边界。
  • 应该提到的是,缝纫算法无法理解应该保留哪个小的(小于工作公差)自由边界以及应该缝合哪个。

歧管和非歧管缝纫

要从一组面创建一个或多个壳,缝合合并属于不同面或一个闭合面的边。

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

面的流形缝合仅将属于不同面或一个闭合面的两条最近边相互合并。面的非流形缝合会在小于指定公差的距离处合并所有边。

对于复杂的拓扑结构,建议先应用歧管缝合,然后再对非歧管缝合应用最小可能的工作公差。但是,对于简单的拓扑,这不是必需的。

给非流形缝合一个大的公差值会导致很多错误,因为所有附近的几何图形都将被缝合。

本地缝纫

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

局部缝纫特别适合开壳。它允许在形状的一个部分缝制不需要的孔并保留所需的孔,该孔小于为形状的另一部分局部缝制指定的工作公差。局部缝纫比在整个形状上缝纫要快得多。

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

例如,如果您想使用局部缝合缝合两个具有重合自由边的开放壳,则必须从两个壳创建复合物,然后使用方法BRepBuilderAPI_Sewing::Load() 加载完整复合物。之后,需要添加局部子形状,应使用方法BRepBuilderAPI_Sewing::Add()进行缝合。可以使用方法BRepBuilderAPI_Sewing::SewedShape()获得缝纫结果。

请参阅示例:

//初始缝合形状
TopoDS_Shape aS1 , aS2; // 这些形状应该是缝好的贝壳
aB.MakeCompound(aComp);
aB.Add(aComp, aS1);
aB.Add(aComp, aS2);
…………………………..
aSewing.Load(aComp);
//应该局部缝合的子形状
aSewing.Add(aF1);
aSewing.Add(aF2);
//进行缝纫
aSewing.Perform();
//结果形状
TopoDS_Shape aRes = aSewing.SewedShape();

特征

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

形式特征

形状特征是凹陷或凸起,包括以下类型:

  • 圆柱;
  • 棱镜草案;
  • 棱镜;
  • 旋转特征;
  • 管道。

根据您希望制作凹陷还是突出,您可以选择移除物质(布尔切割:Fuse 等于 0)或添加它(布尔融合:Fuse 等于 1)。

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

  • 在一定方向上一定长度;
  • 直至极限面;
  • 从高处的限制面;
  • 在平面上方和/或下方。

定义特征构造的形状可以是支撑边或面的相关区域。

在支撑边缘的情况下,可以通过绑定将该轮廓附加到基础形状的面上。当轮廓绑定到这个面上时,轮廓将在面上滑动的信息就可以用于相关的类方法。例如,对于面的相关区域,您可以将其切出并将其移动到不同的高度,该高度定义了突起或凹陷的限制面。

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

BRepFeat包中的Form是一个延迟类,用作表单功能的根。它从BRepBuilderAPI继承MakeShape并提供跟踪所有子形状的方法的实现。

拉伸

BRepFeat_MakePrism类用于构建与形状交互的拉伸。它是从创建或初始化的

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

有六种执行方法:

方法 描述
Perform(Height) 得到的拉伸具有给定的长度。
Perform(Until) 拉伸定义在基座位置和给定面之间。
Perform(From, Until) 拉伸定义在 From 和 Until 两个面之间。
PerformUntilEnd() 拉伸是半无限的,受底座实际位置的限制。
PerformFromEnd(Until) 拉伸是半无限的,受限于面直到。
PerformThruAll() 拉伸是无限的。在凹陷的情况下,结果类似于具有无限拉伸的切割。在突出的情况下,结果中不会保留无限部分。

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

在下面的序列中,执行突出,即将形状的面变为棱柱。

TopoDS_Shape Sbase = …; // 初始形状
TopoDS_Face Fbase = ….; // 拉伸底
gp_Dir Extrusion (.,.,.);
// 给定一个空面作为草图面
BRepFeat_MakePrism thePrism(Sbase, Fbase, TopoDS_Face (), Extrusion, Standard_True, Standard_True);
thePrism, Perform(100.);
if (thePrism.IsDone()) {
TopoDS_Shape theResult = thePrism;
}

图片[50]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

与 MakePrism 融合

图片[51]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

使用 Perform() 在两个面之间创建棱镜

拉伸草案

BRepFeat_MakeDPrism类用于构建与基本形状交互的草图拉伸拓扑。这些可以是凹陷或突起。类对象从以下位置创建或初始化:

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

显然,MakeDPrism 的输入数据与 MakePrism 的输入数据相同,除了一个新参数 Angle 和一个缺失参数 Direction:拉伸生成的方向自动确定为拉伸底部的法线。草稿拉伸特征创建的语义基于形状的构造:

  • 沿一段长度
  • 直到极限面
  • 从一个限制面到一个高度。

拔模拉伸特征的形状定义构造可以是支撑边或面的相关区域。

在支撑边缘的情况下,该轮廓可以通过装订连接到基础形状的面上。当轮廓绑定到这个面上时,轮廓将在面上滑动的信息就可以用于相关的类方法。在面的相关区域的情况下,可以将其切出并将其移动到不同的高度,这将定义突出或凹陷方向的限制面。

Perform方法与MakePrism相同

TopoDS_Shape S = BRepPrimAPI_MakeBox(400.,250.,300.);
Ex.Init(S,TopAbs_FACE);
Ex.Next();
Ex.Next();
Ex.Next();
Ex.Next();
Ex.Next();
c(gp_Ax2d(gp_Pnt2d(200.,130.),gp_Dir2d(1.,0.)),50.);
MW.Add(BRepBuilderAPI_MakeEdge(aline,surf,0.,PI));
MW.Add(BRepBuilderAPI_MakeEdge(aline,surf,PI,2.*PI));
MKF.Init(surf,Standard_False);
MKF.Add(MW.Wire());
TopoDS_Face FP = MKF.Face();
BRepFeat_MakeDPrism MKDP (S,FP,F,10*PI180,Standard_True,
Standard_True);
MKDP.Perform(200);
TopoDS_Shape res1 = MKDP.Shape();

图片[52]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

锥形棱镜

旋转

BRepFeat_MakeRevol类用于构建与形状交互的旋转。它是从以下位置创建或初始化的:

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

有四种执行方法:

方法 描述
Perform(Angle) 由此产生的革命具有给定的规模。
Perform(Until) 旋转是在底座的实际位置和给定面之间定义的。
Perform(From, Until) 旋转定义在两个面之间,From 和Until。
PerformThruAll() 结果类似于 Perform(2*PI)。

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

在下面的序列中,一个面被旋转并且旋转受到基础形状的一个面的限制。

TopoDS_Shape Sbase = …; // 初始形状
TopoDS_Face Frevol = ….; // 棱镜底
TopoDS_Face FUntil = ….; // 面限制旋转
gp_Dir RevolDir (.,.,.);
gp_Ax1 RevolAx( gp_Pnt (.,.,.), RevolDir);
// 给定一个空面作为草图面
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() 管道沿整个路径(脊线)定义
Perform(Until) 管道沿路径定义,直到给定面
Perform(From, Until) 管道在 From 和 Until 两个面之间定义

让我们看一下这个例子:

TopoDS_Shape S = BRepPrimAPI_MakeBox(400.,250.,300.);
Ex.Init(S,TopAbs_FACE);
Ex.Next();
Ex.Next();
gp_Pnt2d p1,p2;
p1 = gp_Pnt2d(100.,100.);
p2 = gp_Pnt2d(200.,100.);
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)));
MKF1.Init(surf,Standard_False);
MKF1.Add(MW1.Wire());
TopoDS_Face FP = MKF1.Face();
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;
(CurvePoles);
BRepFeat_MakePipe MKPipe (S,FP,F1,W,Standard_False,
Standard_True);
MKPipe.Perform();
TopoDS_Shape res1 = MKPipe.Shape();

图片[53]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

管道凹陷

机械特性

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

机械特征的语义是围绕给轮廓赋予厚度而建立的。该厚度可以是对称的——在轮廓的一侧——也可以是不对称的——在两侧。与形状特征的语义一样,厚度是由特定上下文中形状的构造定义的。

然而,在机械特征的情况下,开发环境有所不同。在这里,它们包括挤压:

  • 到基础形状的限制面;
  • 往返限制平面;
  • 到一个高度。

类对象是从创建或初始化的

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

线性形式

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

gp_Pnt p1 = gp_Pnt(0.,0.,0.);
gp_Pnt p2 = gp_Pnt(200.,0.,0.);
p1 = p2;
p2 = gp_Pnt(200.,0.,50.);
p1 = p2;
p2 = gp_Pnt(50.,0.,50.);
p1 = p2;
p2 = gp_Pnt(50.,0.,200.);
p1 = p2;
p2 = gp_Pnt(0.,0.,200.);
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.)));
(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();

图片[54]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

创建肋骨

上胶机

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

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

请注意,每个面和边都必须有界,如果两个粘合面的两条边重合,则它们必须明确有界。

TopoDS_Shape Sbase = …; // the basic shape
TopoDS_Shape Sglued = …; // the glued shape
// Determination of the glued faces
BRepFeat_Gluer theGlue(Sglue, Sbase);
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(Wire, Face) – 在基本形状的面上添加一条新线。
  • Add(Edge, Face) – 在基本形状的面上添加一条新边。
  • Add(EdgeNew, EdgeOld) – 在现有边上添加新边(旧边必须包含新边)。

注意添加的线和边必须在面或位于两条现有边之间的线上定义闭合线。现有边不得相交。

TopoDS_Shape Sbase = …; //基本形状
TopoDS_Face Fsplit = …; // Sbase 的面
TopoDS_Wire Wsplit = …; // Fsplit 中包含的新线
BRepFeat_SplitShape Spls(Sbase);
Spls.Add(Wsplit, Fsplit);
TopoDS_Shape theResult = Spls;

3D 模型

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

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

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

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

在移除特征之前,所有要从形状中移除的面都被分类成连接的块 – 每个块代表一个要移除的单个特征。特征会从形状中一一移除,即使移除存在一些问题(例如,由于输入数据不正确),也可以移除所有可能的特征。

移除的特征由与其相邻的面的延伸部分填充。一般来说,从形状中删除单个特征的算法如下:

  • 找到与特征相邻的面;
  • 延伸相邻面以覆盖特征;
  • 通过原始面的边界修剪扩展面(与特征共同的边界除外),使其仅覆盖特征;
  • 使用重建的相邻面重建实体,避免特征面。

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

Defeaturing 算法有以下选项:

  • 历史支持;

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

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

请注意,此处不支持基类的其他选项,不会产生任何影响。

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

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

  • BOPAlgo_AlertUnsupportedType – 如果输入形状不包含任何实体,则警报将作为错误给出,如果输入形状不仅包含实体,还包含其他形状,则作为警告;
  • BOPAlgo_AlertNoFacesToRemove – 如果没有要从形状中删除的面,则会发出错误警报(无事可做);
  • BOPAlgo_AlertUnableToRemoveTheFeature – 发出警告警报以通知用户无法删除该功能。该算法仍会尝试删除其他特征;
  • BOPAlgo_AlertRemoveFeaturesFailed – 如果操作因未知原因中止,则会发出错误警报。

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

并行处理模式– 允许以并行模式运行算法,更快地获得结果。

该算法有一定的局限性:

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

请注意,要成功移除特征,与特征相邻的扩展面应完全覆盖特征,否则实体将无法重建。看看下图中的简单形状:

图片[55]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

去除间隙的所有三个面是行不通的,因为将没有面来填充台阶的横向部分。虽然,只删除两个面,保留一个横向面,将用保留的面填充间隙:

图片[56]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

保持右侧横向面

图片[57]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

保持左侧横面

用法

以下是在C++ 级别上使用BRepAlgoAPI_Defeaturing算法的示例:

TopoDS_Shape aSolid = …; // 输入形状以从中删除特征
TopTools_ListOfShape aFeatures = …; // 要从形状中删除的特征
Standard_Boolean bRunParallel = …; // 并行处理模式
Standard_Boolean isHistoryNeeded = …; // 历史支持
BRepAlgoAPI_Defeatureing aDF; // 反特征算法
aDF。SetShape (aSolid); // 设置形状
aDF。AddFacesToRemove (aFaces); // 添加要移除的面
aDF。SetRunParallel (bRunParallel); // 定义处理模式(并行或单)
aDF。SetToFillHistory (isHistoryNeeded); // 定义是否跟踪形状修改
aDF.Build(); // Perform the operation
if (!aDF.IsDone()) // Check for the errors
{
// error treatment
aDF.DumpErrors(aSStream);
return;
}
if (aDF.HasWarnings()) // Check for the warnings
{
// warnings treatment
aDF.DumpWarnings(aSStream);
}
const TopoDS_Shape& aResult = aDF.Shape(); // Result shape

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

// 获取形状的修改
// 获取从形状生成的形状
// 检查形状是否被移除

命令removefeatures允许在Draw级别上使用 Defeaturing 算法。

标准历史命令可用于跟踪取消特征期间形状修改的历史。

有关上述命令的更多详细信息,请参阅绘制测试工具用户指南的特征化命令。

例子

以下是 ANC101 模型的特征化示例:

图片[58]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

ANC101 型号

图片[59]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

移除圆柱形突起

图片[60]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

结果

图片[61]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

移除圆柱孔

图片[62]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

结果

图片[63]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

移除圆柱孔

图片[64]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

结果

图片[65]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

去除前面的小缝隙

图片[66]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

结果

图片[67]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

完全消除前面的缝隙

图片[68]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

结果

图片[69]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

移除圆柱形突起

图片[70]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

结果

以下是对包含混合框的模型进行特征化的几个示例:

图片[71]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

盒混合模型

图片[72]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

去除混合物

图片[73]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

结果

图片[74]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

去除混合物

图片[75]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

结果

图片[76]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

去除混合物

图片[77]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

结果

图片[78]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

去除混合物

图片[79]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

结果

图片[80]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

去除混合物

图片[81]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

结果

图片[82]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

去除混合物

图片[83]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

结果

3D 模型周期性

Open CASCADE Technology 提供了用于在 3D 空间中沿指定方向制作任意 3D 模型(或仅形状)的工具。

形状的周期性意味着该形状可以在任何周期方向上重复任意次数,而无需创建新的几何图形或拆分。该算法的想法是使形状在相对侧或周期方向的周期边界上看起来相似。这并不意味着形状的相对侧将被镜像。这只是意味着形状的相对侧应该相互分割并在相对侧获得相同的几何形状。这种方法将允许重复形状,即在周期上平移形状的副本,而无需创建新的几何形状,因为不会有不同维度的重合部分。

为了更好地理解周期性的含义,让我们创建一个简单的棱镜并使其具有周期性。以下绘制脚本创建了扩展为 10x5x10 的 L 形棱镜:

折线 p 0 0 0 0 0 10 5 0 10 5 0 5 10 0 5 10 0 0 0 0 0
mkplane fp
棱镜 SF 0 5 0

图片[84]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

形成周期性的形状

使该形状在 X、Y 和 Z 方向上具有周期性,其周期与形状的扩展相匹配,应该使该形状的负 X 和 Z 侧分裂。Y 方向两侧的形状已经相似,因此预计不会出现新的分割。这是使其周期性后的形状:

图片[85]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

周期性形状

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

图片[86]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

重复形状

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

图片[87]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

重复形状

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

如有必要,该算法将通过将形状与限制形状请求周期的平面拆分来修剪形状以适应请求的周期。例如,让我们使 L 形仅在 X 方向上具有周期性,周期 2 从 X 参数 4 开始:

图片[88]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

周期性修剪形状

形状是如何形成周期性的

为了使形状在某个方向上具有周期性,算法执行以下步骤:

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

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

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

对立形状联想

该算法还关联位于周期性形状相对侧的相同(或双)形状。通过构造,双胞胎应始终具有相同的几何形状并在周期上彼此间隔开。该形状可能没有任何双胞胎。这意味着在重复此形状时不会触及形状的另一侧。在示例中,当形状的周期大于其扩展时,没有一个子形状具有孪生。

周期性形状重复

该算法还提供了在周期性方向上重复周期性形状的方法。要重复形状,该算法会制作所需数量的形状副本,并根据时间 * 周期值将它们一一转换。在制作并翻译完所有副本后,它们会被粘合以具有有效的形状。随后的重复是在重复的形状上执行的,因此例如在任何周期方向上重复形状两次将创建包含三个形状(原始加上两个副本)的结果。在任何方向上的单次后续重复将产生 6 个形状。

可以清除重复并重新开始。

历史支持

该算法支持形状修改的历史,因此可以跟踪形状如何被更改以使其具有周期性以及在重复过程中创建了哪些新形状。分裂历史和周期性形状重复的历史都可以在这里找到。请注意,所有重复的形状都存储为生成的历史记录。

BRepTools_History用于历史支持。

错误/警告

该算法支持错误/警告报告系统,该系统允许获取操作期间发生的错误和警告的扩展概览。一旦出现任何错误,算法就会停止工作。警告允许继续工作,通知用户出现问题。该算法返回以下警报:

  • BOPAlgo_AlertNoPeriodicityRequired – 如果在任何方向上都没有请求周期性,则会给出错误警报;
  • BOPAlgo_AlertUnableToTrim – 如果将形状修整以使其适合请求的周期失败,则会发出错误警报;
  • BOPAlgo_AlertUnableToMakeIdentical – 如果通过移动副本分割形状失败,则会发出错误警报;
  • 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
aPeriodicityMaker.DumpErrors(aSStream);
return;
}
if (aPeriodicityMaker.HasWarnings()) // Check for the warnings
{
// warnings treatment
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()方法获得:

// 获取历史对象

为了在Draw级别使用 MakePeriodic 算法,实现了以下命令:

  • 定期生成
  • 重复形状
  • 周期性双胞胎
  • 清晰的重复

有关周期性命令的更多详细信息,请参阅Draw测试工具用户指南的周期性命令。

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

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

例子

想象一下,您需要使板中的钻头彼此相距相同的距离。为了模拟这个过程,有必要制作很多圆柱体(模拟钻孔)并从板上切割这些圆柱体。使用周期性工具,该过程看起来非常简单:

# 创建板 100 x 100
箱板 -50 -50 0 100 100 1
# 创建一个半径为 1 的钻头
圆柱钻 1 1
# 找到左角的钻头
ttranslate 钻头 -48 -48 0
# 使钻孔周期为 4 作为 X 和 Y 周期,因此钻孔之间的距离将为 2
makeperiodic 钻孔 钻孔 – x 4 -trim -50 – y 4 -trim -50
# 重复钻孔以填充盘子,结果我们得到 25 x 25 钻孔的净值
重复形状钻头 – x 24 – y 24
# 从板上切下钻头
bcut 结果板钻

图片[89]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

带钻的板

隐藏线移除

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

为此,隐藏线移除组件提供了两种算法:HLRBRep_AlgoHLRBRep_PolyAlgo

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

HLRBRep_Algo允许使用形状本身,而HLRBRep_PolyAlgo使用形状的多面体简化。当您使用HLRBRep_Algo时,您会获得精确的结果,而当您使用HLRBRep_PolyAlgo时,您会减少计算时间,但会获得多边形段。

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

HLRBRep_AlgoHLRBRep_PolyAlgo可以处理任何类型的对象,例如,体积、曲面和线的组合,只要其中没有未完成的对象或点即可。

但是,HLR 的使用有一些限制:

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

图片[90]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

“简单的螺丝形状中锋利、光滑和缝合的边缘”,320

图片[91]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

以相同形状勾勒边缘和等参

图片[92]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

带阴影的简单螺丝形状

图片[93]-OpenCasCade官方开发文档翻译(4)–occt建模算法-卡核

显示隐藏锐边的提取

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

加载形状

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

设置视图参数

HLRBRep_Algo::ProjectorHLRBRep_PolyAlgo::Projector设置一个定义视图参数的投影仪对象。这个对象是一个HLRAlgo_Projector

计算预测

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

在 HLRBRep_Algo 的情况下使用HLRBRep_Algo::Update。使用此算法,您还必须调用方法HLRBRep_Algo::Hide来计算要可视化的形状的可见线​​和隐藏线。使用HLRBRep_PolyAlgo对象,可见线和隐藏线由HLRBRep_PolyHLRToShape计算。

提取边缘

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

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

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

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

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

例子

HLRBRep_Something

// 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
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
anIterator(myListOfShape);
for (;anIterator.More();anIterator.Next())
myPolyAlgo-Load(anIterator.Value());
// Set The Projector (myProjector is a
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 Technology 提供了使相同维度的接触形状连接(或粘合)的工具,即用于使一致的几何形状在形状之间拓扑共享。为了使形状连接起来,它们通过通用熔断算法进行粘合。使用了 BOPAlgo_GlueShift 选项,因此如果输入形状受到干扰,算法将无法识别。

使形状组连接起来可能很有用,例如在对组进行网格划分之前。它将允许使生成的网格保形。

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

材料协会

在此工具的框架中,输入形状称为材质,每个输入形状都有唯一的材质。

连接形状后,输入形状的边框元素与它们所属的形状相关联。此时,形状中边框元素的方向被考虑在内。关联针对以下类型进行:

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

为获取材料信息,应使用以下方法

  • MaterialsOnPositiveSide() – 返回位于给定形状正侧的原始形状(材料)(即具有 FORWARD 方向);
  • MaterialsOnNegativeSide() – 返回位于给定形状负侧的原始形状(材料)(即反向方向);
// 返回原始形状,其中图像包含正向方向的给定形状。
// 返回原始形状,其中图像包含具有反向方向的给定形状。

使连接的形状周期性

该工具提供了使连接的形状周期性的可能性。因为通过使形状具有周期性,它确保了相对侧上重合形状的几何形状将是相同的,因此它允许将形状的网格重新用于其周期性孪生。

在使形状周期性之后,材料关联会更新以对应于结果形状的实际状态。从这里也可以重复周期性形状。物质联想不会丢失。

历史支持

该算法支持操作期间形状修改的历史记录。除了由BRepTools_History提供并在此处用作历史工具的标准历史方法之外,该算法还提供了跟踪反向连接的方法 – 从结果形状到输入形状。该方法称为GetOrigins()

// 返回创建当前形状的原始形状列表。

粘合历史和使形状周期性和周期性形状重复的历史都可以在此处获得。请注意,所有重复的形状都存储为生成的历史记录。

错误/警告

该算法支持错误/警告报告系统,该系统允许获取操作期间发生的错误和警告的扩展概览。一旦出现任何错误,算法就会停止工作。警告允许继续工作,通知用户出现问题。该算法返回以下警报:

  • BOPAlgo_AlertTooFewArguments – 尝试在没有参数的情况下运行算法时发出错误警报;
  • BOPAlgo_AlertMultiDimensionalArguments – 尝试在多维参数上运行算法时给出错误警报;
  • BOPAlgo_AlertUnableToGlue – 如果粘合算法无法粘合给定参数,则会给出错误警报;
  • BOPAlgo_AlertUnableToMakePeriodic – 如果周期性制造商无法使用给定选项使连接的形状成为周期性,则会发出警告警报;
  • BOPAlgo_AlertShapeIsNotPeriodic – 警告在尝试重复形状之前发出警告警报。

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

用法

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

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
aMC.DumpErrors(aSStream);
return;
}
if (aMC.HasWarnings()) // Check for the warnings
{
// warnings treatment
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
{
// 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,它为算法提供以下选项:

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

在操作过程中获得的所有历史信息都存储在BRepTools_History对象中,并可通过History()方法获得:

// 获取历史对象

为了在Draw级别使用 MakeConnected 算法,实现了以下命令:

  • 建立连接
  • 材料公司
  • cmakeperiodic
  • 蠕变形状
  • 周期双胞胎
  • 清晰的重复

有关连接命令的更多详细信息,请参阅Draw测试工具用户指南的MakeConnected 命令。

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

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

© 版权声明
THE END
喜欢就支持一下吧
点赞3617 分享
评论 抢沙发
头像
欢迎您留下宝贵的见解!
提交
头像

昵称

取消
昵称表情代码图片

    暂无评论内容