Computer-Aided Design 44 (2012) 697–708

Contents lists available at SciVerse ScienceDirect

Computer-Aided Design
journal homepage: www.elsevier.com/locate/cad

B-spline surface fitting by iterative geometric interpolation/approximation

algorithms
Yuki Kineri a , Mingsi Wang b , Hongwei Lin c , Takashi Maekawa a,∗
a
Department of Mechanical Engineering, Yokohama National University, Japan
b
Product Development Center, YKK, Japan
c
State Key Laboratory of CAD&CG, Zhejiang University, Hangzhou, 310058, China

article info abstract

Article history: Recently, the use of B-spline curves/surfaces to fit point clouds by iteratively repositioning the B-spline’s
Received 30 November 2011 control points on the basis of geometrical rules has gained in popularity because of its simplicity,
Accepted 29 February 2012 scalability, and generality. We distinguish between two types of fitting, interpolation and approximation.
Interpolation generates a B-spline surface that passes through the data points, whereas approximation
Keywords: generates a B-spline surface that passes near the data points, minimizing the deviation of the surface
Interpolation
from the data points. For surface interpolation, the data points are assumed to be in grids, whereas
Approximation
B-spline surfaces
for surface approximation the data points are assumed to be randomly distributed. In this paper, an
Iterative geometric fitting algorithm iterative geometric interpolation method, as well as an approximation method, which is based on the
framework of the iterative geometric interpolation algorithm, is discussed. These two iterative methods
are compared with standard fitting methods using some complex examples, and the advantages and
shortcomings of our algorithms are discussed. Furthermore, we introduce two methods to accelerate the
iterative geometric interpolation algorithm, as well as a method to impose geometric constraints, such
as reflectional symmetry, on the iterative geometric interpolation process, and a novel fairing method for
non-uniform complex data points. Complex examples are provided to demonstrate the effectiveness of
the proposed algorithms.
© 2012 Elsevier Ltd. All rights reserved.

1. Introduction Standard B-spline surface fitting algorithms first associate

Surface fitting is an important problem in many fields, in-
cluding CAD/CAM/CAE, computer graphics, and computer vision.
Non-Uniform Rational B-splines (NURBS) have become the de facto
industry standard [1] for representing complex geometric infor-
mation in CAD/CAM/CAE field. This paper studies the construc-
tion of B-spline surfaces from point clouds using fitting techniques.
We distinguish two types of fitting, interpolation and approxima-
tion [2,1]. Interpolation generates an interpolating B-spline surface
that passes through the data points. In contrast, approximation
generates an approximating B-spline surface that passes near the
data points, minimizing the deviation of the surface from the data
points. For B-spline surface interpolation, we assume that the data
points are given in grids, whereas for surface approximation we as-
sume the data points to be randomly distributed. Furthermore, we
assume that the noise of the point clouds has been filtered by, for
example, a moving least squares method [3].
∗ Corresponding author. Tel.: +81 45 339 3930.
E-mail address: maekawa@ynu.ac.jp (T. Maekawa).
0010-4485/$ – see front matter © 2012 Elsevier Ltd. All rights reserved.
doi:10.1016/j.cad.2012.02.011
suitable parameter values for each input point, known as
parametrization of data, and form a linear system with control
points as unknowns. There is a tremendous amount of literature on
fitting surfaces to a set of data points; however, it is not within the
scope of the present paper to review all of the existing work. Good
surveys of fitting techniques with B-spline surfaces are given by
Hoschek and Lasser [2], Piegl and Tiller [1], Hoschek and Jüttler [4],
and Weiss et al. [5].
Recently, in contrast to the standard surface fitting methods,
iterative geometric fitting methods that do not require the solution
of a linear system have received attention [6–14]. These methods
employ a surprisingly simple geometric-based algorithm which
iteratively updates the control points in a global manner based
on a local point surface distance computation and a repositioning
procedure.
Gofuku et al. [15] introduced a method for the interpolation
of a set of data points, as well as unit tangent vectors (or unit
normal vectors) at the data points, by means of a planar cubic
B-spline curve using an iterative geometric-based algorithm. Very
recently, Abbas et al. [16] have developed a constructive approach
for the generation of a uniform B-spline curve with points, normals
and curvature constraints. However this does not give accurate
698 Y. Kineri et al. / Computer-Aided Design 44 (2012) 697–708

binormal vectors for space curves. Okaniwa et al. [17] presented and generate as output a B-spline surface that interpolates the
a method for the interpolation of a set of data points and unit data points. We now demonstrate how to parametrize the data in
tangents, as well as curvature vectors at the data points, by means the u direction; the v direction is analogous. For each j we assign
of planar and space uniform cubic B-spline curves using an iterative parameter values 0 ≤ ũij ≤ 1 to Qij , i = 0, . . . , n based on
geometric-based algorithm. chord length or a centripetal method, depending on the input data.
In this paper, we fit point clouds in terms of B-spline surfaces When the data takes very sharp turns, the centripetal method gives
using iterative geometric interpolation/approximation algorithms. better results than the chord length method [2,1]. Knot vectors U
The contribution of our work can be summarized as follows: and V in the u and v directions are then constructed. We explain
• We develop acceleration methods for the iterative geometric how to construct U; V is analogous. For a clamped B-spline surface,
interpolation algorithm. the knot vector can be defined using the following technique of
• We study a method to impose geometrical constraints, such as averaging [1]:
reflectional symmetry, in the iterative geometric interpolation
process. u0 j = · · · = uK −1 j = 0, ur − K + 1 j = · · · = ur j = 1 ,
• We introduce a surface fairing method based on Laplacian k+K −2
1 
smoothing. uK +k−1 j = ũi j , k = 1, . . . , n − K + 1, (5)
• We develop a surface approximation method based on the K −1 i =k
framework of the iterative geometric interpolation algorithm.
• We conduct a comparison between the iterative geometric where r = n + K . We average uij across j = 0, . . . , m, and construct
fitting method and the standard fitting method, and discuss the the knot vector U [1].
advantages and shortcomings of the two methods. We then form a sparse linear system with control points as
unknowns, and apply iterative solvers, such as conjugate gradients
This paper is organized as follows: in Section 2, we review the
(CG) [19] or sparse direct solvers [20] to this system. The choice
standard fitting methods for B-spline surfaces. In Section 3, we
of data parametrization greatly affects the quality of the resulting
introduce a novel method to accelerate the geometric interpola-
surface, and therefore an iterative parameter correction technique
tion, and present a method to impose geometrical constraints such
is widely adopted to adjust the parameter values in order to force
as reflectional symmetry on the iterative geometric interpolation
process. A surface approximation method based on the framework the error vectors to be perpendicular to the fitting surface [2,21,5].
of the geometric surface interpolation algorithm is developed in
Section 4, and in Section 5, we compare our iterative geometric fit- 2.3. Surface approximation
ting methods with the standard fitting methods using some com-
plex surfaces. Finally, we conclude the paper in Section 6. For surface approximation, we assume the data points Qk ,
0 ≤ k ≤ N are randomly distributed. Unlike the surface
2. Review of standard fitting methods interpolation case, we are not able to use the cumulative chord
length method for parametrization. Therefore, we construct a so
2.1. Notation of B-spline surfaces called base surface, which is a first approximation of the final
fitted surface [21]. The basic strategy is to project the randomly
Let us first introduce the notation used in the remainder of the distributed points onto the base surface, and use the parameters
paper. An order k B-spline is formed by joining several pieces of of the projected points for surface fitting. To construct the base
polynomials of degree k − 1 with, at most, C k−2 continuity at the surface, we first generate four boundary curves by approximating
breakpoints [18,1]. A set of non-descending break points t0 ≤ t1 ≤ boundary data points. We set the number of control points of
· · · ≤ tr defines a knot vector the boundary curves as low as possible, in order to ensure that
T = (t0 , t1 , . . . , tr ), (1) the overall number of final control points is low, which sacrifices
some accuracy at the boundary. We can use the standard method
which determines the parametrization of the basis functions.
as well as our iterative geometric algorithm to approximate the
Given a knot vector T, the associated B-spline basis functions
boundary curves. The boundary conditions are imposed by fixing
Ni,k (t ), are defined as:
these four boundary curves. Owing to the nature of the tensor
for ti ≤ t < ti+1 product surface, the two boundary curves along the u and v

1
Ni,1 (t ) = (2)
0 otherwise, directions, respectively, must be defined on the same knot vectors.
If the pair of knot vectors are different, we need to merge them into
for k = 1, and
a single common knot vector by knot refinement [1]. We denote
t − ti ti+k − t these knot vectors as U and V. Once we have the four boundary
Ni,k (t ) = Ni,k−1 (t ) + Ni+1,k−1 (t ), (3) (0) (0)
ti+k−1 − ti ti+k − ti+1 curves with control points {Pi0 , i = 0, . . . , n}, {Pim , i = 0, . . . , n},
for k > 1 and i = 0, 1, . . . , r − k. {P(0j0) , j = 0, . . . , m}, {Pnj
(0)
, j = 0, . . . , m}, we determine the interior
An order (K , L) B-spline surface is a tensor product surface control points by bilinear blending [21,9]:
defined by a topologically rectangular set of control points Pij ,
(0)
 
0 ≤ i ≤ n, 0 ≤ j ≤ m and two knot vectors U = (u0 , u1 , . . . , un+K ) 1 − vj
 
(0) P0j (0) (0)
Pij = [1 − ui ui ] (0) + [Pi0 Pim ]
and V = (v0 , v1 , . . . , vm+L ) associated with each parameter u, v . Pnj vj
The corresponding integral B-spline is given by
(0) (0)  
1 − vj
 
P00 P0m
n 
m
− [1 − ui ui ] (0) , (6)
P(nm
0) vj

R(u, v) = Pij Ni,K (u)Nj,L (v). (4) Pn0
i=0 j=0
where ui and vj are defined as
i
2.2. Surface interpolation ui = , i = 0, . . . , n,
n
We assume that the data points are given in a rectangular grid j
of (n + 1) × (m + 1) data points Qij , i = 0, . . . , n, j = 0, . . . , m vj = , j = 0 , . . . , m. (7)
m
 Y. Kineri et al. / Computer-Aided Design 44 (2012) 697–708
For complex surfaces, Azariadis [22] introduced so called Dynamic
Base Surface (DBS) which dynamically adapts to the three-
dimensional shape implied by the point clouds. The method
assumes the existence of four boundary curves. The initial DBS
is constructed from a bicubic Coons surface using these four
boundary curves. A grid of points along the two parameters of the
DBS is then projected onto the cloud-surface along the direction
normal to the DBS by minimizing a set of distance metrics. The
new DBS is then computed by interpolating the projected grid
points with the B-spline surface. If the termination criterion is not
satisfied, more column- and/or row-sections are inserted into the
current DBS and the algorithm continues with the new grid.
Once the parametrization is conducted on the base surface, an
optimization problem is set up to minimize the objective function
F projection method introduced by Hu and Wallner [25]. We use the
N
 parameter value (ũij , ṽij ) associated with Qij , which was introduced
F = |R(uk , vk ) − Qk |2 + λf Fs , (8)
k=0
where R(uk , vk ), k = 0, . . . , N are the surface points that should be
close to Qk , Fs is a smoothing term that enforces the fairness of the
approximating surface [23,5], and λf is a user-defined parameter
that weighs the importance of the fairing factor. If λf is small, then
the resulting surface may not be smooth but will have a high degree
of accuracy. Conversely, if λf is large, the resulting surface will be
smooth but may not be highly accurate. Accordingly, it is a difficult
task to find an optimal value of λf . The fairness function is often
related to a thin plate energy

Fs = (κ12 + κ22 ) dudv, (9)
where κ1 and κ2 are the principal curvatures of the surface. This is a
highly nonlinear function and involves time-consuming numerical
computation. We employ a simplified version of the thin plate
energy, a quadratic function in the second-order partial derivatives
of the surface [23], given by

Fs = (R2uu + 2Ruv + R2vv ) dudv. (10)
Therefore, the objective function is quadratic in the control points
of the surface, and the condition for its minimum is the vanishing
of the partial derivatives of F with respect to the control points,
thus resulting in a system of linear equations
[Adist + λf Afair ]d = b, (11)
where Adist d = b is the usual normal equation, b is the correspond-
ing right hand side, Afair is a so-called energy matrix [23], and d are
the unknown (n + 1)(m + 1) control points. The evaluation of Afair
involves integration of the product of B-spline functions, which can
be calculated efficiently with the Gaussian quadrature [24]. The
matrix Afair can be precomputed, as it does not depend on the point
parametrization.
Approximations generally start with fewer control points,
and, if necessary, control points are added where deviations are
large [1]. Also, parameter corrections are often applied to improve
the quality of the surface.
3. Iterative geometric interpolation algorithm
3.1. Procedures
Once the knot vectors are constructed using the method
described in Section 2.2, the control points of the interpolating
B-spline surface are determined in two steps. In the first step, we
699
assume that the control mesh of the B-spline surface coincides with
the given data points:
n 
m
(0)
R(0) (u, v) =

Pij Ni,K (u)Nj,L (v), (12)
i =0 j =0
(0)
where the superscript (0) denotes the 0th iteration, and Pij = Qij .
(0)
At this stage, of course, R (u, v) will not interpolate the input
rectangular grid mesh, but will instead lie within the convex hull
of the input control mesh.
For each data point Qij , i = 0, . . . , n, j = 0, . . . , m,
except for the four corner points Q00 , Q0m , Qn0 , Qnm , we compute
the closest point on the B-spline surface R(0) (u, v). This can be
obtained by applying the iterative geometric second-order point
in Section 2.2, as the initial value for the iteration, and denote the
resulting parameter value as (ûij , v̂ij ). If there is no solution, we
check whether Qij has an orthogonal projection on one of the four
border curves of the surface.
In the second step, we evaluate the error vector
(0)
eij = Qij − R(0) (ûij , v̂ij ), (13)
for each data point, and adjust the control mesh to obtain the
(1)
updated control points Pij for the next iteration as follows:
(1) (0) (0)
Pij = Pij + eij i = 0, . . . , n, j = 0, . . . , m. (14)
Note that the four corner points remain the same. In the α -th
iteration, we compute the closest point to each input data point
(α)
Qij on the surface R(α) (u, v) defined by the control mesh Pij ,
i = 0, . . . , n, j = 0, . . . , m, and the knot vectors U and V. We
(α) (α+1)
then adjust the control mesh Pij as in (14) to obtain Pij . We
(α)
repeat these two steps until |eij | = |Qij − R(α) (ûij , v̂ij )| becomes
smaller than the prescribed tolerance for all of the data points. If
the convergence is slow at some data points, we can terminate
the global iteration and conduct local iterations for the data points
with slow convergence to save computational time [12].
Lin [14] recently proved the convergence of an algorithm
proposed by Maekawa et al. [12], in which moving the control
points parallel to the position error vectors will interpolate the
input points.
3.2. Surfaces with reflectional symmetry
Many industrial objects such as airplanes, trains, and automo-
biles possess reflectional symmetry. Accordingly, when we recon-
struct such objects, the reflectional symmetry must be preserved.
Zhu and Ke [26] chose a symmetric knot vector, and constrained
the control points to be symmetric in the fitting process. They
employed the method of Lagrange multipliers to enforce the sym-
metry of the control points, and this yielded a linear system with
control points and Lagrange multipliers as unknowns.
The geometric interpolation method preserves reflectional
symmetry in a much simpler way. We first construct a plane of
symmetry that passes through the centroid of the data points and
has a normal vector that is the average of the direction vectors
between pairwise points. Let us assume that the plane of symmetry
is located at x = 0, and contains the yz-plane. We also adjust
the knot vector U to be symmetric. For simplicity, using a slight
abuse of notation, we denote the symmetrical correspondence
of the left-hand side and the right-hand side of the x, y, and
(α) (α) (α) (α)
z components of the control points by (PLx , PRx ), (PLy , PRy ),
(α) (α)
and (PLz , PRz ), and the data points by (QLx , QRx ), (QLy , QRy ), and
700 Y. Kineri et al. / Computer-Aided Design 44 (2012) 697–708

Fig. 1. An automobile hood surface with reflectional symmetry: (a) reconstructed surface without symmetry constraints; (b) reconstructed surface with symmetry
constraints.

Fig. 2. Number of iterations needed to find the closest points versus average parameter difference between iterations: (a) hood model; (b) Fuselage model.

(QLz , QRz ), respectively. Following this notation, the initial control shown in Fig. 1(a) is reconstructed without any constraints, while
points of the iterative geometric algorithm can be set as follows: Fig. 1(b) is reconstructed with constraints (15) and (16). The data
points of the hood surface are generated by slightly perturbing
(0) |QRx | + |QLx | (0) |QRx | + |QLx |
PLx = sgn(QLx ), PRx = sgn(QRx ), the original data shown in Fig. 5(a) so that we can recognize the
2 2 difference.
(0) (0) QRy + QLy
PLy = PRy = , (15) 3.3. Acceleration methods
2
(0) (0) QRz + QLz
PLz = PRz = . In this section, we introduce two ways to speed up the iterative
2 geometric interpolation algorithm, namely the fixing of the closest
When the number of control points in the x-direction is odd, the points and the optimal repositioning of control points.
(0) (0)
center control points PC must lie in the yz-plane, i.e., PCx = 0.
(α)
Similarly, the error vectors eL = (e(α) (α) (α)
Lx , eLy , eLz ) on the left-hand
3.3.1. Fixing closest points
(α) (α) (α) (α) The most time consuming process of the iterative geometric
side, and eR = (eRx , eRy , eRz ) on the right-hand side are adjusted
algorithm is the computation of the closest point. We can observe
as follows:
from Fig. 2 that the parameter values (ûij , v̂ij ) of the closest points
(α) |e(α) (α)
Rx | + |eLx | (α)
barely change after a few iterations. Therefore, they can be fixed
eLx = sgn(eLx ), after a few iterations to avoid performing Newton’s method, which
2
is particularly time-consuming. Once all the distances between the
(α) |e(α) (α)
Rx | + |eLx | (α) data points and the points on the interpolant corresponding to the
eRx = sgn(eRx ),
2 fixed parameter values are within the prescribed tolerance, we
(α) (α) compute the closest point on the surface to check for the exact
(α) (α) eRy + eLy
eLy = eRy = , (16) error. In the numerical experiments, we fix the closest points after
2 two iterations. Table 1 lists the results of this acceleration method
(α) (α) for two models, namely the hood of an automobile and the fuselage
(α) (α) eRz + eLz
eLz = eRz = . of an airplane. The details of the models are provided in Section 5.1.
2
The error in Table 1 is evaluated with respect to the bounding box
We substitute Eqs. (15) and (16) with α = 0 into Eq. (14) to update diagonal of the point clouds.
the control points, and repeat this process until the error becomes It can be observed from Table 1 that we are able to reduce the
smaller than the prescribed tolerance for all of the data points. The computational time by 55% for the hood surface with 100 data
zebra mapping of the hood of an automobile shown in Fig. 1(a) points and 79% for the fuselage surface with 10,000 points. Thus,
and (b) clearly illustrates the effectiveness of our reconstruction this acceleration method is more effective when the number of
algorithm for objects with reflectional symmetry. The hood surface data points is large.
 Y. Kineri et al. / Computer-Aided Design 44 (2012) 697–708 701

Table 1
Effect of fixing the closest points in the iterative geometric interpolation algorithm.
Model # of data points Computational time (s) Ave. err. (%)
Without acceleration With acceleration Without acceleration With acceleration

Hood 100 0.0748 0.0340 5.985E−13 5.766E−13

Fuselage 10,000 5.6752 1.1846 5.179E−15 8.803E−15

3.3.2. Optimal repositioning of control points yielding

The B-spline surface interpolation technique using the iterative n 
m
geometric algorithm updates the control points in a global manner

T = R(uo , vo ) + δij Ni,K (uo )Nj,L (vo ), (23)
based on a simple point-surface distance computation followed by
i=0 j=0
translations of the control points along the error vectors. However,
the length of the translation determined by the magnitude of the λ
error vector may not be optimal. We can speed up the computation
δij = Ni,K (uo )Nj,L (vo ). (24)
2
by seeking the optimal length of the translation vector.
From these equations we can derive
Lu [27] introduced a single weight that applies to all of the
control points of the surface as follows: T − R(uo , vo ) λ δij
= = , (25)
2 n 
m
2 Ni,K (uo )Nj,L (vo )
ω= , Ni2,K (uo )Nj2,L (vo )

(17)
1 + λn (N1 )λm (N2 ) i =0 j =0

where λn (N1 ) and λm (N2 ) are the smallest eigenvalues of the thus we have
collocation matrices N1 = (Ni,K (uj )), i = 0, . . . , n, j = 0, . . . , n
Ni,K (uo )Nj,L (vo )
and N2 = (Ni,L (vj )), i = 0, . . . , m, j = 0, . . . , m, respectively. δij = (T − R(uo , vo ))
n m
However, there are two shortcomings of this technique. The first is
Ni2,K (uo ) Nj2,L (vo )
 
that the weight is constant, independent of the control points. The i=0 j=0
second is that it requires the computation of eigenvalues of n × n
and m × m matrices. = ωij (T − R(uo , vo )) (26)
In this section, we introduce a technique to accelerate the com- where
putation of the geometric interpolation algorithm by determin-
ing the optimal length for each control point without computing Ni,K (uo )Nj,L (vo )
ωij = . (27)
the eigenvalues of the two matrices. The acceleration technique n m
Ni,K 2 (uo ) Nj,L 2 (vo )
 
uses the direct manipulation of the free-form deformation (FFD)
i=0 j =0
method introduced by Hu et al. [28]. Suppose we wish to move a
point on a surface R(uo , vo ) to a target point T by moving each con- Accordingly, we can multiply ωij by the error vector to accelerate
trol point δij . T can be formulated as follows [28]: the computation.
n 
 m Table 2 shows the results of the optimal repositioning acceler-
T = (Pij + δij )Ni,K (uo )Nj,L (vo ) ation method applied to the two models used in Section 3.3.1. In
i=0 j=0 these computations, the acceleration method of fixing the closest
n 
 m n 
 m points is not used. Employing the weights given by (27), we can re-
= Pij Ni,K (uo )Nj,L (vo ) + δij Ni,K (uo )Nj,L (vo ) duce the computational time by 34% for the hood surface and 14%
i=0 j=0 i =0 j =0 for the fuselage surface, respectively.
n 
 m
= R(uo , vo ) + δij Ni,K (uo )Nj,L (vo ). (18) 4. Iterative geometric approximation algorithm
i =0 j =0

The objective function Objt 4.1. Procedures

n 
m
 A surface approximation algorithm takes a set of randomly
Objt = ∥δij ∥2 , (19)
distributed data points Qk , k = 0, . . . , N as input and gener-
i=0 j=0
ates a B-spline surface that approximates the data points. The
is minimized under the constraint (18), yielding a Lagrange Douglas–Peucker algorithm [29,15] is used to determine the initial
function control points of the boundary curves from a series of data points
along the boundaries for the iterative geometric fitting algorithm.

n 
 m
L = ∥δij ∥ + λ · T − R(uo , vo )
2
The curve approximation follows the same procedure as for a sur-
i=0 j=0 face, which is described below. As we discussed in Section 2.3, we
n 
m
 use Farin’s technique [21,9] to generate the base surface for a sim-
ple surface, whereas we use DBS [22] for a complex surface.

− δij Ni,K (uo )Nj,L (vo ) , (20)
i=0 j=0
Once the base surface is constructed, we compute the
error vector Qk − R(0) (ûk , v̂k ) for each data point Qk where
where λ = (λ1 , λ2 , λ3 ) is a Lagrange multiplier. The critical points (ûk , v̂k ) denotes the parameter value of the closest point. In an
of the Lagrange function are obtained by setting interpolation, we have a one-to-one correspondence between
∂L ∂L ∂L the data points and the control points of the interpolating
= = = 0, (21) B-spline surface. In an approximation, we do not have such a
∂λ1 ∂λ2 ∂λ3
correspondence, and therefore it is not trivial to distribute the error
∂L ∂L ∂L vector Qk − R(0) (ûk , v̂k ) to the most appropriate control points of
= y = z = 0, (22)
∂δijx ∂δij ∂δij the approximating B-spline surface.
702 Y. Kineri et al. / Computer-Aided Design 44 (2012) 697–708

Table 2
Effect of optimal repositioning of control points for the iterative geometric interpolation algorithm.
Model # of data points Time (s) Ave. err. (%)
Without acceleration With acceleration Without acceleration With acceleration

Hood 100 0.0748 0.0492 5.985E−13 5.610E−13

Fuselage 10,000 5.6752 4.8750 5.179E−15 4.765E−15

Algorithm 1 Repositioning of the control points.

1: for all k such that 0 ≤ k ≤ N do
2: compute the closest point to Qk on the B- spline surface r(α) (ûk , v̂k ) and
identify its span up ≤ûk < up+1 , vq ≤v̂k < vq+1
3: for i = p-K+1 to p do
4: for j = q-L+1 to q do
5: Wnum [i][j] ← Wnum [i][j]+Ni,4 (ûk )Nj,4 (v̂k )(Qk − R(α) )
6: Wden [i][j] ← Wden [i][j]+ Ni,4 (ûk )Nj,4 (v̂k )
7: end for
8: end for
9: end for
10: for all i such that 0 ≤ i ≤ n do
11: for all j such that 0 ≤ j ≤ m do
(α+1)
12: Pij ← P(α) Wnum [i][j]
ij + W [i][j] den
13: end for
14: end for

is inserted in these locations in both the u and v directions. The

increase in the number of control points provides an increase in
the degrees of freedom of the surface, resulting in the reduction of
local errors. During the error norm check, the row k0 and column
l0 of the spans that have the greatest sum of errors are determined.
A knot is then inserted in the middle of the span (k0 , l0 ) in both the
u and v directions. In most of our examples, a knot is inserted in
both U and V after every 40 iterations.
Fig. 3. Bicubic B-spline patch.

4.2. Proof of convergence

At the parameter value of the closest point (ûk , v̂k ) (up <
ûk < up+1 , vq < v̂k < vq+1 ) corresponding to Qk , there Similar to the interpolation case depicted in Fig. 2, the
are K × L nonzero multiples of basis functions Ni,K (ûk )Nj,L (v̂k ), parameter values (ûk , v̂k ) of the closest points barely change after
i = p − K + 1, . . . , p, j = q − L + 1, . . . , q. As B-spline surfaces a few iterations, and the variations become smaller and smaller
are defined as a linear combination of control points and B-spline as the iteration proceeds, accordingly, we can assume that the
basis functions (see Eq. (12)), the multiple of the basis functions parameter values are fixed in the proof. Let us denote the weight
Ni,K (u)Nj,L (v) is associated with the control point Pij . Accordingly, for the error vector ek as,
we can distribute the error vector Qk − R(0) (ûk , v̂k ) to the control
(0) Ni,K (uk )Nj,L (vk )
points Pij , i = p − K + 1, . . . , p, j = q − L + 1, . . . , q with wkij = , (28)
Wden [i][j]
weights Ni,K (ûk )Nj,L (v̂k ). Note that the sum of the weights is one.
Nishiyama et al. [13] weighted each error vector according to the where Wden [i][j] is defined in Algorithm 1, and the (α + 1)th
barycentric coordinates for the Loop subdivision fitting. Lin [30] B-spline patch as,
extended the progressive-iterative approximation (PIA) [10] to n 
m
R(α+1) (u, v) = (P(α) (α)

the extended progressive-iterative approximation (EPIA), which ij + ∆ij )Ni,K (u)Nj,L (v), (29)
allows the number of control points to be less than that of the i =0 j =0

given data points. However, EPIA only accepts data points given in (α) (α)
where Pij are the control points in the α th iteration and ∆ij are
an array, rather than the randomly distributed data points that are
the repositioning vectors for the corresponding control points.
usually the case in real engineering applications. Fig. 3 illustrates Therefore, the repositioning vector for the control point with
a 7 × 7 control net (large spheres) and knots (small spheres) of index (i, j) is,
a typical bicubic B-spline patch. Suppose that the data point Qk
(α+1)
has its closest point at ×, then u4 ≤ uk < u5 , v5 ≤ vk < v6 . ∆ij
Accordingly, the error vector Qk − R(0) (ûk , v̂k ) is distributed to the
wkij e(α+ 1)
wkij Qk − R(α+1) (ûk , v̂k )
   
= =
control points Pij , i = 1, . . . , 4, j = 2, . . . , 5 (blue spheres) with k
k∈Iij k∈Iij
weights Ni,4 (ûk )Nj,4 (v̂k ).  
n 
m
The overall algorithm for repositioning the control points for
(P(α) (α)
 ij

the α -th iteration is described in Algorithm 1. We repeat steps = w k Qk − gh + ∆gh )Ng ,K (ûk )Nh,L (v̂k )
1–14 until the average and the maximum of the norm of the error k∈Iij g =0 h=0
(α) (α)
vector |Qk − R(α) (ûk , v̂k )|, k = 0, . . . , N become smaller than
 
n 
m
(α)
 ij

the prescribed tolerances εav g and εmax , respectively. Note that in = w k Qk − Pgh Ng ,K (ûk )Nh,L (v̂k )
Algorithm 1, superscripts (α) of the parameter values (ûk , v̂k ) are k∈Iij g =0 h=0

omitted not only for simplicity, but also due to the fact that the 
n 
m

(α)
 ij

changes in parameter values become smaller and smaller. If the − w k ∆gh Ng ,K (ûk )Nh,L (v̂k )
error norm does not become small enough in some regions, a knot k∈Iij g =0 h=0
 Y. Kineri et al. / Computer-Aided Design 44 (2012) 697–708 703

  
wk00 N0,K (ûk )N0,L (v̂k ) wk00 N0,K (ûk )N1,L (v̂k ) ··· wk00 Nn,K (ûk )Nm,L (v̂k )

∈I00
 k k∈I00
 k∈I00
 
 wk01 N0,K (ûk )N0,L (v̂k ) wk01 N0,K (ûk )N1,L (v̂k ) ··· wk01 Nn,K (ûk )Nm,L (v̂k ) 
.
 
C =  k∈I01
 k∈I01 k∈I01  (33)
  nm · · · ··· ··· ···
 
 
wk N0,K (ûk )N0,L (v̂k ) wknm N0,K (ûk )N1,L (v̂k ) wk Nn,K (ûk )Nm,L (v̂k )
nm

···
k∈Inm k∈Inm k∈Inm

Box I.

N0,K (û0 )N0,L (v̂0 ) N0,K (û0 )N1,L (v̂0 ) Nn,K (û0 )Nm,L (v̂0 )
 
···
 N0,K (û1 )N0,L (v̂1 ) N0,K (û1 )N1,L (v̂1 ) ··· Nn,K (û1 )Nm,L (v̂1 ) 
A=
··· ··· ··· ··· . (34)
N0,K (ûN )N0,L (v̂N ) N0,K (ûN )N1,L (v̂N ) ··· Nn,K (ûN )Nm,L (v̂N )

Box II.

Pij + e−γ Pij−1 + Pi−1j + Pi+1j + Pij+1 + e−2γ Pi−1j−1 + Pi+1j−1 + Pi−1j+1 + Pi+1j+1
   
Pij = (39)
1 + 4e−γ + 4e−2γ
where e−γ and e−2γ are the weights of four mid-control points and four corner control points, respectively, and γ determines the
magnitude of the weights. Typically, γ = 2 is used.
Box III.
 
n 
m
So, the eigenvalues of I − C fulfill,
wkij e(α) (α)
  
= k − wkij ∆gh Ng ,K (ûk )Nh,L (v̂k )
k∈Iij k∈Iij g =0 h =0 0 ≤ λ(I − C) = 1 − λ(C) < 1. (38)
n 
m
It means that, the iterative format (32) is convergent. 
= ∆(α) (α)
  ij
ij − ∆gh wk Ng ,K (ûk )Nh,L (v̂k ), (30)
g =0 h =0 k∈Iij

4.3. Fairing
where Iij denotes the set of data points Qk that contribute to the
repositioning vector ∆ij .
By arranging the repositioning vectors for the control points in The standard surface approximation method is usually equi-
a one-dimensional array, i.e., pped with a fairing term (see Eq. (11)) in order to enforce
(β) (β) (β) (β) (β) the smoothness of the resulting surface. However, the iterative
∆(β) = [∆00 , ∆01 , . . . , ∆0m , . . . , ∆10 , . . . , ∆1m , geometric approximation algorithm does not, in general, need
(β)
. . . , ∆n0 , . . . , ∆(β)
nm ] ,
T
β = α, α + 1, (31) fairing, as the algorithm conducts a parameter correction in an
indirect way by moving each control point parallel to the average
we obtain the iterative form, of the error vectors. For very complex surfaces, as shown in Figs. 9
and 11, the variance of the error vectors may be large, and hence
∆(α+1) = (I − C)∆(α) , (32)
we may need to use fairing.
where, I is an (n + 1)(m + 1) × (n + 1)(m + 1) identity matrix, Laplacian smoothing is a technique used for smoothing a
and C is given in Box I. polygonal mesh without changing the topology of the mesh. In our
Furthermore, we have the following result: fairing method, each internal control point Pij , (i = 1, . . . , n −
1, j = 1, . . . , m − 1) is moved to a new position depending on the
Proposition 4.1. If the matrix C (33) is non-singular, the iterative
weighted average of the positions of the 1-ring neighbors of the
format (32) is convergent.
control points of Pij and itself, as shown in Fig. 4(a). More formally,
Proof. To prove the proposition above, we first construct an (N + the fairing operation can be described as in Box III. Fig. 4(b) shows
1) × (n + 1)(m + 1) matrix, A which is given in Box II. the average errors with respect to the number of iterations for a
In fact, denoting mannequin model approximated with and without fairing. We can
  observe a spike-like increase in average errors every 20 iterations
1 1 1
Λ = diag , ,..., , (35) when fairing is applied, but these spikes gradually drop to the error
Wden [0][0] Wden [0][1] Wden [n][m] curve without fairing.
the matrix C (33) can be represented as,

C = ΛAT A. (36) 5. Comparison between standard and iterative geometric

Therefore, if the matrix C is non-singular, AT A is a positive definite
matrix, and all of its eigenvalues are positive, as well as the
eigenvalues of C. On the other hand, since ∥C∥∞ = 1, all of the
eigenvalues of C are less than or equal to 1. In conclusion, the
eigenvalues of C satisfy,
0 < λ(C) ≤ 1.
fitting methods
In this section, we compare our iterative geometric fitting
algorithms with standard fitting methods [23,1]. All examples are
computed on a PC with a Core i7-2600 3.4-GHz processor and 8-GB
RAM. The linear system of the standard fitting methods is solved by
(37) CSparse [20].
704 Y. Kineri et al. / Computer-Aided Design 44 (2012) 697–708

Fig. 4. Laplacian smoothing: (a) control mesh; (b) number of iterations versus average error (mannequin model).

Fig. 5. Hood model: (a) input point clouds (10 × 10); (b) resulting B-spline surface using the iterative geometric interpolation algorithm.

Fig. 6. Fuselage model: (a) input point clouds (50 × 200); (b) resulting B-spline surface using the iterative geometric interpolation algorithm.

5.1. Surface interpolation
We first compare our accelerated iterative geometric inter-
polation method with the standard interpolation method. The
two acceleration methods for the iterative geometric interpolation
method are taken into account. Two examples are used for this pur-
pose. The first example is the hood of an automobile consisting of
10 × 10 data points, as shown in Fig. 5(a). We interpolate these by a
bicubic B-spline surface with 10 × 10 control points (see Fig. 5(b)).
The second example, illustrated in Fig. 6, is the fuselage of an air-
plane, represented by 50 × 200 data points. These are interpolated
by a bicubic B-spline surface with 50 × 200 control points. A fuse-
lage model with 100 × 400 data points is also tested to measure
the computational time for a large number of data points. Table 3
gives the computational results from these three examples. Fig. 7
shows the computational time versus the average error with re-
spect to the bounding box diagonal of the model for two differ-
ent data points of the fuselage model. It can be clearly seen that
the accelerated iterative geometric interpolation algorithm quickly
reaches a coarse fit, while we can progressively obtain a finer fit
by performing more iterations. It is observed that the convergence
rate of the algorithm varies among the tested models, and it differs
whether the acceleration algorithm is applied or not. Furthermore,
as the data points become denser, our method becomes faster than
the standard method for most of the error range. This is due to the
fact that the control points become closer to the limit surface as
their number increases, and hence the iterative geometric inter-
polation method converges quickly.
5.2. Surface approximation
The iterative geometric surface approximation method is
compared with the standard surface approximation method.
Randomly distributed point clouds of three complex surface
models are provided, namely a game controller, a mannequin, and
a crown molding, as shown in Fig. 8(a), 9(a), 11(a), respectively.
 Y. Kineri et al. / Computer-Aided Design 44 (2012) 697–708 705

Table 3
Interpolation results using our algorithm for the models in Figs. 5 and 6.
Method Model # of data points Iter. Max. err. (%) Ave. err. (%) Time (s)

Standard Hood 100 1 1.095E−11 3.430E−12 0.0030

Fuselage 10,000 1 1.495E−14 1.733E−15 0.2862
Fuselage 40,000 1 1.694E−14 1.682E−15 2.1060
Geometric algorithm Hood 100 134 4.121E−12 4.777E−13 0.0140
Fuselage 10,000 108 1.562E−13 3.396E−15 0.8754
Fuselage 40,000 103 1.795E−13 3.044E−15 3.1030

Table 4
Base surfaces of the models in Figs. 8, 9 and 11.
Model #of data pts # of ctrl pts Max. err. (%) Ave. err. (%)

Game controller 3,000 7 × 11 11.342 3.0054

Mannequin 11,469 39 × 39 2.9321 0.2690
Crown molding 100,000 61 × 56 2.5471 0.1330

Table 5
Surface approximation results of the models in Figs. 8, 9 and 11.
Method Model # of ctrl pts Fairing param. Iter. Max. err. (%) Ave. err. (%) Time (s)

Game controller 14 × 18 1.0E−4 81 0.8352 0.0599 1.669

Standard Mannequin 42 × 42 2.0E−5 31 1.0520 0.0598 8.212
Crown molding 62 × 57 2.0E−5 20 0.3254 0.0200 29.93
Geometric algorithm Game controller 11 × 15 * 141 0.5239 0.0598 1.701
Mannequin 42 × 42 2.0 135 0.7750 0.0593 6.234
Crown molding 62 × 57 2.0 54 0.3752 0.0199 23.89

Fig. 7. Fuselage model: computational time versus average error for iterative geometric interpolation, and the standard interpolation method: (a) data points: 10,000; (b)
data points: 40,000.

Information on the point cloud data as well as the details of the
base surface constructed by Azariadis’ DBS method [22] is given in
Table 4. The three models have their own, unique characteristics.
Two of the four boundary curves of the game controller model take
very sharp turns, which forces the interior control points to be
positioned very restrictively, as shown in Fig. 8(f). The mannequin
model consists of four relatively smooth and simple boundary
curves, and a set of complex and non-uniform data points, as
shown in Fig. 9(a). The eyes, ears, nose, and lips are represented by
dense sets of data points, while the rest of the model is represented
by a sparse set of data points. The crown molding model is
surrounded by almost rectangular-shaped boundary curves, as
shown in Fig. 11(a). It consists of the largest number of data
points (100 K) among the three models. The fairing term and
the parameter correction technique are included for the standard
approximation method, whereas the Laplacian smoothing-based
fairing technique is used for the mannequin and the crown molding
models for the iterative geometric surface approach, owing to their
complex geometry.
The computational results of the surface approximation are
listed in Table 5. The computations are terminated when the
average error becomes smaller than 0.06% for the game controller
and the mannequin model, and smaller than 0.02% for the crown
molding model.
The maximum error in the base surface of the game controller is
large compared with the other two models (see Table 4). Fig. 8(d)
illustrates the color-coded error vectors between the data points
and the base surface. When the standard approximation method
with a fairing term is applied to this base surface, self-intersections
occur in the control net. This is due to the large gap, and leads
to unwanted ‘wiggles’, as shown in Fig. 8(e). In order to remedy
these artifacts, the standard method employs a relatively large
fairing factor λf , and inserts many knots to reduce the errors.
Accordingly, the standard method approximation ends up with a
larger number of control points, as shown in Fig. 8(g), and a larger
computational time compared to our method (see Table 5). As our
method gradually approaches the final surface, the chance of a self-
intersection occurring in the control net is small (see Fig. 8(c) and
(h)), and this results in a smaller number of control points and
reduced computation time.
The mannequin model is a very challenging example. Fig. 9(b)
shows the base surface generated by DBS, and Fig. 9(c) shows
706 Y. Kineri et al. / Computer-Aided Design 44 (2012) 697–708

Fig. 8. Game controller model: (a) input point clouds and four boundary curves; (b) base surface generated by DBS; (c) resulting B-spline surface using the iterative geometric
approximation method; (d) color-coded error vectors of point clouds with respect to the base surface; (e) resulting B-spline surface after the first iteration using the standard
method; (f) resulting B-spline surface after the first iteration using the iterative geometric approximation method; (g) Gaussian curvature distribution of the surface generated
by the standard method, iso-parametric lines indicate knot locations; (h) Gaussian curvature distribution of the surface generated by our method.

Fig. 9. Mannequin model: (a) input point clouds and four boundary curves; (b) base surface generated by DBS; (c) resulting B-spline surface using the iterative geometric
approximation method.

the resulting surface using our method. Zebra mappings of the
surfaces constructed by the standard method and our method
are shown in Fig. 10. The left and middle images of the zebra
mapping are the results of the standard method, while the right-
hand one shows the outcome using our method. Apparently, the
middle image, which is the result by the standard method with
73 iterations, has the best quality, and the left and right images
have a similar level of quality. The quality of the surface generated
by the standard method becomes better as we repeatedly update
the control points by solving Eq. (11), which includes the energy
matrix Afair . In contrast, our method is not able to improve the
surface quality of this model after a certain number of iterations.
This is because as the point clouds of the mannequin model are
non-uniformly distributed, having dense and sparse regions, the
number of control points must be large to match with the dense
regions. As a consequence, the sparse regions are also represented
by a large number of control points, and hence the number of
data points in a span becomes very small in the sparse regions.
Accordingly, the repositioning vectors are determined based on
a small number of data points, which makes it very difficult to
 Y. Kineri et al. / Computer-Aided Design 44 (2012) 697–708 707

Fig. 10. Zebra mapping of the mannequin model: (a) the standard method; (b) the standard method with 73 iterations; (c) the iterative geometric approximation method.

Fig. 11. Crown molding model: (a) input point clouds and four boundary curves; (b) base surface generated by DBS; (c) resulting B-spline surface using the iterative geometric
approximation method; (d) color-coded errors of point clouds with respect to the base surface; (e) close-up view of the base surface and the data points; (f) surface after the
application of local iterative geometric surface approximation.

improve the quality of the surface. Nevertheless, both methods
provide reasonably good results in terms of surface quality, as
shown in Fig. 10(a) and (c). In contrast to the game controller
model, the base surface of the crown molding model is very close
to the point clouds except for some boundaries of the leaves,
as illustrated in Fig. 11(d) and (e). Fig. 11(c) shows the surface
approximated using our method. However, bearing in mind that
most of the point clouds are already close to the base surface, we
can employ the local method, as shown in Fig. 11(e) and (f), to fit
the surface. For this example, it takes only 0.97 s to converge. Note
that the standard method cannot handle local methods.
6. Conclusions
We introduced novel methods to interpolate/approximate
a point cloud by B-spline surfaces using iterative geometric
algorithms.
The advantages of our iterative geometric-based fitting inter-
polation and approximation algorithms over the standard fitting
methods are, in general, as follows:
• The algorithm quickly reaches a coarse fit, while we can
progressively obtain a finer fit by performing more iterations.
• The quality of the resulting surfaces are generally good, even
without fairing, as the algorithm conducts parameter correction
in an indirect way by moving each control point parallel to the
error vectors (orthogonal to the surface) in each iteration.
• The implementation is much simpler than for the standard
fitting methods.
• Geometrical constraints, such as reflectional symmetry, can be
easily imposed.
• Local control is easy.
The shortcomings of our iterative geometric fitting algorithms
compared to the standard fitting methods are:
Interpolation
• The standard fitting method is faster when the data points are
sparse. However, our method becomes faster as the data points
become denser.
Approximation
• It is very difficult to fit a high quality surface to highly non-
uniform point clouds.
We provided an outline of the concept of our algorithm, and we
applied it to several cases. There are several possibilities for the
extension of our algorithm, a few of which are listed as follows:
708 Y. Kineri et al. / Computer-Aided Design 44 (2012) 697–708
• We plan to develop an acceleration method for surface approx-
imation.
• We would like to extend this surface interpolation method to a
point-tangent-curvature surface interpolation method.
• We plan to employ other parametrization methods, for exam-
ple, ‘‘meshless parametrization’’ by Floater and Reimers [31].
Acknowledgments
This work is supported by the Japan Society for the Promotion
of Science, Grants-in-Aid for Scientific Research under grant
number 20560127. Hongwei Lin is supported by Natural Science
Foundation of China (Nos. 60970150, 60933008), and Zhejiang
Provincial Natural Science Foundation of China (No. Y1090416).
The mannequin model is courtesy of Microsoft Research. The
crown molding model is courtesy of Laser Design, Inc and
the fuselage model is courtesy of Inria. We would like to
thank our former students Fumitaka Higuchi, Shuichi Gofuku,
Shigefumi Tamura, Kenichiro Machida, and Takahiko Rachi for
their discussions, and Dr. Chongyang Deng for his help in proving
the convergence.
References
[1] Piegl L, Tiller W. The NURBS book. 2nd ed. New York, Inc.: Springer-Verlag;
1997.
[2] Hoschek J, Lasser D. Fundamentals of computer aided geometric design.
Wellesley, MA: A.K. Peters; 1993.
[3] Alexa M, Behr J, Cohhen-Or D, Fleishman S, Levin D, Silva CT. Computing and
rendering point set surfaces. IEEE Transactions on Visualization and Computer
Graphics 2003;9(1):3–15.
[4] Hoschek J, Jüttler B. Techniques for fair and shape preserving surface
fitting with tensor-product B-splines. In: Shape preserving representations in
computer-aided geometric design. Nova Science Pub.; 1999. p. 163–85.
[5] Weiss V, Andor L, Renner G, Várady T. Advanced surface fitting techniques.
Computer Aided Geometric Design 2002;19(1):19–42.
[6] Yamaguchi F. A method of designing free form surfaces by computer display
(1st report). Precision Machinery 1977;43(2):168–73. [in Japanese].
[7] Yamaguchi F. Curves and surfaces in computer aided geometric design. NY:
Springer-Verlag; 1988.
[8] Böhm W, Farin G, Kahmann J. A survey of curve and surface methods in cagd.
Computer Aided Geometric Design 1984;1(1):1–60.
[9] Farin G. Curves and surfaces for computer aided geometric design: a practical
guide. 5th ed. Morgan Kaufmann; 2002.
[10] Lin H, Wang G, Dong C. Constructing iterative non-uniform B-spline curve and
surface to fit data points. Science in China 2004;47(3):315–31.
[11] Fan F, Cheng F, Lai S. Subdivision based interpolation with shape control.
Computer Aided Design and Application 2008;5(1–4):539–47.
[12] Maekawa T, Matsumoto Y, Namiki K. Interpolation by geometric algorithm.
Computer-Aided Design 2007;39(4):313–23.
[13] Nishiyama Y, Morioka M, Maekawa T. Loop subdivision surface fitting by
geometric algorithms. In: T Igarashi, N Max, and F Sillion, editors. Poster
proceedings of pacific graphics 2008. p. 67–74. 2008.
[14] Lin H. The convergence of the geometric interpolation algorithm. Computer-
Aided Design 2010;42(6):505–8.
[15] Gofuku S, Tamura S, Maekawa T. Point-tangent/point-normal b-spline curve
interpolation by geometric algorithms. Computer-Aided Design 2009;41(6):
412–22.
[16] Abbas A, Nasri A, Maekawa T. Generating B-spline curves with points, normals
and curvature constraints: a constructive approach. The Visual Computer
2010;26(6–8):823–9.
[17] Okaniwa S, Nasri A, Lin H, Abbas A, Kineri Y, Maekawa T. Uniform b-spline
curve interpolation with prescribed tangent and curvature vectors. IEEE
Transactions on Visualization and Computer Graphics, (in press).
[18] Patrikalakis NM, Maekawa T. Shape interrogation for computer aided design
and manufacturing. Heidelberg: Springer-Verlag; 2002.
[19] Botsch M, Bommes D, Kobbelt L. Efficient linear system solvers for mesh
processing, IMA Conference on the Mathematics of Surfaces. p. 62–83. 2005.
[20] Davis TA. Direct methods for sparse linear systems. Philadelphia: SIAM; 2006.
[21] Ma W, Kruth J. Parameterization of randomly measured points for leastsquares
fitting of b-spline curves and surfaces. Computer-Aided Design 1995;27(9):
663–75.
[22] Azariadis P. Parameterization of clouds of unorganized points using dynamic
base surfaces. Computer-Aided Design 2004;36(7):607–23.
[23] Dietz U. Fair surface reconstruction from point clouds. In: Proceedings of the
international conference on mathematical methods for curves and surfaces II.
p. 79–86. 1998.
[24] Press WH, Teukolsky SA, Vetterling WT, Flannery BP. Numerical recipes in C.
Cambridge University Press; 1988.
[25] Hu S-M, Wallner J. A second order algorithm for orthogonal projection onto
curves and surfaces. Computer Aided Geometric Design 2005;22(3):251–60.
[26] Zhu W, Ke Y. Reconstruction of symmetric b-spline curves and surfaces.
Chinese Journal of Mechanical Engineering 2007;20(4):112–6.
[27] Lu L. Weighted progressive iteration approximation and convergence analysis.
Computer Aided Geometric Design 2010;27(2):129–37.
[28] Hu S-M, Zhang H, Tai C-L, Sun J-G. Direct manipulation of FFD: efficient explicit
solutions and decomposible multiple point constraints. The Visual Computer
2001;17(6):370–9.
[29] Douglas DH, Peucker TK. Algorithms for the reduction of the number of points
required to represent a line or its caricature. The Canadian Cartographer 1973;
10(2):112–22.
[30] Lin H. An extended iterative format for the progressive-iteration. Computer
and Graphics 2011;35.
[31] Floater MS, Reimers M. Meshless parameterization and surface reconstruction.
Computer Aided Geometric Design 2001;18(2):77–92.
Yuki Kineri completed a BE in Mechanical Engineering at Yokohama National
University in 2011, and is currently working toward an MS degree. His research
interests include reverse engineering and aesthetic freeform surface design.
Mingsi Wang completed a BE in Mechanical Engineering at Dalian University of
Technology in 2008 and an MS in Mechanical Engineering at Yokohama National
University in 2011, respectively, and is currently working at YKK Corporation. His
research interests include geometric modeling, computer graphics, and reverse
engineering.
Hongwei Lin is an associate professor in State Key Laboratory of CAD&CG, Zhejiang
University, China. He received his B.Sc. degree from Department of Applied
Mathematics at Zhejiang University in 1996, and Ph.D. degree from Department
of Mathematics at Zhejiang University in 2004. He worked as a communication
engineer from 1996 to 1999. His current research interests are in computer aided
geometric design, computer graphics, and computer vision. He has published over
twenty papers on these areas.
Takashi Maekawa is a Professor of Mechanical engineering at Yokohama National
University since 2003. Before joining YNU he was a Principal Research Scientist at
MIT, a design engineer at Bridgestone Corporation. His research activities address
a wide range of problems related to geometric modeling, computational geometry,
differential geometry, and CAD/CAM. He received BS and MS degrees from Waseda
University, and a Ph.D. degree in Computer Aided Design and Manufacturing from
MIT.