Dan Staples
EDS PLM Solutions
Huntsville, Ala.

Pity the poor designers trying to generate eye-popping shapes for products they hope will earn "gotta-have" status. If they alter one curve using traditional surfacing software, another can change without permission of the designer, initiating a cascading series of unanticipated fixes that never seem to end until the dream is compromised or lost.

But things are looking up. New technology added to Solid Edge gives it surfacing functions that could reshape how designers create complex surfaces and ergonomic forms. The technology also simplifies the task of creating curves, working with parts associated to others, and edits.

It's important to understand the shortcomings in the traditional ways shapes and surfaces have been created. Briefly, both history and nonhistory-based systems have issues with surface modeling, curve creation, associative modifications, and too many unplanned design iterations. Each can involve complicated, inefficient, and frustrating procedures.

Problems with history

Most solid-modeling systems are history-based, building new geometry on previous shapes. In this way, changes to initial geometry cause changes to shapes that come later. And it makes sense for cutouts to rely on solids that preceded them and update when the solid changes. But this dependence is unnecessary and cumbersome when it comes to designing shapes.

For example, consider a surface defined by four boundaries. Which of the boundaries should be first in the tree? Which should be second? Ordering boundaries makes no sense because the order is more than an artificial construct. It's a catch 22 productivity inhibitor. For example, in a history-based system, suppose Curve 2 depends on Curve 1, Curve 3 depends on Curve 2, and Curve 4 depends on Curve 3. How can users "close the loop?" You cannot make Curve 1 depend on Curve 4 because Curve1 precedes it in history. This is a common problem because of the force-fit relation between a history tree and shape modeling.

This order dependence of 3D curves is quite crude compared to modern sketching environments. Users of modern CAD systems would not tolerate lines in the sketch environment being order-dependent. They don't want to remember the order in which lines are sketched when making inevitable changes. And thanks to variational geometry developed over 10 years ago, they no longer have to deal with this limitation within sketches.

It is also important to understand systems that try to solve the history problem with a limited "pockets of order-independence" approach. These systems allow updating several 3D sketches together. The approach has several drawbacks.

The first is that these sketches are indeed 3D, making creation and editing more complex. More importantly, updating several related sketches requires that users manually group the sketches at one location in the feature tree. This is often not possible.

Nonhistory-based modelers are a bit less restrictive. There is no order-dependence to increase complexity, but this comes at a high cost. Making changes to an element in nonhistory-based system does not affect other elements. This type of system provides a flexible modeling method that appeals to industrial designers, but at the expense of automating updates to related model elements. This is a serious drawback when modeling stylized parts which most often require several iterations.

Solid Edge solves the preceding problems by providing a flexible system in which curve order in the history tree does not restrict editing, and it properly updates downstream geometry based on upstream edits.

BlueDots lets users connect two independent sketches and make them peers, regardless of their location in the history tree. For example, a sketch that defines the shape from the side view can be connected to one that defines the shape from the front. Although the side view sketch may lie below the front view sketch in the history tree, the side view sketch can still drive edits to the other sketch. This "order independence" between sketches allows greater flexibility, enabling more rapid design and iteration.

Problems with curves

Shaping aesthetic designs is a creative process that requires lots of editing. Curves are at the "hub" of all shape modeling. If the curves have defects or don't lend themselves to creating the required shapes, no amount of surfacing technology can fix the outcome. So it's important curves represent the required shape yet remain flexible for editing.

Most CAD systems require excessive manual intervention to make broad changes. Changes in one part of a curve often trigger a sequence of changes. Some surfacing-oriented systems work around this problem by providing explicit commands for special curve modifications, such as scaling and moving control points. While this provides some control, each curve must be manually told what to do. This prevents taking advantage of history and design intent because the behavior is not encapsulated in the curve. If the designer has connected two curves, for example, changes to one may locally distort the other, because it has no rule to tell it not to. This calls for even more manual editing. Designs with hundreds of surfaces lead to incessant edits on a staggering scale.

In contrast, the Shape Preserving Curves introduced with Solid Edge RapidBlue technology encapsulate rules about how to modify themselves when their peers change. Original curves hold design intent so designers need not continue reimposing it.

Consider, for example, a surface defined by one spine (or guide) and five sections. (Guides and sections are usually at right angles to each other.) Each section must connect to the guide to create a valid surface. Assuming the design intent specified is for the guides and sections to remain connected, then any change to the guide readjusts the sections. Shape-preserving curves can tell how an edited curve should adjust.

Shape-preserving curves minimize required edits to maintain a curve's design intent. So a long convex curve (the faces on many consumer products) will remain convex through all but the most extreme edits. RapidBlue cuts time from creating and editing. In addition, shape-preserving curves reduce designer fatigue and frustration. The new curves also give users the most flexible editing control. Curves shaped with RapidBlue use three different types of edit points which may be moved or constrained in any combination. An edit point, for example, can be constrained to an existing edge, or a curve constrained to attach where another curve pierces a sketch plane. Two control vertices can be made horizontal or vertical with one another, enforcing tangent takeoff or symmetry. High and low points of a curve (identified by silhouette points) can attach other elements which belong at a horizon point.

Problems with design iterations

Design calls for iterations. Many alternatives need exploring when style is a goal. As a result, industrial designers need a short feedback loop in the design process and must make changes using continual feedback.

Traditional systems do not give designers this luxury. Styling changes are often executed in a vacuum. Engineers edit curves without seeing the immediate effects on the surface or, in the best case, see only the surface update, not features that depend on the surface. For example, many consumer products are defined by "highlight lines" which the consumer will see. Often, these lines are where curvature changes rapidly, such as where one surface blends into another. The inability to see this highlight line change and move as the underlying curves are edited leads to a frustratingly long cycle of changes.

An additional obstacle is that designs evolve over time based on input from various stakeholders. For example, the designer may sketch a concept using an arc to describe a curve. Reviewers may decide the product needs more flair and a curvier curve.

A few Solid Edge solutions to this problem include dynamic edits, convert-to-curve, and BlueSurf. Dynamic edits let users edit anywhere in the feature tree and see the results in real time. The software preserves design intent and history, recalculates downstream features, and continuously updates the graphics display. This means users can explore more in a shorter period.

Convert-to-curve compliments dynamic edits by translating analytic elements, such as lines and arcs, into Nurbs with a single click. (It's important that such conversions be done using Nurbs representations because only rational b-splines accurately represent arcs and circles. Nonrational representations are only approximations).

Elements become editable curves with no loss of shape data. For example, arcs can be converted to curves, edited into more interesting shapes, and all downstream features properly recompute.

BlueSurf, similar in concept to convert-to-curve, accommodates the inevitable increase in control required as designs progress. What starts out as a simple 1 3 1 sweep (one section and one guide) in early design stages, may be a 3 3 5 loft after the design evolves. A single BlueSurf is well suited to a 1 3 1 sweep, all the way to an n 3 m, with full support for tangency to adjacent surfaces, and along both sections and guides. So even though the initial simple sweep is no longer appropriate, the feature tree does not need repair. Users add control to a BlueSurf by dragging planes in the section or guide directions and "dropping in" additional sections, thereby slicing the surface. The resultant slice becomes an editable guide or section input to the surface, with the resulting surface continuous across all sections and guides, including those dropped in. Using this method, control is progressively added to the surface until the required shape is achieved.

This advanced capability stands in sharp contrast to other systems in which added guides provide only G0 continuity (defines a sharp, not tangent, edge connection) by default or a localized G1 with manual intervention. (G1 refers to a tangent point without continuous curvature.) BlueSurf guarantees a smooth surface fit which accounts for all sections and guides as part of the fitting process.

There is not a flat surface or a straight line on the CD player. More often, that is the rule for modern products. RapidBlue in Solid Edge addresses the needs of industrial designers as well as mechanical designers and those shaping eye-catching products.

A 1x1 network (a crossed guide and section) is easily established using BlueDots to connect curves. The dots can also connect two independent sketches and makes them peers. This means edits to one sketch make appropriate changes to the other.

Four boundaries define the surface shape. But which should be first in the history tree? Ordering the boundaries makes no sense.

The blue line is a proposed cross section. Edit points lie on the line; control points do not. Silhouette points define high and low points on a curve. In Solid Edge, Silhouette points can be dimensioned and constrained.


Putting it all together
A simple workflow illustrates how the new surfacing features that might be used. The task is to design a cover for the CD player in the lead picture.

The 1x1 network (one guide and section) is easily established using BlueDots to connect the curves. Although they lie at different points in the tree, they are peers. Edits to each curve will update its partner.

Curves maintain their shape yet are easily edited.

A BlueSurf easily covers the 1 3 1 network.

Edits to either curve recompute the surface. A partner curve maintains its general shape when edited. All design intent, including rounds, are updated using Dynamic Edit.

New guides are dropped in place as more control is needed over the surface shape. Adding BlueDots makes editing flexible. In addition, curve-defining points may be used with existing constraint commands in Solid Edge.

Editing new guides updates all partner curves.