HilbertW | SuperCollider 3.13.0 Help

Description

Offers the Hilbert and related transforms and analyses of an input signal via Weaver's Third Method.¹

[1] this is a composite pseudo UGen. HilbertW is built with DelayN, Delay1, Delay2, Impulse, LocalBuf, FFT, IFFT, and PV_BrickWall. Method *arSSB also includes SinOsc.

Frequency response

Magnitude

The real output of HilbertW returns an allpass magnitude response.

The imag magnitude response may be regarded as bandpass, with notches at DC and Nyquist.

The real output of HilbertW returns a linear phase response. As a result, the output of the system as a whole is delayed in time. The total delay, in samples, can be calculated as size - blockSize, where blockSize is the number of samples in one control period of the Server in use.

The imag output is offset by -pi/2 radians with respect to real.

Examples

ar

FFT analysis functions

NOTE: FFT returns linear frequency

*/
(
~calcMag = { arg kernel;

var fftResponse, fftMag;

// FFT analysis here!
    fftResponse = fft(
        kernel.as(Signal),
        Signal.newClear(kernel.size),
        Signal.fftCosTable(kernel.size)
    );

// find (& trim magnitude)
    fftMag = fftResponse.magnitude;
    fftMag = fftMag.copyFromStart((kernel.size/2).asInteger);

fftMag;
};

~calcPha = { arg kernel;

var fftResponse, fftPha;

// FFT analysis here!
    fftResponse = fft(
        kernel.as(Signal),
        Signal.newClear(kernel.size),
        Signal.fftCosTable(kernel.size)
    );

// find (& trim phase)
    fftPha = fftResponse.phase;
    fftPha = fftPha.copyFromStart((kernel.size/2).asInteger);

fftPha;
};

)

/*
        TEST Weaver : HilbertW

Impulse Response
*/
(
var size, dur, freq;
var overSample, start;
var plotDbMin, plotDbMax, plotDegMin, plotDegMax;

// kernel size
size = 2048;

overSample = 2;

// plot params
plotDbMin = -60.0;
plotDbMax = 6.0;
plotDegMin = 0.0;
plotDegMax = 180.0;

start = size  - ((size/2).asInt) - s.options.blockSize;  // offset - for kernel normalized to sample delay

dur = size / s.sampleRate;  // in seconds
freq = dur.reciprocal;

fork {
    { // [real,imag]
        HilbertW.ar(
            Impulse.ar(freq), // imulse test, one pulse over fftbuffer size
        size: size);
    }.loadToFloatArray(overSample * dur, s, {
        |arr|
        defer {
            arr = arr.clump(2).flop; // de-interleave
            arr = arr.collect(_.copyRange(start, start+size-1));
            arr.plot("[real, imag]; HilbertW; Impulse input", minval: -1, maxval: 1);
        }
        }
    );

0.5.wait;

{ // plot magnitude - [real,imag]
        HilbertW.ar(
            Impulse.ar(freq), // imulse test, one pulse over fftbuffer size
        size: size);
    }.loadToFloatArray(overSample * dur, s, {
        |arr|
        defer {
            arr = arr.clump(2).flop; // de-interleave
            arr = arr.collect(_.copyRange(start, start+size-1));
            [~calcMag.value(arr.at(0)), ~calcMag.value(arr.at(1))].ampdb.plot(
                name: "Real & Imag Magnitude Response",
                minval: plotDbMin,
                maxval: plotDbMax
            );
        }
        }
    );

0.5.wait;

{ // plot magnitude - system
        HilbertW.ar(
            Impulse.ar(freq), // imulse test, one pulse over fftbuffer size
        size: size);
    }.loadToFloatArray(overSample * dur, s, {
        |arr|
        defer {
            arr = arr.clump(2).flop; // de-interleave
            arr = arr.collect(_.copyRange(start, start+size-1));
            ((Complex.new(~calcMag.value(arr.at(0)), ~calcMag.value(arr.at(1))).magnitude  / 2.sqrt).ampdb).plot(
                name: "System Magnitude Response",
                minval: plotDbMin,
                maxval: plotDbMax
            );
        }
        }
    );

0.5.wait;

{ // plot phase difference - system
        HilbertW.ar(
            Impulse.ar(freq), // imulse test, one pulse over fftbuffer size
        size: size);
    }.loadToFloatArray(overSample * dur, s, {
        |arr|
        defer {
            arr = arr.clump(2).flop; // de-interleave
            arr = arr.collect(_.copyRange(start, start+size-1));
            (~calcPha.value(arr.at(0)) - ~calcPha.value(arr.at(1))).raddeg.plot(
                name: "System Phase Difference",
                minval: plotDegMin,
                maxval: plotDegMax
            );
        }
        }
    );

}
)

/*
        TEST Weaver : HilbertW

single cosine cycle: period = size
*/

(
var size, dur, freq;
var overSample, start;

size = 2048;
overSample = 3;
// plot: jump to the 2nd cycle, to account for "warm up" of Im kernel
start = 2 * size - s.options.blockSize;  // offset - to sync cycle

dur = size / s.sampleRate;  // in seconds
freq = dur.reciprocal;

{ // [real,imag]
    HilbertW.ar(
        SinOsc.ar(freq, pi/2), // cosine test, one cycle over fftbuffer size
        size: size);
}.loadToFloatArray(overSample * dur, s, {
    |arr|
    defer {
        arr = arr.clump(2).flop; // de-interleave
        arr = arr.collect(_.copyRange(start, start+size-1));
        arr.plot("[real, imag]; HilbertW; Cosine input", minval: -1, maxval: 1);
    }
}
);
)

arRotate

/*
        TEST Weaver : *arRotate

single cosine cycle: period = size
*/
(
var size, dur, freq, angles;
var overSample, start;

size = 2048;
overSample = 3;
// plot: jump to the 2nd cycle, to account for "warm up" of Im kernel
start = 2 * size - s.options.blockSize;  // offset - to sync cycle

dur = size / s.sampleRate;  // in seconds
freq = dur.reciprocal;

angles = Array.series(9, 0, pi/4);  // in radians

{
    angles.do(
        { arg angle, i;

{ // phase rotation
                HilbertW.arRotate(
                    SinOsc.ar(freq, pi/2), // cosine test, one cycle over fftbuffer size
                    angle,
                    size: size);
            }.loadToFloatArray(overSample * dur, s, {
                |arr|
                defer {
                    arr = arr.copyRange(start, start+size-1);
                    arr.plot(format("HilbertW *arRotate; Angle = % degrees", angle.raddeg), minval: -1, maxval: 1);
                }
            }
            );

0.5.wait;
        }
    )
}.fork
)

arSSB

/*
        TEST Weaver : *arSSB

single cosine cycle: period = size
*/
(
var size, dur, freq, harmonics;
var overSample, start;

size = 2048;
overSample = 3;
// plot: jump to the 2nd cycle, to account for "warm up" of Im kernel
start = 2 * size - s.options.blockSize;  // offset - to sync cycle

dur = size / s.sampleRate;  // in seconds
freq = dur.reciprocal;

harmonics = 8;  // number of harmonics to SSB

{
    harmonics.do(
        { arg hNum;
            var ssbFreq;

ssbFreq = hNum * freq;

{ // frequency shifting
                HilbertW.arSSB(
                    SinOsc.ar(freq, pi/2), // cosine test, one cycle over fftbuffer size
                    ssbFreq,
                    size: size);
            }.loadToFloatArray(overSample * dur, s, {
                |arr|
                defer {
                    arr = arr.copyRange(start, start+size-1);
                    arr.plot(format("HilbertW *arSSB; Freq = % Hz", ssbFreq), minval: -1, maxval: 1);
                }
            }
            );

0.5.wait;
        }
    )
}.fork
)

/*
        Sideband control: upper and lower bands
*/

// Build simple spectrum with a rolloff to shift in frequency
(
d = SynthDef(\help_HilbertW_ssb, { |out=0, frq=1000, shft=5000, amp=1|
    var sig;
    sig = Mix.ar(
        5.collect{|i|
            SinOsc.ar(frq * (i+1), mul: 5.reciprocal * (i+1).reciprocal)
        }
    );

Out.ar( out,
        HilbertW.arSSB(
            sig,
            freq: shft,
            size: 2048,
            mul: amp,
        )
    )
}).add
)

// Play the synth to a bus
b = Bus.audio(s, 1);
x = Synth(\help_HilbertW_ssb, [\out, b.index, \frq, 400, \shft, 3000, \amp, 0.5]);

// View the spectrum
f = s.freqscope();
f.scope.inBus_(b.index);

x.set(\shft, -3000);    // lower sidebands: negative freqency shift
x.set(\shft, 3000);     // upper sidebands

// Cleanup
[x, b].do(_.free); f.window.close;

arMag

/*
        TEST Weaver : *arMag

single cosine cycle: period = size
*/

(
var size, dur, freq, amps;
var overSample, start;

size = 2048;
overSample = 3;
// plot: jump to the 2nd cycle, to account for "warm up" of Im kernel
start = 2 * size - s.options.blockSize;  // offset - to sync cycle

dur = size / s.sampleRate;  // in seconds
freq = dur.reciprocal;

amps = Array.geom(9, 1, 0.5);  // amplitudes to test

{
    amps.do(
        { arg amp;

{ // frequency shifting
                HilbertW.arMag(
                    SinOsc.ar(freq, pi/2, amp), // cosine test, one cycle over fftbuffer size
                    size: size);
            }.loadToFloatArray(overSample * dur, s, {
                |arr|
                defer {
                    arr = arr.copyRange(start, start+size-1);
                    arr = arr.ampdb;
                    arr.plot(format("HilbertW *arMag; Cosine input; Amp = % dB", amp.ampdb), minval: -48, maxval: 0);
                }
            }
            );

0.5.wait;
        }
    )
}.fork
)

arPhase

[1] - Weaver, Donald. “A Third Method of Generation and Detection of Single-Sideband Signals.” Proceedings of the IRE, vol. 44, no. 12, 1956, pp. 1703–1705.

[2] - Smith, J.O. “Analytic Signals and Hilbert Transform Filters”, in Mathematics of the Discrete Fourier Transform (DFT) with Audio Applications, Second Edition, https://ccrma.stanford.edu/~jos/st/Analytic_Signals_Hilbert_Transform.html, online book, 2007 edition, accessed 2017-08-08.

[3] - decrement

[4] - Aka, frequency-shifting.

helpfile source: HelpSource/Classes/HilbertW.schelp
link::Hilbert/Classes/HilbertW::

HilbertW
Extension

Description

Class Methods

.ar

Arguments:

Returns:

.arRotate

Arguments:

Returns:

.arSSB

Arguments:

Returns:

.arMag

Arguments:

Returns:

.arPhase

Arguments:

Returns:

Frequency response

Magnitude

Phase

Examples

ar

arRotate

arSSB

arMag

arPhase

in	The input signal to transform.
size	The size of the FFT used for Weaver Half-Band filtering.
mul	Output will be multiplied by this value.
add	This value will be added to the output.

in	The input signal.
angle	Rotation angle, in radians.
size	The size of the FFT used for Weaver Half-Band filtering.
mul	Output will be multiplied by this value.
add	This value will be added to the output.

in	The input signal.
freq	Frequency to shift by. May be positive or negative.
size	The size of the FFT used for Weaver Half-Band filtering.
mul	Output will be multiplied by this value.
add	This value will be added to the output.

in	The input signal to analyze.
size	The size of the FFT used for Weaver Half-Band filtering.
mul	Output will be multiplied by this value.
add	This value will be added to the output.

HilbertWExtension

.ar

Arguments:

Returns:

.arRotate

Arguments:

Returns:

.arSSB

Arguments:

Returns:

.arMag

Arguments:

Returns:

.arPhase

Arguments:

Returns:

HilbertW
Extension