HilbertPDN | SuperCollider 3.13.0 Help

Description

Offers the Hilbert and related transforms and analyses of an input signal via Weaver's Second Method,¹ known as Hartley Phasing,² expressed as a 12th-order Phase Differencing Network.³

[1] this is a composite pseudo UGen. HilbertPDN is built with SOS. Method *arSSB also includes SinOsc.

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 PDN : HilbertPDN

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 = nil;
plotDegMax = nil;

start = 0;  // offset - for kernel normalized to sample delay

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

fork {
    { // [real,imag]
        HilbertPDN.ar(
            Impulse.ar(freq, 0.5) // imulse test, one pulse over fftbuffer 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]; HilbertPDN; Impulse input", minval: -1, maxval: 1);
        }
    }
    );

0.5.wait;

{ // plot magnitude - [real,imag]
        HilbertPDN.ar(
            Impulse.ar(freq, 0.5) // imulse test, one pulse over fftbuffer 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
        HilbertPDN.ar(
            Impulse.ar(freq, 0.5) // imulse test, one pulse over fftbuffer 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
        HilbertPDN.ar(
            Impulse.ar(freq, 0.5) // imulse test, one pulse over fftbuffer 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 PDN : HilbertPDN

single cosine cycle: period = size
*/

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

size = 2048;
overSample = 4;

// plot: adjust "by hand":
// 1) account for "warm up" of Re & Im
// 2) account for non-linear phase response of PDN
start = size + 779;  // size = 2048, sampleRate = 44100

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

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

arRotate

/*
        TEST PDN : *arRotate

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

size = 2048;
overSample = 4;

// plot: adjust "by hand":
// 1) account for "warm up" of Re & Im
// 2) account for non-linear phase response of PDN
start = size + 779;  // size = 2048, sampleRate = 44100

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

0.5.wait;
        }
    )
}.fork
)

arSSB

/*
        TEST PDN : *arSSB

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

size = 2048;
overSample = 4;

// plot: adjust "by hand":
// 1) account for "warm up" of Re & Im
// 2) account for non-linear phase response of PDN
start = size + 779;  // size = 2048, sampleRate = 44100

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
                HilbertPDN.arSSB(
                    SinOsc.ar(freq, pi/2), // cosine test, one cycle over fftbuffer size
                    ssbFreq);
            }.loadToFloatArray(overSample * dur, s, {
                |arr|
                defer {
                    arr = arr.copyRange(start, start+size-1);
                    arr.plot(format("HilbertPDN *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_HilbertPDN_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,
        HilbertPDN.arSSB(
            sig,
            freq: shft,
            mul: amp,
        )
    )
}).add
)

// Play the synth to a bus
b = Bus.audio(s, 1);
x = Synth(\help_HilbertPDN_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 PDN : *arMag

single cosine cycle: period = size
*/

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

size = 2048;
overSample = 4;

// plot: adjust "by hand":
// 1) account for "warm up" of Re & Im
// 2) account for non-linear phase response of PDN
start = size + 779;  // size = 2048, sampleRate = 44100

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

0.5.wait;
        }
    )
}.fork
)

[2] - US Patent 1,666,206, Modulation System, April 17, 1928, United States Patent and Trademark Office.

[3] - B. Hutchins, “The Design of Wideband Analog 90° Phase Differencing Networks without Large Spread of Capacitor Values”, Electronotes, Special Issue G, No. 168, http://electronotes.netfirms.com/EN168-90degreePDN.PDF, accessed 2017-08-08.

[4] - 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.

[5] - decrement

[6] - Aka, frequency-shifting.

helpfile source: /home/stefan/.local/share/SuperCollider/downloaded-quarks/Hilbert/HelpSource/Classes/HilbertPDN.schelp
link::Classes/HilbertPDN::

HilbertPDN : Object
Extension

Description

Class Methods

HilbertPDN.ar(in, mul: 1.0, add: 0)

Arguments:

Returns:

HilbertPDN.arRotate(in, angle: 0.0, mul: 1, add: 0)

Arguments:

Returns:

HilbertPDN.arSSB(in, freq: 0.0, mul: 1, add: 0)

Arguments:

Returns:

HilbertPDN.arMag(in, mul: 1, add: 0)

Arguments:

Returns:

HilbertPDN.arPhase(in, mul: 1, add: 0)

Arguments:

Returns:

Inherited class methods

Undocumented class methods

HilbertPDN.calcSOSCoefs(poles)

Instance Methods

Inherited instance methods

Examples

ar

arRotate

arSSB

arMag

arPhase

Frequency response

Magnitude

Phase

in	The input signal to transform.
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.
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.
mul	Output will be multiplied by this value.
add	This value will be added to the output.

in	The input signal to analyze.
mul	Output will be multiplied by this value.
add	This value will be added to the output.

HilbertPDN : Object Extension

HilbertPDN.ar(in, mul: 1.0, add: 0)

Arguments:

Returns:

HilbertPDN.arRotate(in, angle: 0.0, mul: 1, add: 0)

Arguments:

Returns:

HilbertPDN.arSSB(in, freq: 0.0, mul: 1, add: 0)

Arguments:

Returns:

HilbertPDN.arMag(in, mul: 1, add: 0)

Arguments:

Returns:

HilbertPDN.arPhase(in, mul: 1, add: 0)

Arguments:

Returns:

HilbertPDN.calcSOSCoefs(poles)

HilbertPDN : Object
Extension