Thinking in Fields - A Primer for Implicit Modeling

For clarity, within the context of Implicit Modeling, the term field takes the following definition: at every coordinate in a space, usually within some practical bounds, the field returns a signed scalar value (e.g., 1.0, -3.1, 0.0, etc.). We use field as a shortening of the more complete term, scalar field. The information encoded by the field is of the form {x-coordinate, y-coordinate, z-coordinate, signed scalar value}.

Implicit Modeling makes use of some important conventions within the context of geometry. Firstly, negative scalar values are assumed to be internal to the modeled object, and positive scalar values are external. The surface of the object, itself, appears at every location in space that returns a scalar value of zero. As such, the signed scalar values in the field give an immediate inside/outside check for any coordinate in space.

The following paragraphs describe the different types of fields that are useful in Implicit Modeling and that fall within the scope of this definition.

Signed-Distance Fields (SDFs)

SDFs are a special case in terms of scalar fields. The scalar value reported at each coordinate encodes the shortest distance to the surface of an object. As we move away from the surface in an outward direction, the positive scalar values become larger. Similarly, as we move away from the surface in an inward direction, effectively traveling deeper into the object, the negative scalar values become larger in magnitude.

SDFs are particularly useful as they give instant inside/outside checks, and they tell you how close a point is to the surface of an object. This arrangement is optimal for creating accurate offset surfaces for a given geometry, and they also enable controlled blending between surfaces, filleting operations, and much more.

Unsigned Distance Fields (UDFs)

UDFs share all of the same properties as SDFs with one clear exception: all scalar values in the field have the same sign (+/-), irrespective of whether they are internal or external to the object being modeled. Some geometries produce UDFs by construction, such as lines, curves, and points. This is because there is no well-defined notion of inside and outside for these objects. However, it can sometimes be useful to construct an UDF in place of an SDF. This is achieved by taking the absolute value of the SDF, producing all positive distances.

Distance-Like Scalar Fields

Some fields behave similarly to SDFs (or UDFs), but their scalars don’t encode the exact distance to the surface. Often these fields have scalar values that are zero at the surface and increase in magnitude as a you get farther from the surface (inwardly or outwardly). However, the rate at which the scalars change may be different than that of the true SDF. You can think about this in terms of how the scalar values change per unit of length of movement away from the surface. In a SDF, the scalars change in a ratio of 1:1 when comparing the scalar value with the distance moved away from the surface. Conversely, the scalars in a distance-like scalar field might vary by a ratio of 2:1, thereby not encoding the distance to the surface.

Binary and Piecewise Constant Fields

It is possible to create binary fields, which, by convention, are zero everywhere outside and on the surface and one everywhere inside of the surface of an object. These fields can be very useful for masking off regions in space to limit the scope of a downstream operation. For example, you might wish to apply geometry edits strictly within certain regions without applying them elsewhere. This is like saying “perform an operation in all of these positions, but do not perform the operation anywhere else.”

Similar to binary fields, it can be useful to create constant fields. Typically, these fields have one user-defined value inside and on the object, and either the same or a different user-specified values outside of the object. For example, you could create a field that has scalar values of 3 inside and on the surface of the object and a value of 5 outside the object. These fields can be useful for setting, for example, thicknesses of lattice elements in different regions.

Interpolating Scalar Fields

Inverse Distance Weighting

When using Inverse Distance Weighting, the scalar value at a position that is not specified in the point cloud data is computed as the weighted average of scalar values of points in the point cloud. The weighting with respect to each point in the point cloud is a function of the distance to each point in the cloud. Scalar values at a point specified in the point cloud data will be exactly equal to the supplied scalar value. Different exponent values can be used to control the fall-off for the distance weighting. Two example fields are shown below for a simple point cloud.

Nearest Neighbor Interpolation

Nearest Neighbor interpolation is simpler to visualize. Each position in the field adopts the scalar value of the nearest point in the point cloud. This technique forces abrupt changes in the resulting Interpolating Scalar field as nearby positions in space may "snap" to different scalar values.

The following simple example explains how this works.

In 3D Cartesian coordinates, a popular equation for a sphere is

${\left(x-x_0\right)}^2+{\left(y-y_0\right)}^2+{\left(z-z_0\right)}^2=r^2$ ,

where $\left(x_{0,}{y}_{0,}{z}_{0,}\right)$ are the center coordinates of the sphere and $r$ is the radius.

However, to represent the sphere as a SDF, we present the equation of the sphere in the following format:

$||p-p_0||-r=0$

In this representation, $p_0$ is a 1x3 vector, identifying the center position of the sphere. Similarly, $p$ represents the x-, y-, and z-coordinate of a query point in space. As before, $r$ is the radius of the sphere. The double vertical lines, used as parentheses, denote the Euclidean 2-norm. In this case, their usage implies that we are calculating the length of the vector between the query point and the center of the sphere. Piecing all this together, we subtract the radius of the sphere from the distance between the query point and the center of the sphere. If the distance between the query point and center of the sphere is less than the radius, this equation produces a negative number, placing this query point inside the sphere. You can satisfy yourself that the scalar value returned by this equation will always return the signed distance from a query point to the surface of the sphere.

For examples, please see Video Tutorial: Creating Field-Driven Effects in Lattices.

Here is a simple example of field-driven design.

This principle can be applied throughout the Implicit Modeling workflow in two ways. The first method is to define a field, usually based on some reference geometry, prior to its usage in the construction history. In other words, you construct the field before constructing the geometry that uses the field to control one of its parameters. To do this, you should select the Field tool on the Implicit Modeling ribbon.

The second method is to create the field within the context of the geometry that will ultimately make use of that field.

Some Common Misconceptions and Pitfalls When Working with Implicit Modeling

"I'm used to working with sketches."

Traditional CAD workflows tend to start with 2D sketches that get developed into 3D features using a handful of tools that loosely map onto manufacturing processes (extrude, revolve, etc.). Implicit Modeling is different in that it builds shapes up by defining, combining, and blending between volumetric (3D) shape representations from the beginning. If you need to develop your model from sketches, you should follow a traditional CAD workflow and then convert your model into an Implicit format when the time is right.

"Why can't I click on individual features?"

Traditional CAD, driven by NURBS surfaces, explicitly defines the surfaces that envelop the modeled object. The trimming lines for each surface that form well-defined boundaries between surfaces and features are also available by construction. Implicit Modeling has no such features, and they cannot be readily selected, highlighted, or edited. This is because the entire surface of the object is a single isosurface, implied as the boundary between the interior and exterior regions of the object's field. It is therefore difficult to select points on a surface, lines that separate features, and isolated faces. For the time being, this is the price that is paid for the additional flexibility in terms of creating complex, robust, and field-driven geometry.

"Why isn't there a dimension tool?"

As Implicit modeling is not sketch, feature, and constraint driven (like traditional CAD), a dimensioning tool is limited in its usefulness. Instead, geometry sizing and positions should be entered carefully at the point of creation, possibly controlled by a variable or field for added flexibility.

"I want to convert/export my Implicit Modeling to Parametric CAD (NURBS)."

Almost every geometry representation can be converted into an Implicit format with little difficulty. This conversion process outputs a SDF for the object. However, Implicit geometry cannot always convert back to other formats as easily. Implicit geometry is easy to mesh and can be output as .stl, .obj, and .3mf formats. You should be mindful that very complex implicit models might produce dense meshes with very high triangle counts. The route back to parametric CAD is via the PolyNURBS tool. This tool can be used to fit subdivision surfaces to the Implicit model, making them editable CAD surfaces. Again, care should be taken during these steps, as you will be trading off computing time and accuracy during the fitting process. Parametric CAD is a poor choice for a very complex model, as their will be too many surfaces to handle the model efficiently.

"Why do sharp edges look rounded?"

Although many fields technically have infinite resolution, they ultimately end up being sampled using a 3D grid. The coarseness or fineness of this grid is controlled by the Visualization Quality. Were the grid to be infinitely fine, sharp edges would be perfectly sharp. As the grid becomes coarser to match the computing resources available, sharp edges become somewhat rounded in both rendering and any subsequent conversion to, for example, a triangle mesh.

To illustrate this, these two images show the same lattice structure viewed on Very Low and Very High visualization quality, respectively.

To minimize this effect, you should finish the design in the highest visualization quality that your computer can tolerate, possibly even using a custom quality.

A Not So Obvious Pitfall: Not All Implicit Modeling Operations Preserve Distances When Combining SDFs

A common operation in implicit modeling is to combine separate bodies to form one connected body. This is often referred to as a Boolean union operation, but implicit modeling uses the shorter term "Combine." One would be forgiven for thinking that combining two bodies, each represented by an SDF, would result in another SDF. However, let's take a look at what happens to the field in this case. The images below were created using the following steps:

1. Create two cuboid primitives that are offset from each other but still overlapping.
2. Combine the objects (Boolean union).
3. Create an inward shell of the combined object to create a hollow object of constant wall thickness.

Careful inspection of the above images will show that the wall thickness is not constant. Specifically, the region where the wall thickness causes the internal corners to touch represents a wall thickness that is larger than expected.

The corrected solution is shown in the images below. Note that the wall thickness is now constant, with appropriately rounded corners, as requested.

To summarize, simply combining multiple SDFs does not necessarily result in a SDF after the operation. The same is true of other operations, such as smoothing, morphing, and offsetting operations. It is useful to keep this in mind when using Implicit Modeling in general.

Specific information on how to use each of the tools within the Implicit Modeling ribbon are given throughout the rest of the Implicit Modeling documentation.