BasicBSpline.jl

https://hyrodium.github.io/BasicBSpline.jl/stable/
Admin
BasicBSpline.jl is a Julia package that provides basic mathematical operations for B-spline basis...
Tokens:32,572
Snippets:163
Trust Score:9.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### Setup: Load BasicBSpline and plotting packages

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/math/refinement

Loads required packages for the refinement examples: BasicBSpline, BasicBSplineExporter, StaticArrays, and Plots.

```julia
using BasicBSpline
using BasicBSplineExporter
using StaticArrays
using Plots

```

--------------------------------

### Setup dependencies

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/interpolations

Initial imports required for the interpolation examples.

```julia
using BasicBSpline
using IntervalSets
using Random; Random.seed!(42)
using Plots
```

--------------------------------

### Setup: Import BasicBSpline, Random, and Plots

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/math/bsplinebasis

Loads the BasicBSpline package for B-spline functionality, Random for random number generation, and Plots for plotting. Required before using any B-spline functions in the examples.

```julia
using BasicBSpline
using Random
using Plots
```

--------------------------------

### Setup: import packages

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/math/fitting

Loads the required packages for B-spline fitting and plotting.

```julia
using BasicBSpline
using BasicBSplineFitting
using StaticArrays
using Plots

```

--------------------------------

### Install BasicBSplineExporter

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/visualization/basicbsplineexporter

Install the BasicBSplineExporter package using Julia's package manager.

```julia
] add BasicBSplineExporter
```

--------------------------------

### Import required packages for B-spline derivative examples

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/math/derivative

Loads the BasicBSpline, StaticArrays, and Plots packages, which are required for the derivative examples on this page.

```julia
using BasicBSpline
using StaticArrays
using Plots
```

--------------------------------

### Setup: import BasicBSpline, StaticArrays, LinearAlgebra, Plots

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/math/rationalbsplinemanifold

Loads the required packages for defining and plotting rational B-spline manifolds.

```julia
using BasicBSpline
using StaticArrays
using LinearAlgebra
using Plots
```

--------------------------------

### Load BasicBSpline and Plots

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/math/knotvector

Loads the BasicBSpline and Plots packages, required for the examples on this page.

```julia
using BasicBSpline
using Plots
```

--------------------------------

### Setup: using BasicBSpline, StaticArrays, and Plots

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/math/bsplinemanifold

Imports the required packages for working with B-splines and plotting. Note that StaticArrays is imported twice in the source.

```julia
using BasicBSpline
using StaticArrays
using StaticArrays
using Plots
```

--------------------------------

### Plot support intervals with bsplinesupport_R

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/math/bsplinebasis

Plots the support intervals returned by `bsplinesupport_R`, which is identical to `bsplinesupport`. Uses the same plotting style as the previous example.

```julia
pl = plot(; yticks=nothing, legend=nothing, size=(600,150))
for i in 1:dim(P)
    plot!(pl, bsplinesupport_R(P,i); offset=-i/10, linewidth=3, markersize=5, ylims=(-(dim(P)+1)/10, 1/10))
end
plot!(pl, k; color=:black)
```

--------------------------------

### Construct and evaluate RationalBSplineManifold

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/api

Constructs a rational B-spline manifold from control points, weights, and a B-spline space. The example creates a quarter arc and evaluates it at a parameter, showing the norm is 1.0.

```julia
julia> using StaticArrays, LinearAlgebra

julia> P = BSplineSpace{2}(KnotVector([0,0,0,1,1,1]))
BSplineSpace{2, Int64, KnotVector{Int64}}(KnotVector([0, 0, 0, 1, 1, 1]))

julia> w = [1, 1/√2, 1]
3-element Vector{Float64}:
 1.0
 0.7071067811865475
 1.0

julia> a = [SVector(1,0), SVector(1,1), SVector(0,1)]
3-element Vector{SVector{2, Int64}}:
 [1, 0]
 [1, 1]
 [0, 1]

julia> M = RationalBSplineManifold(a,w,P);  # 1/4 arc


julia> M(0.3)
2-element SVector{2, Float64} with indices SOneTo(2):
 0.8973756499953727
 0.4412674277525845

julia> norm(M(0.3))
1.0
```

--------------------------------

### Construct BSplineDerivativeSpace from BSplineSpace

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/api

Constructs a derivative B-spline space from a B-spline space and a differential order. The example shows that the degree of the derivative space is one less than the original space.

```julia
julia> P = BSplineSpace{2}(KnotVector([1,2,3,4,5,6]))
BSplineSpace{2, Int64, KnotVector{Int64}}(KnotVector([1, 2, 3, 4, 5, 6]))

julia> dP = BSplineDerivativeSpace{1}(P)
BSplineDerivativeSpace{1, BSplineSpace{2, Int64, KnotVector{Int64}}, Int64}(BSplineSpace{2, Int64, KnotVector{Int64}}(KnotVector([1, 2, 3, 4, 5, 6])))

julia> degree(P), degree(dP)
(2, 1)
```

--------------------------------

### Base.:* — Method

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/api

Product of integer and knot vector. For example, 2⋅(1,2,2,5)=(1,1,2,2,2,2,5,5).

```APIDOC
## `Base.:*` — Method

### Description
Product of integer and knot vector. For example, 2⋅(1,2,2,5)=(1,1,2,2,2,2,5,5).

### Method
`*`

### Parameters
- **m** (integer) - Required - Integer multiplier
- **k** (KnotVector) - Required - Knot vector

### Examples
```julia
julia> k = KnotVector([1,2,2,5]);


julia> 2 * k
KnotVector([1, 1, 2, 2, 2, 2, 5, 5])
```

```

--------------------------------

### Construct and evaluate BSplineManifold

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/api

Constructs a B-spline manifold from control points and a B-spline space. The example evaluates the manifold at a parameter inside the domain and shows that evaluating outside the domain raises a DomainError.

```julia
julia> using StaticArrays

julia> P = BSplineSpace{2}(KnotVector([0,0,0,1,1,1]))
BSplineSpace{2, Int64, KnotVector{Int64}}(KnotVector([0, 0, 0, 1, 1, 1]))

julia> a = [SVector(1,0), SVector(1,1), SVector(0,1)]
3-element Vector{SVector{2, Int64}}:
 [1, 0]
 [1, 1]
 [0, 1]

julia> M = BSplineManifold(a, P);


julia> M(0.4)
2-element SVector{2, Float64} with indices SOneTo(2):
 0.84
 0.64

julia> M(1.2)
ERROR: DomainError with 1.2:
The input 1.2 is out of domain 0 .. 1.
[...]
```

--------------------------------

### Union and inclusion of knot vectors with ∪ and ⊆

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/api

Constructs knot vectors using the knotvector string macro and demonstrates union (∪) and inclusion (⊆) operations. The example shows the resulting knot vectors and checks that k1 ∪ k2 equals k3, and that both k1 and k2 are subsets of the union.

```julia
julia> k1 = knotvector"12 3 1"
KnotVector([1, 2, 2, 4, 4, 4, 6])

julia> k2 = knotvector" 1 412"
KnotVector([2, 4, 4, 4, 4, 5, 6, 6])

julia> k3 = knotvector"12 412"
KnotVector([1, 2, 2, 4, 4, 4, 4, 5, 6, 6])

julia> k1 ∪ k2 == k3

julia> k1 ⊆ k1 ∪ k2

julia> k2 ⊆ k1 ∪ k2
```

--------------------------------

### Torus: rational B-spline torus from circle

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/math/rationalbsplinemanifold

Builds a torus as a rational B-spline manifold by combining the circle control points and weights from the previous example. Uses plotly() and plots the resulting 3D surface.

```julia
plotly()
R1 = 3
R2 = 1

A = push.(a, 0)

a1 = (R1+R2)*A
a5 = (R1-R2)*A
a2 = [p+R2*SVector(0,0,1) for p in a1]
a3 = [p+R2*SVector(0,0,1) for p in R1*A]
a4 = [p+R2*SVector(0,0,1) for p in a5]
a6 = [p-R2*SVector(0,0,1) for p in a5]
a7 = [p-R2*SVector(0,0,1) for p in R1*A]
a8 = [p-R2*SVector(0,0,1) for p in a1]

a = hcat(a1,a2,a3,a4,a5,a6,a7,a8,a1)
M = RationalBSplineManifold(a,w*w',P,P)
plot(M)
```

--------------------------------

### Construct BSplineSpace from degree and knot vector

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/api

Constructs a B-spline space from a polynomial degree and a knot vector. The example shows the resulting BSplineSpace type.

```julia
julia> p = 2
2

julia> k = KnotVector([1,3,5,6,8,9])
KnotVector([1, 3, 5, 6, 8, 9])

julia> BSplineSpace{p}(k)
BSplineSpace{2, Int64, KnotVector{Int64}}(KnotVector([1, 3, 5, 6, 8, 9]))
```

--------------------------------

### changebasis_R: compute change-of-basis matrix between B-spline spaces

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/api

Computes the change-of-basis matrix from a B-spline space to a refined space using `changebasis_R`. The example defines two spaces with different degrees and knot vectors, checks that the first is a subset of the second, and prints the resulting sparse matrix.

```julia
julia> P = BSplineSpace{2}(knotvector"3 13")
BSplineSpace{2, Int64, KnotVector{Int64}}(KnotVector([1, 1, 1, 3, 4, 4, 4]))

julia> P′ = BSplineSpace{3}(knotvector"4124")
BSplineSpace{3, Int64, KnotVector{Int64}}(KnotVector([1, 1, 1, 1, 2, 3, 3, 4, 4, 4, 4]))

julia> P ⊆ P′
true

julia> changebasis_R(P, P′)
4×7 SparseArrays.SparseMatrixCSC{Float64, Int32} with 13 stored entries:
 1.0  0.666667  0.166667   ⋅         ⋅         ⋅         ⋅
 ⋅   0.333333  0.722222  0.555556  0.111111   ⋅         ⋅
 ⋅    ⋅        0.111111  0.444444  0.888889  0.666667   ⋅
 ⋅    ⋅         ⋅         ⋅        0.333333  1.0
```

--------------------------------

### Base.:+ — Method

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/api

Sum of knot vectors. For example, (1,2,3,5)+(4,5,8)=(1,2,3,4,5,5,8).

```APIDOC
## `Base.:+` — Method

### Description
Sum of knot vectors. For example, (1,2,3,5)+(4,5,8)=(1,2,3,4,5,5,8).

### Method
`+`

### Parameters
- **k1** (KnotVector) - Required - First knot vector
- **k2** (KnotVector) - Required - Second knot vector

### Examples
```julia
julia> k1 = KnotVector([1,2,3,5]);


julia> k2 = KnotVector([4,5,8]);


julia> k1 + k2
KnotVector([1, 2, 3, 4, 5, 5, 8])
```

```

--------------------------------

### Compare bsplinesupport, bsplinesupport_R, and bsplinesupport_I outputs

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/math/bsplinebasis

Shows the output of `bsplinesupport`, `bsplinesupport_R`, and `bsplinesupport_I` for indices 1 and 3. Note that `bsplinesupport_I` returns a different interval for index 1, while all three agree for index 3.

```julia
julia> bsplinesupport(P,1), bsplinesupport_R(P,1), bsplinesupport_I(P,1)(0.0 .. 5.5, 0.0 .. 5.5, 2.5 .. 5.5)  
julia> bsplinesupport(P,3), bsplinesupport_R(P,3), bsplinesupport_I(P,3)(2.5 .. 9.0, 2.5 .. 9.0, 2.5 .. 9.0)
```

--------------------------------

### Get knot vector length

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/math/knotvector

Returns the number of knots in each knot vector using length.

```julia
julia> length(k1)
12  
julia> length(k2)
18
```

--------------------------------

### Construct KnotVector from array or range

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/api

Constructs a knot vector from an array or a range. The example shows both forms produce the same KnotVector.

```julia
julia> k = KnotVector([1,2,3])
KnotVector([1, 2, 3])

julia> k = KnotVector(1:3)
KnotVector([1, 2, 3])
```

--------------------------------

### Get unique elements of knot vector

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/math/knotvector

Returns a knot vector containing only the unique elements of the original knot vector.

```julia
julia> unique(k1)
KnotVector([1, 3, 5, 7, 8, 10, 12, 13])  
julia> unique(k2)
KnotVector([1, 2, 3, 5, 7, 8, 10, 12, 13, 15, 18])
```

--------------------------------

### Construct UniformKnotVector from range

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/api

Constructs a uniform knot vector from a range. The example shows that a descending range is normalized to ascending order.

```julia
julia> k = UniformKnotVector(1:8)
UniformKnotVector(1:8)

julia> UniformKnotVector(8:-1:3)
UniformKnotVector(3:1:8)
```

--------------------------------

### Create SubKnotVector with view

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/api

Creates a sub knot vector by viewing a range of a knot vector. The example shows the resulting SubKnotVector.

```julia
julia> k = knotvector"1 11 211"
KnotVector([1, 3, 4, 6, 6, 7, 8])

julia> view(k, 2:5)
SubKnotVector([3, 4, 6, 6])
```

--------------------------------

### Compute bsplinesupport_R for basis functions

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/api

Computes the support of the 1st and 2nd basis functions on the right side using bsplinesupport_R. The outputs are not shown in the source.

```julia
julia> bsplinesupport_R(P,1)

julia> bsplinesupport_R(P,2)
```

--------------------------------

### Visualize tensor product basis function with BasicBSpline

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/math/bsplinemanifold

Defines knot vectors and B-spline spaces, then plots the basis functions and the tensor product surface. Uses plotly backend and the bsplinebasis function.

```julia
# Define shape
k1 = KnotVector([0.0, 1.5, 2.5, 5.5, 8.0, 9.0, 9.5, 10.0])
k2 = knotvector"31 2  121"
P1 = BSplineSpace{3}(k1)
P2 = BSplineSpace{2}(k2)

# Choose indices
i1 = 3
i2 = 4

# Visualize basis functions
plotly()
plot(P1; plane=:xz, label="P1", color=:red)
plot!(P2; plane=:yz, label="P2", color=:green)
plot!(k1; plane=:xz, label="k1", color=:red, markersize=2)
plot!(k2; plane=:yz, label="k2", color=:green, markersize=2)
xs = range(0,10,length=100)
ys = range(1,9,length=100)
surface!(xs, ys, bsplinebasis.(P1,i1,xs') .* bsplinebasis.(P2,i2,ys))
```

--------------------------------

### BasicBSpline.BSplineSpace — Method

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/api

Convert BSplineSpace to BSplineSpace

```APIDOC
## `BasicBSpline.BSplineSpace` — Method

### Description
Convert BSplineSpace to BSplineSpace

### Method
`BSplineSpace`

### Parameters
None explicitly documented.

### Examples
No examples provided in source.

```

--------------------------------

### Compute bsplinesupport_I for basis functions

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/api

Computes the support of the 1st and 2nd basis functions restricted to the interval I using bsplinesupport_I. The output for the first call is truncated in the source.

```julia
julia> bsplinesupport_I(P,1)
2.5 ..

julia> bsplinesupport_I(P,2)
```

--------------------------------

### Create EmptyKnotVector

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/api

Creates an empty knot vector, which is intended for internal use. The example shows the default element type is Bool and that a type parameter can be specified.

```julia
julia> EmptyKnotVector()
EmptyKnotVector{Bool}()

julia> EmptyKnotVector{Float64}()
EmptyKnotVector{Float64}()
```

--------------------------------

### Construct and evaluate a BSplineManifold

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/math/bsplinemanifold

Creates a 2D B-spline manifold with quadratic basis and three control points, then evaluates it at t=0.4. The output is a 2-element SVector.

```julia
P = BSplineSpace{2}(KnotVector([0,0,0,1,1,1]))
a = [SVector(1,0), SVector(1,1), SVector(0,1)]  # `length(a) == dim(P)`
M = BSplineManifold(a, P)
M(0.4)  # Calculate `sum(a[i]*bsplinebasis(P, i, 0.4) for i in 1:dim(P))`
```

```julia
2-element StaticArraysCore.SVector{2, Float64} with indices SOneTo(2):
 0.84
 0.64
```

--------------------------------

### Compute bsplinesupport for BSplineSpace{2}

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/api

Creates a degree-2 B-spline space with a given knot vector and computes the support of the 1st and 2nd basis functions using bsplinesupport, returning intervals 0.0..5.5 and 1.5..8.0.

```julia
julia> k = KnotVector([0.0, 1.5, 2.5, 5.5, 8.0, 9.0, 9.5, 10.0])
KnotVector([0.0, 1.5, 2.5, 5.5, 8.0, 9.0, 9.5, 10.0])

julia> P = BSplineSpace{2}(k)
BSplineSpace{2, Float64, KnotVector{Float64}}(KnotVector([0.0, 1.5, 2.5, 5.5, 8.0, 9.0, 9.5, 10.0]))

julia> bsplinesupport(P,1)
0.0 .. 5.5

julia> bsplinesupport(P,2)
1.5 .. 8.0
```

--------------------------------

### Hyperbolic paraboloid B-spline surface

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/math/bsplinemanifold

Defines a hyperbolic paraboloid B-spline surface using plotly backend, reusing the knot vector and space from the previous paraboloid example. Plots the manifold.

```julia
plotly()
a = [SVector(i,j,2i^2-2j^2) for i in -1:1, j in -1:1]
M = BSplineManifold(a,P,P)
plot(M)
```

--------------------------------

### BasicBSpline.changebasis_I

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/api

Returns the coefficient matrix A that satisfies B_{(i,p,k)} = Σ_j A_{i,j} B_{(j,p',k')} for the change of basis between two B-spline spaces.

```APIDOC
## BasicBSpline.changebasis_I — Method

### Description
Returns the coefficient matrix A that satisfies B_{(i,p,k)} = Σ_j A_{i,j} B_{(j,p',k')} for the change of basis between two B-spline spaces.

### Method
Method

### Endpoint
`BasicBSpline.changebasis_I`

### Parameters
#### Arguments
- **P** (AbstractFunctionSpace) - Required - Original function space
- **P′** (AbstractFunctionSpace) - Required - Target function space

### Request Example
```julia
julia> P = BSplineSpace{2}(knotvector"3 13")
BSplineSpace{2, Int64, KnotVector{Int64}}(KnotVector([1, 1, 1, 3, 4, 4, 4]))

julia> P′ = BSplineSpace{3}(knotvector"4124")
BSplineSpace{3, Int64, KnotVector{Int64}}(KnotVector([1, 1, 1, 1, 2, 3, 3, 4, 4, 4, 4]))

julia> P ⊑ P′
true

julia> changebasis_I(P, P′)
4×7 SparseArrays.SparseMatrixCSC{Float64, Int32} with 13 stored entries:
 1.0  0.666667  0.166667   ⋅         ⋅         ⋅         ⋅
  ⋅   0.333333  0.722222  0.555556  0.111111   ⋅         ⋅
  ⋅    ⋅        0.111111  0.444444  0.888889  0.666667   ⋅
  ⋅    ⋅         ⋅         ⋅         ⋅        0.333333  1.0
```

### Response
#### Success Response
Returns the coefficient matrix A.

#### Response Example
```julia
4×7 SparseArrays.SparseMatrixCSC{Float64, Int32} with 13 stored entries:
 1.0  0.666667  0.166667   ⋅         ⋅         ⋅         ⋅
  ⋅   0.333333  0.722222  0.555556  0.111111   ⋅         ⋅
  ⋅    ⋅        0.111111  0.444444  0.888889  0.666667   ⋅
  ⋅    ⋅         ⋅         ⋅         ⋅        0.333333  1.0
```
```

--------------------------------

### Compute changebasis_I between BSplineSpaces

Source: https://hyrodium.github.io/BasicBSpline.jl/stable/api

Defines two B-spline spaces P and P′ with different degrees and knot vectors, checks that P is a subspace of P′ using ⊑, and computes the change-of-basis matrix with changebasis_I, returning a 4×7 sparse matrix.

```julia
julia> P = BSplineSpace{2}(knotvector"3 13")
BSplineSpace{2, Int64, KnotVector{Int64}}(KnotVector([1, 1, 1, 3, 4, 4, 4]))

julia> P′ = BSplineSpace{3}(knotvector"4124")
BSplineSpace{3, Int64, KnotVector{Int64}}(KnotVector([1, 1, 1, 1, 2, 3, 3, 4, 4, 4, 4]))

julia> P ⊑ P′
true

julia> changebasis_I(P, P′)
4×7 SparseArrays.SparseMatrixCSC{Float64, Int32} with 13 stored entries:
 1.0  0.666667  0.166667   ⋅         ⋅         ⋅         ⋅
 ⋅   0.333333  0.722222  0.555556  0.111111   ⋅         ⋅
 ⋅    ⋅        0.111111  0.444444  0.888889  0.666667   ⋅
 ⋅    ⋅         ⋅         ⋅         ⋅        0.333333  1.0
```
Tokens:
Raw