Open CASCADE Technology 6.6.0
|
The Precision package offers a set of functions defining precision criteria
for use in conventional situations when comparing two numbers.
Generalities
It is not advisable to use floating number equality. Instead, the difference
between numbers must be compared with a given precision, i.e. :
Standard_Real x1, x2 ;
x1 = ...
x2 = ...
If ( x1 == x2 ) ...
should not be used and must be written as indicated below:
Standard_Real x1, x2 ;
Standard_Real Precision = ...
x1 = ...
x2 = ...
If ( Abs ( x1 - x2 ) < Precision ) ...
Likewise, when ordering floating numbers, you must take the following into account :
Standard_Real x1, x2 ;
Standard_Real Precision = ...
x1 = ... ! a large number
x2 = ... ! another large number
If ( x1 < x2 - Precision ) ...
is incorrect when x1 and x2 are large numbers ; it is better to write :
Standard_Real x1, x2 ;
Standard_Real Precision = ...
x1 = ... ! a large number
x2 = ... ! another large number
If ( x2 - x1 > Precision ) ...
Precision in Cas.Cade
Generally speaking, the precision criterion is not implicit in Cas.Cade. Low-level geometric algorithms accept
precision criteria as arguments. As a rule, they should not refer directly to the precision criteria provided by the
Precision package.
On the other hand, high-level modeling algorithms have to provide the low-level geometric algorithms that they
call, with a precision criteria. One way of doing this is to use the above precision criteria.
Alternatively, the high-level algorithms can have their own system for precision management. For example, the
Topology Data Structure stores precision criteria for each elementary shape (as a vertex, an edge or a face). When
a new topological object is constructed, the precision criteria are taken from those provided by the Precision
package, and stored in the related data structure. Later, a topological algorithm which analyses these objects will
work with the values stored in the data structure. Also, if this algorithm is to build a new topological object, from
these precision criteria, it will compute a new precision criterion for the new topological object, and write it into the
data structure of the new topological object.
The different precision criteria offered by the Precision package, cover the most common requirements of
geometric algorithms, such as intersections, approximations, and so on.
The choice of precision depends on the algorithm and on the geometric space. The geometric space may be :
More...
#include <Precision.hxx>
Static Public Member Functions | |
static Standard_Real | Angular () |
Returns the recommended precision value when checking the equality of two angles (given in radians). Standard_Real Angle1 = ... , Angle2 = ... ; If ( Abs( Angle2 - Angle1 ) < Precision::Angular() ) ... The tolerance of angular equality may be used to check the parallelism of two vectors : gp_Vec V1, V2 ; V1 = ... V2 = ... If ( V1.IsParallel (V2, Precision::Angular() ) ) ... The tolerance of angular equality is equal to 1.e-12. Note : The tolerance of angular equality can be used when working with scalar products or cross products since sines and angles are equivalent for small angles. Therefore, in order to check whether two unit vectors are perpendicular : gp_Dir D1, D2 ; D1 = ... D2 = ... you can use : If ( Abs( D1.D2 ) < Precision::Angular() ) ... (although the function IsNormal does exist). | |
static Standard_Real | Confusion () |
Returns the recommended precision value when checking coincidence of two points in real space. The tolerance of confusion is used for testing a 3D distance : | |
static Standard_Real | SquareConfusion () |
Returns square of Confusion. Created for speed and convenience. | |
static Standard_Real | Intersection () |
Returns the precision value in real space, frequently used by intersection algorithms to decide that a solution is reached. This function provides an acceptable level of precision for an intersection process to define the adjustment limits. The tolerance of intersection is designed to ensure that a point computed by an iterative algorithm as the intersection between two curves is indeed on the intersection. It is obvious that two tangent curves are close to each other, on a large distance. An iterative algorithm of intersection may find points on these curves within the scope of the confusion tolerance, but still far from the true intersection point. In order to force the intersection algorithm to continue the iteration process until a correct point is found on the tangent objects, the tolerance of intersection must be smaller than the tolerance of confusion. On the other hand, the tolerance of intersection must be large enough to minimize the time required by the process to converge to a solution. The tolerance of intersection is equal to : Precision::Confusion() / 100. (that is, 1.e-9). | |
static Standard_Real | Approximation () |
Returns the precision value in real space, frequently used by approximation algorithms. This function provides an acceptable level of precision for an approximation process to define adjustment limits. The tolerance of approximation is designed to ensure an acceptable computation time when performing an approximation process. That is why the tolerance of approximation is greater than the tolerance of confusion. The tolerance of approximation is equal to : Precision::Confusion() * 10. (that is, 1.e-6). You may use a smaller tolerance in an approximation algorithm, but this option might be costly. | |
static Standard_Real | Parametric (const Standard_Real P, const Standard_Real T) |
Convert a real space precision to a parametric space precision. <T> is the mean value of the length of the tangent of the curve or the surface. Value is P / T | |
static Standard_Real | PConfusion (const Standard_Real T) |
Returns a precision value in parametric space, which may be used : | |
static Standard_Real | PIntersection (const Standard_Real T) |
Returns a precision value in parametric space, which may be used by intersection algorithms, to decide that a solution is reached. The purpose of this function is to provide an acceptable level of precision in parametric space, for an intersection process to define the adjustment limits. The parametric tolerance of intersection is designed to give a mean value in relation with the dimension of the curve or the surface. It considers that a variation of parameter equal to 1. along a curve (or an isoparametric curve of a surface) generates a segment whose length is equal to 100. (default value), or T. The parametric tolerance of intersection is equal to : | |
static Standard_Real | PApproximation (const Standard_Real T) |
Returns a precision value in parametric space, which may be used by approximation algorithms. The purpose of this function is to provide an acceptable level of precision in parametric space, for an approximation process to define the adjustment limits. The parametric tolerance of approximation is designed to give a mean value in relation with the dimension of the curve or the surface. It considers that a variation of parameter equal to 1. along a curve (or an isoparametric curve of a surface) generates a segment whose length is equal to 100. (default value), or T. The parametric tolerance of intersection is equal to : | |
static Standard_Real | Parametric (const Standard_Real P) |
Convert a real space precision to a parametric space precision on a default curve. Value is Parametric(P,1.e+2) | |
static Standard_Real | PConfusion () |
Used to test distances in parametric space on a default curve. This is Precision::Parametric(Precision::Confusion()) | |
static Standard_Real | PIntersection () |
Used for Intersections in parametric space on a default curve. This is Precision::Parametric(Precision::Intersection()) | |
static Standard_Real | PApproximation () |
Used for Approximations in parametric space on a default curve. This is Precision::Parametric(Precision::Approximation()) | |
static Standard_Boolean | IsInfinite (const Standard_Real R) |
Returns True if R may be considered as an infinite number. Currently Abs(R) > 1e100 | |
static Standard_Boolean | IsPositiveInfinite (const Standard_Real R) |
Returns True if R may be considered as a positive infinite number. Currently R > 1e100 | |
static Standard_Boolean | IsNegativeInfinite (const Standard_Real R) |
Returns True if R may be considered as a negative infinite number. Currently R < -1e100 | |
static Standard_Real | Infinite () |
Returns a big number that can be considered as infinite. Use -Infinite() for a negative big number. |
static Standard_Real Precision::Angular | ( | ) | [static] |
static Standard_Real Precision::Approximation | ( | ) | [static] |
static Standard_Real Precision::Confusion | ( | ) | [static] |
static Standard_Real Precision::Infinite | ( | ) | [static] |
static Standard_Real Precision::Intersection | ( | ) | [static] |
static Standard_Boolean Precision::IsInfinite | ( | const Standard_Real | R | ) | [static] |
static Standard_Boolean Precision::IsNegativeInfinite | ( | const Standard_Real | R | ) | [static] |
static Standard_Boolean Precision::IsPositiveInfinite | ( | const Standard_Real | R | ) | [static] |
static Standard_Real Precision::PApproximation | ( | ) | [static] |
static Standard_Real Precision::PApproximation | ( | const Standard_Real | T | ) | [static] |
static Standard_Real Precision::Parametric | ( | const Standard_Real | P | ) | [static] |
static Standard_Real Precision::Parametric | ( | const Standard_Real | P, |
const Standard_Real | T | ||
) | [static] |
static Standard_Real Precision::PConfusion | ( | const Standard_Real | T | ) | [static] |
static Standard_Real Precision::PConfusion | ( | ) | [static] |
static Standard_Real Precision::PIntersection | ( | const Standard_Real | T | ) | [static] |
static Standard_Real Precision::PIntersection | ( | ) | [static] |
static Standard_Real Precision::SquareConfusion | ( | ) | [static] |