BSPLND, A B-Spline N-Dimensional Package for Scattered Data Interpolation

Transcription

1 BSPLND, A B-Spline N-Dimensional Pakage for Sattered Data Interpolation Mihael P. Weis Traker Business Systems 85 Terminal Drive, Suite Rihland, WA mike@vidian.net Robert R. Lewis Washington State University, Shool of EECS 7 University Drive Rihland, WA bobl@triity.wsu.edu ABSTRACT The problem of sattered data interpolation is the fitting of a smooth surfae (or, more generally, a manifold) through a set of non-uniformly distributed data points that extends to all positions in a domain. Common soures of sattered data inlude experiments, physial measurements, and omputational values. Sattered data interpolation assists in interpreting suh data through the alulation of values at arbitrary positions in the domain. Despite muh attention in the literature, sattered data interpolation remains a diffiult and omputationally expensive problem to solve. BSPLND is a software pakage that solves this problem. It uses the sattered data interpolation tehnique presented in [] (hereafter, LWS). This tehnique is fast and produes a C -ontinuous interpolation funtion for any set of sattered data using a hierarhial set of ubi B-splines. BSPLND extends the tehnique to work with data having an arbitrary number of dimensions for both its domain and range. In this paper, we will set up the problem in the ontext of bivariate data in setion, and then refer you to [] for the details of the mathematial development. In setion, we extend the math to data having an arbitrary number of dimensions in both its domain and range. The design and implementation of BSPLND are presented in setions 4 and 5, respetively.. Problem Definition for Bivariate Data Let Ω = {(x, y) x < m, y < n} be a retangular domain in the xy-plane, and P = {(x, y, z )} be a set of sattered points in D spae. LWS define an approximation funtion f of this data as a uniform biubi B-spline funtion in terms of a ontrol lattie Φ overlaid on domain Ω. The ontrol lattie is a (m) (n) set of ontrol points that spans the integer grid in Ω. Restriting the ontrol points to integer values simplifies the math, without loss of generality. Figure, illustrates the relationship of Φ to Ω. Categories and Subjet Desriptors I..4 [Graphis Utilities], I..5 [Computational Geometry and Objet Modeling], G.. [Approximation], E. [Data Storage Representations]. General Terms Algorithms, Performane, Design. n n φ n y φ mn Φ Keywords Sattered data interpolation, multilevel B-splines, data approximation.. INTRODUCTION The sattered data interpolation tehnique presented by LWS is disussed in the ontext of bivariate data where the independent data is in D and the dependent data is a salar. LWS develop the multilevel B-spline approximation method and the simpler algorithm on whih it depends, the B-spline approximation method. The B-spline approximation method defines an approximation funtion for a set of sattered data in terms of uniform ubi B-spline basis funtions on its own merit, and the multilevel tehnique improves upon it. - - φ Ω m φ m m Figure. Control lattie onfiguration (from LWS). Let φ ij be the value of the ij-th ontrol point in lattie Φ, loated at (i, j) for i = -,,, m and j = -,,, n. The approximation funtion f is defined in terms of these ontrol points by f ( x, y) = B ( s) B ( t) φ, () k = l= k l ( i k )( j l ) x

2 where i = x, j = y, s = x x, and t = y y. B k and B l are uniform ubi B-spline funtions defined as B o ( t) =, ( t) / 6 B ( t) = (t 6t 4) / 6, B ( t) = ( t t t ) / 6, B ( t) = / 6, t where t <. These funtions serve as blending funtions, weighing the ontribution of eah ontrol point to f(x, y) based on its distane to (x, y). Note that as B-spline urves, they sum to a value of one at eah value of t. The problem of determining f then, is redued to solving for the ontrol points in Φ that best approximate the sattered data in P. We refer the reader to [] for the D mathematial development of alulating ontrol lattie Φ, whih defines an approximation funtion for fitting the sattered data. As mentioned in the introdution, LWS present two methods for its alulation, the B-spline approximation method, or BA algorithm, and its more apable desendant, the multilevel B-spline approximation method, or MBA algorithm. In the next setion, we extend their mathematial development to data in any number of dimensions.. Extending the Tehnique to Data of Arbitrary Dimensionality In handling sattered data having an arbitrary number of dimensions in both its domain and range, we denote the number of dimensions in the domain and range by D and R, respetively. Beause eah of the R data values in the range of a data point are independent of eah other, we an determine one approximation funtion in terms of the independent data for eah dimension of the range. Solving this problem then, an be redued to solving R approximation funtions with domain D and range R = and grouping the R funtions in some manner. The following is a derivation of the BA algorithm for a domain of dimension D and the range a salar.. The BA Algorithm The development is similar to the D ase. Let the domain be defined as Ω = {(x, x,, x D- ) x < m, x < m,, x D- < m D- } and the sattered data be defined as P = {( x,, x,,, x D-,, z )}. The ontrol lattie Φ overlaid on Ω is a (m ) (m ) (m D- ) set of ontrol points that spans the integer grid in Ω. Let φ be the i i i D- -th ontrol point in lattie Φ loated at (i, i,, i D- ) for i = -,,, m, i = -,,, m,, i D- = -,,, m D-. The approximation funtion is defined in terms of these ontrol points by f ( x, x,, x D ) = = k = k = k = k = k kd = kd = B ( t ) B D d = k ( t ) B Bk ( td ) φ d kd ( t D ) φ ( i k )( i k ) ( i k ) ( i k )( i k ) ( i k ) where i d = x d and t d = x d x d for d =,,, D- (one per dimension d of the domain). Eah of the B are uniform ubi B- spline funtions defined earlier, where eah of the D subsripts k d =,,,, and the D arguments t d range from zero to one: t d <. Thus k d in () we extend the tensor produt form of () to generate the funtion f for a D-dimension domain. Similar to the D ase, the problem of determining f is to solve for the ontrol points in Φ that best approximate the sattered data in P. To start, we onsider one data point in P, (x,, x,,, x D-,, z ) and its relationship to the 4 D ontrol points in its neighborhood. Assuming that x,, x,,, x D-, < as LWS do in the D ase, then ontrol points φ for k, k,, k D- =,,, determine the value of f kk k at (x,, x,,, x D-, ). For f to evaluate to z at (x,, x,,, x D-, ), the ontrol points φ must satisfy where kk k k = k = z = w φ, (a) D w = kk k Bk d ( t d d = kd = ) kk k D kk k D and t d = x d, for d =,,, D-. We onvert (a) to matrix notation, by defining olumn vetors W = [ w k, k,, k D- =,,, ] T and Φ = [ φ k, k,, kk kd k D- =,,, ] T : z W T =. (b) kk k Note that Equation () is a hyperplane in 4 D -spae in unknowns φ. Speifying the same minimization onstraint as LWS for kk k the D ase, that the sum of the squares of the 4 D variables φ (Φ T Φ) be minimized, amounts to loating the point on this kk k hyperplane that is losest to the origin. This onstraint is hosen to minimize the deviation of f from zero over the domain Ω. The parametri form of the line through the origin perpendiular to the hyperplane is given by = uw, (4) where W represents a normal vetor to the hyperplane and u is a salar. Substituting (4) into (b) yields z = uw T Next we onsider the effets of all the () data points in P on ontrol lattie Φ. For eah data point, (5) an be used to evaluate the 4 D ontrol points in its neighborhood. When the neighborhoods of two data points overlap, multiple assignments to a ontrol point our via (5). To resolve multiple assignments to a ontrol point, LWS onsider all the data points in its neighborhood, alling this set of data points its proximity data set. The proximity data set of the single ontrol point φ is given by P = {(x,,, x D-,, z ) P i x, < i W Solving for u and substituting into (4) gives the solution: z W =. (5) T W W Summarizing, the 4 D equations given by (5) are the solution to ontrol points φ in the viinity of data point (x,, x,,, x D-, ). kk k Therefore, by diret substitution of (5) into (b) we see that funtion f evaluates to z at data point (x,, x,,, x D-, ). Equation (5) is the general solution to the D ase presented in LWS, where there are 4 = 6 ontrol points in the viinity of any given data point. D

3 ,, i D- x D-, < i D- }. For eah data point in P, (5) gives the single ontrol point φ a different value φ : where w = w z φ =, (6) W T W D w = kk kd Bk d ( t d d = D ), and k d = i d ( x d, ) and t d = x d, x d, for d =,,, D-. To resolve multiple assignments to ontrol point φ, we follow LWS in their D approah by minimizing the error e( φ ) = Σ (w φ w φ ), where the term (w φ w φ ) is the differene between the real (w φ ) and expeted (w φ ) ontributions of φ to funtion f at (x,, x,,, x D-, ). Taking the derivative of approximation error e with respet to φ and equating the result to zero to find a minimum gives: wφ φ i i =. (7) D w Developing the pseudoode for the BA algorithm to handle an arbitrary number dimensions in the domain is a straightforward extension of the algorithm by LWS using the derivation given here. Reall that this derivation assumes that R =, and as suh the solution is applied one for eah dimension of the range of dimension R. This aspet of the algorithm shall be presented in Setion 4 in the disussion of BSPLND. Here is the BA algorithm extended to a D-dimensional domain. BA Algorithm (R = ) Input: sattered data P = {(x,, x,,, x D-,, z )} Output: ontrol lattie Φ = { φ } for all i, i,, i D- do let δ = and ω = D for eah point (x,, x,,, x D-,, z ) in P do for eah dimension d = to D- do let i d = x d, let t d = x d, x d, end w (W T W) end end ompute k = k = k = kk k for k, k,, k D- =,,, do ompute w, an element of W kk kd ompute φ, an element of Φ, using (5) kk k add w φ to δ )( ) ( ) kk k kk k ( i k i k i D kd add w to )( ) ( ) k k k D ω ( i k i k i D kd for all i, i,, i D- do if ω then end ompute φ = δ / ω, using (7) else let φ = D The BA algorithm has three major loops. In the first loop, the algorithm initializes the numerator and denominator of (7) for eah ontrol point in Φ. The seond loop visits eah data point, first alulating its effet on the 4 D ontrol points in its neighborhood with (5), and seond aumulating the numerator and denominator of (7). The third and final loop optimizes the multiple assignments to eah ontrol point by applying (7), if its partiular denominator is nonzero; otherwise it is assigned a value of zero.. The MBA Algorithm A tradeoff exists between the shape smoothness and the approximation auray of B-spline funtion f generated by the BA algorithm. LWS develop the multilevel B-spline approximation method, or MBA algorithm, to generate a funtion that is both smooth in shape and that losely approximates the data in P. This MBA algorithm generates a hierarhy of ontrol latties, eah via the BA algorithm, that represent a sequene of funtions, the sum of whih is the desired approximation funtion. The first funtion in the sequene is derived from a oarse lattie. The auray of this initial funtion on data in P is improved upon by subsequent funtions in the sequene derived from finer latties. Improving further upon this multilevel algorithm, LWS formulate a tehnique alled B-spline refinement to redue this sum of B-spline funtions into one equivalent B-spline funtion. We refer the reader to [] for the detailed development of the multilevel approah in D. However, we will briefly summarize the algorithm through the reprodution of a graphial illustration and the algorithm pseudoode from []. The MBA algorithm omes in two forms, eah generating the same approximation funtion f. The first form, the basi MBA, generates a hierarhy of oarse to fine ontrol latties Φ, Φ,, Φ h, overlaid on domain Ω and representing a sequene of funtions f k, the sum of whih is the desired result f. The oarsest lattie Φ is hosen to approximate the data in P via the BA algorithm. The differene between the data in P and the initial funtion f evaluated at the data in P (speifially, z - f (x,, x,,, x D-, )) serves as input to the next appliation of the BA algorithm to generate the next ontrol lattie Φ, hosen by LWS to be twie the size (or density). This proess ontinues for the alulation of subsequent latties, eah twie the size as the previous in the sequene, as appliations of the BA algorithm for the latties beyond Φ serve to remove the residual error. Figure a illustrates the basi MBA for the D ase.

4 ontrol lattie hierarhy (a) without B-spline refinement evaluate evaluate evaluate evaluate B-spline funtion sequene = approximation funtion f f f f f Φ Φ Φ Φ ontrol lattie hierarhy Ψ ( Φ ) = Ψ Ψ = (b) with B-spline refinement refine refine = refine = progressive ontrol latties evaluate approximation funtion f Ψ (Φ) Figure. Approximation funtion evaluation in the MBA algorithm (from LWS). Here is the algorithm for the basi MBA from LWS, modified for a domain of dimension D. Note that z = z. Basi MBA Algorithm (R = ) Input: sattered data P = {(x,, x,,, x D-,, z )} Output: ontrol lattie hierarhy Φ, Φ,, Φ h let k = while k h do let P k = {(x,, x,,, x D-,, k z ) ompute Φ k from P k by the BA algorithm ompute k z = k z - f k (x,, x,,, x D-, ) at eah data pt. let k = k end Notie that evaluating f requires (h) evaluations of a B-spline funtion by (), rather than a single evaluation afforded by the BA algorithm (exept when h=). To eliminate this extra overhead in omputation, whih an be signifiant if f is evaluated for a large number of points in Ω, LWS formulate a tehnique they all B-spline refinement, illustrated in Figure b. This tehnique will redue the (h) B-spline funtions into one equivalent B-spline funtion. This is the seond form of the MBA algorithm. The B-spline refinement tehnique is progressive in that it is applied at eah level in the ontrol lattie hierarhy. Figure b illustrates the proess desribed here. Let F(Φ) denote the B-spline funtion generated by ontrol lattie Φ and let Φ denote the lattie size of Φ. Starting with the initial ontrol lattie in the hierarhy Φ, a new ontrol lattie Φ an be derived through B-spline refinement suh that F(Φ ) = F(Φ ) = f and Φ = Φ. In other words, Φ an be derived whih defines an equivalent B-spline funtion to Φ, but whih has the size of the next lattie in the hierarhy Φ. Then the sum of funtions f f an be satisfied by a single lattie Ψ whih results from the sum of eah orresponding ontrol point in Φ and Φ. Referring to Figure b, we ontinue the progression at the next level with lattie Ψ, applying B-spline refinement to derive lattie Ψ suh that F(Ψ ) = F(Ψ ) and Ψ = Φ. The progression ends at the finest lattie in the hierarhy. Ψ Ψ Ψ The proess is generalized by the following pseudoode by LWS, modified for a domain of dimension D. In the algorithm, P F(Φ) represents the updated data {(x,, x,,, x D-,, k z )}, where P = {(x,, x,,, x D-,, k z )} and f k = F(Φ). MBA Algorithm (R = ) Input: sattered data P = {(x,, x,,, x D-,, z )} Output: ontrol lattie Ψ Let Φ be the oarsest lattie Let Ψ = while Φ does not exeed the finest ontrol lattie do ompute Φ from P by the BA algorithm ompute P = P - F(Φ) ompute Ψ = Ψ Φ let Φ be the next finer ontrol lattie in the hierarhy refine Ψ into Ψ whereby F(Ψ ) = F(Ψ) and Ψ = Φ end The B-spline refinement step, the last one in the loop, an be performed by a variety of methods as noted by LWS. For the D ase, LWS hoose to refine a (m ) (n ) ontrol lattie Φ into a (m ) (n ) lattie Φ whose ontrol point spaing is half as large as that of Φ. Then the refined lattie is the same size as the next lattie in the hierarhy and the sum of the two latties Ψ and Φ in the algorithm is a simple matter of summing their orresponding ontrol points. Letting φ ij and φ ij be the ij-th ontrol point in Φ and Φ, respetively, then the position of ontrol point φ i,j in Φ orresponds to ontrol point φ ij in Φ. LWS define the following relationships between the ontrol points in Φ and those in Φ: φ i, j = [ φi, j φi, j φi, j φi, j 6( φi, j φi, j φi, j φi, j ) 6φ ij ] 64 φ i, j = [ φi, j φi, j φi, j φi, j 6( φij φi, j 6 φ, j = [ φi, j φi, j φi, j φi, j 6( φij φi 6 i, j φ = [ φi, 4 i, j j φi, j φi, j φi, j Note there are four equations for the D ase. In general, there are D unique equations, eah relating a ontrol point in Φ to up to D ontrol points in Φ in its viinity. Notie that the fators that blend the ontrol points in Φ sum to one (for example, the four fators of ¼ in the last of the four equations given here). 4. BSPLND Design The BSPLND pakage implements the MBA algorithm, for data having an arbitrary number of dimensions in its domain and range. BSPLND provides its user with two options for alulating an approximation funtion via the MBA algorithm given a set of sattered data points bsplnd_fit and bsplnd_fittotol. Eah routine returns a data struture ontaining the ontrol lattie that defines the approximation funtion. The ontrol lattie in this form an then be passed to BSPLND s bsplnd_eval routine to evaluate the funtion at any independent data value, thereby implementing the D-dimensional form of the approximation funtion in (). Beause the data struture is alloated dynamially at run time, the pakage provides bsplnd_delete to free this memory. BSPLND provides the user with flexibility in its two separate implementations of the MBA algorithm. The routine bsplnd_fit ] )] )]

5 aepts as input the number of levels of B-spline refinement (defined by h - see the basi MBA), so that the user predetermines the size of the ontrol lattie hierarhy. When given h = for no refinement, bsplnd_fit implements the BA algorithm. The seond routine, bsplnd_fittotol aepts a tolerane, or measure of auray, that the approximation funtion must ahieve in its evaluation at the sattered data points. Therefore, this routine determines the number of levels of B-spline refinement required to ahieve this tolerane. The primary hallenge in implementing the MBA algorithm and the supporting routines suh as bsplnd_eval and bsplnd_delete, is the programming and data struture design required to handle data with an arbitrary number of dimensions in its domain and range. Beause BSPLND routines must aept the dimensionalities D and R of the domain and range as input in order to properly interpret the sattered data they reeive, the dimensions of an array to store the D- dimensional ontrol lattie annot be speified at ompile time, but rather must be determined at run time. The solution to this problem, along with other features of the design, shall be disussed in this setion. First we shall present the data struture design for storing the D-dimensional ontrol lattie and follow that disussion with the proedural design for aessing the struture. This will be aomplished through a set of proedures, or algorithms, that led to the implementation of the BSPLND routines mentioned above. We will start with the algorithm for bsplnd_eval, whih demonstrates read aess to the data struture. This algorithm assumes that the ontrol lattie has already been alulated. It is the simplest of the algorithm set and will help us introdue the more omplex multidimensional BA algorithm, whih will now be presented in the ontext of the ontrol lattie data struture. This algorithm demonstrates write aess to the data struture, for it alulates the ontrol lattie. We will follow this with the multidimensional algorithm for B-spline refinement, whih, given a ontrol lattie, generates a finer ontrol lattie defining the same approximation funtion. Then, we an use both the BA algorithm and the B-spline refinement algorithm to build the MBA algorithm, as illustrated in Figure b. This algorithm led to the implementation of BSPLND routine bsplnd_fit and, with slight modifiation, the routine bsplnd_fittotol. We name a BSPLND algorithm the same as its implemented ounterpart when the algorithm led diretly to the implementation. Whether referring to the algorithm, whih led to the implementation, or the implementation itself, should be obvious from the ontext. 4. Storage and Aess to the D-Dimensional Control Lattie In the following disussion about the ontrol lattie data struture we will frequently referene the BA algorithm rather than the MBA algorithm, beause the BA algorithm atually alulates the ontrol lattie. The MBA algorithm uses the BA algorithm to alulate the (h ) latties in the ontrol lattie hierarhy. The prinipal input to the BA algorithm is the set of sattered data points P and the prinipal output is a D-dimensional ontrol lattie Ψ overlaid on the domain Ω of the data. In order to properly interpret the sattered data the BA algorithm must also reeive the number of dimensions in the domain and range of the data, D and R, and the number of data points, p. One method for storing the sattered data in memory is with two separate data stores, a p D two-dimensional array for the independent data, and a p R two-dimensional array for the dependent data, where eah of the p rows in these orresponding arrays represent the absissa and ordinate of one data point, respetively. Let x = {(x,, x,,, x D-, )} and z = {( z,, z,,, z R-, )} denote these two data sets, where x and z are the domain and range of P, respetively. While the sattered data an onveniently be stored in a two-dimensional array struture as detailed here, storage for the output data, the ontrol lattie, requires a D-dimensional array, beause the lattie is overlaid on the domain Ω of the data, as illustrated in Figure. Herein lies the diffiulty in storing the lattie. Beause D is speified as input, the array dimensions annot be speified at ompile time, but must be determined when the implementation of the BA algorithm runs. A review of how a two-dimensional array may be aessed as a onedimensional array will provide some insight into solving the problem we fae in storing and aessing the data for the ontrol lattie. A aller of the BA algorithm an pass sattered data x and z (along with D, R, and p) as two-dimensional arrays. A oneptual view of x in memory as a two-dimensional array, where subsript varies over the p data points from to p -, is illustrated in Figure a. x,p- x,p- x D-,p- x, x, x D-, x, x, x D-, (a) two-dimensional array x, x, xd-, x, x, xd-, x,p- x,p- xd-,p- (b) one-dimensional array (two indies) x x x Dp- () one-dimensional array (one index) Figure. The independent data x in a two-dimensional array and orresponding one-dimensional array. In this figure, we use a Cartesian indexing sheme that is onsistent with the indexing used for ontrol points (see Figure ), where the first of the two indies is the fastest varying index, or subsript, indiating ontiguous memory loations. We shall ontinue with this onvention when introduing the multidimensional ontrol lattie shortly. This is ontrary to the C-onvention of indexing two-dimensional arrays where the seond index varies the fastest (row-major order). Either of these two onventions an be used in onverting a two-dimensional index into a one-dimensional index. From the aller s perspetive, passing x as a two-dimensional array makes the most sense, for this is how the data is logially organized. However, beause the two-dimensional array is stored in a ontiguous set of memory loations, the BA algorithm an aess the data as a one-dimensional array of p D elements, as illustrated in Figure b. Figure b is derived from Figure a by traversing the data in Figure a from left to right and bottom to top. As long as parameter x is passed to the BA algorithm as a pointer to the first data value x,, the algorithm an index it as a one dimensional array, using the following relationship: x i Dj = x i, j, (8) where i and j represent the two-dimensional array indies. Figure illustrates the one-dimensional indexing of array x. The BA algorithm aesses the sattered data in input x and z in this fashion. This gives the aller the freedom to pass x (and z) as a two-dimensional or a onedimensional array, as long as it passes the algorithm a pointer to the first element in the array (along with values for D, R, and p).

6 We an store the D-dimensional ontrol lattie in a one-dimensional array and aesses it in a similar manner. The array is alloated at run time with a apaity of (m ) (m ) (m D- ) R elements, one for eah ontrol point in the lattie. Reall that when R > we an alulate a separate lattie for eah dimension of the range under the assumption that R = for that partiular dimension. Taking this disussion in steps, we assume R = for now. Afterwards we shall elaborate on how the storage and aess of the lattie is affeted when R >. When R =, the one-dimensional array onsists of (m ) (m ) (m D- ) elements. To demonstrate, onsider a three dimensional domain (D = ). Figure 4 illustrates the three-dimensional view of the ontrol lattie using the Cartesian indexing sheme. φ,, M, M,, φ, M φ φ,, φ,, φ M,, S = M, M, M φ φ,, φ,, φ M,, S = S = M M φm, M, φ M,, φ,, φ,, φ,, φ,, φ M, M, M φ M,, M φ,, M φ,, M φ M,, M Figure 4. Three-dimensional ontrol lattie. Similar to the subsripting of independent data store x, we use zerobased indexing for the ontrol points and have simplified subsripting with a hange of variable, so that M d = m d, (9) for d =,,, D-. M d is the number of ontiguous ontrol points in dimension d of the domain. Similar to the two-dimensional example for independent data store x, the first dimension (d = ) is along the horizontal from left to right and represented by the first subsript, the seond (d = ) is along the vertial from bottom to top and represented by the seond subsript, and the third dimension (d = ) is into the page from front to bak and represented by the third subsript. The figure introdues the onept of the stride represented by variable S. The stride will provide the means of indexing the one-dimensional array in this example that is similar to the two-dimensional ase in (8). If all M M M elements in the three dimensional array were laid out end-to-end, then S d is the number of elements between two adjaent elements in dimension d. Figure 5 illustrates the one-dimensional array storage of the three-dimensional ontrol lattie and the stride S. S = S = M S = M M φ,, φ,, φ,, φ,, φ,,,, M M φ,, M φ M, M M φ,, φ, φ,, M φ M, M, M Notie how the stride maps from the three-dimensional view in Figure 4 to the one-dimensional view of the data in Figure 5a. We an speify the one-dimensional array index for the ontrol lattie, illustrated in Figure 5b, as a funtion of the three-dimensional array indies and the stride S as is js ks φ i, j, k φ =. () where S =, S = M, and S = M M from Figures 4 and 5. For example for ontrol point φ,,, the one-dimensional array index is S S S = M M M = M M. Explaining this result, we notie from Figure 4 that starting at the initial ontrol point φ,,, and traversing them from left to right, bottom to top, and front to bak in the order we would lay them out in one dimension, that ontrol point φ,, is the (M M )th ontrol point in the sequene. With zero-based indexing, the index to the orresponding one-dimensional array is M M, as alulated. We an extend this three-dimensional example to the general ase where the domain is of D dimensions. Notie that in this example that the stride is inreasing as the dimension of the data (d) inreases, as more elements must be skipped to reah the adjaent element in dimension d. We apply the pattern that develops in the threedimensional ase to D dimensions to define the stride reursively as S d = S d- M d-, () where S = and d =,,, D-. The one-dimensional array index is then a funtion of the D-dimensional indies and the stride: φ I S I S I φ S D D I d = d Sd = φ = φ I, I,, I I, I,, I, () where I d =,,, M d, and I d = i d for d =,,, D-. Reall that i d was used in the (-)-based indexing for the multidimensional ontrol lattie introdued in Setion.. Notie that (8) is the twodimensional appliation of the general ase. We now elaborate on the ase where R >. As we mentioned in Setion, when the range of the sattered data is a vetor (R > ), we solve R approximation funtions, one for eah dimension of the range, and group them in some manner. We an aommodate the R ontrol latties defining these R funtions by inreasing the ontrol lattie array from M M M D- elements to M M M D- R elements. In essene, eah ontrol point is an R-element vetor. Figure 6 illustrates a two-dimensional oneptual view of this storage, where the first array index is for the dimension of the range and the seond is the onedimensional index alulated with (), so that the R values for eah ontrol point vetor are adjaent in memory. (a) one-dimensional array (three indies) S = M S = M M S = φ φ φ φ M φ M M M M M φ φ M M M (b) one-dimensional array (one index) Figure 5. Storing the ontrol lattie in a one-dimensional array.

7 φ, M M M φ, M M M φ R, M M M D D φ, φ, φ R-, φ, φ, φ R-, D Figure 6. Two-dimensional view of omplete ontrol lattie. In this ase the two values of stride are S = and S = R. Aessing this as a one-dimensional array is straightforward from (8):, () φ = φ r jr r, j where r =,,, R- and j =,,, M M M D-. Thus, we index the ontrol lattie as a one-dimensional array with two steps: first by (), then by (). Combining the two relationships yields, φ. (4) r D [ I ] r, I, I, I D d Sd R d = = φ 4. BSPLND Algorithms 4.. Evaluation of the Approximation Funtion with bsplnd_eval The bsplnd_eval algorithm evaluates an approximation funtion defined by ontrol lattie Ψ at one position (x, x,, x D- ) in the domain Ω; in other words, it implements (). This algorithm shall demonstrate the proedural design for aessing the one-dimensional array of the D-dimensional ontrol lattie with (4). It assumes that the ontrol lattie has been alulated (for example, via the BA algorithm). First, we introdue the data struture of the objet that enapsulates the ontrol lattie data store and several other data elements. The additional data or fields of this struture inlude data required of the user of BSPLND to alulate the ontrol lattie (e.g., D and R) and alulated data (e.g., S) useful to several of the BSPLND algorithms. Rather than pass them as separate parameters or require their alulation in eah algorithm, they are pakaged into this one struture and the struture (or a pointer to it) is ommuniated as a whole. Table lists the data fields of this struture. Table. Data struture for storing ontrol lattie. Field Array Size Desription φ M[]M[] Number of ontrol points in M[D-]R ontrol lattie. S D The stride. D Salar No. of dimensions in the domain. R Salar No. of dimensions in the range. M D No. of ontrol points in one dimension of the domain. xmin, xmax slope, interept D, D D, D Lower and upper boundary values of the domain, one per dimension of the domain. Fields slope and interept represent a transformation funtion from the domain of the sattered data to the domain of the ontrol lattie. h Salar No. of levels of B-spline refinement used in alulating this ontrol lattie. Data fields D, R, S, and M maintain their definitions. Fields xmin and xmax are D-element arrays of real numbers that speify the lower and upper bound of the domain Ω in eah dimension d. Fields slope and interept are D-element arrays of real numbers that define a linear mapping funtion from domain Ω of the sattered data to the domain of the ontrol lattie. We define the domain of the ontrol lattie as follows. It is not reasonable that the BSPLND user be required to speify the domain Ω as defined in Setion., suh that the ontrol points span the integer grid in Ω. Therefore, we define the domain of the ontrol lattie to be one defined similar to the one in Setion. for Ω as {(x, x,, x D- ) x < M -, x < M,, x D- < M D- } and map domain Ω to it, so that (zero) orresponds to xmin[d] in Ω and M d- = M[d] orresponds to xmax[d] in Ω, for all d. We then an map any position (x, x,, x D- ) in the sattered data s domain Ω to this domain using fields slope and interept, and still use the development in Setion.. Field h of this data struture is the number of levels of B-spline refinement used to alulate this lattie. Finally, data field φ is a M[]M[] M[D-]Relement array of real numbers that are the ontrol points of the ontrol lattie, initially zero elements in size. All array sizes but that of array φ an be preset with some reasonable upper limit on D without onsuming too muh memory, but beause the apaity of φ an beome rather large in pratie and an vary widely, we dynamially alloate its storage prior to alulating it in the BA algorithm. Before listing the bsplnd_eval algorithm, we introdue three algorithms. The first alulates the stride S: al_stride(d, M, S{ }) S[] for d to D do S[d] S[d ] M[d ] 4 end The mapping funtion stored in fields slope and interept is alulated in the bsplnd_new algorithm. The bsplnd_new algorithm initializes the ontrol lattie objet Φ (Table ). It aepts D, R, M, xmin, and xmax as input (ultimately from the BSPLND user) and ontrol lattie objet Φ as output. It populates Φ, inluding fields slope and interept, for the BA algorithm before the BA alulates the ontrol lattie in field φ. We shall use it later. bsplnd_new(d, R, M, xmin, xmax, Φ{ })

8 Φ.D D Φ.R R Φ.h 4 for d to D do 5 Φ.M[d] M[d] 6 Φ.xMin[d] xmin[d] 7 Φ.xMax[d] xmax[d] 8 range xmax[d] xmin[d] 9 Φ.slope[d] (M[d] )/range Φ.interept[d] ((M[d] ) xmin[d])/range end al_stride(d, M, Φ.S) Calulate the apaity for field φ and alloate its memory 4 size M[D ] Φ.S[D ] R 5 Allo(Φ.φ, size) The BSPLND algorithms al_stride and bsplnd_new use a pseudoode that more losely resembles an atual programming language like C or Pasal than do the algorithms by LWS in previous setions. The BSPLND algorithms generally follow the pseudooding onventions in []. Note that an output parameter is indiated by { } in the formal parameter list of an algorithm, and an input/output parameter in indiated by { }. Absene of a symbol after the parameter denotes an input parameter. Also, for arrays in greater than one dimension, we use the C subsripting onvention of row-major order. Before listing the bsplnd_eval algorithm we present one more algorithm, alled eval_basis_funtions, whih evaluates the four uniform ubi B-spline funtions at a given value t. This algorithm is alled by bsplnd_eval. eval_basis_funtions(t, B{ }) a t b aa tt 4 d t 5 B[] ab/6 6 B[] d/ / 7 B[] -d/ / t/ /6 8 B[] d/6 After exeution of this algorithm, array B ontains the four B-spline funtion evaluated at t: B (t), B (t), B (t), and B (t). The four B-spline funtions are not readily reognizable in eval_basis_funtions, beause the algorithm alulates them with the minimum number of operations possible. We used the software appliation Mathematia [] to determine the quikest means of alulating these four funtions, beause this algorithm is alled D times for eah sattered data point input into the BA algorithm given later. We now list the bsplnd_eval algorithm, whih implements () by evaluating the approximation funtion stored in ontrol lattie objet Ψ at independent data stored in D-element array X. It returns the result in the R-element array Z. bsplnd_eval(ψ, X, Z{ }) Loate the independent data X relative to the ontrol lattie with the anhor index i[d] for eah dim. d of the domain and evaluate the four B-spline funtions for eah dim. d. 4 for d to Ψ.D do Loop # 5 Xmap Ψ.slope[d] X[d] Ψ.interept[d] 6 i[d] Xmap i d in () 7 t[d] Xmap Xmap t d in () 8 eval_basis_funtions(t[d], CubiBsplines[d]) 9 end Evaluate ontrol lattie for eah dim. r of the range. for r to Ψ.R - do Loop # Z[r] Calulate the sum of the 4 D terms in () s summation. 4 for TermCnt to ( << ( Ψ.D)) do Loop #. 5 IndexD 6 BsplineProd 7 For this term, generate unique ombination of k d; 8 al. B-spline fun. produt; aum; D index to Ψ.φ. 9 for d to Ψ.D do Loop #.. k[d] (TermCnt >> (d)) & x k d in () D Aumulate Bk ( t d ) in (). d d = BsplineProd BsplineProd CubiBsplines[d][k[d]] Aum. D index to Ψ.φ with (), assuming R=. 4 IndexD IndexD Ψ.S[d] ((i[d] ) k[d]) 5 end 6 Finish D index to Ψ.φ via (), to aount for dim. r. 7 IndexD r IndexD Ψ.R 8 Add urrent term to the summation. 9 Z[r] Z[r] BsplineProd Ψ.φ[IndexD] end end The algorithm for bsplnd_eval follows diretly from () and the mathematial development given here for aessing the D-dimensional ontrol lattie stored in a one-dimensional array. It may be helpful to the reader to refer bak to equation () at this point, as many of the terms in this equation are referened in walking through bsplnd_eval. The first loop of the algorithm alulates data to be used in the seond loop. First, it maps the independent data in X to the ontrol lattie domain. Using this result, it alulates the D-dimensional, (-)-based indies i d in array i, where eah i d is the first of the four ontrol point indies in dimension d that effet the value of the approximation funtion at X. Later, in Loop #, these partiipate in generating the one-dimensional array index to the ontrol lattie in Ψ.φ for aessing one ontrol point for one term in (). After alulating in array t the arguments t d to the four B-spline funtions, Loop # evaluates these funtions with a all to eval_basis_funtions. Upon ompletion of Loop #, the array CubiBsplines ontains 4D values as illustrated in Figure 7. We onserve exeution time by alulating the 4D unique evaluations of the B-spline funtions in the first loop and storing them in memory. If alulated in Loop # on an as needed basis, () requires D4 D evaluations of these funtions. d= B (t[]) B (t[]) B (t[]) B (t[]) d= B (t[]) B (t[]) B (t[]) B (t[]) d=d- B (t[d-] ) B (t[d-]) B (t[d-]) B (t[d-]) Figure 7. The populated CubiBsplines array at the onlusion of Loop # in bsplnd_eval. The seond loop aumulates the 4 D terms of the summation in () for eah dimension of the range independently, aessing the appropriate 4 D ontrol point elements in array Ψ.φ. As noted earlier, there is a

9 d = Bk d t d separate set of M[]M[] M[D-] ontrol points in Ψ.φ for eah dimension r of the range. When Loop # ompletes it has stored the R separate evaluations in output array Z. Nested Loop #. alulates the summation for dimension r of the range; therefore, eah pass through this loop generates one term in the summation of (). Key to the algorithm, nested Loop #.. generates a unique ombination of the summation variables k d in array k (one per dimension d, where k d =,,, or ) as a funtion of the loop iteration variable TermCnt. The summation variables k d index the B-spline funtions in the B-spline D funtion produt ( ) of (), and assist in indexing the onedimensional ontrol lattie array Ψ.φ. At the onlusion of D Loop #.. then, we have alulated ( ) for one term in the d = Bk d t d summation, and indexed the one-dimensional array Ψ.φ with (). This indexing, whih ours in line 4, inrements the array element i[d] by one to onvert to zero-based indexing. Then in line 7, the algorithm ompletes the indexing of the one-dimensional ontrol lattie, taking into aount the orret dimension of the range with (). Finally, in line 9, the algorithm adds the urrent term to the aumulating sum in Z for the urrent dimension of the range. 4.. The BSPLND BA Algorithm: bsplnd_fitul In this setion we present BSPLND s multidimensional BA algorithm. This algorithm and BSPLND s B-spline refinement algorithm in the next setion are the basi building bloks of BSPLND s MBA algorithm, whih will omplete the algorithm set. The name of the BSPLND version of the BA algorithm is bsplnd_fitul. (The UL stands for uni-level as the BA algorithm is used to alulate a ontrol lattie at one level in the ontrol lattie hierarhy in the MBA algorithm.) The bsplnd_fitul algorithm, listed below, aepts sattered data in parameters x and z, where x is an array of the independent data and z is an array of the dependent data. Given input parameters D and R for the domain and range, respetively, and p for the number of sattered data points, the algorithm assumes that x is a (p D)-element array and that z is a (p R)-element array. Furthermore, it assumes the D omponents of eah data point s independent data are stored in ontiguous memory loations, as well as the R omponents of eah data point s dependent data. The boundaries of the sattered data domain Ω are passed to bsplnd_fitul in parameters xmin and xmax, D-element arrays, so that it an properly map the independent data to the ontrol lattie domain defined by input parameter M, also a D- element array. Input parameter return_dz is a boolean variable whih if true will ause bsplnd_fitul to alulate the deviation of the alulated approximation funtion from the data points, overwriting the range of the data points in input/output parameter z. This feature will be useful to the MBA algorithm in alulating the ontrol lattie hierarhy. The sole output parameter Φ represents the ontrol lattie objet. The algorithm assumes the objet ontains no meaningful data, inluding a zero-element ontrol lattie array in data field Ψ.φ. Thus, bsplnd_fitul will determine the ontrol lattie s size and alloate the memory for it. bsplnd_fitul(p, D, x, R, z{ }, return_dz, M, xmin, xmax, Φ{ }) Populate ontrol lattie objet bsplnd_new(d, R, M, xmin, xmax, Φ) Calulate size of ontrol lattie array and alloate size elements 4 for numerator δ and denominator ω of (7) 5 size M[D ] Φ.S[D ] R 6 Allo(δ, size) 7 Allo(ω, size) 8 for j to size do Loop # 9 δ[j] ω[j] For eah data point, alulate its effet on the 4 D ontrol points nearby (atually, one set of 4 D points per dimension of range). for to p do Loop # Loate data point relative to the D-dim. ontrol lattie by 4 alg. the anhor index i[d] for eah dim. d of the domain; 5 Evaluate the four B-spline funtions for eah dimension d. 6 for d to D do Loop #. 7 Xmap Φ.slope[d] x[d D] Φ.interept[d] 8 i[d] Xmap 9 t[d] Xmap Xmap eval_basis_funtions(t[d], CubiBsplines[d]) end Calulate the SS of the 4 D B-spline produts, W T W in (6). BsplineProdSumSqrs 4 for TermCnt to ( << (D)) do Loop #. 5 BsplineProd 6 for d to D do Loop #.. 7 k[d] (TermCnt >> (d)) & x 8 BsplineProd BsplineProd CubiBsplines[d][k[d]] 9 end BsplineProdSumSqrs BsplineProdSumSqrs BsplineProd BsplineProd end Calulate a ontrol lattie for eah dimension r of the range for r to R - do Loop #. 4 Aum. effet of data point on the 4 D ntrl. Pts. nearby for 5 dim. r of range, using the results from Loops #. and #. 6 for TermCnt to ( << (D)) do Loop #.. 7 IndexD 8 BsplineProd 9 Gen. B-spline produt (w in (6)); al. D array 4 index to Φ.φ independent of r (using i from Loop #.) 4 for d to D do Loop #... 4 k[d] (TermCnt >> (d)) & x 4 BsplineProd BsplineProd CubiBsplines[d][k[d]] 44 IndexD IndexD Φ.S[d] ((i[d] ) k[d]) 45 end 46 Complete D index to Φ.φ, aounting for dim. r of range 47 IndexD r IndexD R 48 Calulate data point s effet on one ontrol point with (6) 49 phi_ (BsplineProd z[r R])/BsplineProdSumSqrs 5 Indexing this one ontrol point, aumulate the 5 numerator and denominator of (7) 5 δ[indexd] δ[indexd] BsplineProd BsplineProd phi_ 5 ω[indexd] ω[indexd] BsplineProd BsplineProd 54 end end for eah ontrol point in the viinity of data point 55 end end for eah dimension r of range 56 end end for eah data point 57 Calulate the ontrol lattie using (7) 58 for j to size do Loop # 59 if ω[j] <> then 6 Φ.φ[j] δ[j]/ω [j] 6 else 6 Φ.φ[j] 6 end 64 Return the deviation of the approx. funtion defined by the lattie 65 from the sattered data points, storing in i/o parameter z. 66 if return_dz then 67 for to p do Loop #4

10 68 bsplnd_eval(φ, Addr(x[D]), Z) 69 for r to R - do Loop #4. 7 z[r R] z[r R] Z[r] 7 end 7 Cleanup 7 Free(δ) 74 Free(ω) A walk through the ode of bsplnd_fitul reveals that the BSPLND version of the BA algorithm losely follows the logi of the extended BA algorithm from Setion.. This version however, brings the BA algorithm loser to implementation as it onsiders the data store for the D-dimensional ontrol lattie and it aounts for multiple dimensions in the range of the sattered data. The algorithm first performs some setup by initializing the ontrol lattie objet in parameter Φ with a all to bsplnd_new. It then alloates storage, one element per ontrol point, for loal arrays δ and ω for aumulating the numerator and denominator of (7) for eah ontrol point. After this setup, the algorithm alulates the ontribution of eah data point to the 4 D ontrol points in its viinity, storing its ontribution in the appropriate 4 D elements of δ and ω. This is atually done for eah dimension of the range independently, so that one data point effets 4 D R elements of δ and ω. After eah data point has been visited, the algorithm alulates eah ontrol point by dividing ω into δ element by element for a nonzero denominator or sets the ontrol point to zero otherwise. A ontrol point in the latter ategory does not have any data points in its proximity data set. Finally, the algorithm alulates the deviation of the alulated approximation funtion from the data points, if so requested. In essene, bsplnd_fitul alulates R separate ontrol latties in parallel, the algorithm viewing eah omponent of the range as a separate salar range (R = ) applied against the full domain of the data. Control lattie objet Φ has been designed to aommodate them, and the algorithm is oded to store them in Φ separate from eah other. 4.. The BSPLND B-spline Refinement Algorithm: bsplnd_refine In this setion we present BSPLND s multidimensional B-spline refinement algorithm, the seond basi building blok of BSPLND s MBA algorithm. The name of the algorithm, listed below, is bsplnd_refine. The bsplnd_refine algorithm aepts a ontrol lattie Ψ that has already been alulated, and alulates a finer lattie defining an equivalent approximation funtion, returning it in output parameter Ψ. bsplnd_refine(ψ, Ψ { }) D Ψ.D R Ψ.R Alloate memory for oarse lattie indies that will ontribute 4 to eah ontrol point in the fine lattie and memory for weights. 5 apaity 6 for d to D do Loop # 7 apaity apaity 8 M_tmp[d] Ψ.M[d] refined lattie to be twie as fine 9 end Allo(CoarseIdxs, apaity) Allo(Weights, apaity) Populate refined lattie to be twie as fine as the oarse bsplnd_new(d, R, M_tmp, Ψ.xMin, Ψ.xMax, Ψ ) 4 size Ψ.M[D ] Ψ.S[D ] Assume R= 5 Cal. the fine lattie, one ontrol point at a time. Assume R=. 6 for j to size do Loop # 7 Resolve the D index j into its D-dimensional indies 8 rem j 9 for d D downto do Loop #. FineIdxs[d] (rem div Ψ.S[d]) (-)-based indexing rem rem mod Ψ.S[d] end Calulate the D array indies of the oarse lattie Ψ and their 4 weights that ontribute to the urrent ontrol point j in the 5 refined lattie Ψ. To do so, use the D-dimensional indies of 6 ontrol pt. j to loate the related D-dimensional indies in the 7 oarse lattie and onvert these bak to a D index. 8 CoarseIdxs[] 9 Weights[]. NumWgts for d to D do Loop #. odd index if FineIdxs[d] & x <> then begin 4 MinIdx (FineIdxs[d] )/ -based indexing 5 for i NumWgts downto do Loop #.. 6 CoarseIdxs[i ] CoarseIdxs[i] (MinIdx ) Ψ.S[d] 7 CoarseIdxs[i] CoarseIdxs[i] (MinIdx) Ψ.S[d] 8 Weights [i ] Weights [i] (.5) 9 Weights [i] Weights [i] (.5) 4 end 4 NumWgts NumWgts 4 end 4 even index 44 else begin 45 MinIdx (FineIdxs[d]/ ) -based indexing 46 for i NumWgts downto do Loop #.. 47 CoarseIdxs[i ] CoarseIdxs[i] (MinIdx ) Ψ.S[d] 48 CoarseIdxs[i ] CoarseIdxs[i] (MinIdx ) Ψ.S[d] 49 CoarseIdxs[i] CoarseIdxs[i] (MinIdx) Ψ.S[d] 5 Weights[i ] Weights[i] (.5) 5 Weights[i ] Weights[i] (.75) 5 Weights[i] Weights[i] (.5) 5 end 54 NumWgts NumWgts 55 end 56 end end for dimension of the domain 57 Calulate the ontrol points. Aount for R>, so that we are 58 omputing eah of the R latties in Ψ in parallel. 59 for r to R - do Loop #. 6 Ψ.φ[r jr] 6 for r to R - do Loop #.4 6 for i to NumWgts do 6 Ψ.φ[r jr] Ψ.φ[r jr] Ψ.φ[r CoarseIdxs[i] R] Weights[i] 64 end The algorithm first performs some setup by populating Ψ with a all to bsplnd_new. This lattie will have the same values as Ψ for data fields D, R, xmin, and xmax beause the domain and range do not hange; however, it will have different values in fields M, S, slope, and interept whih are dependent on the size of the lattie. The setup proess also inludes memory alloation for the D ontrol points in oarse lattie Ψ that eah ontrol point in refined lattie Ψ an

11 potentially relate to (in the D ase there are nine), and the orresponding weights that will blend these ontrol points into the one. Then in line 4, it alulates the number of ontrol points to alulate in Ψ, assuming R=. After the setup, the algorithm fills these two data stores CoarseIdxs and Weights for eah ontrol point it must alulate in Ψ. This ours in the Loop #, where the one-dimensional index for the urrent ontrol point in Ψ is given by loop ounter j. In Loop #., the one dimensional index j is resolved into its (-)-based D-dimensional indies and stored in FineIdxs. Reall that this is the indexing sheme presented by LWS in Figure. Then in Loop #., the two arrays CoarseIdxs and Weights are alulated solely as a funtion of these D indies (in FineIdxs). Finally, in Loops #. and #.4, the ontrol points in Ψ (CoarseIdxs) that ontribute to the value of ontrol point j in Ψ are blended (via Weights) to give its value. Beause the alulation of CoarseIdxs and Weights is stritly a funtion of the geometri position of ontrol point j in the fine lattie, here we an perform this alulation for eah dimension r of the range, independently The BSPLND MBA Algorithm: bsplnd_fit In this setion we present BSPLND s multidimensional MBA algorithm to omplete the algorithm set. It is built from the BA algorithm bsplnd_fitul and the B-spline refinement algorithm bsplnd_refine. It is the predeessor to the BSPLND pakage s bsplnd_fit routine. After presenting this algorithm we ll disuss how to modify it to be tolerane-based, alulating the levels of B-spline refinement required to ahieve a given level of auray in the approximation funtion. The bsplnd_fit algorithm follows the logi displayed in Figure b, the LWS diagram for the MBA. Before listing it however, we list three short algorithms that it alls that orrespond to this figure niely. The first, bsplnd_finer, alulates the next finer lattie Φ k in the ontrol lattie hierarhy (see Figure b) given the urrent lattie Φ k and the urrent deviation of the hierarhy from the sattered data. It also alulates the new deviation from the data of the now extended hierarhy, to be fed into a subsequent all to bsplnd_finer. The algorithm bsplnd_add alulates a lattie as the sum of two equally sized latties defined on the same domain of the sattered data (see Figure b). Finally, the algorithm bsplnd_delete frees the memory dynamially alloated in data field φ of the ontrol lattie objet, allowing bsplnd_fit to reuse memory used by previous levels in the hierarhy as the algorithm progresses. bsplnd_finer(φ, p, x, dz{ }, Φ_next{ }). Next lattie in hierarhy is to be twie as fine.. for d to Φ.D do. M_tmp[d] Φ.M[d] 4. Calulate next lattie in hierarhy and return deviation in dz 5. bsplnd_fitul(p, Φ.D, x, Φ.R, dz, TRUE, M_tmp, Φ.xMin, Φ.xMax, Φ_next) bsplnd_add(φ, Φ, Φ_sum{ }). Populate sum.. bsplnd_new(φ.d, Φ.R, Φ.M, Φ.xMin, Φ.xMax, Φ_sum). Sum orresponding ontrol points. 4. size Φ.M[Φ.D ] Φ.S[Φ.D ] Φ.R 5. for i to size do 6. Φ_sum.φ[i] Φ.φ[i] Φ.φ[i] bsplnd_delete(φ{ }). if Φ.φ <> NIL then. Free(Φ.φ) The listing for bsplnd_fit follows. Notie that the parameter list mathes the BA algorithm bsplnd_fitul, exept that the dependent data is stritly an input parameter (z), and the addition of parameter h, the number of levels of B-spline refinement. Indeed, when h = bsplnd_fit redues to bsplnd_fitul. Sine bsplnd_fit is a publi routine in implementation (as opposed to bsplnd_fitul) we don t edit the user s data. Note that in returned lattie Ψ, data field M is not the same as input parameter M. Eah level in the hierarhy above level zero doubles the lattie size in the all to bsplnd_finer. The algorithm diretly maps to Figure b. bsplnd_fit(p, D, x, R, z, M, xmin, xmax, h, Ψ{ }) urrent lattie in hierarhy: Φ urrent unrefined lattie: Ψ urrent refined lattie: Ψ 4 Ψ.φ NIL initialize; important for memory reuse 5 Storage for the delta of the lattie from the sattered data points. 6 Start with the data itself. 7 Allo(dz, pr) 8 for to p do Loop # 9 for r to R - do Loop #. dz[r R] z[r R] Calulate one ontrol lattie Ψ = to the ontrol lattie hierarhy for k to h do Loop # AtFirstLevel (k = ) 4 if Ψ.φ <> NIL then 5 bsplnd_delete(ψ) memory reuse 6 Ψ = Φ Ψ (Figure 7b) 7 if AtFirstLevel then 8 bsplnd_fitul(p, D, x, R, dz, TRUE, M, xmin, xmax, Ψ) 9 else bsplnd_add(φ, Ψ, Ψ) AtLastLevel (k = h) if not AtLastLevel then bsplnd_delete(ψ ) memory reuse 4 Refine Ψ into Ψ (Figure b) 5 bsplnd_refine(ψ, Ψ ) 6 Next finer Φ in hierarhy from urrent deviation (Figure b) 7 if AtFirstLevel then 8 bsplnd_finer(ψ, p, x, dz, Φ) 9 else bsplnd_finer(φ, p, x, dz, Φ) end