Overlapping Tensor-Product Free-Knot B-Spline Patches

• Overlapping tensor-product free-knot B-spline patches are a family of spline constructions that use additive patch superposition and localized knot optimization to achieve adaptive geometric flexibility.
• They employ various overlap mechanisms, including coefficient blending and partition-of-unity chart blending, to ensure smooth transitions and efficient local approximations.
• Such constructions enable energy-based variational optimization that yields significant computational gains in handling localized features compared to uniform mesh discretizations.

Searching arXiv for recent and foundational papers on overlapping tensor-product free-knot B-spline patches and closely related constructions. Overlapping tensor-product free-knot B-spline patches are a class of spline-based approximation constructions in which the global trial or surface representation is assembled from multiple local tensor-product spline patches whose supports may overlap spatially, while some aspect of the knot structure is chosen locally rather than by a single globally coordinated tensor-product grid. Across the literature, the phrase does not denote a single standardized formalism. Instead, it spans several distinct mechanisms: additive superposition of independently parameterized patchwise spline expansions with knots treated as nonlinear parameters (Magueresse et al., 25 Aug 2025); overlapping local fitting neighborhoods whose local tensor-product spline coefficients are blended into a single global control mesh rather than retained as separate overlapping patches (Tekumalla et al., 2014); chart-based partition-of-unity constructions that blend local polynomial or spline approximants over overlapping charts and reproduce B-splines in regular regions (Zhang et al., 2019); and local geometric-continuity patch systems that avoid global knot coordination without constituting a free-knot B-spline basis in the classical sense (Karciauskas et al., 2016). The most precise contemporary use of the phrase is the nonlinear variational setting of energy minimization with a global ansatz formed as a sum of overlapping tensor-product free-knot B-spline patches, where knot positions act as optimization variables (Magueresse et al., 25 Aug 2025).

1. Terminological scope and conceptual variants

The expression combines four ideas that the literature treats with different levels of strictness: tensor-product, meaning multivariate bases built from univariate spline factors; patches, meaning local spline blocks rather than one single global grid; overlapping, meaning either overlapping supports, overlapping fitting neighborhoods, or overlapping chart domains; and free-knot, meaning that knot positions are not fixed a priori but become local design parameters or optimization variables.

In the strictest sense currently documented, the construction consists of several tensor-product spline patches placed on the physical domain, with the global discrete function formed as a sum of patchwise spline functions, and the knot vectors treated as nonlinear parameters controlling the geometry of the discretization (Magueresse et al., 25 Aug 2025). In that setting, overlap is literal and persistent in the final representation: several local tensor-product spline systems can cover the same region of the domain, and their contributions are superposed additively.

A broader and older nearby class uses local tensor-product B-spline fits on overlapping neighborhoods but does not retain the final model as overlapping patches. The paper on reverse engineering point clouds constructs local tensor-product cubic B-spline fits on neighboring subdomains and then averages corresponding coefficients into one global tensor-product surface. It therefore uses overlap at the level of data neighborhoods and local fitting, not as an explicit final representation of overlapping patches (Tekumalla et al., 2014).

A different nearby class replaces patch overlap by overlapping manifold charts. There, the global field is a weighted sum of local approximants defined on overlapping chart domains, and exact B-spline reproduction is obtained on structured regions. This provides an overlapping-patch architecture in the partition-of-unity sense, but not free-knot optimization (Zhang et al., 2019).

Another related branch avoids global knot coordination around T-junctions by using geometrically continuous tensor-product polynomial patches with local reparameterizations. These constructions are “B-spline-like” and local, but they are not free-knot B-splines and do not rely on overlapping basis support in the standard spline-space sense (Karciauskas et al., 2016).

A plausible implication is that the topic is best understood as a family of local tensor-product spline technologies rather than a single spline space. The decisive distinctions are whether overlap persists in the final representation, whether knots are optimized continuously or only adapted discretely, and whether inter-patch coupling is additive, variational, partition-of-unity-based, or geometric-continuity-based.

2. Patchwise tensor-product structure and global assembly

The modern nonlinear approximation formulation uses a patchwise sum space. If $r$ denotes the number of patches, each patch has its own degree vector, knot counts, knot vectors, and coefficient block, and the global trial function is the sum of all patch contributions (Magueresse et al., 25 Aug 2025). For a given knot configuration $T$, the corresponding patchwise sum space is

$$S_{N,P}(T) \doteq \bigoplus_{s = 1}^{r} S_{N_s,P_s}(T_s).$$

The family of all such spaces obtained by varying the knots is

$$S_{N,P} \doteq \left\{ S_{N,P}(T),\ T \in K_N \right\}.$$

Its realization map is defined by

$$R_{N,P}(W, T) = \sum_{s = 1}^{r} \sum_{i = 1}^{N_s - (P_s + 1)} W_{s,i}\, B_{i,N_s}(T_s),$$

so the approximation is linear in the coefficients $W$ and nonlinear in the knot positions $T$ (Magueresse et al., 25 Aug 2025). This gives the most direct meaning of “overlapping tensor-product free-knot B-spline patches”: each patch is itself a tensor-product spline space over an axis-aligned rectangular grid whose lines can move, and several such patches may overlap in the same region.

The tensor-product structure itself is standard. For multivariate knot vectors $T=(T_1,\ldots,T_d)$, the basis takes the form

$$B_{i,p}(T)(x) \doteq \prod_{t=1}^{d} B_{i_t,p_t}(T_t)(x_t),$$

and the associated spline space is

$$S_{n,p}(T) \doteq \bigotimes_{t=1}^{d} S_{n_t,p_t}(T_t) = \mathrm{Span}\left( B_{i,p}(T)\right)$$

with compact rectangular support (Magueresse et al., 25 Aug 2025). The essential departure from ordinary tensor-product discretizations is therefore not the basis formula, but the fact that the global approximation is built from several such tensor-product blocks whose knots are chosen patchwise.

Not all overlapping tensor-product constructions use additive patch superposition. In the point-cloud reverse-engineering framework, a local patch uses the tensor-product cubic B-spline basis functions nonzero on the current knot rectangle, yielding $T$0 coefficients interpreted as the 16 control points of a local patch, but the final object is one global cubic tensor-product B-spline surface after coefficient averaging (Tekumalla et al., 2014). In the manifold-based setting, the global approximant is instead

$T$1

with a partition of unity over overlapping charts (Zhang et al., 2019). These alternatives show that “overlap” may refer to additive superposition of patches, coefficient-space blending of local fits, or partition-of-unity blending of local chart functions.

This suggests a useful taxonomy. One can distinguish additive-overlap models in which patch contributions are summed in the final ansatz (Magueresse et al., 25 Aug 2025); coefficient-blending models in which local tensor-product estimates are merged into one global control mesh (Tekumalla et al., 2014); and chart-blending models in which local approximants are combined by weights summing to one over overlapping parameter domains (Zhang et al., 2019).

3. Free-knot versus adaptive-knot interpretations

The most important conceptual ambiguity concerns the word free-knot. In the strict approximation-theoretic sense, free-knot means that knot positions are treated as optimization variables and are jointly adapted with the spline coefficients. The 2025 energy-minimization formulation is explicit on this point: it studies a nonlinear approximation scheme “based on overlapping tensor-product free-knot B-spline patches, where knot positions act as nonlinear parameters controlling the geometry of the discretisation” (Magueresse et al., 25 Aug 2025). The method performs direct energy minimization over both coefficients and mesh geometry, with the discrete energy

$T$2

This is the clearest example of true free-knot behavior among the papers considered.

By contrast, several related constructions are only adaptive in a weaker sense. The reverse-engineering framework uses an automated knot placement strategy based on recursive subdivision of the parameter domain, stopping when local cubic polynomial fitting error falls below a threshold or a maximum recursion depth is reached. Knot positions are therefore data-adaptive, but there is no continuous optimization over knot locations and no joint nonlinear solve over knots and coefficients (Tekumalla et al., 2014). The same paper explicitly distinguishes this from free-knot methods cited in its related work.

The adaptive Lagrangian point-cloud evolution framework is also not a classical free-knot method. It uses local tensor-product B-spline patches with open uniform basis functions initially, and adaptivity is introduced through local knot insertion triggered by a Greville-based deviation indicator: $T$3 If this exceeds a tolerance, new knots are inserted at the parameter location of maximal deviation (Ammad et al., 16 Jan 2026). This is local adaptive refinement, not free-knot optimization.

A further distinct use of local knot flexibility appears in GT-splines with T-junctions. There, the authors emphasize that the construction “do[es] not require a global coordination of knot intervals,” but the method avoids the global knot problem by geometric $T$4 continuity and reparameterization of tensor-product polynomial patches over unit domains, not by free-knot B-spline spaces (Karciauskas et al., 2016). Similarly, domain-fitted diversified non-uniform B-splines use arbitrary non-uniform knot sequences and local condensation to derive effective local knot vectors, but do not optimize knots as unknowns (Sissouno, 2016).

Accordingly, the literature supports three distinct categories. True free-knot optimization treats knot locations as nonlinear design variables (Magueresse et al., 25 Aug 2025). Adaptive knot placement derives knot vectors by subdivision, insertion, or condensation (Tekumalla et al., 2014, Ammad et al., 16 Jan 2026, Sissouno, 2016). Knot-free geometric substitutes avoid global knot coordination through reparameterized patch constructions rather than explicit local knot optimization (Karciauskas et al., 2016).

4. Overlap mechanisms: additive superposition, weighted neighborhoods, and partition of unity

Overlap is equally non-unique across the literature. In the nonlinear variational patch-sum formulation, overlap is literal: several patches may occupy the same region of the domain and their contributions are summed. This is precisely why the method can emulate non-truncated hierarchical B-spline methods while retaining more geometric freedom, since several patches can be moved and compressed around localized features independently (Magueresse et al., 25 Aug 2025).

In the reverse-engineering setting, overlap is introduced at the level of the data used for each local fit. For a patch $T$5, the local least-squares fit uses not only points inside the current interval but also neighboring intervals through a windowing function centered on the patch midpoint: $T$6 For surfaces, the same idea is extended by using the 16 active tensor-product cubic basis functions on a knot rectangle and a tensor-product window built from the univariate windows (Tekumalla et al., 2014). The paper states: “To fit each individual patch, we consider points from the patch under consideration and the adjoining patches to get a smooth blend.” The final surface, however, is not evaluated as a partition-of-unity sum of local patches; local coefficients are averaged into one global tensor-product control mesh.

In manifold-based B-splines on unstructured meshes, overlap is chart-based. The manifold is covered by overlapping subdomains

$T$7

and the blending functions satisfy

$T$8

The global basis is

$T$9

and the global approximant is a weighted blend of chart-local approximants over overlaps (Zhang et al., 2019). Here overlap is not a by-product of fitting neighborhoods but a defining feature of the representation.

Overlap may also be induced by geometric visibility. In stabilized Stokes discretizations on overlapping NURBS patches, the geometry is obtained via overlapping patches in a predefined hierarchical order, and the visible parts of lower patches are trimmed by higher-priority patches (Wei et al., 2023). This is a PDE discretization framework rather than a free-knot approximation scheme, but it is a genuine overlapping tensor-product patch construction. A plausible implication is that overlapping tensor-product patches can be used either as a nonlinear approximation manifold for adapting to solution features (Magueresse et al., 25 Aug 2025) or as an embedded geometric decomposition for PDEs on composite spline domains (Wei et al., 2023).

These mechanisms should not be conflated. Additive overlap retains all overlapping patch contributions in the final function (Magueresse et al., 25 Aug 2025). Neighborhood overlap uses nearby data to stabilize local fitting but collapses the result into one global spline (Tekumalla et al., 2014). Partition-of-unity overlap blends chart-local functions at evaluation time (Zhang et al., 2019). Visibility-based overlap uses trimming and weak coupling on independent patches (Wei et al., 2023).

5. Continuity, coupling, and smoothness across patches

Continuity properties depend entirely on the chosen overlap mechanism. In additive patch-sum free-knot models, the global approximation is simply the sum of patchwise spline functions, so $$S_{N,P}(T) \doteq \bigoplus_{s = 1}^{r} S_{N_s,P_s}(T_s).$$0-conformity follows whenever the minimum patch degree is at least one: “$$S_{N,P}(T) \doteq \bigoplus_{s = 1}^{r} S_{N_s,P_s}(T_s).$$1 is $$S_{N,P}(T) \doteq \bigoplus_{s = 1}^{r} S_{N_s,P_s}(T_s).$$2-conforming whenever $$S_{N,P}(T) \doteq \bigoplus_{s = 1}^{r} S_{N_s,P_s}(T_s).$$3” (Magueresse et al., 25 Aug 2025). There is no interface continuity problem in the classical multi-patch sense because patches are not stitched edge-to-edge; they are superposed.

In coefficient-blending models derived from local fitting, smoothness comes from the final global spline basis after patchwise control coefficients are averaged. The reverse-engineering paper yields one global cubic tensor-product B-spline surface with open cubic knot vectors, and the resulting continuity is the standard $$S_{N,P}(T) \doteq \bigoplus_{s = 1}^{r} S_{N_s,P_s}(T_s).$$4 continuity of cubic B-splines with simple interior knots; in the curve case the paper explicitly states that the pieces are “joined with $$S_{N,P}(T) \doteq \bigoplus_{s = 1}^{r} S_{N_s,P_s}(T_s).$$5 continuity” (Tekumalla et al., 2014).

Partition-of-unity manifold constructions obtain continuity from smooth blending functions and smooth chart transitions. The chart-local approximants are combined by weights $$S_{N,P}(T) \doteq \bigoplus_{s = 1}^{r} S_{N_s,P_s}(T_s).$$6 whose derivatives up to order $$S_{N,P}(T) \doteq \bigoplus_{s = 1}^{r} S_{N_s,P_s}(T_s).$$7 vanish at chart boundaries, and the global function inherits continuity from the blended atlas construction (Zhang et al., 2019). In structured regular regions, the construction can exactly reproduce B-splines while preserving the overlapping-chart architecture.

When patches meet along interfaces rather than overlap volumetrically, classical $$S_{N,P}(T) \doteq \bigoplus_{s = 1}^{r} S_{N_s,P_s}(T_s).$$8 or $$S_{N,P}(T) \doteq \bigoplus_{s = 1}^{r} S_{N_s,P_s}(T_s).$$9 coupling reappears. For two-patch analysis-suitable $$S_{N,P} \doteq \left\{ S_{N,P}(T),\ T \in K_N \right\}.$$0 parameterizations, the geometry maps $$S_{N,P} \doteq \left\{ S_{N,P}(T),\ T \in K_N \right\}.$$1 and $$S_{N,P} \doteq \left\{ S_{N,P}(T),\ T \in K_N \right\}.$$2 satisfy

$$S_{N,P} \doteq \left\{ S_{N,P}(T),\ T \in K_N \right\}.$$3

and $$S_{N,P} \doteq \left\{ S_{N,P}(T),\ T \in K_N \right\}.$$4 continuity of functions is equivalent to

$$S_{N,P} \doteq \left\{ S_{N,P}(T),\ T \in K_N \right\}.$$5

across the common interface (Kapl et al., 2017). This is not an overlapping construction, but it is directly relevant whenever one asks how independently parameterized tensor-product patches can be coupled smoothly.

For quad meshes with T-junctions, GT-splines abandon matched knot intervals and instead impose $$S_{N,P} \doteq \left\{ S_{N,P}(T),\ T \in K_N \right\}.$$6 compatibility by reparameterization. Two adjacent patches satisfy

$$S_{N,P} \doteq \left\{ S_{N,P}(T),\ T \in K_N \right\}.$$7

which is the fundamental joining condition for the local bi-3 frame and bi-4 cap patches around the T-junction (Karciauskas et al., 2016). This provides a local geometric substitute for free-knot patch coordination.

The literature also contains a sharp lower-bound result on the complexity of bicubic tensor-product spline patches over general quad meshes. For a vertex-localized unbiased $$S_{N,P} \doteq \left\{ S_{N,P}(T),\ T \in K_N \right\}.$$8 construction without forced linear boundary segments, bicubic tensor-product splines require at least two internal double knots per edge (0906.1226). This lower bound concerns knot multiplicity and segmentation rather than exact placement, and it indicates that local smooth tensor-product patch coupling has irreducible complexity even before overlap or free-knot optimization is introduced.

6. Variational approximation, optimization, and computational behavior

The most fully developed mathematical analysis of overlapping tensor-product free-knot patches is variational. For linear, self-adjoint elliptic PDEs with energy

$$S_{N,P} \doteq \left\{ S_{N,P}(T),\ T \in K_N \right\}.$$9

the discrete problem minimizes the composed energy over both coefficients and knot parameters: $$R_{N,P}(W, T) = \sum_{s = 1}^{r} \sum_{i = 1}^{N_s - (P_s + 1)} W_{s,i}\, B_{i,N_s}(T_s),$$0 The analysis shows that under a mild mesh size condition the discrete energy has the structural properties required for local and global convergence of the constrained optimization scheme developed in the companion work, thereby fitting the adaptive free-knot B-spline space into that abstract framework (Magueresse et al., 25 Aug 2025).

A major analytical task is understanding the dependence of B-splines on their knots. The same paper derives explicit spatial and parametric derivatives of the B-spline functor, including

$$R_{N,P}(W, T) = \sum_{s = 1}^{r} \sum_{i = 1}^{N_s - (P_s + 1)} W_{s,i}\, B_{i,N_s}(T_s),$$1

and

$$R_{N,P}(W, T) = \sum_{s = 1}^{r} \sum_{i = 1}^{N_s - (P_s + 1)} W_{s,i}\, B_{i,N_s}(T_s),$$2

which support gradient-based knot optimization (Magueresse et al., 25 Aug 2025). The same work proves boundedness, Hölder/Lipschitz continuity, compactness of the constrained knot set, and uniform coercivity under a global minimum mesh-size bound.

The admissible set includes both within-patch and across-patch spacing restrictions. For a univariate knot vector $$R_{N,P}(W, T) = \sum_{s = 1}^{r} \sum_{i = 1}^{N_s - (P_s + 1)} W_{s,i}\, B_{i,N_s}(T_s),$$3, the minimum local spacing is

$$R_{N,P}(W, T) = \sum_{s = 1}^{r} \sum_{i = 1}^{N_s - (P_s + 1)} W_{s,i}\, B_{i,N_s}(T_s),$$4

and a basic requirement is

$$R_{N,P}(W, T) = \sum_{s = 1}^{r} \sum_{i = 1}^{N_s - (P_s + 1)} W_{s,i}\, B_{i,N_s}(T_s),$$5

In the multi-patch case, pairwise separation across patches is also enforced along each axis to preserve coercivity (Magueresse et al., 25 Aug 2025). This is the technical price of allowing overlapping free-knot patches with independent local knot systems.

The implementation reported there alternates between solving for the best linear coefficients at fixed knots by conjugate gradients and updating nonlinear knot parameters with ADAM followed by projection to the feasible set. The stated details are: CG tolerance $$R_{N,P}(W, T) = \sum_{s = 1}^{r} \sum_{i = 1}^{N_s - (P_s + 1)} W_{s,i}\, B_{i,N_s}(T_s),$$6, exact linear solve every 25 iterations, ADAM parameters $$R_{N,P}(W, T) = \sum_{s = 1}^{r} \sum_{i = 1}^{N_s - (P_s + 1)} W_{s,i}\, B_{i,N_s}(T_s),$$7, $$R_{N,P}(W, T) = \sum_{s = 1}^{r} \sum_{i = 1}^{N_s - (P_s + 1)} W_{s,i}\, B_{i,N_s}(T_s),$$8, $$R_{N,P}(W, T) = \sum_{s = 1}^{r} \sum_{i = 1}^{N_s - (P_s + 1)} W_{s,i}\, B_{i,N_s}(T_s),$$9, learning-rate warmup

$W$0

up to 1000 iterations, or 3000 for larger problems, and minimum patchwise mesh size $W$1 (Magueresse et al., 25 Aug 2025).

Numerical experiments reported in that paper show one to three orders of magnitude gains over uniform meshes in several localized-feature problems, especially when multiple patches are used in 2D, with 1, 4, or 9 patches initially laid out as $W$2, $W$3, and $W$4 (Magueresse et al., 25 Aug 2025). The key observation is that overlap and multiple patches are crucial: with one patch gains are moderate, while with 4 or 9 patches the improvements become much larger.

Other overlapping tensor-product patch frameworks exhibit different computational profiles. The local-blending point-cloud fitting method solves only small local systems with 16 unknowns per surface patch and reports effective $W$5 fitting complexity under its assumptions, versus $W$6 for a large global least-squares solve (Tekumalla et al., 2014). By contrast, the localized Lagrangian surface-evolution framework uses overlapping local tensor-product B-spline patches for meshless geometric evolution and estimates total cost

$W$7

contrasted with a traditional repeated-global-interpolation cost

$W$8

(Ammad et al., 16 Jan 2026). These comparisons are not directly comparable across tasks, but they illustrate a common motivation for overlap: preserving local structure while avoiding monolithic global reconstruction.

7. Related constructions, misconceptions, and research boundaries

Several common misconceptions arise around the topic. One is to equate any adaptive tensor-product spline method with free-knot patches. The literature does not support that. Recursive subdivision (Tekumalla et al., 2014), local knot insertion (Ammad et al., 16 Jan 2026), local knot condensation (Sissouno, 2016), and geometric reparameterization without global knot coordination (Karciauskas et al., 2016) are all distinct from treating knot locations as continuous unknowns in an optimization problem (Magueresse et al., 25 Aug 2025).

A second misconception is to equate overlap with patchwise interface coupling. In some methods, overlap means that multiple patch contributions are simultaneously active at the same spatial location (Magueresse et al., 25 Aug 2025). In others, overlap refers only to fitting neighborhoods (Tekumalla et al., 2014) or manifold chart domains (Zhang et al., 2019). Interface-coupled multi-patch $W$9 constructions, such as analysis-suitable $T$0 two-patch spaces, are highly relevant to patch coupling but are not overlapping in this sense (Kapl et al., 2017).

A third misconception is that global knot coordination is the only route to smooth local refinement. The T-junction literature shows that local $T$1 patch constructions can avoid global coordination of knot intervals altogether, though at the cost of leaving the classical B-spline basis framework (Karciauskas et al., 2016). Conversely, the quad-mesh complexity result shows that even in a non-overlapping one-patch-per-face architecture, local smooth bicubic tensor-product coupling has a sharp lower bound of two internal double knots per edge in the generic setting (0906.1226).

The broader research landscape can therefore be organized around three questions. The first is representation: additive patch sums (Magueresse et al., 25 Aug 2025), coefficient-averaged local fits (Tekumalla et al., 2014), partition-of-unity manifold charts (Zhang et al., 2019), and reparameterized $T$2 caps and frames (Karciauskas et al., 2016) are not interchangeable. The second is adaptation mechanism: continuous free-knot optimization (Magueresse et al., 25 Aug 2025) differs fundamentally from insertion, subdivision, or condensation (Tekumalla et al., 2014, Ammad et al., 16 Jan 2026, Sissouno, 2016). The third is coupling model: smoothness may arise from functional superposition, global basis assembly, chart blending, or explicit geometric continuity constraints (Kapl et al., 2017).

A plausible implication is that overlapping tensor-product free-knot B-spline patches form a particularly expressive but also particularly nonlinear approximation manifold. The overlap restores locality that a single tensor-product free-knot patch still lacks, while the free-knot degrees of freedom provide geometric adaptivity unavailable to standard hierarchical or uniformly refined spline spaces (Magueresse et al., 25 Aug 2025). At the same time, the literature shows clear boundaries: global directional convexity is hard to verify in full generality (Magueresse et al., 25 Aug 2025), classical free-knot optimization is absent from many practically successful overlapping patch frameworks (Tekumalla et al., 2014, Ammad et al., 16 Jan 2026), and formal cross-patch continuity is often replaced by approximate local consistency unless one moves to explicit interface constructions or geometric continuity theory (Kapl et al., 2017, Karciauskas et al., 2016).

In that sense, overlapping tensor-product free-knot B-spline patches are best viewed as a meeting point of nonlinear spline approximation, local tensor-product geometry, adaptive discretization, and patch-coupling theory. The strictest instantiation is the additive energy-minimization framework with knots as nonlinear parameters (Magueresse et al., 25 Aug 2025), but its closest neighbors—local blended fits (Tekumalla et al., 2014), manifold chart splines (Zhang et al., 2019), geometric T-junction patch systems (Karciauskas et al., 2016), interface $T$3 constructions (Kapl et al., 2017), domain-fitted diversified non-uniform B-splines (Sissouno, 2016), and localized overlapping spline patches for evolving point clouds (Ammad et al., 16 Jan 2026)—collectively define the technical context in which the topic is now understood.