Multi-sided implicit surfacing with I-patches

I-patches represent a family of implicit multi-sided surfaces. Similarly to functional splines, each boundary curve of the patch is deﬁned as the intersection of a primary and a bounding surface, both given in implicit form, and the patch can connect to the primaries with arbitrary geometric continuity. Following the publication of Várady et al. [1], this paper elaborates the basic formulation in more detail


Introduction
Surface modeling with multi-sided patches is dominated by representations given in parametric form [2,3,4]; however, there are various design situations, where the use of implicit multi-sided patches is preferable: (i) Creating accurate connections to surfaces given in implicit form, in particular to planes and natural quadrics, e.g. in hole filling, vertex blending and lofting. (ii) Defining a complex free-form object by a control polyhedron and obtaining a collection of smoothly connected patches, where the implicit form is beneficial since regular shapes can also be incorporated. (iii) Approximating complex surfaces defined by vector fields of distances and gradients, e.g. cell-based representations and marching surface techniques.
Parametric surface representations offer a great versatility in shape design and analysis; however, for mapping a planar domain to 3D we need some intrinsic parameterization, and this is a delicate issue. While it is easy to tessellate parametric surfaces, there are several geometric interrogations that proved to be computationally demanding, e.g. intersections and joining trimmed patches.
Among implicit surface representations, algebraic polynomials are mostly used to represent simple regular surfaces. Representing free-form shapes is not easy, as high-degree algebraic polynomials may produce various shape problems, such as singularities, self-intersections, and disconnected parts. Implicit surfaces are more rigid than parametrics, and editing the shape interior is a real challenge, as there are no obvious control structures to do so. They are generally C ∞ -continuous, representing half-spaces, so point membership classification is easy. No parameterization is needed for distance computations and approximating data points. Implicit surfaces are favorable in photorealistic rendering, due to their computational efficiency in ray tracing (see e.g. [5,6]).
In this paper we revisit the classical arena of implicit representations, and attempt to significantly enhance the I-patch concept of Várady et al. [1], published almost two decades ago. In some sense, I-patches are similar to transfinite schemes, where boundary curves and cross-derivatives -given in parametric form -are blended together in a smooth, somewhat controllable manner. I-patches interpolate a loop of boundary curves, where each segment is defined as the intersection of a primary and a bounding surface, both given in implicit form (similarly to functional splines [7]). A simple 3-sided example is shown in Figure 1. Three primaries (conic sweeps) and three bounding surfaces (planes) define the boundary constraints for the two patches in Figs. 1b and 1c; this also illustrates that there is some degree of freedom to control the fullness of the patch, i.e., the curvatures in the interior, as will be explained later). I-patches smoothly connect to the primaries with G 1 , G 2 or higher degree geometric continuity (see Section 3). The primary surfaces may be a priori determined, or often they are created artificially to satisfy positional and tangential constraints along given boundaries; in this case we prefer to use the term (primary) ribbon. Our current interest is to elaborate multisided implicit surface representations that play a somewhat similar role as their parametric counterparts, i.e., we wish to (i) constrain and edit the boundaries of the shape, and (ii) possibly modify its interior while avoiding awkward twists and selfintersections. At the same time, we wish to exploit the advantages of having exact, algebraic representations.
The paper is structured as follows. After reviewing prior work in Section 2, we revisit the basic theory of I-patches, supplemented by a new, distance-based interpretation (Section 3). We continue with the construction of ribbons and bounding surfaces in Section 4, and focus on I-patches with conic boundaries. This is followed by two potential application areas -vertex blending and polyhedral design (Section 5). In Section 6 we discuss some special cases and related difficulties that need to be handled, then compare I-patches to alternative formulations and show a few test examples. Suggestions for future research conclude the paper.

Previous work
Implicit surfaces have an extensive literature, related to a wide range of topics, including scattered data interpolation, approximation, ray tracing, etc. For a general introduction, see the classic book on the subject [8]. In this paper, we are mainly interested in blending and modeling with implicit surfaces, as well as in methods of tessellation. The rest of this section is organized around these keywords.

Blending
Creating a smooth blend between two or more surfaces is a basic operation in CAD systems. Implicit blending surfaces were introduced in the seminal paper of Hoffmann and Hopcroft [9], and many important problems -like unwanted bulges and discontinuities -were identified and resolved by the displacement blend [10]. The superelliptic blend used in this method still had gradient discontinuities, which can be avoided by replacing the standard set-theoretic CSG operators of Ricci [11] with F-rep [12], based on R-functions, or soft blending [13], which satisfies a Lipschitz condition. Recent developments include gradient-based operators [14] and better topology control [15].
There is also another approach to blending -the one followed by this work -, where the boundaries of the created surface are explicitly defined (in contrast to just specifying a blending range). As outlined in the Introduction, the boundary curves are determined from the intersection of a primary and a bounding surface. The generated patch interpolates these curves, while smoothly connecting to the primary surfaces. (For the definition of geometric continuity in an implicit context, see [16].) The feasibility and minimal degree of this construction was explored in [17], which gives explicit equations, based on Bézout's theorem, for the interpolation of Hermite boundary conditions with implicit surfaces, resulting in a linear system. While a direct fit gives important insights, the eligible solutions often include highly curved and self-intersecting surfaces, which are difficult to filter out. (See also Section 6.2.2 for an example.) Functional splines [7,18,19,20], on the other hand, take a more pragmatic approach, by defining the patch as a blend between a base and a transversal surface, generalizing Liming's conic formula [21]. In our setting, these correspond to the products of the primary and bounding surfaces, respectively. The exact patch equation can be found in Section 6.2.1, along with an example and comparisons to our method. The bounded blend of Pasko et al. [22] also defines boundaries as the intersections of primaries and a single bounding surface, while ensuring that the latter contains the entire blend.
The present work is based on I-patches [1], which is defined as the weighted sum of mixed products between primary and bounding surfaces -see Section 3 for details. (Note that a similar idea had already appeared in [23].)

Modeling
Implicit surface modeling is generally done by CSG operations, extended by blending [24]. This also allows sketch-based modeling [25,26]. However, these methods generate "blobby" objects, suitable mainly for organic models and animations.
Warren [27] proposes local fitting of implicit surfaces in a subdivision of 3D space (e.g. a simplicial mesh), in this way avoiding the problems of higher-order interpolation. The implicit surface is defined as an interpolant of values at given vertices. Continuity constraints at the vertices are computed from a user-defined collection of planes embedded in the mesh -in other words, a control polyhedron. Depending on the interpolant used, the surface can exactly interpolate the values at the vertices or approximate them with additional smoothness.
Algebraic splines and A-patches [28,29] are very similar, in that they are also defined in simplexes. In 3D, the generated patches are always 3-or 4-sided. It can be proved that the 3sided implicit surfaces defined in tetrahedra have at most one intersection with a line going through the apex, so there will be no self-intersections; a comparable assertion is known for 4sided surfaces, as well. The construction is such that C 1 or C 2 continuity between the patches can be ensured, and the remaining degrees of freedom can be used for (local and/or global) shape adjustment.
A framework for polyhedral design with implicit surfaces was published in [30], generating a C 1 -continuous set of surfaces from a triangular mesh, using the interpolation method of [17].
As we will see, I-patches can be used for complex hole filling problems, such as the setback vertex blend (Section 5.1), and for modeling with arbitrary topology polyhedra (Section 5.2).

Tessellation
There is a plethora of polygonization methods for implicit surfaces; see [31] for a general survey. In our context, since the isosurface may have several branches from which we need to display only one, region growing methods, such as [32,33], are favorable. Alternatively, we propose a simple and efficient method that generates high-quality meshes using an auxiliary parametric surface (see Section 6.4 for details).

I-Patches
In this section we revisit I-patches, and show a new interpretation based on distances.

Basic concept
Multi-sided I-patches are defined by a loop of 3D curves; each curve c i is the intersection of two surfaces given in implicit form c i = {P i = 0} {B i = 0}, where P i (x, y, z) = 0 denotes the primary surface to which the patch will smoothly connect, and B i (x, y, z) = 0 denotes the bounding surface that defines the intersection. The equation of I-patches in Várady et al. [1] was given in the following polynomial form: where the w i -s are scalar weights associated with the individual sides, and w 0 is a central weight that influences the fullness of the patch. It is easy to demonstrate this concept with a 3-sided patch, given as This I-patch will interpolate the boundary curves. For example, take the curve c 1 . The first term will be zero due to P 1 = 0, the other three terms due to B 1 = 0. This also shows that the effect of P 1 will gradually vanish as we get close to side 2 or 3, where the bounding functions B 2 and B 3 become zero.
The I-patch will smoothly connect to the primaries, since its gradient vector will be parallel to them. For example, take again boundary curve c 1 , and write the equation as since the second, third and fourth terms equal to zero on c i . In an analogous way, G 2 or higher degree geometric continuity to the primaries can be achieved, if the exponent of the bounding surfaces is three or higher.

Remarks
It should be noted that at the corners of the I-patches, where two primaries and two bounding surfaces meet, the gradient vector is always zero. Take, for example, the corner of c 1 and c 2 , then the G function in the above expression will be zero due to B 2 = 0, so the gradient will vanish, as well. This can be an advantage or a disadvantage. If two primaries at the corner share a common tangent plane, the normal vector of the I-patch will be uniquely determined. However, if not, a singular vertex is created, see for example point Q 1 in Figure 2.
Another special case to be investigated is when two (or more) bounding surfaces coincide. We demonstrate the problem again through a 3-sided patch. Assume that we have three boundaries P 1 B 12 , P 2 B 12 , and P 3 B 3 . Then we can factor out B 2 12 from the equation to obtain which is a branching surface, since neither of the terms interpolates all sides. The solution to this problem is to collect all primary surfaces that belong to the same boundary, and handle them as a single surface in the form of their product. Taking our example, will yield the correct result. Note that we can assign only a single weight to P 1 P 2 . An example is shown in Figure 2. This I-patch (orange) connects to three curved primary surfaces; the two blue primaries (vertical sweeps) are intersected by the same planar bounding surface. It is easy to constrain an I-patch to interpolate an arbitrary 3D point (x 0 , y 0 , z 0 ). Assuming that the weights w i have already been fixed, then the value w 0 can be determined by solving the equation I(x 0 , y 0 , z 0 ) = 0, where w 0 is the only unknown. Figure 1 shows two variants of a 3-sided patch interpolating two different reference points in the middle.

Distance-based interpretation
Here we show that I-patches can also be interpreted based on distances. This helps to better understand the formulation and set certain shape parameters. A somewhat similar approach occurs in classical geometry, as well. Take an ellipse and its implicit equation It can be interpreted as the locus of points, where the sum of the Euclidean distances from two focal points is constant, i.e., We generalize this for I-patches and combine distances from the primitive surfaces. We may take d i = P i (x, y, z) and search for the locus of points where n i=1 d i = d 0 ; however, in order to ensure the interpolation property, we need to involve the bounding surfaces, as well, and apply weighted algebraic distances d i in the form of d i = w i P i /B 2 i . These can be derived from the polynomial I-patch equation, if we divide all terms by n j=1 B 2 j . For example, a 3-sided I-patch in rational form is the following: In fact, it is easy to show that distance-based I-patches can reproduce certain standard implicit surfaces. For example, combining three primaries of orthogonal elliptic cylinders and three related planar bounding surfaces, one can exactly reproduce an ellipsoid: (See Section 4.6 on how to set w 0 .) This expression contains the equation of the ellipsoid multiplied by a second term, which is an isolated point at the origin. When a = b = c = 1, we obtain an octant of a sphere with unit radius. In Figure 3 we show a sequence of isosurfaces combination of this sort of algebraic distance fields produce the final I-patch. The distance-based formula nicely works for the interior points of the patch; however, it degenerates to 0/0 expressions in the vicinity of boundary curve c i . In order to avoid this, we use another formula, multiplying the equation by B 2 i /w i . For example, At the points of c 1 both terms are zero; in the close vicinity of c 1 the quadratic expression B 2 1 /w 1 remains small, thus the I-patch behaves as P 1 , satisfying our expectations.
The distance-based formulation helps to efficiently evaluate the surface in the interior, and set the individual weights w i (see Section 4.6).

Constructing I-patches
In this section we discuss how to construct the components of I-patches, including boundaries, primary ribbons and bounding surfaces. We explain how to orient them, and what are the options for shape editing.
The I-patch has n corner points denoted by Q i (Figure 4), and for each there is a well-defined tangent plane π i with normal vector N i (see concrete constructions in Section 5). Each primary ribbon P i interpolates the i-th boundary curve and satisfies the tangential constraints at the related two corners. We deal with straight boundaries, conic boundaries, I-segments and general boundary curves.

Straight boundaries
The simplest case is when the tangent planes π i and π i+1 are identical, containing the desired straight segment Q i Q i+1 . Then P i is directly defined, and B i will be a plane orthogonal to P i , containing both Q i and Q i+1 .

Conic boundaries
A conic boundary c i is defined by a control triangle, using Liming's formula [21], as follows. Take the corner points and pick a middle control point (denoted by E i ) on the intersection line of planes π i and π i+1 . Then the segments determine three lines in implicit form, denoted by l 1 , l 2 and l 3 , respectively. The curve c i goes smoothly from l 1 to l 2 , touching them at their intersection points with l 3 . This is a planar implicit equation given in the form Here λ i is the fullness factor, which also determines the type of conic. For example, in Figure 4 Q 2 E 2 Q 3 represents a control triangle for curve c 2 . All conics can also be defined in rational Bézier form c i (t), using the same three control points and a rational weight -a property we are going to exploit later, see the tessellation algorithm in Section 6.4.
We consider three cases. Case 1. Let us construct a quadratic primary ribbon P i that contains c i . It is a natural idea to use Liming's technique for three planes, then where π i denotes the cutting plane. This must contain the chord Q i Q i+1 , but there is a degree of freedom, called the sweep direction s i , by means of which we actually determine this plane. The normal of π i will always be the vector product of the chord and s i . One special case is when s i is chosen to be orthogonal to the plane of the control triangle, and simple conical sweeps are generated. If both N i and N i+1 are contained in the plane of the control triangle, and the conic represents a circular arc, a cylindrical surface is obtained. In order to set a good sweep direction for arbitrary tangent plane normals, we propose to set it orthogonal to the average of N i and N i+1 ; this method degenerates to the above cylindrical surface. In these cases, a planar bounding surface B i is used, determined by the control triangle, thus c i is reproduced. An example of a Liming-ribbon, which touches the corners Q 2 and Q 3 , can be seen in Figure 5.
Case 2. Another possible way of creating conic boundaries is when the primary ribbon P i is set as the plane of the control triangle, being incident to π i and π i+1 . Then we define B i as a quadratic Liming surface using binormals M i at the two corners. This construction produces curved bounding surfaces. Since B i also contains the conic, the intersection with P i will reproduce c i , as required. Figure 6 shows a curved bounding surface interpolating corners Q 1 and Q 2 .  Case 3. We may need to create conic boundaries by combining the previous two cases. When the angle of the sweep direction with the plane of the control triangle is less than a given tolerance, we retain the general quadratic Liming-ribbon P i , and intersect it with a curved bounding surface B i .
It is a necessary condition for the existence of a conic boundary with Liming-ribbons that the opposite corner points fall into the consistently oriented positive half spaces of the tangential planes. Formally, π i (Q i+1 ) > 0 and π i+1 (Q i ) > 0 must hold. This condition was also pointed out by Bajaj and Ihm [30]. An example is shown in Figure 7; the top curve of an "almost toroid" surface lies in the xy-plane, while the left normal vector N 2 is tilted forward, and the right normal vector N 1 is tilted backwards. Here the above criterion is not satisfied, and no appropriate conic ribbon can be inserted, since the two normals would point into different half-spaces, yielding a nonsense shape. In these cases, we need to apply another advanced construction, described in the next section.

I-segments and I-ribbons
First we describe I-segments. These are the 2D counterparts of I-patches, where two implicit curves are being blended. Isegments, defined by quartic polynomials, are more general curves than conics. Given two primitive lines l i and two local bounding lines h i in the plane of the control triangle, the segment runs from one intersection point to the other (see examples in Figure 8). We use the following polynomial formula: I-ribbons are based on the same logic, combining tangent planes π i and π i+1 at two adjacent corners with local bounding planes µ i and µ i+1 . Then A natural choice for the local bounding surfaces is to use two parallel planes perpendicular to the chord and interpolating the corner points. Thus we have created an I-ribbon P i ; its corresponding bounding surface B i can either be a plane or a curved bounding surface, as discussed for Liming-ribbons. In Figure 7 an I-ribbon is shown that resolves the difficult case with twisted normals mentioned above.

General boundary curves
In addition to these special constructions, arbitrary primary and bounding surfaces can also be used, producing general 3D boundary curves.

Orienting ribbons and bounding surfaces
In contrast to functional splines, the orientation of the ribbons is crucial for I-patches. These ribbons occur in separate terms in the equation (not as a single product), and for each ribbon we require that the local gradient must have the same direction as that of the final patch.
Let us see some simple 2D examples in Figure 8. In 8a the functional spline curve matches the orientation of the primaries. In 8b we have an I-segment with inconsistent orientation, yielding a wrong curve, however, 8c is consistent, and we obtain a good result. In 8d the functional spline curve cannot properly match the given orientations, and a nonsense curve is obtained. Fig. 8e shows an incorrectly oriented I-segment, but in 8f the expected result is obtained. It can be seen that the functional spline has problems with creating inflections, while the I-segment can solve these if the primary orientation is consistent.
It is a basic assumption that we wish to keep the I-patch within the union of the positive half-spaces of the bounding surfaces, i.e., we envision the shape on the same side of the B i -s. (We need to check whether this condition is satisfied, and modify some of the boundary surfaces, when needed, see Section 6.1.) We also assume that a consistently oriented, piecewise normal vector fence exists for the boundary loop, as shown in Figure 9. Matching this will define the correct orientation (sign) of the primary surfaces.

Setting the shape parameters
If we construct Liming-ribbons, we may assign a fullness value λ i for each boundary; circular arcs are often chosen, to connect to cylinders. In principle, the sweep direction of these ribbons may also be a parameter to be tweaked.
Once the primaries or the primary ribbons are defined, we need to set the w i weights. We are not aware of any single best method to do so, however, we apply a heuristic setting that yields good default values in the majority of cases. All w i must be positive, since the orientation of primaries -as set in the previous subsection -must be retained. Let us pick a reference point R that is typically, but not necessarily, a point to be interpolated by the I-patch. We set the weighting of the components by satisfying w i P i (R)/B 2 i (R) = ±1, using the algebraic distances from Section 3.3. The sign depends on the location of the reference point with respect to the ribbon. For example, in Figure 4, the reference point is under the Q 1 Q 2 ribbon, but above the Q 2 Q 3 ribbon. Thus we combine the surfaces in a way that they will have the same contribution at the reference point.
Keeping the above initial w i values, we have freedom to choose an arbitrary w 0 weight in Eq. (1), that will globally control the fullness of the patch. The geometric meaning is that this value corresponds to the sum of the distances, so accordingly tighter or looser patch interiors can be produced. We set the coefficients such that in R the sum of the absolute values of all weighted algebraic ribbons is one; however, their sign depends on the sign of the P i -s. We want the patch to interpolate R, so w 0 needs to be set to sgn(P i (R)), which ensures that the patch interpolates R.
Of course, it may make sense to modify the default weights w i . In our experience, these are appropriate for simple models, but for complex, twisted configurations some tuning may be necessary. It is possible to manually edit the weights, but this requires experience. Instead we propose to run a numerical optimization: first we create an initial triangulated mesh (as described in Section 6.4) using the defaults, then these values are updated by minimizing the polyhedral energy functional proposed in [34]. Generally a good shape is obtained.

Surface modeling with I-patches
In this section we show two application areas where I-patches are useful. The first is setback vertex blending, where a multisided I-patch is formed to connect primary surfaces and edge blends. The second application is polyhedral design, where a complex free-form shape is defined by means of a control polyhedron, yielding a collection of smoothly connected I-patches. The common boundaries and the ribbons are naturally derived.

Setback vertex blending
Vertex blends play an important role in surface and solid modeling. While edge blends (fillets) replace sharp intersection curves, vertex blends smoothly connect converging edge blends. Vertex blending is a difficult modeling task, as the edges to be blended may represent very complex configurations; we  may have convex, concave or smooth edges with uneven angles and radii, and must handle many special cases, including tangential, cuspate and degenerate edge pairs. A general solution to this problem is setback vertex blending, see the early papers by Braid [35] and Várady et al. [36,37]. The termination of the edge blends are pushed away from the vertex by various setback values to ensure the necessary space for a smooth transition. Later further multi-sided setback vertex blends were published using variants of functional splines [19] and S-patches [38]. It has been emphasized in [37] that for connecting n edge blends the most genuine surface model is not an n-sided, but a 2n-sided patch, although it is possible that the setback vertex blends degenerate, having an arbitrary number of sides between n and 2n.
The basic components of a setback vertex blend are shown in Figure 10: Construction of a setback vertex blend. Figure 10. Here we describe vertex blends for polyhedra, but the concept nicely generalizes for more complex ribbons and bounding surfaces. The i-th edge blend, generally a cylinder, is bounded by two rail curves (colored pink), that run on the "previous" and "next" primary surfaces. The edge blends terminate at profile curves (blue); for example, one connects two corner points C 1 and C 2 . Together with the edge point E 12 , a planar control triangle is formed, a placeholder for a circular (or conic) profile.
On each primary surface there are two corners that need to be connected by a spring curve (blue); for example, the one that connects C 2 and C 3 . The rail curves that pass through these points intersect at point I 23 , defining another triangle for a conic segment. Altogether, the vertex blend is bounded by an alternating sequence of profile curves and spring curves. A formula to compute the extent of the setbacks can be found in Appendix A; for more details see [37].
The actual construction is fairly straightforward: first an alternating sequence of cylindrical edge blends and planar primary surfaces are computed, then these are intersected by an alternating sequence of bounding planes and curved bounding surfaces. We define a reference point by adding to the central vertex O a displacement vector based on the average deviation between the edgepoints E i j and the midpoints of the related circular profiles. Then we set the weights w i and the fullness of the patch, and apply the I-patch equation. We will discuss potential ribbon problems and show interesting examples in Section 6.

Polyhedral design
Modeling with control polyhedra has many manifestations. The most well-known is recursive subdivision (see e.g. [39]), but quadrilateral parametric surfaces can also be stitched together in various ways (see e.g. [40]). In most of these approaches, handling irregular vertices is still a crucial research issue. Quadratic and cubic S-patches can also be used for polyhedral design [41], but the topological structures in these constructions are somewhat limited.
Here we propose a polyhedron-based representation that produces smoothly connected I-patches. The control polyhedron has a general topology with faces of arbitrary number of sides and vertices of arbitrary valency. The faces are not necessarily planar, and the control structure may be open or closed, but T-nodes are not permitted.
The surface model is determined by a free-form curve network of conic arcs. Its topological structure corresponds to the dual graph of the polyhedron, see Figure 11. For each face of the polyhedron we compute a centroid, Q i . For each straight segment of the polyhedron there is a corresponding crossing curved edge that connects the centroids of the neighboring faces. For each vertex of the polyhedron with valency k we compute a k-sided surface patch, bounded by a loop of k curved edges.
At the centroid we determine a local tangent plane; for planar control faces this is obvious, for non-planar faces we compute a best-fit plane that contains the centroid and approximates the midpoints of the edges in least-squares sense. The Liming-ribbons (or the I-ribbons) are uniquely defined by two centroids and two local tangent planes, being shared by the adjacent patches along the common boundary.
A simple example is shown in Figure 11. The control polyhedron has one 5-sided and six 4-sided faces. It has internally two 3-valent vertices and one 5-valent vertex, which will yield two 3-sided patches and one 5-sided patch. The Q 2 Q 3 ribbon, for example, is then uniquely defined for both the left 3-sided and the 5-sided patch, ensuring smooth connection.

Discussion
We would like to emphasize that modeling with implicit surfaces is a difficult area. We have discussed the mathematical background of I-patches; however, we have to keep in mind that these schemes will produce good shapes only if the ribbons  and the bounding surfaces are "suitable" for patch generation. Certain problems can be detected, and the components can be fixed, as explained below. In the second half of this Section we will compare I-patches with alternative schemes, then show a few test examples, and discuss our tessellation algorithm.

Handling ribbon problems
In Section 4.3 we have already discussed special cases, where it was impossible to create a Liming-ribbon, and we had to apply a more complex construction, the I-ribbon. Here we deal with two further problems.

Poor ribbons
The I-patch scheme may produce dubious shapes, if the distance fields produced by the primary ribbons abruptly change their sign within the space where the I-patch is going to be created. This may be due to multiple surface branches in the vicinity of the boundaries, or high curvatures, when the ribbon "turns under" itself; see the transparent surfaces in Figures 13  and 14. Self-intersections within the ribbon may also lead to visible shape problems.
In these cases we have different options to repair the ribbons. We can change the fullness λ i of the boundary conics, which strongly affects the shape of the Liming-ribbons, as well. As the curvature becomes smaller, the artifacts disappear. Such an example can be seen in Figure 13, where the original ribbon of the I-patch was replaced by a "broader" one that locally prevents interference with the interior of the patch.
Another option is to change the representation of the primary ribbon, and exclude the highly curved portion or the undesired branch. We can modify Liming's method to obtain a piecewise Liming-ribbon: An example is shown in Figure 14, where a cylinder with small radius was replaced by a piecewise ribbon, yielding a good setback vertex blend. The drawback of this method is that having G 1 continuity along π i may affect internal continuity within the patch, although in many cases the curvature maps or the isophote lines do not indicate this phenomenon at all, see for example Figure 15.

Intersecting bounding surfaces
We assume that the union of the bounding surfaces forms a well-defined, connected space for the patch to be created, and accordingly all bounding surfaces are supposed to have a constant sign inside the patch. This is violated when a bounding surface B j intersects another boundary curve, where P i = B i = 0, and thus I-patches of unacceptable quality are obtained. We can detect this problem by checking whether the bounding surface intersects the boundary loop on the distant boundaries. An example is shown in Figure 16, where the top right bounding surface intersects the bottom left boundary. The problem is fixed, if we use a curved bounding surface.

Comparisons with other schemes
In the following we will show some comparisons with functional splines [7,19] and algebraic Hermite interpolation [17].

Functional splines
Functional splines [7] are defined by the equation a generalization of Liming's formula, cf. Equation (11). Here f is the base surface, and g is the transversal surface. The resulting isosurface interpolates the intersection of f and g, joining to the former with G k continuity. While in special cases it can be simplified, generally this means that f = i P i and g = i B i . It has been known [42] that a large class of low-degree functional splines are convex, and thus cannot be used for specific boundary configurations. Take for example the 6-sided hole loop with alternating convex and concave boundary constraints in Figure 17. In [7], this model was generated as a collection of six smoothly connected functional splines. As discussed in Section 4.5, with I-patches we can set the sign of each primary so that a consistent normal orientation can be achieved.  A variation of the above definition is the symmetric functional spline [19] F(x, y, z) which -similarly to I-patches -combines the primary and bounding surfaces. This modified formula allows the creation of non-convex surfaces, such as house corner blends, but some ingenuity is required in choosing the correct base and transversal surfaces (see its application for vertex blends in [19]). In contrast, I-patches, having separate components, have more potential to be tuned as they have more degrees of freedom. This is illustrated in Figure 18, where isophote lines are compared.

Algebraic Hermite interpolation
The fitting framework described in [17] gives a direct solution for the hole-filling problem, leading to a homogeneous system of linear equations. The algorithm ensures finding the sur- face of least degree satisfying the boundary constraints. Finding an acceptable solution, however, is not trivial, as we will demonstrate in the following example.
Take the setback vertex blend configuration shown in Figure 19a. The profile curves are circular arcs, while the spring curves are parabolas. The normal vectors at the vertices are defined by the end tangent vectors of the adjacent curves; the normal fence along the curves is a linear blend between the end normals, as in [30].
The least degree for which the system is solvable is four, but the (unique) quartic patch contains several singularities (normal flips) on its boundary. Going one degree higher, we find the nice surface shown in Figure 19b. The problem is that this is but one of the infinitely many solutions, as the kernel is 6dimensional, and any linear combination of its basis vectors corresponds to a valid solution. Most of these, however, contain self-intersections or have large bumps in the interior. Figure 19c, for example, shows another quintic surface that nicely interpolates the boundary constraints, but has a gaping hole inside. (Here the full isosurface is shown to appreciate its form; black lines show the setback vertex blend boundaries.)

Test cases
1. We have shown a 6-sided vertex blend earlier in Figure 10.
This connected three cylindrical edge blends with radii 20, 50 and 10 and setbacks 100, 60 and 125. These parameters can easily be edited. 2. An interesting 10-sided patch is shown in Figure 20, connecting three cylinders of almost 90 degree arcs with two very flat cylinders. The I-patch is sliced with parallel planes, and the curvature map is also shown. Piecewise Liming-ribbons were used. 3. The next test case is a combination of connected setback vertex blends, applied on a polyhedron. In Figure 21, three 8-sided and three 6-sided patches smoothly connect to pla-  nar faces (not shown). The patches are displayed with curvature map and contours. 4. We have shown earlier a collection of three smoothly connected I-patches defined by a control polyhedron, see Figure 12. 5. Finally, we mimic polyhedral design using a very simple test object ( Figure 22). We performed simple operations, such as dragging the right face and repositioning the top vertices, the shape was modified in a natural manner. On the left side, we extruded the left face and created a new knob-like shape.

Tessellation
I-Patches with parametrizable boundary curves can be tessellated in the following way. First create an auxiliary multi-sided parametric patch (in this paper the C 0 multi-sided Coons patch is used, see Appendix B) with the same boundary curves as the I-patch. Then compute normal vectors at the corner points from the end tangents of the boundaries. After tessellating the auxiliary patch, at each mesh vertex define a ray by taking a convex combination of the corner normals using generalized barycentric coordinates [43]. Along the boundaries this will be a linear  sweep between the corner normals; it is assumed that in the interior the rays remain within the union of the positive halfspaces of the bounding surfaces. The rays intersect the I-patch and produce a tessellation (see Figure 23); the angles between the rays and the gradients of the surface should remain under a prescribed threshold. When this is violated, the I-patch is categorized as "poor", possibly having abrupt curvature changes, internal holes or branching. In this case the I-patch needs to be repaired (see Section 6.1). Experience shows that this algorithm produces a nice mesh for valid I-patches and is suitable to recognize ill-conditioned cases.

Conclusion
In this paper we revisited classical surfacing techniques using implicit patches, and attempted to widen the limits of former representations. We believe that the use of implicit multisided patches is justified when we want to accurately connect to other, mainly regular, implicit surfaces, and/or want to exploit the well-known benefits of algebraic representations. I-patches represent an interesting approach, where the primary surfaces can be individually controlled by weighted bounding surfaces. We have discussed the basic construction with useful geometric observations, including a distance-based interpretation, consistent orientation of the primaries, and curved bounding surfaces. In our I-patch applications of setback vertex blending and polyhedral design, mainly Liming-ribbons with conic boundaries were combined; however, various cases with more general surface components have also been studied.
Concerning future work, there are interesting issues to enhance the current scheme, including the generation of the most suitable bounding surfaces and the automatic calculation of the ribbon weights that could replace the current heuristic method. The GPU implementation of I-patches is also an important computational topic.