Morphing Between LFO Shapes with 3 Intuitive Parameters

Table Of Contents

Introduction

Low Frequency Oscillator (LFO) is a popular modulator every sound designer have in their arsernal. A standard LFO generally propose as a serie of shapes (Triangle, Sinus, Square, Saw, Inverted Saw, Pulse, …) that you can access threw a menu widget.

Instead of having a finite number of shape, we propose to offer to the user three parameters :

• Shape
• Symmetry
• Pulse Width

Those three parameters will allow you to morph between all of those standard shapes, so you will have an unlimited number of shapes at disposal.

The benefit of doing this is double, you can first fine tune the shape, and as sound designer pov, it makes also 3 new parameters that you can modulate to morph the shape of your LFO over the time.

Input

The starting point of our parametric lfo is a triangle wave. Defined as follow :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import numpy as np
import matplotlib.pyplot as plt

def triangle(x):
    return 2 * abs((x - 1/2) % 2 - 1) - 1

plt.figure(figsize=(12, 2))
x = np.linspace(-5, 5, 10000)
plt.plot(x, triangle(x), color = "white")
plt.show()

Parameter #1: Shape

The shape parameter allows us to morph between triangular, sinusoidal, and sawtooth waveforms using an y-axis mapping function defined as follows:

$$ f_{0}(x, \alpha) = \begin{cases} (1 + x)^{\alpha} - 1, & \qquad x < 0 \newline 1 - (1 - x)^{\alpha}, & \qquad \text{else} \end{cases} $$

This function is particularly interesting because it approaches a sinusoidal shape for \(\alpha = 1.75028\).

The \(\alpha\) parameter can be remapped to a new parameter \(v\), allowing a natural user range between 0% and 100%, where 0% corresponds to a pure triangle and 100% corresponds to a pure square. We use the following mapping:

$$ \alpha = f_{1}(v) = e^{2.82 \operatorname{arctanh}(v)} = \left(\frac{1 + v}{1 - v}\right)^{1.41} $$

We may extend the shape parameter range to \([-100\%, 100\%]\) to allow for more complex, spiky shapes, as illustrated in the code below. In this case, it would be advantageous to include an epsilon multiplier in the shape function to mitigate spike intensities as the curve approaches -100%, thereby preventing aliasing.

Combining all this information, our final shape function is expressed as:

$$ \operatorname{shape}(x, v) = f_{0}(0.995x, f_{1}(v)) $$

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

def shape(x, v):
    x = 0.995 * x
    v *= 0.999999 # Avoid div by zero
    alpha = ((1 + v) / (1 - v)) ** 1.41
    return np.piecewise(x, [x < 0, x >= 0], [lambda x: (1 + x)**alpha - 1, lambda x: 1 - (1 - x)**alpha])

plt.figure(figsize=(12, 2))
default_color = plt.rcParams['axes.prop_cycle'].by_key()['color'][0]
for v in np.linspace(-1, 1, 9):
    plt.plot(x, shape(triangle(x), v), color = "grey",alpha = 0.5)
plt.plot(x, shape(triangle(x), 0.25), color = "white")
plt.show()

Parameter #2: Symmetry

The symmetry parameter provide a way to morph between a sawtooth, a triangle and an inverted sawtooth by remapping the phase holded by the input variable \(x\), using the following function:

$$ g(x, v) = \begin{cases} \frac{x - v}{1 - v}, & \qquad x > v \newline \frac{x - v}{1 + v}, & \qquad \text{else} \end{cases} $$

The \(g\) function is valid for input \(x\in]-1, +1[\), in order to make it working on the whole phase range \(x\in]-\infty, +\infty[\), we need to wrap \(x\) by some modulus function as we did for the triangle formula.

We also might bias the waveform phase in function of the input parameter \(v\) such that the points on the middle of the y-axis remains invariant, as it was found to be more natural to use.

The complete transformation function \(\operatorname{sym}(x, v)\), incorporating the wrapped and biased phase, is provided in the code below.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

def sym(x, v):
    x = (x + (1+v)/2) % 2 - 1
    v *= 0.999999 # Avoid div by zero
    return 1/2 + np.where(x>v, (x-v)/(1-v), (x-v)/(1+v))

plt.figure(figsize=(12, 2))
for v in np.linspace(-0.99, 0.99, 9):
    plt.plot(x, triangle(sym(x, v)), color = "grey",alpha = 0.5)
plt.plot(x, triangle(sym(x, -0.5)), color = "white")
plt.show()

Parameter #3: Pulse Width

The final parameter we introduce is the pulse width parameter, which enables us to shift the waveform to the left or right by adjusting the phase axis, similar to the symmetry parameter. Additionally, we want this parameter to support the creation of exponential decay curves, commonly used in envelope modulation. This requirement constrains the pulse width function as follows:

$$ \operatorname{pw}(x, v) = \begin{cases} x, & \qquad v = 0 \newline \frac{e^{v(1 - x)} - e^{v}}{1 - e^{v}}, & \qquad v \neq 0, \ x < 0 \newline -\frac{e^{v(1 + x)} - e^{v}}{1 - e^{v}}, & \qquad \text{else} \end{cases} $$

To handle potential overflow in floating-point arithmetic when \(v\) becomes large, an alternative form is:

$$ \operatorname{pw}(x, v) = \begin{cases} x, & \qquad v = 0 \newline \frac{e^{-v x} - e^{v}}{1 - e^{v}} - 1, & \qquad v \neq 0, \ x < 0 \newline 1 - \frac{e^{v x} - e^{v}}{1 - e^{v}}, & \qquad \text{else} \end{cases} $$

With this approach, the pulse width parameter effectively enables both waveform shifting and exponential decay, allowing greater flexibility in waveform shaping.

We might then invert the \(\operatorname{pw}\) function to compute \(v\) in function of the position of the center, that will provide a more intuitive control for the user.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

def pw(x, v):
    x = (x+1/2) % 2 - 1
    v *= 5
    return 1/2 + (x if v == 0 else np.where(x < 0,
                                            (np.exp(-v*x) - np.exp(v)) / (1 - np.exp(v)) - 1,
                                            1 - (np.exp(v*x) - np.exp(v)) / (1 - np.exp(v))))

plt.figure(figsize=(12, 2))
for a in np.linspace(-0.99, 0.99, 11):
    plt.plot(x, triangle(pw(x, a)), color = "grey",alpha = 0.5)
plt.plot(x, triangle(pw(x, 0.2)), color = "white")
plt.show()

Assembling Everything

The final result consists of calling the created functions in the correct sequence to obtain:

$$ \operatorname{LFO}(v_{\text{shape}}, v_{\text{pw}}, v_{\text{sym}}) = \operatorname{shape}\left(\operatorname{triangle}\left(\operatorname{pw}\left(\operatorname{sym}(x, v_{\text{sym}}), v_{\text{pw}}\right)\right), v_{\text{shape}}\right) $$

With this setup, we can experiment with different values to create various LFO presets using these three control parameters.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

def parametric_lfo(x, v_shape, v_pw, v_sym):
    return shape(triangle(pw(sym(x, v_sym), v_pw)), v_shape)

plt.figure(figsize=(12, 17))
i = 1
def plot(v_shape, v_pw, v_sym, title):
    global i
    ax = plt.subplot(10, 2, i)
    i += 1
    ax.plot(x, parametric_lfo(x, v_shape, v_pw, v_sym), color = "white")
    plt.title(title)
    plt.ylim(-1.3, 1.3)
    plt.axis('off')
    plt.tight_layout()
  
plot(0, 0, 0, "Triangle")
plot(0.2, 0, 0, "Sinus")
plot(0.99, 0, 0, "Square")
plot(0, 0, -1, "Saw")
plot(0, 0, 1, "Ramp")
plot(0, -0.9, 0, "Spike")
plot(0, 0.9, 0, "Dome")
plot(-0.4, 0, 0, "Bipolar Spike")
plot(0.99, -0.8, 0, "Pulse")
plot(0.99, 0.8, 0, "Pulse Inv")
plot(0.3, -0.5, -0.6, "Analog Pulse")
plot(0, -0.8, -1, "Exponential Decay")
plot(0, -0.8, 1, "Exponential Growing")
plot(0, 0.8, 1, "Exponential Decay Inv")
plot(0.5, 0, 1, "S-Curve")
plot(0.5, 0, -1, "N-Curve")
plot(-0.99, 0, 0, "Flat Middle")
plot(0.99, 100, 0, "Flat Top")
plot(0.99, -100, 0, "Flat Bottom")
plot(0.99, -5, 0, "Impulse Train")
plt.show()