Abstract:
Described is a method for sketching with a digitizing device. A set of digitized points along a path of the digitizing device are acquired and a parametric representation is fit to the path. Fitting includes generating a vector distance field representation of a set of objects corresponding to the set of digitized points and initializing a parametric representation for the set of objects. A fitting error indicating an accuracy of the fit of the parametric representation to the set of objects is determined from the vector distance field representation. The parametric representation is adjusted and the fitting error is again determined in an iterative manner until an acceptable fitting error is achieved. The method has numerous technical advantages such as robustness, speed, simplicity relative to standard approaches, and the ability to manage constraints such as maintaining corners and enforcing continuity.

Description:
FIELD OF THE INVENTION 
       [0001]    The invention relates generally to fitting a parametric representation to a digital representation of an object. More particularly, the invention relates to a method using a vector distance field representation of a set of objects to determine a parametric representation of the set of objects. 
       BACKGROUND OF THE INVENTION 
       [0002]    Fitting Parametric Surfaces to Digital Data 
         [0003]    Digital data such as a set of positions recorded from a digital input device, a set of curves representing a character glyph, or a set of experimental measurements, can be fit with a parametric representation that approximates the shape of the digital data to reduce memory requirements for storing and transmitting the digital data or to facilitate processing of the digital data. 
         [0004]    For example, when drawing via a computer mouse or digital pen, the path of the input device is sampled, the sampled points are typically quantized to integer pixel locations, and these digitized points are supplied to an application. While some applications simply represent the input path by the sequence of digitized points, fitting a parametric curve to the digitized points has various advantages such as: 1) a parametric curve generally requires less memory than a list of digitized points; 2) a parametric curve can be scaled, rotated, deformed, etc. without degrading the quality of the path when it is rendered; 3) an application can enforce smoothness and continuity constraints on a parametric curve; and 4) users can generally edit a parametric curve easily. 
         [0005]    Although there are many different parametric representations for curves as described by Farin in “ Curves and Surfaces for CAGD: A Practical Guide” , Morgan Kaufmann Publishers, Academic Press, 2002, many applications use piecewise polynomial curves such as cubic Bezier curves. A piecewise polynomial curve is composed of multiple polynomial curve segments. When fitting a piecewise polynomial curve to a sequence of digitized points, the goal is to determine an optimal set of curve segments, where optimal can mean some combination of a minimum number of curve segments, a minimum error between the curve segments and the input path, and curve segments that enforce a number of other constraints such as curve continuity or maintaining intended corners of the input path. 
         [0006]    Fitting a parametric representation of a medial axis to the center of a set of outlines representing a character glyph is a second example in which digital data is fit with a parametric representation. The medial axis can be used for several applications such as approximating the character glyph to reduce its size or facilitating optical character recognition. For a closed three-dimensional shape, a parametric representation of the medial surface is also of value for shape compression and shape recognition as described by Sheehy et al. in “Shape Description by Medial Surface Construction”,  IEEE Transactions On Visualization  &amp;  Computer Graphics,  1996. 
         [0007]    Fitting a parametric surface to a set of digitized points in three-dimensional space, such as a set of points acquired by a range scanning device, is a third example in which digital data is fit with a parametric representation. Various parametric surface representations are used to approximate the scanned surface including a triangle mesh, a set of quadratic, cubic, or higher order Bezier patches, or a set of non-uniform rational B-splines (“NURBs”) patches as described by Farin in “ Curves and Surfaces for CAGD: A Practical Guide” , Morgan Kaufmann Publishers, Academic Press, 2002. In one variation, a parametric surface is fit to a regularly sampled volume or an adaptively sampled distance field to generate a parametric representation of an iso-surface of an implicit function. Various methods for constructing triangle meshes from sampled data exist, including Marching Cubes, described in U.S. Pat. No. 4,710,876, and SurfaceNets, described in U.S. Pat. No. 6,943,789. 
         [0008]    Fitting an N-dimensional ellipsoid to a set of measured or simulated N-dimensional data to represent a probability distribution of the set of measured or simulated N-dimensional data is a fourth example in which digital data is fit with a parametric representation. 
         [0009]    A review of standard approaches for fitting curves and surfaces to a set of digitized points is presented in “ Least Squares Orthogonal Distance Fitting of Curves and Surfaces in Space ”, S. J. Ahn, Lecture Notes in Computer Science, Springer-Verlag, 2004 (“Ahn”). In the case of piecewise polynomial curves, the curve fitting problem reduces to finding a set of control vertices for the curve segments that minimizes the geometric, or Euclidean, distance between the digitized points and the fit curve. Ahn observes that the geometric distance is a non-linear function of the control vertices and that the task of computing and minimizing the sum of squared geometric distances is complex. Ahn describes the curve fitting problem as essentially a non-linear optimization problem which should be solved using iteration. Given a sequence of digitized points {Pi}, i=1, 2, . . . N, an iterative approach for curve fitting applies the following steps:
       1. Start with a simple initial estimating curve, such as a straight line segment connecting the endpoints of the sequence, and an initial set of minimum distance points {Q i }, i=1, 2, . . . N, where each Q i  is a point on the estimating curve that is closest to a corresponding digitized point P i .   2. Iteratively adjust control vertices of curve segments of the estimating curve to reduce the fitting error (i.e., a measure of the accuracy of the fit to the estimating curve), where the fitting error is typically estimated as the sum of squared distances between each {P i , Q i } pair. For each iteration, the set of minimum distance points {Q i } is re-computed. Typically, the re-computation also requires an iterative approach.   3. If necessary, subdivide the estimating curve into additional curve segments.   4. Repeat steps 2 and 3 until the fitting error is acceptable.       
 
         [0014]    Re-computing the minimum distance points in step 2 is done for each iteration of the control vertex adjustment. Unfortunately, this inner loop is generally the most time consuming part of the algorithm. There are two basic approaches for finding the minimum distance points as described by Ahn. The first approach determines the closest point Q i  on the estimating curve for each digitized input point P i  directly using an iterative polynomial root finder. This requires solving a 5th order polynomial for each cubic Bezier curve segment of the estimating curve. The second approach determines a parameter value t i  for each digitized point P i  so that Q(t i ) is the closest point on the piecewise parametric estimating curve to P i . When using the second approach, the parameterization of the digitized points is typically initialized using chord length parameterization of the estimating curve and then adjusted iteratively using a polynomial root finder as described by Schneider in “ Phoenix: An Interactive Curve Design System Based on the Automatic Fitting of Hand - sketched Curves” , Master&#39;s Thesis, University of Washington, 1988, and in “An Algorithm for Automatically Fitting Digitized Curves”, in  Graphics Gems , ed. Andrew Glassner, Academic Press, 1990. 
         [0015]    Standard approaches for curve and surface fitting suffer from a number of drawbacks. One such drawback is that the standard approaches are designed to operate only on a full sequence of digitized points, such as all of the points recorded along a single input path. Because the fit curve is not determined until the input path has been completed, an approximation of the input path, such as the digitized points themselves or a polyline connecting the digitized points, must be drawn to provide feedback to the user. This can result in a delay after the input path is complete and can result in a noticeable change in the shape of the drawn path when the approximation of the input path is replaced by the fit curve. 
         [0016]    A second major drawback is the costly inner loop for determining minimum distance points. The computation involved in the inner loop is proportional to the number of points in the sequence of digitized points. Preprocessing can be used to reduce the number of digitized points as well as to remove noise such as hand jitter from the input data; however, preprocessing is time consuming and can result in a loss of intended detail. Other problems with standard approaches occur because of a lack of robustness in the iterative methods for determining minimum distance points. These methods are sensitive to local minima, particularly for complex, self-intersecting input paths, and require a good initial set of minimum distance points. 
         [0017]    Thus, there is a need for an improved method for fitting curves and surfaces to digital data. 
         [0018]    Distance Fields 
         [0019]    A distance field of a shape measures, for any point in space, the distance from that point to the closest point on the shape. Distance fields have been used for many applications in computer graphics, computer aided design and manufacturing, computer vision, and robotics. A general review of the use of distance fields in computer graphics and vision is described by Frisken and Perry in “Efficient Estimation of 3D Euclidean Distance Fields from 2D Range Images”, in  Proc. Symposium on Volume Visualization and Graphics,  2002. A review of the use of distance fields in shape modeling is described by Frisken and Perry in “Designing with Distance Fields”, in  Interactive Shape Editing , ACM SIGGRAPH 2006 Course Notes, ACM Press, 2006. 
         [0020]    Conventionally, distance fields are scalar fields, for example distance fields which represent the scalar Euclidean distance from any point to a shape. In contrast, vector distance fields represent the distance at any point as a vector value. Vector distance fields are more suitable than scalar distance fields for representing shapes that do not have a well defined inside and outside and for algorithms that require the gradient of the distance field. Although the following description is directed to Euclidean vector distance fields, which have obvious geometric meaning, the principles also apply to non-Euclidean vector distance fields such as vector distance fields whose magnitudes vary as the square of the Euclidean distance. 
         [0021]    The two-dimensional vector distance (dx, dy) from any given sample point (x, y) in          2 to a closest point (u, v) on a two-dimensional shape is defined to be the two-dimensional vector from the sample point to the closest point, i.e., (dx, dy)=(u-x, v-y). The extension to three-dimensional and higher dimensional vector distances is straightforward. The magnitude of the vector distance, (dx 2 +dy 2 ) 1/2 , is the minimum Euclidean distance from the sample point to the shape, and the vector distance itself is equal to the unit gradient vector of the Euclidean distance field at the sample point scaled by the minimum Euclidean distance to the shape. 
         [0022]    A vector distance field of an object represents, at any point in space, the vector distance from that point to the object. Vector distance fields were introduced for shape representation as described in U.S. Pat. No. 6,396,492 and for evolving surfaces via level sets as described by Faugeras and Gomes in “Dynamic Shapes of Arbitrary Dimension: The Vector Distance Functions”, Proceedings IMA Conference on Mathematics of Surfaces, pp. 227-262, 2000. Vector distance fields are particularly well suited for representing shapes that do not have a well defined inside and outside (e.g., points, lines, curves, and infinitely thin surfaces) because each component (e.g., dx, dy) of the vector distance varies smoothly (i.e., from negative to positive) from one side of the shape to the other. In contrast, scalar distance fields of such shapes are non-differentiable at points on the shape so that, for example, it is not possible to use linear interpolation to locate points on the shape, where the scalar distance is zero, from sample points that span the shape since sampled values on opposite sides have the same sign. 
         [0023]    Vector distance fields are also well suited for applications that require the gradient of the distance field since the gradient can be interpolated directly and more accurately from sampled vector distances using bilinear interpolation rather than indirectly from sampled Euclidean distances using a higher order and less accurate gradient operator such as the central differences operator. 
         [0024]    There are various representations of vector distance fields. Vector distance fields can be represented by analytic functions, for example, the three-dimensional vector distance at a sample point (x, y, z) to a point (u, v, w) is (u-x, v-y, w-z), or by procedures. Vector distance fields can be sampled and stored in a regularly sampled two-dimensional array, referred to as a vector distance map. Vector distances between sample points in a vector distance map can be reconstructed using bilinear interpolation of each component of the vector distance. Vector distance fields can also be adaptively sampled and represented as an adaptively sampled distance field, as described in U.S. Pat. No. 6,396,492. 
       SUMMARY OF THE INVENTION 
       [0025]    In one aspect, the invention features a method for sketching with a digitizing device. A set of digitized points along a path of a digitizing device is acquired and a parametric representation is fit to the path of the digitizing device. Fitting includes generating a vector distance field representation of a set of objects corresponding to the set of digitized points and initializing a parametric representation to fit the set of objects. Fitting also includes determining a fitting error from the vector distance field representation and adjusting the parametric representation to reduce the fitting error. The fitting error indicates an accuracy of the fit of the parametric representation to the set of objects. 
         [0026]    In another aspect, the invention features a computer program product for sketching with a digitizing device. The computer program product includes a computer useable medium having program code embodied therein. The program code includes program code for acquiring a set of digitized points along a path of the digitizing device, program code for generating a vector distance field representation of a set of objects corresponding to the set of digitized points, and program code for initializing a parametric representation to fit the set of objects. The program code of the computer program product also includes program code for determining a fitting error from the vector distance field representation and program code for adjusting the parametric representation to reduce the fitting error. 
         [0027]    In still another aspect, the invention features a digital sketching device. The digital sketching device includes means for acquiring a set of digitized points along an input path of the digitizing device, means for generating a vector distance field representation of a set of objects corresponding to the set of digitized points, and means for initializing a parametric representation to fit the set of objects. The sketching device also includes means for determining a fitting error from the vector distance field representation and means for adjusting the parametric representation to reduce the fitting error. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0028]      FIG. 1  is a diagram of a two-dimensional vector distance from a point to a two-dimensional curve; 
           [0029]      FIG. 2  is a flow diagram of a method for fitting a parametric representation to a digital representation of an object according to the present invention; 
           [0030]      FIGS. 3A , and  3 B are diagrams depicting the fitting of a parametric curve to a set of digital points according to standard methods; 
           [0031]      FIGS. 4A ,  4 B, and  4 C are diagrams depicting the fitting of a parametric curve to a set of digital points according to the present invention; 
           [0032]      FIG. 5  is a flow diagram of a method for fitting a parametric representation to a sequence of digitized points according to the present invention; 
           [0033]      FIG. 6  is a diagram depicting the constraint of a parameter of a parametric representation according to the present invention; 
           [0034]      FIGS. 7A ,  7 B,  7 C, and  7 D are depictions of the fitting of a parametric surface to a three-dimensional set of digital points according to the present invention; 
           [0035]      FIGS. 8A ,  8 B,  8 C, and  8 D are diagrams depicting the fitting of a medial axis to a closed outline of a character glyph according to the present invention; and 
           [0036]      FIG. 9  is a flow diagram of a method for recognizing a shape from a set of digitized points according to the present invention. 
       
    
    
     DETAILED DESCRIPTION 
       [0037]    The invention relates to the fitting of a parametric representation to a digital representation of an object. Some examples of digital representations for the object are: a set of digitized points; a set of line segments or curve segments; a set of surface patches such as triangle patches, quadrilateral patches, Bezier patches, or NURBs patches; an implicit function; an analytic function; or a set of sampled data such as a two dimensional image, a three-dimensional sampled volume, or an adaptively sampled distance field. 
         [0038]    The method of the invention uses a vector distance field representation of the object.  FIG. 1  illustrates a two-dimensional vector distance  102  from a point P  108  in two-dimensional space to a closest point Q  110  on a two-dimensional curve  112 . The vector distance  102  is composed of components dx  104  and dy  106 . 
         [0039]    General Description 
         [0040]    Fitting a parametric representation to a digital representation of an object, such as a set of digitized points along an input path of a digitizing input device, is typically posed as a non-linear optimization problem which is usually solved using an iterative approach. In such an iterative approach, a simple parametric representation is initialized to approximate the object, a fitting error (i.e., a measure of the accuracy of the fit) between the parametric representation and the object is determined, and parameters of the parametric representation are iteratively adjusted to reduce the fitting error. 
         [0041]    In standard approaches, the fitting error is a function of distances from sample points on the object, such as a set of digitized points along an input path, to the parametric representation. These approaches require finding the closest point on the parametric representation for each sample point on the object. Finding each closest point is an expensive operation that is performed for every sample point on the object each time the parameters are adjusted. 
         [0042]    According to the invention, a vector distance field representation of the object is generated and a fitting error that represents the distance from a set of test points on the parametric representation to the object is determined. The distance at each test point is determined using the vector distance field representation. 
         [0043]    A common measurement of the fitting error is a sum of squared distances between the estimating curve and the input path at a set of test points. There are alternative measurements of the fitting error such as a sum of unsigned scalar distances between the estimating curve and the input path at a set of test points, or a function of signed scalar distances between the estimating curve and the input path at a set of test points. 
         [0044]      FIG. 2  is a flow diagram of a method  200  for fitting a parametric representation to an object according to an embodiment of the invention. A vector distance field is generated  204  and a parametric representation to be fit to the object is initialized  208 . A fitting error is determined  212  from the vector distance field and the parametric representation. If it is determined  216  that the fitting error is acceptable then the method  200  ends, otherwise the parameters of the parametric representation are adjusted  220  and the fitting error is examined  212  in an iterative manner until it is determined  216  that the fitting error is acceptable. An acceptable fitting error can occur when the value is less than a predetermined value. 
         [0045]    The particular parametric representation used may depend on the object to be fit. For example, a two-dimensional parametric curve such as a two-dimensional cubic Bezier curve, whose parameters comprise its four control vertices, can be fit to a set of digitized points acquired along a path of a digitizing device such as a computer mouse or a digital pen. 
         [0046]    As a second example, a parametric surface patch such as a NURBs surface patch, whose parameters comprise a set of control vertices, can be fit to a set of three-dimensional points acquired with a range scanning device. 
         [0047]    As a third example, a two-dimensional ellipse, whose parameters comprise a center point, an orientation, a major radius and a minor radius, can be fit to a set of two-dimensional sampled data points to represent a level set of a bivariate probability density function modeling the data points. 
         [0048]    As a fourth example, a set of two-dimensional parametric curves can be fit to a medial axis of a closed two dimensional outline. 
         [0049]    As a fifth example, a piecewise polynomial Bezier surface can be fit to an iso-surface of an adaptively sampled distance field. 
         [0050]    There are other examples of parametric representations such as: line segments, curves, circles, and rectangles for representing one-dimensional manifolds; triangles, filled ellipses, polygons, and curved patches for representing two-dimensional manifolds; spheres, ellipsoids, super ellipsoids and rectangular solids for representing three-dimensional manifolds; and n-dimensional solids for representing n-dimensional manifolds. 
         [0051]    Sketching with a Digitizing Device 
         [0052]    In a first embodiment, a piecewise polynomial estimating curve composed of two-dimensional cubic Bezier curve segments is fit to a sequence of digitized points representing a path of a digitizing device on-the-fly, i.e., as each digitized point is provided to the application. In this embodiment, the digitized points are recorded using a two-dimensional input device such as a computer mouse or a digital pen, or a three-dimensional input device such as a force feedback device or a three-dimensional tracking device. 
         [0053]    Standard curve fitting approaches measure a distance from each digitized point to the estimating curve, which requires finding a closest point on the estimating curve for each digitized point each time parameters of the estimating curve are adjusted.  FIG. 3A  illustrates the closest points Q i    311 ,  312 , . . . ,  319  (generally Q) on the estimating curve  300  corresponding to each sample point P i    301 ,  302 , . . . ,  309  (generally P) of the object. As illustrated in  FIG. 3B , the closest points Q are typically determined using an iterative approach. Such approaches iteratively adjust a set of initial estimates Q* i    321 ,  322 , . . . ,  329  until they are approximately located at the closest points Q. 
         [0054]    To fit a parametric representation to an object according to the invention, the distances from a set of test points on the estimating curve to an approximation of the input path are determined.  FIG. 4A  illustrates a set of test points B j    401 ,  402 , . . . ,  405  on the estimating curve  300  and their corresponding vector distances  411 ,  412 , . . . ,  415  to a polyline  420  which approximates the input path. Various approximations of the input path are possible, such as the sequence of digitized points P or the polyline  420  connecting the sequence of digitized points P.  FIG. 4B  illustrates iso-contours of the magnitude of the vector distance field of the polyline  420 .  FIG. 4C  illustrates iso-contours of the magnitude of the vector distance field of the sequence of digitized points P. The input path is approximated with a set of polylines where each polyline connects a subsequence of the sequence of digitized points P, the subsequences partitioning the sequence of digitized points P at corner points in the input path. 
         [0055]    This paradigm shift increases the efficiency of curve fitting for several reasons such as: 1) each polyline is represented as a sampled vector distance field so the distance from test points to the polyline can be computed directly and efficiently using linear interpolation of sampled vector distances in the sampled vector distance field; 2) the polyline&#39;s vector distance field changes only incrementally as each new digitized point is added to the polyline and does not change each time parameters of the estimating curve are adjusted; and 3) the number of test points along the estimating curve can be significantly smaller than the number of digitized points without compromising quality, thereby avoiding the need for preprocessing to reduce the number of digitized points. The increase in efficiency allows the curve to be fit to the input path incrementally, thereby providing a means for updating the estimating curve as new digitized points become available. 
         [0056]    The estimating curve is constrained to have G 1  continuity to ensure that the fit curve is a smooth approximation to the input path. In addition, an acceptable non-zero curve fit error (e.g., an error of 1-2 pixels) is predefined so that the estimating curve is not required to be exactly fit to the polyline. 
         [0057]    The first embodiment applies the following steps, illustrated in  FIG. 5 , for fitting a piecewise polynomial curve to a sequence of digitized points as each digitized point is acquired:
       1. Initialize  504  a first two-dimensional cubic Bezier curve segment of the piecewise polynomial estimating curve by setting its control vertices to a first digitized point in the sequence of digitized points.   2. Initialize  508  and clear  510  a two-dimensional vector distance field for representing a polyline corresponding to a current curve segment.   3. Repeat, the following sub-steps as each new digitized point is received  512  from the digitizing device:
           i. Test  516  for a corner between the current curve segment&#39;s last endpoint and the new digitized point by comparing a path angle to a maximum corner angle, where the path angle is an angle from the current curve segment&#39;s tangent vector at the current curve segment&#39;s last endpoint and a line segment from the current curve segment&#39;s last endpoint to the new digitized point. If a corner exists, finalize  520  the current curve segment, initialize  552   a  new curve segment in the estimating curve and clear  510  the two-dimensional vector distance field representation. Require only C 0  continuity at the new curve segment&#39;s first endpoint to maintain a corner point at the new curve segment&#39;s first endpoint.   ii. If no corner is determined  516  to exist, update  524  the vector distance field representation with the new digitized point.   iii. Adjust  532  control vertices of the current curve segment to reduce a fitting error of the estimating curve, which is determined  528  using vector distances from test points on the estimating curve to the polyline. Enforce G 1  continuity with the previous curve segment if required.   iv. Test  536  for an inadequate curve fit. If, after adjusting  532  the current curve segment&#39;s control vertices, the fitting error of the estimating curve exceeds a maximum fitting error, undo the control vertex adjustments, finalize  520  the current curve segment, initialize  532  a new curve segment in the estimating curve and clear the vector distance field representation  510 . Require G 1  continuity at the new curve segment&#39;s first endpoint.   v. Prior to initializing  532  each new curve segment, the method  500  can re-render  540  to a display, store  544  in memory, or transmit over a network  548 , the piecewise polynomial estimating curve.   
               
 
         [0066]    The fitting error, E, of each curve segment in the estimating curve is approximated as an average squared scalar distance from a set of test points {Q i =B(t i )} on the curve segment to the polyline connecting the subsequence of digitized points corresponding to the current curve segment: 
         [0000]    
       
         
           
             
               E 
               = 
               
                 
                   1 
                   N 
                 
                  
                 
                   
                     ∑ 
                     
                       i 
                       = 
                       1 
                     
                     N 
                   
                    
                   
                     
                       d 
                        
                       
                         ( 
                         
                           Q 
                           i 
                         
                         ) 
                       
                     
                     2 
                   
                 
               
             
             , 
           
         
       
     
         [0000]    where d(Q) is the scalar distance from Q to the polyline. 
         [0067]    In the first embodiment, endpoints of each curve segment in the estimating curve are constrained to lie on a digitized point and an iterative algorithm is used to reduce the fitting error of the curve segment by adjusting its off-curve control vertices. A point B(t) on a cubic Bezier curve with endpoints C 0  and C 3  and off-curve control vertices C 1  and C 2  can be expressed as a cubic polynomial of a parameter tε[0, 1]: 
         [0000]        B ( t )= C   0 (1 −t ) 3 +3 C   t   t (1− t ) 2   +C   2   t   3 (1− t )+ C   3   t   3 . 
         [0068]    During each iteration, off-curve control vertices are moved according to an adjustment force in a direction that reduces the curve fitting error, such as the direction of the derivative of the error with respect to the position of the off-curve control vertex. Taking this derivative for the first off-curve control vertex and using the chain rule, the adjustment “force” {right arrow over (f)} 1  acting on off curve control vertex C 1  is: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       f 
                       ⇀ 
                     
                     l 
                   
                   = 
                   
                     
                       ∇ 
                       
                         C 
                         1 
                       
                     
                      
                     E 
                   
                 
               
             
             
               
                 
                   = 
                   
                     
                       1 
                       N 
                     
                      
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           1 
                         
                         N 
                       
                        
                       
                         2 
                          
                         
                           
                             d 
                              
                             
                               ( 
                               
                                 Q 
                                 i 
                               
                               ) 
                             
                           
                           · 
                           
                             
                               ∇ 
                               
                                 C 
                                 1 
                               
                             
                              
                             
                               d 
                                
                               
                                 ( 
                                 
                                   Q 
                                   i 
                                 
                                 ) 
                               
                             
                           
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                   
                     
                       1 
                       N 
                     
                      
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           1 
                         
                         N 
                       
                        
                       
                         2 
                          
                         
                           
                             d 
                              
                             
                               ( 
                               
                                 B 
                                  
                                 
                                   ( 
                                   
                                     t 
                                     i 
                                   
                                   ) 
                                 
                               
                               ) 
                             
                           
                           · 
                           
                             
                               
                                 ∇ 
                                 
                                   C 
                                   1 
                                 
                               
                                
                               
                                 d 
                                  
                                 
                                   ( 
                                   
                                     B 
                                      
                                     
                                       ( 
                                       
                                         t 
                                         i 
                                       
                                       ) 
                                     
                                   
                                   ) 
                                 
                               
                             
                             . 
                           
                         
                       
                     
                   
                 
               
             
           
         
       
     
         [0000]    Note that 
         [0000]    
       
         
           
             
               
                 ∇ 
                 
                   C 
                   1 
                 
               
                
               
                 d 
                  
                 
                   ( 
                   
                     B 
                      
                     
                       ( 
                       
                         t 
                         i 
                       
                       ) 
                     
                   
                   ) 
                 
               
             
             = 
             
               ( 
               
                 
                   
                     ∂ 
                     
                       d 
                        
                       
                         ( 
                         
                           B 
                            
                           
                             ( 
                             
                               t 
                               i 
                             
                             ) 
                           
                         
                         ) 
                       
                     
                   
                   
                     ∂ 
                     
                       x 
                       1 
                     
                   
                 
                 , 
                 
                   
                     ∂ 
                     
                       d 
                        
                       
                         ( 
                         
                           B 
                            
                           
                             ( 
                             
                               t 
                               i 
                             
                             ) 
                           
                         
                         ) 
                       
                     
                   
                   
                     ∂ 
                     
                       y 
                       1 
                     
                   
                 
               
               ) 
             
           
         
       
       
         
           for 
         
       
       
         
           
             
               
                 
                   
                     C 
                     1 
                   
                   = 
                   
                     ( 
                     
                       
                         x 
                         1 
                       
                       , 
                       
                         y 
                         1 
                       
                     
                     ) 
                   
                 
               
             
             
               
                 
                   = 
                   
                     ( 
                     
                       
                         
                           
                             ∂ 
                             
                               d 
                                
                               
                                 ( 
                                 
                                   x 
                                    
                                   
                                     ( 
                                     
                                       t 
                                       i 
                                     
                                     ) 
                                   
                                 
                                 ) 
                               
                             
                           
                           
                             ∂ 
                             
                               x 
                                
                               
                                 ( 
                                 
                                   t 
                                   i 
                                 
                                 ) 
                               
                             
                           
                         
                         · 
                         
                           
                             ∂ 
                             
                               x 
                                
                               
                                 ( 
                                 
                                   t 
                                   i 
                                 
                                 ) 
                               
                             
                           
                           
                             ∂ 
                             
                               x 
                               1 
                             
                           
                         
                       
                       , 
                       
                         
                           
                             ∂ 
                             
                               d 
                                
                               
                                 ( 
                                 
                                   y 
                                    
                                   
                                     ( 
                                     
                                       t 
                                       i 
                                     
                                     ) 
                                   
                                 
                                 ) 
                               
                             
                           
                           
                             ∂ 
                             
                               y 
                                
                               
                                 ( 
                                 
                                   t 
                                   i 
                                 
                                 ) 
                               
                             
                           
                         
                         · 
                         
                           
                             ∂ 
                             
                               y 
                                
                               
                                 ( 
                                 
                                   t 
                                   i 
                                 
                                 ) 
                               
                             
                           
                           
                             ∂ 
                             
                               y 
                               1 
                             
                           
                         
                       
                     
                     ) 
                   
                 
               
             
           
         
       
       
         
           for 
         
       
       
         
           
             
               
                 B 
                  
                 
                   ( 
                   
                     t 
                     i 
                   
                   ) 
                 
               
               = 
               
                 ( 
                 
                   
                     x 
                      
                     
                       ( 
                       
                         t 
                         i 
                       
                       ) 
                     
                   
                   , 
                   
                     y 
                      
                     
                       ( 
                       
                         t 
                         i 
                       
                       ) 
                     
                   
                 
                 ) 
               
             
             , 
           
         
       
     
         [0069]    using the chain rule. 
       Consequently, 
       [0070]    
       
         
           
             
               
                 
                   
                     
                       ∇ 
                       
                         C 
                         1 
                       
                     
                      
                     
                       d 
                        
                       
                         ( 
                         
                           B 
                            
                           
                             ( 
                             
                               t 
                               i 
                             
                             ) 
                           
                         
                         ) 
                       
                     
                   
                   = 
                   
                     3 
                      
                     
                       
                         t 
                         i 
                       
                       · 
                       
                         
                           ( 
                           
                             1 
                             - 
                             
                               t 
                               i 
                             
                           
                           ) 
                         
                         2 
                       
                       · 
                       
                         ( 
                         
                           
                             
                               ∂ 
                               
                                 d 
                                  
                                 
                                   ( 
                                   
                                     x 
                                      
                                     
                                       ( 
                                       
                                         t 
                                         i 
                                       
                                       ) 
                                     
                                   
                                   ) 
                                 
                               
                             
                             
                               ∂ 
                               
                                 x 
                                  
                                 
                                   ( 
                                   
                                     t 
                                     i 
                                   
                                   ) 
                                 
                               
                             
                           
                           , 
                           
                             
                               ∂ 
                               
                                 d 
                                  
                                 
                                   ( 
                                   
                                     y 
                                      
                                     
                                       ( 
                                       
                                         t 
                                         i 
                                       
                                       ) 
                                     
                                   
                                   ) 
                                 
                               
                             
                             
                               ∂ 
                               
                                 y 
                                  
                                 
                                   ( 
                                   
                                     t 
                                     i 
                                   
                                   ) 
                                 
                               
                             
                           
                         
                         ) 
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                   
                     3 
                      
                     
                       
                         t 
                         i 
                       
                       · 
                       
                         
                           ( 
                           
                             1 
                             - 
                             
                               t 
                               i 
                             
                           
                           ) 
                         
                         2 
                       
                       · 
                       
                         
                           ∇ 
                           
                             d 
                              
                             
                               ( 
                               
                                 B 
                                  
                                 
                                   ( 
                                   
                                     t 
                                     i 
                                   
                                   ) 
                                 
                               
                               ) 
                             
                           
                         
                         . 
                       
                     
                   
                 
               
             
           
         
       
     
       Thus, 
       [0071]    
       
         
           
             
               
                 
                   
                     
                       f 
                       ⇀ 
                     
                     1 
                   
                   = 
                   
                     
                       1 
                       N 
                     
                      
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           1 
                         
                         N 
                       
                        
                       
                         2 
                          
                         
                           
                             d 
                              
                             
                               ( 
                               
                                 B 
                                  
                                 
                                   ( 
                                   
                                     t 
                                     i 
                                   
                                   ) 
                                 
                               
                               ) 
                             
                           
                           · 
                           3 
                         
                          
                         
                           
                             t 
                             i 
                           
                           · 
                           
                             
                               ( 
                               
                                 1 
                                 - 
                                 
                                   t 
                                   1 
                                 
                               
                               ) 
                             
                             2 
                           
                           · 
                           
                             ∇ 
                             
                               d 
                                
                               
                                 ( 
                                 
                                   B 
                                    
                                   
                                     ( 
                                     
                                       t 
                                       i 
                                     
                                     ) 
                                   
                                 
                                 ) 
                               
                             
                           
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                   
                     
                       6 
                       N 
                     
                      
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           1 
                         
                         N 
                       
                        
                       
                         
                           t 
                           i 
                         
                         · 
                         
                           
                             ( 
                             
                               1 
                               - 
                               
                                 t 
                                 i 
                               
                             
                             ) 
                           
                           2 
                         
                         · 
                         
                           d 
                            
                           
                             ( 
                             
                               B 
                                
                               
                                 ( 
                                 
                                   t 
                                   i 
                                 
                                 ) 
                               
                             
                             ) 
                           
                         
                         · 
                         
                           
                             ∇ 
                             
                               d 
                                
                               
                                 ( 
                                 
                                   B 
                                    
                                   
                                     ( 
                                     
                                       t 
                                       i 
                                     
                                     ) 
                                   
                                 
                                 ) 
                               
                             
                           
                           . 
                         
                       
                     
                   
                 
               
             
           
         
       
     
         [0000]    Similarly, the adjustment “force” {right arrow over (f)} 2  acting on off curve control vertex C 2  is 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       f 
                       ⇀ 
                     
                     2 
                   
                   = 
                   
                     
                       
                         ∇ 
                         
                           C 
                           2 
                         
                       
                        
                       E 
                     
                     = 
                     
                       
                         1 
                         N 
                       
                        
                       
                         
                           ∑ 
                           
                             i 
                             = 
                             1 
                           
                           N 
                         
                          
                         
                           2 
                            
                           
                             
                               d 
                                
                               
                                 ( 
                                 
                                   Q 
                                   i 
                                 
                                 ) 
                               
                             
                             · 
                             
                               
                                 ∇ 
                                 
                                   C 
                                   2 
                                 
                               
                                
                               
                                 d 
                                  
                                 
                                   ( 
                                   
                                     Q 
                                     i 
                                   
                                   ) 
                                 
                               
                             
                           
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                   
                     
                       6 
                       N 
                     
                      
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           1 
                         
                         N 
                       
                        
                       
                         
                           t 
                           i 
                           2 
                         
                         · 
                         
                           ( 
                           
                             1 
                             - 
                             
                               t 
                               i 
                             
                           
                           ) 
                         
                         · 
                         
                           d 
                            
                           
                             ( 
                             
                               B 
                                
                               
                                 ( 
                                 
                                   t 
                                   i 
                                 
                                 ) 
                               
                             
                             ) 
                           
                         
                         · 
                         
                           
                             ∇ 
                             
                               d 
                                
                               
                                 ( 
                                 
                                   B 
                                    
                                   
                                     ( 
                                     
                                       t 
                                       i 
                                     
                                     ) 
                                   
                                 
                                 ) 
                               
                             
                           
                           . 
                         
                       
                     
                   
                 
               
             
           
         
       
     
         [0072]    To reduce the fitting error, the positions of the off-curve control vertices C 1  and C 2  are iteratively adjusted by adding to them, the adjustment forces {right arrow over (f)} 1  and {right arrow over (f)} 2 , respectively, scaled by a proportionality constant α: 
         [0000]    
       
      
       C 
       1 
       j+1 
       =C 
       1 
       j 
       +α{right arrow over (f)} 
       1  
      
     
         [0000]    
       
      
       C 
       2 
       j+1 
       =C 
       2 
       j 
       +α{right arrow over (f)} 
       2  
      
     
         [0073]    In general, the proportionality constant αε[0,1] determines stability and convergence properties of the curve fitting, with a smaller α providing more stability but slower convergence. However, because components of the vector distance field are nearly linear close to the polyline, the method according to the first embodiment is reasonably insensitive to α so that an α value of 1 provides fast convergence and good stability. 
         [0074]    Both {right arrow over (f)} 1  and {right arrow over (f)} 2  are functions of the scalar distance to the polyline d(Q) and the gradient of the scalar distance field ∇d(Q) at the set of test points {Q i =P(t i )} on the curve segment. In particular, d(Q)·∇d(Q)=//(dx, dy)//·(dx, dy), where (dx, dy) is the vector distance at point Q. Thus, the adjustments {right arrow over (f)} 1  and {right arrow over (f)} 2  can be computed directly by interpolating the vector distance map of the polyline at the test points {Q i }. 
         [0075]    Maintaining G 1  Continuity of the Estimating Curve 
         [0076]    The smoothness of an analytic curve can be described in terms of its continuity, which is a function of its differentiability at points along the curve. Because polynomial curves are everywhere infinitely differentiable, the continuity of a piecewise polynomial curve is determined by the continuity at the joints between curve segments: C 0  continuity simply implies that curve segments are connected at their endpoints; C 1  continuity implies that the tangent vectors of connected curve segments are parallel and have equal length at the point where they are joined; C 2  continuity implies that the curvature of connected curve segments is equal at the point where they are joined, and so on. 
         [0077]    Geometric continuity, G N , is somewhat less restrictive than algebraic continuity, C N . In particular, two curve segments are G 1  continuous if their tangent vectors are parallel but not necessarily equal in length at the point where they are joined. Note that G 1  continuous curve segments are smooth enough for most applications but the first embodiment can be extended to achieve higher order algebraic or geometric continuity when higher order Bezier curves are used in the piecewise polynomial curve. 
         [0078]    The tangent vector of a cubic Bezier curve is {right arrow over (t)}(t)=(dB(t)/dx, dB(t)/dy)=3(C 1 −C 0 )(1−t) 2 +6(C 2 −C 1 )t(1−t)+3(C 3 −C 2 )t 2 . At the curve&#39;s first and last endpoints, {right arrow over (o)}(0)=3(C 1 −C 0 ) and {right arrow over (t)}(1)=3(C 2 −C 3 ), respectively. These endpoint tangent vectors lie on the lines connecting the first endpoint to the first off-curve control vertex and the second endpoint to the second off-curve control vertex, respectively. Hence, to maintain G 1  continuity at non-corner points between a new curve segment and its preceding curve segment, the first off-curve control vertex of the new curve segment is constrained to lie on a line passing through the preceding curve segment&#39;s second endpoint and its second off-curve control vertex. 
         [0079]    The first off-curve control vertex of the new curve segment originates on the line because it is initialized to lie at the endpoint common to the new curve segment and the preceding curve segment. Thus, the first off-curve control point can be constrained to lie on the line by restricting the displacement {right arrow over (f)} 1  of the first control vertex to be parallel to the line. Thus, to maintain G 1  continuity at the first endpoint of the new curve segment, {right arrow over (f)} 1  is replaced with the constrained displacement {right arrow over (f)} 1 *=({right arrow over (f)} 1 ∘{right arrow over (l)}) I, where {right arrow over (l)} is the unit direction vector of the line and ‘∘’ is the vector dot product, and the first off-curve control vertex of the new curve segment is adjusted using C 1   j+1 =C 1   j +α{right arrow over (f)} 1 *. 
         [0080]      FIG. 6  illustrates a method for constraining the first off-curve control vertex. Two curves  602  and  604  are joined at a point  606 , which is the last control vertex of curve  602  and the first control vertex C 0  of curve  604 . Curve  602  has tangent vector t 1    608  at the point  606 . To maintain G 1  continuity at the point  606 , the first off-curve control vertex C 1    610  of curve  604  is constrained to lie on the line L  612  which is collinear with the tangent vector  608 . Hence the determined displacement {right arrow over (f)} 1    614  for reducing the fitting error, which would move the first control vertex  608  off of the line  612  to a new position C′ 1    616 , is modified to the constrained displacement {right arrow over (f)} 1 *  618  parallel to the line  612 . The constrained displacement  618  moves the control vertex  610  to a new position C″ 1    620  which lies on the line  612 , thereby maintaining G 1  continuity. 
         [0081]    The constrained adjustment of control vertex C 1    610  can be applied in a number of different ways. One way is to use the constrained displacement {right arrow over (f)} 1 *  618  to adjust C 1    610  as described above. A second way is to use the un-constrained displacement {right arrow over (f)} 1    614  to adjust C 1    610  to C′ 1    616  and then to project onto L  612 . 
         [0082]    Efficient Incremental Computation of the Vector Distance Field 
         [0083]    Computing the control vertex adjustments required for on-the-fly curve fitting described above uses vector distances from test points along the estimating curve to the input path. These vector distances can be computed using a brute force approach that first computes vector distances from each test point to every line segment in the polyline representing the input path and then chooses the vector distance with the minimum magnitude. The brute force approach can be improved using geometric data structures to reduce the number of distances computed and compared for each test point. 
         [0084]    In the first embodiment, the polyline is represented by a vector distance map that is incrementally updated as each new digitized point is acquired. Vector distances at test points can then be efficiently interpolated from sampled distances in the vector distance map, for example, by using bilinear interpolation. Achieving on-the-fly curve fitting during drawing requires an efficient method for computing the vector distance map. 
         [0085]    In the first embodiment, the vector distance map is stored in a two-dimensional image with the same dimensions and resolution as the display window used by the drawing application. Two 32-bit floating point values are stored per pixel, one value for dx and one value for dy. Alternatively, two 8-bit values can be used to reduce memory requirements without compromising accuracy. If required, using an adaptively sampled vector distance field representation can provide additional compression and/or reduce processing loads. 
         [0086]    The vector distance field of the polyline is a CSG union of the vector distance fields of the polyline&#39;s individual line segments, where the CSG union of two vector distances chooses the vector distance with the smaller magnitude. Thus the vector distance map of the polyline can be constructed incrementally; when a new digitized point becomes available, the vector distance field of the line segment from the end of the existing polyline to the new digitized point is simply added to the existing vector distance map using a CSG union operation. 
         [0087]    The vector distance field of a line segment is composed of the field closest to the line segment and the field closest to the digitized points defining its endpoints. In practice the vector distance field of only one of the two endpoints is computed for each line segment because endpoints are shared along the polyline. Computing the vector distance field for each line segment can be made very efficient for the following two reasons. 
         [0088]    First, the estimating curve is not far from the polyline. Hence, the vector distance field is only required within a limited radius, R, from the polyline, where R is determined by the maximum allowable curve error and the spacing between input points. Consequently, a limited region enclosing each line segment is defined within which the vector distance field is computed. Because contributions from each line segment are added using the CSG union operator, the limited regions can overlap, allowing the use of regions with simple geometry. Quadrilateral regions are chosen—for an endpoint, an axis-aligned square centered on the endpoint with sides of length  2 R is used and, for a line segment, a rectangle centered along the line segment with width  2 R is used. 
         [0089]    Second, the x and y components of the vector distance fields of points and lines are linear. Thus, to add the vector distance field of a new line segment to the existing vector distance field, two simple geometric shapes are rasterized: a square limiting the vector distance field of the line segment&#39;s first endpoint and a rectangle limiting the vector distance field of the line segment. During rasterization, the x and y components of the vector distance fields are computed at corners of their respective quadrilateral regions and linearly interpolated across the quadrilateral regions. The CSG union operator compares the magnitude of the interpolated vector distance at a particular raster location to the magnitude of the corresponding vector distance already stored in the vector distance map and chooses the vector distance with the smaller magnitude. 
         [0090]    Fitting a Surface to a Set of Surface Points 
         [0091]    A second embodiment of the method of the invention fits a parametric surface representation to a set of digitized points. A first step of the second embodiment is to generate a vector distance field representation of the set of digitized points. There are various approaches for generating the vector distance field. In the second embodiment, the vector distance field is sampled and stored in a regularly sampled volume. Alternatively, the vector distance field can be sampled adaptively and represented as an adaptively sampled distance field. In another alternative, the vector distance field is represented analytically, for example as the CSG union of the vector distances to each point in the set of digitized points. In yet another alternative, the vector distance field is represented procedurally, for example as a procedure that first finds a set of closest digitized points from a spatial data structure and then determines the vector distance from the set of closest digitized points. 
         [0092]    The vector distance field can also be derived from a scalar distance field by scaling the gradient of the scalar distance field at any point by its scalar distance, the absolute value of its scalar distance, the square of its scalar distance, or a function of its scalar distance. The gradient of the scalar distance field can be determined analytically or procedurally depending on the representation of the scalar distance field. For example, a common approach for estimating the gradient of a regularly sampled scalar distance field is to use the central differences operator, which is known in computer graphics and image processing. 
         [0093]    The vector distance field can be generated directly from the set of digitized points, for example by combining the vector distance fields of all of the digitized points using a CSG operation that chooses a vector distance from a set of vector distances with the smallest magnitude, or a blending function that computes a weighted sum or average of a set of vector distances. Alternatively, the vector distance field can be generated from an intermediate representation in a manner similar to that used to represent the polyline approximation of the input path of a digitizing device in the first embodiment described above. For example, the set of digitized points can be triangulated using Delaney triangulation and then vector distances are computed from sample points to the triangulated surface. 
         [0094]    A second step of the second embodiment is to initialize a parametric surface representation to approximate the set of digitized points. There are various approaches for initializing the parametric surface. For example, a user can construct an initial parametric surface composed of a set of coarse surface patches using a drawing application or computer aided design system. As a second example, the parametric surface can be automatically initialized as a minimal bounding sphere surrounding the digitized points. As a third example, the parametric surface can be initialized to be a coarse triangular mesh that is generated either automatically or semi-automatically to approximate the surface. 
         [0095]    A third step of the second embodiment is to iteratively adjust parameters of the parametric surface, where the adjustment is responsive to a fitting error between the parametric surface and the set of digitized points using the vector distance field. Parameters of the parametric surface are adjusted to reduce the fitting error, for example, by changing a parameter in a direction that reduces the fitting error the most according to the partial derivative of the fitting error with respect to the parameter. 
         [0096]    The parameter adjustment can be constrained to improve the quality of the parametric surface or to improve the fitting process. For example, parameter adjustment can be constrained to reduce surface curvature, thereby favoring a smoother surface. As a second example, when the vector distance field is generated by combining the vector distance fields of all of the digitized points, parameter adjustment can be constrained so that forces acting on the surface are always perpendicular to the surface, for example, by taking the dot product of the vector distance at a test point with the surface normal vector when determining the fitting error. 
         [0097]      FIGS. 7A-7D  illustrate fitting a parametric surface to a set of three-dimensional points. In  FIG. 7A , a set of digitized points  702  are provided by the application. A vector distance field can be generated to represent the set of digitized points  702  by first determining a set of triangles  704  that connect the digitized points  702  as illustrated in  FIG. 7B  and then computing vector distances to the set of triangles  704 . Parameters of an initial parametric surface  706  as shown in  FIG. 7C  can then be adjusted to fit the parametric surface to the set of digitized points using the vector distance field. Alternatively, the vector distance field can be generated by combining vector distances  708  shown in  FIG. 7D  to the set of digitized points  702  and constraining adjustments to the parametric surface to reduce surface curvature or to move the parametric surface in a direction of the surface normal vector at each test point. 
         [0098]    Surfacing a Sampled Distance Field 
         [0099]    A third embodiment of the method of the invention fits a surface mesh composed of parametric surface elements to an iso-surface of a regularly sampled distance field. A variation of the third embodiment fits a surface composed of parametric surface elements to an iso-surface of an adaptively sampled distance field. A first step of the third embodiment is to generate a sampled vector distance field. There are various approaches for generating the sampled vector distance field. For example, the sampled vector distance field can be generated directly from a geometric representation of a set of objects or it can be generated from a sampled scalar distance field by computing the gradient of the scalar distance field at sample points in the sampled vector distance field. 
         [0100]    In a second step, a surface mesh composed of parametric surface elements is initialized. In this embodiment, a modification of the SurfaceNets algorithm described in U.S. Pat. No. 6,943,789 is used to initialize a surface mesh made up of quadrilateral elements for a regularly sampled vector distance field and triangular and quadrilateral elements for an adaptively sampled vector distance field. Examples of such elements include triangular and quadrilateral cubic Bezier patches or NURBs patches. To initialize the surface mesh, a vertex of the surface mesh is placed at the center of cells of the sampled vector distance field that contain an iso-surface of the vector distance field, that is, in cells with corners on different sides of the iso-surface. Triangular and quadrilateral elements of the surface mesh are then constructed to connect the vertices of each set of cells that share a common edge intersecting the iso-surface. 
         [0101]    In a third step, parameters of the mesh surface elements are iteratively adjusted to better fit the surface to the iso-surface of the sampled distance field. This step computes a fitting error from the sampled vector distance field at a set of test points on the mesh surface and adjusts parameters of the mesh surface elements to reduce the fitting error. The adjustments can be constrained to control the curvature of the mesh surface or to control continuity along and across edges of the mesh surface elements. 
         [0102]    Determining a Medial Axis of a Closed Outline 
         [0103]    A fourth embodiment of the method of the invention determines a medial axis of a two-dimensional closed outline, where the medial axis is composed of a set of piecewise polynomial segments. 
         [0104]    In a first step, a two-dimensional adaptively sampled vector distance field of the closed outline is generated, where the adaptive sampling rate is higher near the medial axis of the closed outline. In a second step, cells of the adaptively sampled vector distance field that are inside the closed outline and that contain the medial axis are determined. There are various ways to determine cells that contain the medial axis from the vector distance field. For example, the directions of vector distances at the corner vertices of a cell containing the medial axis are substantially different. Alternatively, the divergence of the vector distance field within a cell containing the medial axis is substantially greater than zero. The divergence of the vector distance field can be determined from the partial derivatives of the vector distance field over the faces of the cell. Alternatively, an interpolated vector distance field within a cell that is defined by bilinearly interpolating the sampled vector distances at the corners of a medial axis cell has a minimum magnitude at a point or a locus of points in the cell. 
         [0105]    In a third step, a piecewise polynomial curve is initialized to represent the medial axis. Various initializations are possible, such as a polyline connecting the centers of cells containing the medial axis or a polyline connecting points on the medial axis on the edges of cells containing the medial axis. 
         [0106]    In a fourth step, parameters of the piecewise polynomial curve are iteratively adjusted to reduce a fitting error. Just as there are various ways for determining cells that contain the medial axis, there are various ways to determine the fitting error. For example, the fitting error can be determined by comparing samples of the vector distance field on either side of the parametric representation of the medial axis or from samples of partial derivatives of the vector distance field near the parametric representation of the medial axis. 
         [0107]      FIG. 8  is illustrates the fitting of a piecewise parametric curve to the medial axis of a closed outline  802  of a glyph ‘I’.  FIG. 8A  shows the closed outline  802 .  FIG. 8B  shows vector distances (depicted as small arrows) from various sample points in two-dimensional space to the closed outline  802 .  FIG. 8C  shows various iso-contours  806 ,  808 ,  810 ,  812  of the magnitude of the vector distance field of the closed outline  802 .  FIG. 8D  shows the medial axis  814  of the closed outline  802 . 
       Recognizing Stroked Characters 
       [0108]    A fifth embodiment of the method of the invention fits a parametric representation to a set of digitized points sampled along a path of a digitizing device where the path of the digitizing device approximates an intended shape, such as a character glyph, a signature, a symbol, or a pattern, and then compares the parametric representation to the parametric representations of a set of known shapes to recognize the intended shape. 
         [0109]      FIG. 9  illustrates the method  900  according to the fifth embodiment. A digitizing device records  904  a set of digitized points along an input path representing an intended shape such as a particular character glyph. A vector distance field representing the input path is initialized  908  and a parametric representation of the set of digitized points is initialized  912 . As each new digitized point is recorded by the digitizing device, the vector distance field is updated  916 . 
         [0110]    A fitting error is determined  920  from the vector distance field and the parametric representation. Parameters of the parametric representation are iteratively adjusted  928  to reduce the fitting error if it is determined  924  that a fitting criterion is not satisfied. Various fitting criteria can be applied. For example, the parameter adjustment can be terminated when the fitting error is less than a specified threshold, when a maximum number of iterations have been performed, or when a user stops the fitting adjustment. 
         [0111]    Features such as corners in the input path, positions of high curvature, time intervals along the input path, as well as positions and timings of pen-down and pen-up events are detected  932  and associated with the parametric representation to form an augmented parametric representation. The augmented parametric representation is then transformed  936 , for example by scaling and offsetting, to form a transformed parametric representation. Finally, the transformed parametric representation is compared  940  to the transformed parametric representations of a set of known shapes and a closest shape in the set is selected to be the recognized shape. 
         [0112]    Although the invention has been described by way of preferred embodiments, it is to be understood that various other applications and modifications can be made within the spirit and scope of the invention. Therefore, it is the object of the appended claims to cover all such variations and modifications as come within the true spirit and scope of the invention.