One aspect of producing a spline blend surface between two closed curves ... In the end, the active .... is not part of a polyline ending near a local minimum.
Surface Creation and Curve Deformations Between Two Complex Closed Spatial Spline Curves Joel Daniels II and Elaine Cohen University of Utah
Abstract. This paper presents an algorithm to generate a smooth surface between two closed spatial spline curves. With the assumption that the two input curves can be projected to a single plane so that the projections do not have any mutual or self intersections, and so that one projection completely encloses the other. We describe an algorithm that generates a temporal deformation between the input curves, one which can be thought of as sweeping a surface. Instead of addressing feature matching, as many planar curve deformation algorithms do, the deformation method described generates intermediate curves that behave like wavefronts as they evolve from the shape of one boundary curve to a medial type curve, and then gradually take on the characteristics of the second boundary curve. This is achieved in a manner that assures there will be neither singularities in the parameterization nor self-intersections in the projected surface.
1
Introduction
This paper presents an algorithm to generate a parameterized spline surface between two closed spatial spline curves. The input curves are allowed to have
2
differing degrees, parameterizations and shapes; however, they must project onto a single plane P without mutual or self intersections so that one projected curve completely encompasses the other. The algorithm creates a parameterized smooth spline surface, without any self-intersections, with the original closed curves as the boundaries. Techniques to generate a surface from boundary curves are often used in geometric modeling. Usually, the interior of a surface is blended from four distinct boundary curves that correspond to mappings of the edges of the unit square. Our algorithm is quite different since it creates a surface between two quite dissimilar closed curves. This solution is related to surface completion solutions that build triangular patches to fill holes within a mesh [6, 7]. These methods are useful in resolving gaps of a model when it is important to make it water tight. Designing parting surfaces for injection molds is another modeling application that requires generating a surface between two closed spatial curves. An injection mold clamps two components together, forming a cavity that defines the object being molded. The parting curve of an object separates which parts of the object are represented in each of the mold pieces. The parting surface is the interface between the injection mold pieces that joins this parting curve with the mold’s boundary curve. When these two curves are non-planar and when creating a ruled surface is not straightforward, then defining the parting surface can be technically challenging. Our surface generation solution creates surfaces under these very conditions. Technique Overview Conceptually, the surface generation algorithm builds two continuously deforming curves that sweep the output surface between the input spatial splines over time. Each curve deformation is constructed on P , the projection plane, and originates at the projection of one of the two input curves. The deformations can be developed between curves with little or no common feature characteristics. The properties of our planar deformations guarantee that the surface swept by the temporal curve deformation on P has no singularities in the parameterization and never self-intersects. Therefore, the final output is a smooth height field over P that defines a surface in R3 blending the two input spline curves.
2
Related Work
Surface Completion Hole filling or surface completion techniques investigate problems that are related to the surface generation problem addressed here. There are two classes of research. One addresses holes bounded by piecewise linear curves and derives piecewise planar triangulated results while the other addresses holes or regions bounded by curves. Triangulation methods exist for simple holes bounded by polylines; however, these solutions do not apply in more complex geometric configurations. Many techniques have addressed these challenges, for example, Davis et al. [7]; however,
3
we are interested in higher degree boundary curves for which piecewise linear representations are not adequate. One aspect of producing a spline blend surface between two closed curves requires constructing a tensor product parameterization. Using medial axis information to aid in forming a parameterization, [15] develops a radial parameterization of a region inside a planar boundary curve. Curve Deformations Curve deformation research can be divided into two separate topic areas: feature matching and vertex paths. Feature matching establishes a correspondence between the major features of two curves, for example [5, 9, 11, 17]. These techniques are able to pair similarities between two planar curves. However, considering the deformations as surfaces, self-intersections frequently occur. Consequently, the vertex path problem of curved deformations is more relevant to this research. Examples of this includes methods to prevent self-intersections intermediate shapes both locally [16] and globally [12]. While these methods produce better deformation paths, the surfaces swept by their algorithms may contain singularities. This research is constrained in that no self-intersections can occur on any intermediate shape, nor can a single point be on more than one temporal projected deformation curve. Snakes and Active Contours In this literature image processing methods place curves within an image, then evolve them until they are oriented along the edges of contrast between neighboring pixels. These curves, termed snakes or active contours [3, 13, 18, 19], minimize energy functions that are computed over the image’s pixels by using gradient descent methods. In the end, the active contours are used to segment the image into a set of coherent components. Our method for generating the surfaces is similar to these curve evolution methods. Conceptually, we initialize active contours to the projection of the input curves and deform each snake towards the other. Because our work uses the deformation paths to parameterize a surface, it is necessary to address issues that do not concern the image processing community. These challenges include resolution of the surface singularities that occur from stationary pieces of an active contour, parameterization matching of multiple active contours, and height computations to create non-planar surfaces. Robot Path Planning Related to the vertex path problem is the robotic path planning problem of computing paths for robot seeds to navigate through an environment filled with obstacles represented by polygonal shapes. Chuang [4] assigns each obstacle a potential function by defining a scalar value that drops exponentially as the distance to the obstacle grows. The summation of these functions over all obstacles in the environment defines a potential field. The robot’s motion is computed by gradient descent techniques. To define a global minimum within the potential field, goal destinations have been assigned negative potential functions [10]. However, some formations of obstacles can create local minima that prevent trajectories from reaching their target destinations. In [14] Lewis and Weir use intermediate goals as way-points that can be used to navigate away from local minima.
4
Fig. 1. The surface generation algorithm, composed of four stages, uses the projection of the input curves. (1) Compute vertex trajectories, (2) build a planar surface, (3) establishes C 0 continuity between the two surfaces, and (4) lift the surfaces into 3D.
Robot path planning research has also investigated the collaborated movement of multiple agents. Balch and Hybinette [1] extend potential fields for group path planning by locally repelling robots from each other and developing social potentials. Social potentials are attraction locations associated with the robots that show good results in achieving formations during travel. We extend the concepts of robotic path planning techniques to address the vertex path problem of curve deformations within our algorithm for surface generation. Medial Axis Approximations The medial axis for a planar polygon shape is the set of points equidistant to 2, or more, points on the polygon [8]. There are many techniques to quickly compute piecewise linear medial axis approximations for planar polygonal shapes, which are adequate for our purposes as we project the curves to a plane. We assume that we are given an approximation of the medial axis of the region bounded by the projected curves.
3
Parametric Surface Generation
The algorithm generates a parameterized spline surface between the input curves, γ1 (u) where u ∈ Iu and γ2 (v) where v ∈ Iv , by developing a curve deformation based on γ˜1 (u) and γ˜2 (v), the curves that have been projected on to P . Let C˜i = {˜ ci,j }j denote the control polygon for γ˜i . The technique, illustrated in Figure 1, can be decomposed into four main stages: 1: Compute vertex paths from the control points of γ˜1 (u) and γ˜2 (v) to a medial axis approximating polyline between the projected curves. 2: Compute two planar curve deformations, σ ˜ 1 (u, t) and σ ˜ 2 (v, t), from the trajectories that sweep surfaces without overlaps. 3: Refine and relax σ ˜ 1 (u, t) and σ ˜ 2 (v, t) until ∃f : Iu → Iv such that σ ˜ 1 (u, 1) = σ ˜2 (f (u), 1) and f is continuous and a bijection. 4: Lift σ ˜ 1 (u, t) and σ ˜ 2 (v, t) to define σ1 (u, t) and σ2 (v, t) as height fields above P , such that σ1 (u, 0) ≡ γ1 , σ2 (u, 0) ≡ γ2 , and σ1 (u, 1) ≡ σ2 (f (u), 1).
5
Fig. 2. (left) A visualization of Vr in a complex concavity, (right) where vertex trajectories travel towards local minima.
Fig. 3. Classified skeleton segments: core edges (blue), branch edges (green), and extraneous edges (dotted grey).
Consequently, the output surface is composed of two spline surfaces, σ1 (u, t) and σ2 (v, t). The following subsections describe each of these stages in further detail. 3.1
Stage 1: Vertex Trajectories
The goal of Stage 1 is to compute vertex trajectories for all c˜i,j of the two projected curves. These trajectories are defined as paths over time through a vector field and serve as a basis for the control mesh of the final output surface. The vertex trajectories begin at c˜i,j and traverse the vector field V towards an intermediate shape B which is piecewise linear. The following subsections further define B and explain how to construct a vector field in which the vertex trajectory curves are guaranteed to reach B and not intersect each other. Vector Field Without Local Minima Similar to the obstacles in a robot path planning environment, the segments of C˜1 and C˜2 are assigned a repulsion vector field. The i, j th repulsion field is defined as: vr,i,j (¯ x) = k¯ x − p¯k−k (
x¯ − p¯ ), k¯ x − p¯k
where, the point p¯ is the closest point on the line segment connecting c˜i,j and c˜i,j+1 to the point, x¯, at which the force is being evaluated, and the exponent, k, controls theP exponential fall P off. The final repulsion field, Vr , is the sum all x). x) + k vr,2,k (¯ vr,i,j : Vr (¯ x) = l vr,1,l (¯ Unfortunately, vertex trajectories that traverse Vr are not guaranteed to reach B. As in robot path planning, local minima may arise within the complex concavities formed by γ˜1 (u) and/or γ˜2 (v), illustrated in Figure 2. Consequently, our algorithm requires a third input: a skeleton S of C˜1 and C˜2 on P . S is a medial axis approximation of the environment that is defined by a collection of polylines. The line segments, or edges, of S can be classified, illustrated in Figure 3, as one of three types: core, branch, or extraneous. A core
6
edge is a line segment of S that divides C˜1 from C˜2 on P . A branch edge is a segment that separates C˜i from itself and is part of a polyline that originates at a core edge and terminates within a region of P that contains a local minimum. Lastly, an extraneous edge is a line segment that separates C˜i from itself but is not part of a polyline ending near a local minimum. The vertex trajectory computation uses the classified edges of S to help define two additional vector fields Va and Vf that overcome the motion towards local minima. We define a new vector field, V = Vr + Va + Vf , without local minima through which vertex trajectories can be computed for c˜i,j . The set of core edges of S is a closed polyline on P between C˜1 and C˜2 that defines B with vertices {bi }i , the initial goal curve for the vertex trajectories. These edges are assigned global and local attraction functions, vg,i and vl,i , to pull seed points towards their location. The final attraction vector field Va is the P x) + vl,i (¯ x). sum of all vg,i and vl,i : Va (¯ x) = i vg,i (¯ The global attraction function attracts seed points no matter their distance from the segment and is defined as: vg,i (¯ x) = k¯ p − x¯k−k (
p¯ − x ¯ ). k¯ p−x ¯k
The vg,i is assigned to the segment between bi and bi+1 , where p¯ is the closest point on that segment to the input x ¯. The second attraction function is designed to increase the local attraction field so that vertex trajectories within this region will snap to the segment in an appropriate place. The influence of the function defined on a segment of B is restricted to the viewable range of the segment. In this manner, the local attraction force disallows points from traveling parallel to a segment if they can be snapped immediately to B. For the segment connecting bi to bi+1 , the local attraction function is defined as: ( ¯ p−¯ ¯ xk) p) ¯ p−¯ ¯ x (s(¯ p) cos( (r(p)−k ) + s(2.0 )( kp−¯ p−x ¯k ≤ r(¯ p), r(p) ¯ ¯ xk ) f or k¯ vl,i (¯ x) = (0, 0) otherwise, where, p¯ is the closest point on the segment to x ¯, r(¯ p) determines the radius of influence of the segment at p¯, and s(¯ p) is a scalar value that controls the magnitude of the vectors. The linear interpolating function r is defined on each segment such that r(bi ) = dcurve (bi ) and r(bi+1 ) = dcurve (bi+1 ), where dcurve (¯ y) is equal to the distance from the point, y¯, to the closest point on C˜1 and C˜2 . Similarly, the magnitude scalar function, s, is a linear interpolant between s(bi ) and s(bi+1 ). In practice we achieve good results by assigning s(bi ) = r(bi ) and s(bi+1 ) = r(bi+1 ). Branch segments of S are used to guide seed points out of complex concavities by defining flow fields. The ith flow field is a locally defined vector field parallel assigned to a branch segment that connects points qi to qj of S: ( q¯ −q¯ ¯ p−¯ ¯ xk) p) ¯ (s(¯ p) cos( (r(p)−k ) + s(2.0 )( kq¯jj −q¯ii k ) f or k¯ p−x ¯k ≤ r(¯ p), r(p) ¯ vf,i (¯ x) = (0, 0) otherwise,
7
Fig. 4. The same concave section of curve as Figure 2 with (left) a visualization our vector field construction without local minima, (center) vertex trajectories trace to B, (right) seed repulsion avoid intersections that may result from numerical integration
where, p¯ is the closest point on the segment to x ¯. The orientation of qi and qj is chosen so the flow field is parallel to the polyline and directed towards a core edge of S (i.e. B). The maximum magnitude function, s, is evaluated for each segment to guaranteePthat s(qi ) > kVr (qi )k and s(qj ) > kVr (qj )k. Therefore, the flow field, Vf (¯ x) = i vf,i (¯(x)), overpowers the motion towards local minima of Vr and guarantees that trajectories will be able to reach B. The radius of influence of each vf,i is measured at the endpoints, in the same manner as vl,i , such that r(q) = dcurve (q). Consequently, the influence of a flow field is restricted to the concave region in which the branch edge resides. The extraneous edges of S are ignored. Since no local minima exist in these regions of Vr , seed points are not be trapped in their neighborhood. x) = P The resulting P vector field, P V , is summed over allPassigned forces, V (¯ v (¯ x ) + v + (v (¯ x ) + v (¯ x )) + v (¯ x ), and does not g,m k r,1,k l r,2,l m l,m n f,n contain local minima (see Figure 4). In this way, seed points placed within the environment, on P , can be guaranteed to trace successfully to B. Neighbor Avoidance Path Computation Vertex trajectories computed within a continuous vector field can be guaranteed not to cross in their limit by the Uniqueness Theorem [2]. We modify the vector field functions, vr,i,j , vg,i , vl,i , and vf,i , to satisfy the constraints of the Uniqueness theorem in Appendix A. Then in theory, the vertex trajectories will not intersect each other. However, numerical integration methods used to compute these paths take discrete sampling steps. Even with fifth order Runge-Kutta approximation, there is enough error in some pathological cases to cause path crossings. Consequently, additional efforts are required to prevent such anomalous path intersections. To avoid this problem, we assigns a repulsion force, identical to a scaled versions of that assigned to the core edges of S, to the vertex trajectories based on proximity of nearest neighbors. While these forces are able to prevent vertex path intersections, they may introduce new local minima within V . The algorithm, illustrated in Figure 5, presents a method to compute the discrete steps of the
8
Fig. 5. Discrete vertex step computation for neighbor avoidance.
vertex trajectories that avoids the introduction of local minima. It applies these forces only in the direction perpendicular to the desired direction of travel as a 4 step process: 1: Approximate the desired step vector, s¯, of a vertex point, p¯, through V with fifth order Runge-Kutta (see Figure 5a). 2: Extend the two neighbor paths of the vertex by estimating P 0 a number of future steps, then compute their repulsion force, r¯ = vg (¯ s + p¯), at the desired step point (see Figure 5b). 3: Compute the component of r¯, r¯0 , perpendicular to s¯ (see Figure 5c). 4: Move the vertex point, p¯ = s¯ + r¯0 (see Figure 5d). 5: Repeat steps 1-4 until all trajectories intersect B. This new vertex trajectory computation method relaxes the paths as they travel through V . Forward progress is not hindered by the repulsion forces as only the component perpendicular s¯ is considered. Additionally, the estimation of future steps for the neighbor paths aids in ensuring that the r¯0 will not allow the vertex path to cut in front of another trajectory. The neighbor avoidance and step computation successfully navigates groups of vertices through V , while evenly spreading the distances between paths that had been previously congested, as illustrated in Figure 4. 3.2
Stage 2: Planar Spline Surface Creation
Stage 2 generates a planar parameterization of a spline surface, σ ˜ i from the vertex trajectories associated with the control points of γ˜i . The knot vector and degree of σ ˜i equals that of γ˜i in the first parametric variable. This section ˜ i , that will be associated with σ describes the construction of a control mesh, M ˜i . ˜ i does not contain any intersections between Consequently, it is necessary that M its row and column edges so the spline variation diminishing property can be used to guarantee that σ ˜i is without self-intersections. We extend a greedy data reduction algorithm to approximate the vertex ˜ i . Greedy data reduction trajectories with polylines that define the columns of M
9
Fig. 6. 1-5 compute a C 0 boundary between σ ˜ 1 and σ ˜2 , and 6-8 align tangents.
of a curve is done by fitting the longest line segments to the curve without violating a curvature approximation tolerance. Our extension performs the data reduction on the vertex trajectories simultaneously and adds a new violation metric. ˜ i to C˜i . We advance the data reducing line segThe algorithm initializes M ments over all vertex trajectories in parallel. The approximation line segments ˜ i if advancing these line segments one more are appended to the columns of M position will violate one of two conditions on any vertex trajectory. The first trigger condition is the classic curvature threshold test of the greedy algorithm. This guarantees that the polylines determined by the data reduction closely approximate the computed vertex trajectories. In fact, the column polylines will converge towards the computed trajectories as the threshold value is lowered to zero. The second trigger condition tests that the approximating line segments do not intersect each other, nor the established rows and columns of the growing ˜ i . This condition guarantees that the output mesh will not have any intersecM tions. While this process is described as a second independent stage, we run the creation phase in parallel with Stage 1. 3.3
Stage 3: Boundary Computation
˜ 1 and M ˜ 2 , to have The goal of Stage 3 is to modify the control meshes, M σ ˜1 (u, 1) ≡ σ ˜2 (v, 1) as they meet along the common boundary curve B 0 . Because there is no restriction on the parameterizations and degrees of γi , B 0 must be a piecewise linear. Each surface will degree-raise B 0 , so σ ˜i and the degree-raised B 0 will have matching knot vectors. Each column that terminates at a vertex
10
of B 0 will have a knot value with multiplicity equal to the degree of σ ˜ i . These columns will be referred to as multi-knot columns. At the multi-knot columns, σ ˜i breaks C 1 continuity as a function of u (or v) to form the piece-wise linear shape of B 0 despite the degree and parameterization of σ ˜i . Stage 3 consists of eight steps, illustrated in Figure 6. The first five steps align σ1 and σ2 along a boundary with C 0 continuity, while the final three steps define tangents across this boundary. The tangents are defined such that they are equal in direction (but not magnitude) to facilitate the construction of a G1 continuous boundary in Stage 4. The boundary alignment steps are as follows: 1: Compute a polyline, B 0 , along B 6: that connects all control points in the final row of σ ˜1 and σ ˜2 . 7: 2: Data reduction method removes extraneous points from B 0 . 3: For each vertex of B 0 , find the closest control point in the final row of each σ ˜i . If point within a threshold distance, slide it to the vertex and relax the column. 4: Perform knot insertion of de- 8: gree multiplicity on σ ˜i to create the multi-knot columns that will align closely to the vertices of B 0 . 5: Slide the new multi-knot columns to the vertices of B 0 .
Insert a new row between the last ˜ i. and second to last rows of M For each multi-knot column, com¯ of the pute the halfway vector, h, neighbor edges in the final row. Slide the inserted control point ¯ until the length of the along h growing column edge is equal to original length or an intersection in the mesh is created. For each non-multi-knot column, slide the inserted control point ¯ 0 , computed as a along the vector, h linear combination of the previous and next multi-knot columns’ ¯ h.
Stage 3 modifies σ ˜1 and σ ˜2 , so they continuously span the region between γ˜1 and γ˜2 without self or mutual intersections. They meet along a polyline, B 0 , such that a C 0 boundary can be achieved despite the parameterizations and degree of each σ ˜i , as shown in Figure 6 (step 8). Stage 3 performs the point sliding and relaxation routines incrementally while modify surrounding rows and columns to ensure that no overlaps are created. 3.4
Stage 4: 3D Surface Creation
The final stage lifts the planar surface parameterizations into 3D as height fields above P , who’s unit normal is N . The surfaces, σ ˜1 and σ ˜2 do not contain foldovers on P , and therefore, their corresponding 3D height fields, σ1 and σ2, are well defined. The computation of height components for the planar parameterizations is segmented into four steps as listed and illustrated in Figure 7. The final height field, the surface generation output, is composed of σ1 and σ2 . The height computations smooth the output surface so that it is G1 continuous at all points except for small regions around the vertices of the piece-wise linear boundary curve shared by σ1 and σ2 .
11 9: Add a vector in the direction of N to each control point in the first row of σ ˜ i , such that σi (u, 0) = γi (u). 10: Add a vector in the direction of N to each control point in the final row of the two surfaces, so σ1 (u, 1) ≡ σ2 (v, 1), and is a weighted average of the heights assigned to σ1 (u, 0) and σ2 (v, 0). 11: Add a vector in the direction of N to the remaining control points as the weighted average of the heights of previously computed control points. The height components computed in the previous steps for the first and last rows of Mi serve as the original sources for this height diffusion. 12: Relax heights across multi-knot columns of σi and across the boundary shared by σ1 and σ2 for G1 continuity where possible.
Fig. 7. Steps 9-12 raise the planar parameterizations into 3D.
4
Conclusion
This paper presents a novel method of spline surface generation between two closed spatial boundary curves. The algorithm develops a spatial curve deformation solution that sweeps the well-behaved surfaces illustrated in Figure 8, by guaranteeing that intermediate curve shapes do not contain local or global intersections between themselves nor each other. The algorithm builds upon concepts traditionally found in robot path planning, addressing navigational challenges associated with their gradient descent methods. Our approach develops vector fields without local minima that guarantee multiple vertices can simultaneously navigate through the environment to their goal without intersections. This surface generation solution is contains concepts that are applicable to navigational challenges and curve deformations, but is also useful in geometric modeling areas. Our algorithm, through implementation decisions and guarantees, is able to automatically generate smooth parting surfaces for injection molds. The results directly parameterize the surface without the use of trimmed NURBS, while handling the complex concavities cause most other techniques to behave poorly. Limitations Our algorithm requires a medial axis approximation to construct a vector field without local minima and where the global minima represents the goal destinations. The medial axis can be computed quickly for planar polygonal shapes, but may be unstable in dynamic scenes. Many of the changes translate
12
Fig. 8. 3D generated surfaces (and curve deformations as black iso-curves) spanning between spatial curves, viewed from an angle and from above.
to modifications of extraneous edges, in which case our algorithm operates unchanged. However, the birth or death of a branch segment may pose a computational challenge. Implementation decisions limit the application of our algorithm. Because we built this system in order to produce parting surfaces for automated mold designing, the algorithm must guarantee that the projection of the resulting surface is without self-intersections. We plan to remove this restriction for future application. Future Work This is a novel approach to surface generation and curve deformations that is suggestive of multiple avenues of future work. We plan to improve the algorithm allowing for wider range of input curve types and to develop parameterizations directly in R3 rather than on P . The concepts that deal with curve deformation can benefit enforcement of a feature match, as well as extension to surface-to-surface deformations. Acknowledgments This work was supported in part by NIH 573996 and NSF IIS0218809. All opinions, findings, conclusions or recommendations expressed in this document are those of the author and do not necessarily reflect the views of the sponsoring agencies.
5
Appendix A: Continuous Vector Field
The advantage of computing vertex trajectories within a vector field is that it can be guaranteed that no two paths will intersect through the Uniqueness Theorem[2] if the vector field is C 1 continuous. Therefore, we modify the functions, vr , vg , vl , and vf , to guarantee that ∂V ∂t is continuous. The vector functions are re-defined in terms of a new coordinate system that aligns the line segment along
13
the x-axis such that q¯1 = (0, 0) and q¯2 = (a, 0), for example:
vr,i,j (x, y) =
(x,y) ) f or x < 0 k(x, y)k−k ( k(x,y)k y −k (|y|) (0, |y| ) f or 0 ≤ x < a
k(x − a, y)k−k (
(x−a,y) k(x−a,y)k )
otherwise,
Each of the transformed branch functions share a common structure: f1 (x, y) f or x < a F (x, y) = f2 (x, y) f or a ≤ x < b f3 (x, y) otherwise.
(a,y) (a,y) (b,y) However, for each function it can be shown that ∂f1∂x 6= ∂f2∂x , and ∂f2∂x 6= ∂f3 (b,y) 1 . Therefore, two transition functions are defined to obtain C continuity ∂x between the consecutive branch functions at x = a and x = b. The new vector field functions will have the form: f1 (x, y) f or x < p1b t 1,2 (x, y) f or p1b ≤ x < p2a f2 (x, y) f or p2a ≤ x < p2b G(x, y) = t 2,3 (x, y) f or p2b ≤ x < p3a f3 (x, y) otherwise,
where, the transition function, ti,j (x, y), creates a C 1 continuous bridge between functions fi (x, y) and fj (x, y). In other words, a transition function, ti,j (x, y), must satisfy the following set of conditions: ti,j (pib , y) = fi (pib , y), ti,j (pja , y) = fj (pja , y),
∂ti,j ∂x ∂ti,j ∂x
i (pib , y) = ∂f ∂x (pib , y), ∂fj (pja , y) = ∂x (pja , y),
∂ti,j ∂y (pib , y) = ∂ti,j ∂y (pja , y) =
∂fi ∂y (pib , y), ∂fj ∂y (pja , y).
It can be shown that a transition function defined as: x − pja x − pib x − pib 2 x − pja 2 ) + s(x, y)( )( ) + fj (x, y)( ) , pib − pja pib − pja pja − pib pja − pib (x − pja )(pja − pib ) (x − pib )(pib − pja ) s(x, y) = −2fi (x, y) − 2fj (x, y) , 2 (pib − pja ) (pja − pib )2
ti,j (x, y) = fi (x, y)(
satisfies the required list of conditions. Therefore, re-writing the vector field functions, vr0 , vg0 , vl0 and vf0 , such that they are C 1 continuous only requires substituting into the generic branch function, G(x, y), where the transition functions are defined above. The transition functions are used to span over some distance such that p1b = −, p2a = 0, p2b = a, and p3a = a + . Because the final vector field functions are each individually C 1 continuous, their sum, V , will also be continuous. The uniqueness theorem guarantees that all seeds dropped within V will trace non-intersecting paths.
14
References 1. Balch, T., and Hybinette, M. Social potentials and scalable multi-robot formations. ICRA (2000). 2. Blanchard, P., Devaney, R., and Hall, G. Differential Equations. International Thomson Publishing Inc., 1998. 3. Caselles, V., Kimmel, R., and Sapiro, G. Geodesic active contours. International Journal of Computer Vision 22, 1 (February 1997), 61–79. 4. Chuang, J. Potential-based modeling of three-dimensional worksapce for obstacle avoidance. IEEE Transactions on Robtics and Automation 14, 5 (October 1998), 778–785. 5. Cohen, S., Elber, G., and Yehuda, R. Matching of freeform curves. Computer Aided Design 29, 5 (1997), 369–378. 6. Curless, B., and Levoy, M. A volumetric method for building complex models from range images. In Proceedings of SIGGRAPH ’96 (1996), pp. 303–312. 7. Davis, J., Marschner, S., Garr, M., and Levoy, M. Filling holes in complex surfaces using volumetric diffusion. In Proceedings of the First International Symposium on 3D Data Processing, Visualization and Transmission (3DPVT-02) (June 2002), IEEE Computer Society, pp. 428–438. 8. de Berg, M., van Kreveld, M., Overmars, M., and Schwarzkopf, O. Computational Geometry: Algorithms and Applications. Springer-Verlag Berlin Heidelberg, 1997. 9. Elber, G. Metamorphosis of freeform curves and surfaces. Computer Graphics International ’95 (June 1995), 29–40. 10. Ge, S., and Cui, Y. New potential functions for mobile path planning. IEEE Transactions on Robotics and Automation 16, 5 (2000), 615–620. 11. Goldstein, E., and Gotsman, C. Polygon morphing using a multiresolution representation. Graphics Interface (1995), 247–254. 12. Gotsman, C., and Surazhsky, V. Guaranteed intersection-free polygon morphing. Computers and Graphics 25 (2001), 67–75. 13. Kass, M., Witkin, A., and Terzopolous, D. Snakes: Active contour models. International Journal of Computer Vision 1, 4 (January 1988), 321–331. 14. Lewis, J., and Weir, M. Using subgoal chaining to address the local minimum problem. In Proceedings of Second International ICSC Symposium on Neural Computation (2000). 15. Martin, W., and Cohen, E. Surface completion of an irregular boundary curve using a concentric mapping. In Fifth International Conference on Curves and Surfaces (June 2002). 16. Sederberg, T., Gao, P., Wang, G., and Mu, H. 2d blending shapes: An intrinsic solution to the vertex path problem. In Proceedings of SIGGRAPH ’93 (1993), vol. 27, pp. 15–18. 17. Sederberg, T., and Greenwood, E. A physically based approach to 2d shape blending. Computer Graphics 26, 2 (July 1992), 25–34. 18. Tsai, A., Yezzi, A., and Willsky, A. Curve evolution implementation of mumford-shah functional for image segmentation, denoising, interpolation, and magnification. IEEE Transactions on Image Processing 10, 8 (August 2001). 19. Xu, C., and Prince, J. Snakes, shapes, and gradient vector flow. IEEE Transactions on Image Processing 7 (March 1998), 359–369.
