# Curve

### From DocR25

The concept of a *curve* captures the intuitive idea of a geometrical *one-dimensional* and *continuous* object.

## Contents |

## Curve Types

ACIS supports two types of curves: *analytic* and *interpolated*. These are analogous to the two types of surfaces: analytic and spline.

### Analytic Curves

An *analytic curve* represents a simple curve that can be represented analytically by an equation (algebraic formula). ACIS implements three types of analytic curves: straight lines, ellipses (which includes circles), and helices.

### Interpolated Curves

An *interpolated curve* or intcurve may represent either a B-spline curve or a procedural curve. B-spline curves are represented by non-uniform rational B-spline (NURBS) curves. Various types of procedural curves are represented by the various *flavors* of interpolated curves. (For more details on the implementation of flavors of interpolated curves, refer to *Intcurve*.)

## Curve Forms

If the two ends of the curve are different in object space, the curve is *open* (refer to the following figure). If they are the same, it is *closed*. If a closed curve joins itself smoothly, and is defined for all values of the parameter, the curve is *periodic*, with its period being the length of the interval on which it is primarily defined. A periodic curve may be evaluated outside its principal range.

## Curve Classes

The `curve` class is the base *construction geometry* class for curves. All specific construction geometry curve classes are derived from it. The curve class is an abstract class, whereas its children are instantiable classes. The following four classes are derived from `curve`:

`ellipse`Represents an ellipse. A circle is a special case of an ellipse. `helix`Represents a (possibly tapered) helical curve. `straight`Represents a straight line. `intcurve`Represents an interpolated curve.

The primary data elements of these classes (those that define the shape and parameterization) are enumerated in the diagram below.

The construction geometry classes described above are not persistent. There are *model geometry* classes (with `UPPERCASE` names) that correspond to these construction geometry classes. The `CURVE` class is the base class for model geometry curves; specific model geometry curve classes (`ELLIPSE`, `HELIX`, `INTCURVE` and `STRAIGHT`) are derived from it. Each specific model geometry curve class contains an instance of its corresponding specific construction geometry curve. Thus, the non-persistent, specific construction geometry curve classes function as data containers for the persistent classes. The `CURVE` class is an abstract class, whereas its children are instantiable classes. The `CURVE` class is derived from the `ENTITY` class; therefore, `CURVE`s are part of the persistent model and inherit all of the Model Management capabilities of the `ENTITY` class.

## Curve Sense

Care must be taken to ensure that the *sense* of the parameterization of an object space or parameter space curve is interpreted correctly. When evaluating positions along the object space curve of an edge or the parameter space curves of any of its coedges, the parameter limits of the curves depend upon the start and end parameters of the edge, and one or more reversal flags.

Recall that when a parameter range (an *interval*) is reversed, the interval (*a*,*b*) becomes ( − *b*, − *a*). Also recall that a parameter space curve (a *pcurve*) must be attached to each coedge of a face lying on a parametric surface. An edge common to two faces, each having a parametric surface, has an object space curve and two parameter space curves. (Each of the parameter space curves lies in the parameter space of one of the two parametric surfaces.) In addition, each coedge of a tolerant edge must have a parameter space curve.

Consider evaluating an edge first: If the edge has the opposite sense to its underlying curve, the edge parameter range (*a*,*b*) recorded in the edge is taken to be the interval ( − *b*, − *a*) when finding points along the curve.

There are two methods to trace out the points along a coedge in the direction of a coedge. It is possible to trace out points along the edge and then take the set of points in reverse order if the coedge is reversed with respect to the edge. Alternatively, if the coedge has a pcurve, it is possible to find the same set of points (strictly, a similar set of points) from the coedge and its parameter space curve. The procedure is to find the parameter limits (*a*,*b*) from the edge, reverse them to ( − *b*, − *a*) if the coedge is reversed with respect to the edge, and then present these limits to the stored pcurve to obtain the points ordered along it. In other words, a pcurve has the same orientation and parameterization as its coedge. The first method is preferred for non-tolerant coedges because pcurves are usually approximations, obtained by mapping of the points of the curve into the parameter space of the surface.

The simplest way to evaluate a coedge or edge is to use the functions declared in `geometry.hxx`. Of course, you must understand the parameter range of the edge or coedge to properly use these functions.

In the case of an `intcurve` class, there is a flag within the `intcurve` that allows the `intcurve` to be reversed without altering the details of the stored `bs3_curve`. Thus, if you are evaluating the `bs3_curve` directly, you must account for this potential sense reversal as well as any reversals in the topology above it. (Typically you do not evaluate a `bs3_curve` directly.)

As with an `intcurve`, a private `pcurve` contains a sense bit so that a private pcurve may be reversed without having to change the underlying details of the stored 2D curve or 3D surface. For `pcurves` associated with an `intcurve`, sense reversal is denoted by a negative value of *n*, where* n* refers to the *n*th pcurve of the referenced intcurve. Thus, if you are evaluating the `bs2_curve` directly, you must account for these potential sense reversals as well.

Because the interpretation of a curve is governed by all of the intervening sense bits, it is essential to understand the details of these senses when evaluating or setting `bs2_curves` underlying `pcurves` or `bs3_curves` underlying `intcurves`.

## B-spline Curve Interface

The Spline Interface provides a low-level interface for 2D and 3D B-spline curves. It contains utilities for construction, manipulation, evaluation, querying, and destruction of `bs2_curve` and `bs3_curve` curves.

The spline interface functions form a subset of the Direct Interface (DI) functions. The spline interface functions are implemented in the Kernel Component (KERN) and have names with the following prefixes:

`bs2_curve_*`: Operate on 2D B-spline curves.`bs3_curve_*`: Operate on 3D B-spline curves.

## Conic Sections

ACIS represents ellipses and circles using an analytic curve class, an `ellipse`. ACIS does not contain specific classes to represent other types of conic sections (for example, parabolas or hyperbolas). However, a conic section can be precisely represented by a segment of a NURBS curve. ACIS provides an interface to generate conic sections using a *rho* conic description. The parameter *rho* is a measure of the eccentricity of the curve and is defined as the ratio of two distances as shown in the *Figure. rho Definition*. The parameter *rho* must have a value between 0 and 1 and defines the type of curve:

- Values of
*rho*less than 0.5 result in an ellipse. - Values of
*rho*greater than 0.5 result in a hyperbola. - Values equal to 0.5 result in a parabola.

A NURBS representation of a *rho* conic can be constructed using `api_mk_ed_conic`.

## Continuity Requirements

*Main article: Continuity*

ACIS prefers that curves and surfaces be *G*^{2} continuous, but will allow *G*^{1} continuity at the knots of curves and surfaces. The C++ class `discontinuity_info` records discontinuity information. It is used internally by ACIS in the curve and surface extension and intersection algorithms.

Some modeling operations (such as offsetting, shelling, and blending) may fail on surfaces that are not *G*^{1} continuous. The evaluation of mass properties in ACIS requires that curves be *C*^{1} continuous.

## Parameterization Requirements

No assumption is made about the relationship between parameter values and object space distances, and parameterization is transformation-independent. *However*, it is advantageous for the parameterization to be as homogeneous as possible, because various iterative processes are likely to be more reliable and faster.