Inverting a Spline-Function (Bezier or BSpline)

Question

I would like to use a Spline-Function to describe a transformation from one range of reals to another, that is I would like to have a function which maps a value $y$ on $x$ and for simplicity let us assume that $x,y \in [0,1]$.

The idea was to define a smooth, nonlinear function which is to be within the boundary points $\{(0,0),(\alpha,\beta),(1,1)\}$ with $\alpha,\beta \in [0,1]$, also. Thus a Bezier- or BSpline-Function seemed to be appropriate.

Unfortunately I can't see how I can use the Spline-Function directly to map $y$ on $x$ (or vice versa for that). The Spline-Function will one parameter $t$ with $t \in [0,1]$ and will give all points on the curve, e.g. $spline(0) = (0,0), spline(1) = (1,1)$.

So to find say the corresponding $x$ value for $y=0.6$, I tried something like this:

f = BSplineFunction[{{0, 0}, {0.2, 0.7}, {1, 1}}];
FindInstance[Last@f[t]==0.6,t]

But what I am getting is the false answer $\{\{t\rightarrow 0.6 \}\}$. The correct answer should have been $t = 0.5$.

So far I have also tried Reduce, Solve, NSolve, FindRoot (giving a start value for t) and have of course given the domain to be Reals. But nothing works.

Is there a way to do this without having to substitute a simpler function for the Spline-Function (e.g. using Interpolation[])?

Answer 1

Inverse of your function sampled and interpolated:

g = InverseFunction@Interpolation[f /@ Range[0, 1, .1]]

(* gives x for y = .6 *)
g[.6]
    0.35

Using FindRoot:

FindRoot[second[f[t]] == .6, {t, .5}]    
    {t -> 0.5}

f[.5]    
    {0.35, 0.6}

Delaying evaluation:

second[r_?(VectorQ[#, NumericQ] &)] := r[[2]]

More general delay:

delay[f_, r_?(VectorQ[#, NumericQ] &)] := f[r]

FindRoot[delay[First, f[t]] == .6, {t, .2}]
    {t -> 0.720759}

I can't understand why BSplineFunction generates a message (Quiet for quieting that) but the result is correct, right?

Answer 2

If you absolutely must use B-splines, you can explicitly build the component functions that make up the B-spline, using the usual definitions:

pts = {{0, 0}, {0.2, 0.7}, {1, 1}};

n = Min[Length[pts] - 1, 3]; (* B-spline degree *)
m = Length[pts];
(* clamped uniform knots for B-spline *)
knots = {ConstantArray[0, n + 1], Range[m - n - 1]/(m - n),
         ConstantArray[1, n + 1]} // Flatten;

{xu, yu} = Transpose[pts];
bs = BSplineFunction[pts];

(* B-spline component functions *)

f[t_] = xu.Table[BSplineBasis[{n, knots}, i - 1, t], {i, Length[pts]}];
g[t_] = yu.Table[BSplineBasis[{n, knots}, i - 1, t], {i, Length[pts]}];

Now, you can do this:

tval = t /. First @ FindRoot[g[t] == 0.6, {t, 0.6, 0, 1}]
   0.5

bs[tval]
   {0.35, 0.6}

Answer 3

Given the discussion, another approach you might want to consider would be to explicitly parameterize a function -- -- this way you get to control very precisely the form of the function and you can choose it to have a nice shape. As an added bonus, you can perhaps even find an analytical inverse, which greatly simplifies that part of the problem. For example, you might do something like:

Clear[f,g]
f = NonlinearModelFit[{{0, 0}, {0.2`, 0.7`}, {1, 1}}, b x + a x^(1/3), {a, b}, x]

You can plot this the normal way

g[x_] := Normal[f]; Plot[g[x], {x, 0, 1}, PlotRange -> All]

And of course the inverse can then be found (if the function is sufficiently simple, as this one is) using

Solve[y == g[x], x]

Probably you can think of a better functional form for your data.