HilbertH | 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.²

[1] this is a composite pseudo UGen. HilbertH is built with DelayN and Convolution2. Method *arSSB also includes SinOsc.

Class Methods

.ar

The Hilbert Transform, returning two signals in phase-quadrature. Considered as a complex analytic signal,³ the first may be regarded as the real component and the second as the imaginary.

Arguments:

in	The input signal to transform.
size	The size of the kernel used for Hartley Phasing filtering.
mul	Output will be multiplied by this value.
add	This value will be added to the output.

Returns:

An array of channels: [real, imag]

NOTE: The kernel used for Hartley Phasing filtering is windowed with the Signal: *kaiserWindow, where alpha is set to 1.

.calcRealCoeffs

Generate real coefficients.

Arguments:

size	The size of the kernel used for Hartley Phasing filtering.

Discussion:

WARNING: To be deprecated! Use Signal *hilbert.real instead.

.calcImagCoeffs

Generate imaginary coefficients.

Arguments:

size	The size of the kernel used for Hartley Phasing filtering.

Discussion:

WARNING: To be deprecated! Use Signal *hilbert.imag instead.

Frequency response

Magnitude

The real output of HilbertH returns an allpass magnitude response.

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

The real output of HilbertH 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/2 + 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 Hartley : HilbertH

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 - s.options.blockSize;  // offset - for kernel normalized to sample delay

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

fork {
    { // [real,imag]
        HilbertH.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]; HilbertH; Impulse input", minval: -1, maxval: 1);
        }
        }
    );

0.5.wait;

{ // plot magnitude - [real,imag]
        HilbertH.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
        HilbertH.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
        HilbertH.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 Hartley : HilbertH

single cosine cycle: period = size
*/

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

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

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

{ // [real,imag]
    HilbertH.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]; HilbertH; Cosine input", minval: -1, maxval: 1);
    }
}
);
)

arRotate

/*
        TEST Hartley : *arRotate

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

size = 2048;
overSample = 4;
// plot: jump to the 2nd cycle, to account for "warm up" of Im kernel
start = 2 * size + ((size/ 2).floor).asInt - 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
                HilbertH.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("HilbertH *arRotate; Angle = % degrees", angle.raddeg), minval: -1, maxval: 1);
                }
            }
            );

0.5.wait;
        }
    )
}.fork
)

arSSB

/*
        TEST Hartley : *arSSB

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

size = 2048;
overSample = 4;
// plot: jump to the 2nd cycle, to account for "warm up" of Im kernel
start = 2 * size + ((size/ 2).floor).asInt - 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
                HilbertH.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("HilbertH *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_HilbertH_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,
        HilbertH.arSSB(
            sig,
            freq: shft,
            size: 2048,
            mul: amp,
        )
    )
}).add
)

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

single cosine cycle: period = size
*/

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

size = 2048;
overSample = 4;
// plot: jump to the 2nd cycle, to account for "warm up" of Im kernel
start = 2 * size + ((size/ 2).floor).asInt - 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
                HilbertH.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("HilbertH *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] - US Patent 1,666,206, Modulation System, April 17, 1928, United States Patent and Trademark Office.

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

[4] - decrement

[5] - Aka, frequency-shifting.

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

HilbertH
Extension

Description

Class Methods

.ar

Arguments:

Returns:

.arRotate

Arguments:

Returns:

.arSSB

Arguments:

Returns:

.arMag

Arguments:

Returns:

.arPhase

Arguments:

Returns:

.calcRealCoeffs

Arguments:

Discussion:

.calcImagCoeffs

Arguments:

Discussion:

Frequency response

Magnitude

Phase

Examples

ar

arRotate

arSSB

arMag

arPhase

in	The input signal.
angle	Rotation angle, in radians.
size	The size of the kernel used for Hartley Phasing 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 kernel used for Hartley Phasing 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 kernel used for Hartley Phasing filtering.
mul	Output will be multiplied by this value.
add	This value will be added to the output.

HilbertHExtension

.ar

Arguments:

Returns:

.arRotate

Arguments:

Returns:

.arSSB

Arguments:

Returns:

.arMag

Arguments:

Returns:

.arPhase

Arguments:

Returns:

.calcRealCoeffs

Arguments:

Discussion:

.calcImagCoeffs

Arguments:

Discussion:

HilbertH
Extension