Tuesday, March 31, 2009

History-Free CAD, Much More than Direct Editing

Most all major CAD companies are now selling or developing history free, direct, explicit, (whatever you want to call it) technologies. Most of the talk is related to how this technology can bring new flexibility to the geometry editing process regardless of how or where the geometry originated. What I don’t see being discussed much is how history-free technology can be utilized to actually design products.  There are many characteristics of history-free technology that can bring new and flexible approaches to the design process if implemented properly.  It can be much more than direct editing.

There are several characteristics of typical history-based CAD systems that, to some extent, impose rigid methods and process into the task of creating models, and eventually designing products. Most of these characteristics have been common place in 3D CAD for so many years that we really don’t consider them as being something that may inhibit our ability to actually design products. With history-based CAD, a user is creating a “program” (usually called a history tree) that if done properly will represent the product design.  Because of this a user must be careful and cautious in creating and manipulating the program. But not only that, the CAD system must closely control how it is being used to develop this program; otherwise the program (history tree) could easily be corrupted. Here are just a few of these characteristics.

  • In most training manuals for history-based CAD systems you will find early on that users are coached and encouraged to spend some time in up-front thought and planning before beginning the actual modeling process. To create the “program” (history tree) correctly you must know something about the “intent” of the program. What dimensions are critical for the design? What dimensions and parameters might change throughout the lifecycle? What relationships are critical to the design? In reality, with history-based CAD you may be “documenting” what is already designed more than you are actually “designing”. As there is no recorded tree or “program” with history-free CAD, there is no need for up-front planning. Just quickly get into the process of design.
  • In history-based CAD, the sketch is a critical component in the tree. Each sketch creates a feature that is ordered in the tree. Too much complexity in the sketch can make editing difficult, too little can lead to overly complex and large trees. With history-free CAD a sketch can have as little or as much complexity with no impact to the end results. Complex nested profiles are just a valid as a simple rectangle.
  • There are some modeling operations that don't come natural when working in a history-based environment. Operations like Unite or Merge for joining two parts together into one part, or Section for cutting one part into two new parts, (don’t confuse this with the interaction between multi-bodies of a single part). These functions can be very useful and will allow users to leverage and take full advantage of existing 3D data. If these functions do exist in the assembly mode of a history-based CAD system, they will be tightly controlled and somewhat inflexible, and in the end may overly complicate the history-tree. How geometry is created makes no difference in a history-free CAD system. In a mature history-free CAD system you should find many geometry creation and modification functions that can bring much flexibility and productivity to the design process.
  • As mentioned in an earlier post about in-context design, history-based CAD systems must have a part mode and an assembly mode. This can significantly complicate the process of product design. Special functionality is required to make top-down and in-context design possible in history-based CAD. With mature history-free CAD there will be no part mode or assembly mode, you will be working in a virtual 3D space. In-context and top-down is just the natural way of working.
  • History-based CAD provides a nice platform for capturing so called design intent. As a matter of fact, with history-based CAD you are capturing and managing much of this intelligence whether it is needed or not. With mature history-free CAD, you should be able to add and utilize design intent where and when it makes sense including constraints, relationships, dimensions, tolerances, features and other annotation. Combining parametric modeling with history-free modeling is nothing new.

There are several other characteristics that fit here, but these are some of the more obvious. 

Combining history-free, direct editing technologies into a history-based CAD system will not reduce, minimize or eliminate these characteristics and their impact on the design process. If the CAD system records modeling and assembly operations in a tree structure, these characteristics will exist.

If you are interested in the potential benefits of history-free "design", be sure to look for the following characteristics.

  • There should be no need for up-front planning.
  • There should be complete flexibility in sketching. The sketch should have no impact to the future use of the model.
  • There should be a variety of methods for creating and modifying geometry with complete flexibility in how it's done.
  • There should be no part mode or assembly mode. In-context and/or top-down should be natural and normal.
  • You should be able to add and utilize design intent where and when it makes sense.
  • Oh, and I don’t want to forget – you should be able to directly edit geometry regardless of where and how it was created.

And now for the usual disclaimer: History-free CAD is not for everyone. It’s not the answer to all your design needs, and it is certainly not the only tool you may need in your product design toolbox. It can however bring much more value to the process of product design than just direct editing. It just depends on how it's implemented within the CAD system.


Monday, March 16, 2009

Design In-Context - What's the Big Deal?

In-context design is a term used to describe the process of creating models of parts and assemblies within the context of other parts and assemblies.  Recently I have been forcing myself to spend more time using several of the more popular history-based tools just to make sure I still have some understanding of the “other side”.  While doing this I am learning that I have been taking for granted the ability to easily and almost unconsciously do in-context design within my usual history-free environment, which in my case is typically CoCreate Modeling.
With most parametric history-based modeling tools (and maybe all) there are two modes that users work in; part modeling mode and assembly modeling mode.  One of the first things you must do after starting up one of these history-based applications is to decide whether you will be working with a part or an assembly.  This is so frustrating to me, but it does make sense considering history-based technology.  Keeping these two environments separate is important with a history-based system.  The system needs to know which part history tree or which assembly history tree the modeling operation will be recorded into.  Because of the need for two separate environments, in-context design is naturally a challenge for a history-based system.  Makers of history-based CAD systems have had to develop specific functionality to work around the related complexities that come with history-based in-context design.  But even with the special functionality and workarounds, users still need to be somewhat careful when taking advantage of these special capabilities.
With a history-free design system, there is no need to have two separate environments, one for part modeling and one for assembly modeling; since there is no history tree to manage.  Users can always create parts and assemblies in context and simultaneously.  History-free design systems provide a very natural environment for top-down or in-context design. No special functionality or workarounds need to exist.  It’s like working on your desk with physical parts.  In this environment an assembly is just a structure.  Parts and subassemblies can be placed into the assembly structure anytime.  Once in the structure, the owning assembly manages the positions and relationships of the parts and subassemblies.
Here is just a simple demonstration showing an example of in-context design using PTC CoCreate Modeling.  A few key points to watch for during the demo:
  • Creating multiple, unique parts in one modeling operation
  • Modifying multiple parts with one sketch and one modeling operation
  • Modifying multiple parts with many sketches in one operation
  • Modifying a part by referencing geometry from another part
  • Moving multiple parts while modifying a part, in one operation, without constraints
  • Manipulating assemblies and parts in one environment
This demo seems so simple and trivial to me, but I can’t figure out how to do the same with any of the history-based systems I've been using. Can it be done? I know that with some of the history-based tools you can create multi-body parts, and then extract one of those bodies as a part, but the resulting part turns into a dumb solid with no history.  Can history-based in-context design really be that difficult? I guess so.

Wednesday, March 4, 2009

Feature Recognition and Direct Editing

Three dimensional automatic feature recognition technologies have been around for at least 20 years.  There are many uses for feature recognition in our industry.  Makers of parametric history-based modeling systems have attempted to use feature recognition capabilities to turn “dumb” imported solid models into feature-based solids.  CAM vendors have used feature recognition to automatically identify holes, slots, pockets and bosses in 3D geometry to help automate the process of tool path generation.

While useful for the two cases mentioned above, feature recognition is critical to good direct editing and history-free design.  Direct editing functions require that a face or collection of faces be passed to the edit function (for some functions, it may be edges).  There are a variety of ways that a face or collection of faces can be identified.  Certainly you can select one face at a time.  Some systems allow for a viewport box select.  There is also what I call conditional recognition, where geometry is selected based on conditions such as tangent, adjacent, coincident and so on. And then there is feature recognition. Robust, predictictable feature recognition can greatly speed the process of direct editing.

Automatic feature recognition will require the user to select a single face; some call this the seed face.  The feature recognition algorithm will start with the seed face and walk through the topology of a solid model looking for very specific conditions and regularities in the topology to identify a useful collection of faces, perhaps representing a hole, a boss, a pocket or perhaps a rib or slot.  The term “Automatic” should already tell you that the results may not always align with expectations, but good robust feature recognition should deliver predictable results.

The above images show a fairly complex rib in a portable drill case. With one pick on a side face of the rib, the feature recognition algorithm walks through the topology to find specific conditions and then provides the highlighted results. In this situation the algorithm has recognized all of the other faces associated with the rib, even though the rib intersects with multiple other faces. Without this capability the user would have to try to box select the entire rib, most likely getting too many other faces from the same region, or perhaps select each face individually. Now that these faces are selected they can be passed to, or consumed by, an edit function – perhaps move it, taper it, make it thicker or thinner, copy and paste it somewhere else, or even remove it. It just depends on what direct edit functions are available in the system and how robust they are. Since feature recognition is topology based, it will work the same for any 3D geometry format such as IGES, STEP, SAT or native.

Each CAD system today has different concepts and capabilities of feature recognition. With parametric history-based CAD systems, multiple face selection really does not apply as modifications are done through preexisting parameters and feature definitions. However it certainly can apply and be very useful for the direct editing functions, depending on the direct editing capabilities. Most of these systems do have direct editing capabilities now, but very few of them have useful tools like feature recognition to help with face selection. NX seems to have a reasonable collection of conditional and feature recognition capabilities and I am sure we will see others follow.

For history-free systems, feature recognition becomes very important. With all history-free CAD systems you will drive many edits by selecting the geometry to edit and then specify the modification, (an exception may be when driving change through parameters and/or dimensions). The geometry selection process can be simplified with good feature recognition. CoCreate Modeling, SpaceClaim and KeyCreator all have good feature recognition capabilities, although there are some significant differences in how they work and how robust they are. These systems also come with a good variety of conditional recognition capabilities.

It is a bit interesting to see how differently these algorithms actually work from one system to the other. If you are considering direct editing within a parametric history-based system as an important tool for your product design process, or perhaps considering history-free design, it would be good to spend a bit of time evaluating this capability. Good feature recognition can save a fair amount of time while making those needed modifications. Don’t forget to check it out.