de.sciss.fscape.graph

Automatic range control UGen. It traces the range of a windowed input signal.

If all values of a window are the same, the lo value is output.

An affine transformation UGen for image rotation, scaling, translation, shearing. It uses either a sinc-based band-limited resampling algorithm, or bicubic interpolation, depending on the zeroCrossings parameter.

All window defining parameters (widthIn, heightIn, widthOut, heightOut) are polled once per matrix. All matrix and filter parameters are polled one per output pixel.

A UGen that produces an arithmetic sequence of values. If both start and step are of integer type (Int or Long), this produces an integer output, otherwise it produces a floating point output.

E.g. ArithmSeq(start = 1, step = 2) will produce a series 1, 3, 5, 7, ....

A UGen that reads in an audio file. The output signal is the monotonously increasing number of frames written, which can be used to monitor progress or determine the end of the writing process. The UGen keeps running until the in signal ends.

A binary operator UGen, for example two sum or multiply two signals. The left or a input is "hot", i.e. it keeps the UGen running, while the right or b input may close early, and the last value will be remembered.

A second order filter section (biquad) UGen. Filter coefficients are given directly rather than calculated for you. The formula is equivalent to:

y(n) = b0 * x(n) + b1 * x(n-1) + b2 * x(n-2) - a1 * y(n-1) - a2 * y(n-2)

where x is in, and y is the output. Note the naming and signum of the coefficients differs from SuperCollider's SOS.

A blob detection UGen. It is based on the meta-balls algorithm by Julien Gachadoat (http://www.v3ga.net/processing/BlobDetection/).

Currently, we output four channels:

• 0 - numBlobs - flushes for each window one element with the number of blobs detected
• 1 - bounds - quadruplets of xMin, xMax, yMin, yMax - for each blob
• 2 - numVertices - the number of vertices (contour coordinates) for each blob
• 3 - vertices - tuples of x and y for the vertices of each blob

Inserts a buffer into the stream of up to size frames.

Straight outta ScalaCollider.

A comb filter delay line UGen with no interpolation.

'''Warning:''' window parameter modulation is currently not working correctly (issue #30)

'''Warning:''' window parameter modulation is currently not working correctly (issue #30)

Binary operator assuming operands are complex signals (real and imaginary interleaved). Outputs another complex stream even if the operator yields a purely real-valued result.

XXX TODO - need more ops such as conjugate, polar-to-cartesian, ...

Binary operation UGen between two complex signals. Complex signals are represented by interleaved real and imaginary components.

'''Note:''' Unlike the "normal" real-valued BinaryOp, this UGen terminates as soon as one of the two inputs a or b terminates.

Unary operator assuming stream is complex signal (real and imaginary interleaved). Outputs another complex stream even if the operator yields a purely real-valued result (ex. abs).

XXX TODO - need more ops such as conjugate, polar-to-cartesian, ...

Concatenates two signals.

A scalar constant used as an input to a UGen.

A UGen that performs a constant Q spectral analysis, using an already FFT'ed input signal. For each input window, the output signal consists of numBands filter output values. These values are '''squared''', since further processing might need to decimate them again or take the logarithm. Otherwise the caller needs to add .sqrt to get the actual filter outputs.

The default settings specify a range of nine octaves and numBands = 432 thus being 48 bands per octave. At 44.1 kHz, the default minimum frequency would be 35.28 Hz, the maximum would be 18063.36 Hz.

A scalar information UGen that reports the control block size.

A UGen that convolves an input signal with a fixed or changing filter kernel. kernelUpdate is read synchronous with in, and while it is zero the most recent kernel is reused (making it possible to use more efficient calculation in the frequency domain). When kernelUpdate becomes 1, a new kernel is polled.

For example, if you want to update the kernel every ten sample frames, then kernelUpdate could be given as Metro(10).tail or Metro(10, 1). If the kernel is never updated, then kernelUpdate could be given as constant zero. If a new kernel is provided for each input sample, the value could be given as constant one.

Creates a constant infinite signal.

A UGen for type II discrete cosine transform.

An envelope generator UGen similar to SuperCollider's DemandEnvGen.

For each parameter of the envelope (levels, durations and shapes), values are polled every time a new segment starts. The UGen keeps running as long as level inputs are provided. If any of the other inputs terminate early, their last values will be used for successive segments (e.g. one can use a constant length or shape).

Note that as a consequence of having a "hot" levels input, the target level of the last segment may not be reached, as the UGen would terminate one sample earlier. As a workaround one can duplicate the last level value with a length of 1.

The difference to DemandEnvGen is that this UGen does not duplicate functionality in the form of levelScale, levelBias, timeScale, and it does not provide reset and gate functionality. Durations are given as lengths in sample frames.

A debugging UGen that completes a promise with the input values it sees.

A debugging UGen that completes a promise with the input values it sees.

A debugging UGen that completes a promise with the input values it sees.

A debugging UGen that installs a persistent no-op sink, allowing the in UGen to remain in the graph even if it does not have a side-effect and it is not connected to any other graph element.

A UGen that passes through its input, and upon termination prints the number of frames seen.

For convenience, import DebugThrough._ allows to write

 val sin = SinOsc(freq) <| "my-sin"

A UGen that outputs triggers for local maxima within a sliding window. If multiple local maxima occur within the current window, only the one with the largest value will cause the trigger.

By definition, the first and last value in the input stream cannot qualify for local maxima.

If a local maximum spreads across multiple samples (adjacent values are the same), the location of the last sample is reported.

A UGen that outputs the differences between adjacent input samples.

The length of the signal is the length of the input. The first output will be the first input (internal x1 state is zero).

A UGen that collects distinct values from the input and outputs them in the original order.

'''Note:''' Currently keeps all seen values in memory.

A UGen that outputs a single frame of 1 when the input is finished.

Inserts a buffer into the stream of num blocks.

A single channel UGen of zero length.

First stage of a feedback process. This UGen outputs the signal eventually fed to it via .back.

A UGen that filters its input, retaining only those elements in the output sequence for which the predicate gate holds.

You can think of it as Gate but instead of outputting zeroes when the gate is closed, no values are output at all. Consequently, the length of the output stream will differ from the length of the input stream.

A graph element that flattens the channels from a nested multi-channel structure.

We operate on a complex cepstrum (size is the number of complex frames). We distinguish a left L (causal) and right R (anti-causal) half. The formulas then are

reL_out = crr * reL + ccr * reR
reR_out = clr * reR + car * reL
imL_out = cri * imL + cci * imR
imR_out = cli * imR + cai * imL

Note that causal and anti-causal are misnamed in the coefficient.

For example, to make the signal causal for minimum phase reconstruction: We add the conjugate anti-causal (right) part to the causal (left) part: crr = 1, ccr = 1, cri = 1, cci = -1 and clear the anti-causal (right) part: clr = 0, car = 0, cli = 0, cai = 0 (you can just call FoldCepstrum.minPhase for this case)

Disk-buffered (large) Fourier transform. Output windows will have a complex size of (size + padding).nextPowerOfTwo

A UGen that generates a signal that incrementally counts the frames of its input. The first value output will be 1, and the last will correspond to the number of frames seen, i.e. Length(in).

A UGen that passes through its input while the gate is open, and outputs zero while the gate is closed.

A repeated window generator UGen. It repeats the same window again and again (unless parameters are modulated). The parameters are demand-rate, polled once per window.

A UGen that produces a geometric sequence of values. If both start and grow are of integer type (Int or Long), this produces an integer output, otherwise it produces a floating point output.

E.g. GeomSeq(start = 1, grow = 2) will produce a series 1, 2, 4, 8, ....

A UGen similar to GIMP's Slur image filter. Instead of a hard-coded kernel, the probability table must be provided as a separate input. The kernel width and height should be odd, so that the kernel is considered to be symmetric around each input image's pixel. If they are odd, the centre corresponds to integer divisions kernelWidth/2 and kernelHeight/2.

A UGen that orthogonalizes an input matrix using the stabilized Gram-Schmidt algorithm. It processes the row vectors per matrix by making them orthogonal to one another, optionally also orthonormal.

A second order high-pass filter UGen. It implements the same type of filter as the SuperCollider equivalent.

A UGen that produces a continuous hash value, useful for comparisons and debugging applications. The hash is produced using the 64-bit Murmur 2 algorithm, however the continuous output is given without "finalising" the hash, and it is not initialized with the input's length (as it is unknown at that stage).

'''Not yet implemented:''' Only after the input terminates, one additional sample of finalised hash is given (you can use .last to only retain the final hash).

A UGen that calculates running histogram of an input signal with given boundaries and bin-size. The bins are divided linearly, if another mapping (e.g. exponential) is needed, it must be pre-applied to the input signal.

'''Note:''' currently parameter modulation (bin, lo, hi, mode, reset) is not working correctly.

Beginning of a conditional block.

A side effecting conditional block. To turn it into a full if-then-else construction, call Else or ElseIf.

Reads a sequence of images, outputting them directly one after the other, determining their file names by formatting a template with a numeric argument given through indices.

Writes a sequence of images, taken their data one by one from the input in, and writing them to individual files, determining their file names by formatting a template with a numeric argument given through indices.

Impulse (repeated dirac) generator. For a single impulse that is never repeated, use zero.

A UGen that generates a signal that incrementally counts the frames of its input. The first value output will be 0, and the last will correspond to the number of frames seen minutes one.

Aliased sawtooth oscillator. Note that the frequency is not in Hertz but the normalized frequency as we do not maintained one global sample rate. For a frequency in Hertz, freqN would be that frequency divided by the assumed sample rate.

'''Note:''' Unlike SuperCollider where LFSaw starts at zero for a zero phase, this oscillator begins at -1. To let it start at zero, use a phase of 0.5

A second order low-pass filter UGen. It implements the same type of filter as the SuperCollider equivalent.

A sample-and-hold UGen. It passes through its input while the gate is open, and outputs the last held value while the gate is closed.

A filter UGen to remove very low frequency content DC offset.

This is a one-pole highpass filter implementing the formula

y[n] = x[n] - x[n-1] + coeff * y[n-1]

Reports the length of the input as a single value one the input has terminated.

A UGen that limits the amplitude of its input signal. Modelled after FScape 1.0 limiter module. N.B.: The UGen outputs a gain control signal, so the input must be multiplied by this signal to obtain the actually limited signal.

A UGen that solves the traveling salesman problem (TSP) using the Lin-Kernighan heuristic. For each input value of size, a corresponding initial tour and edge weight sequence are read, the tour is optimized and output along with the tour's cost.

Currently, we output two channels:

• 0 - tour - the optimized tour
• 1 - cost - the cost of the optimized tour, i.e. the sum of its edge weights

A line segment generating UGen. The UGen terminates when the segment has reached the end.

A line can be used to count integers (in the lower ranges, where floating point noise is not yet relevant), e.g. Line(a, b, b - a + 1) counts from a to b (inclusive).

A loudness measurement UGen, using Zwicker bands. One value in Phon per window is output.

The original algorithm outputs a minimum value of 3.0. This is still the case, but if a window is entirely silent (all values are zero), the output value is also 0.0. Thus one may either distinguish between these two cases, or just treat output value of <= 3.0 as silences.

A UGen that extends or truncates its first argument to match the length of the second argument. If in is shorter than ref, it will be padded with the zero element of its number type. If in is longer, the trailing elements will be dropped.

Note: mode is not yet implemented.

A UGen that stitches together sequences of sub-matrices to a larger matrix. The matrix dimensions and offsets are updated per "matrix chunk" which is are columnsOuter/columnNum input matrices of size rowsInner * columnsInner. In other words, the UGen has no intrinsic knowledge of the height of the output matrix.

For example, if the input matrices are of size (5, 6) (rows, columns), and we want to assemble the cells (1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), that is copped matrices of size (2, 3) beginning at the second row and second column, and we want the outer matrix to have 9 columns, so that each three input matrices appear horizontally next to each other, the settings would be rowsInner = 5, columnsInner = 6, columnsOuter = 9, rowOff = 1, columnOff = 1, rowNum = 2, columnNum = 3.

For more complex behaviour, such as skipping particular rows or columns, ScanImage can be used.

A UGen that maps short-time Fourier transformed spectra to the mel scale. To obtain the MFCC, one has to take the log of the output of this UGen and decimate it with a DCT.

Example:

def mfcc(in: GE) = {
 val fsz  = 1024
 val lap  = Sliding(in, fsz, fsz/2) * GenWindow(fsz, GenWindow.Hann)
 val fft  = Real1FFT(lap, fsz, mode = 1)
 val mag  = fft.complex.mag.max(-80)
 val mel  = MelFilter(mag, fsz/2, bands = 42)
 DCT_II(mel.log, 42, 13, zero = 0)
}

Metronome (repeated dirac) generator. For a single impulse that is never repeated, use a period of zero. Unlike Impulse which uses a frequency and generates fractional phases prone to floating point noise, this is UGen is useful for exact sample frame spacing. Unlike Impulse, the phase cannot be modulated.

A UGen that normalizes each input window according to a mode. It can be used for normalizing the value range or removing DC offset. If the last window is not entirely filled, the output will pad that window always to zero (no matter the normalization mode!)

A window size of 1 should be avoided (and does not really make sense), although the UGen makes efforts to not output NaN values.

A graph element that produces an integer with number-of-channels of the input element.

Overlapping window summation with offset (fuzziness) that can be modulated.

A one pole (IIR) filter UGen. Implements the formula :

out(i) = ((1 - abs(coef)) * in(i)) + (coef * out(i-1))

A one pole (IIR) filter UGen applied to windowed data. Implements the formula :

out(i) = ((1 - abs(coef)) * in(i)) + (coef * out(i-1))

This filter runs in parallel for all frames of the window (or matrix). That is, in the above formula out is replaced by each window element, and i is the window count.

A UGen that performs overlap-and-add operation on a stream of input windows. The size and step parameters are demand-rate, polled once per (input) window.

'''Warning:''' window parameter modulation is currently not working correctly (issue #30)

'''Warning:''' window parameter modulation is currently not working correctly (issue #30)

A UGen that calculates the Pearson product-moment correlation coefficient of two input matrices.

A UGen that writes the pixels of an image using an x and y input signal. It uses either a sinc-based band-limited resampling algorithm, or bicubic interpolation, depending on the zeroCrossings parameter.

All window defining parameters (width, height) are polled once per matrix. All writing and filter parameters are polled one per output pixel.

A graph element that implements Boersma's auto-correlation based pitch tracking algorithm.

cf. Paul Boersma, ACCURATE SHORT-TERM ANALYSIS OF THE FUNDAMENTAL FREQUENCY AND THE HARMONICS-TO-NOISE RATIO OF A SAMPLED SOUND, Institute of Phonetic Sciences, University of Amsterdam, Proceedings 17 (1993), 97-110

Note that this is currently implemented as a macro, thus being quite slow. A future version might implement it directly as a UGen. Currently stepSize is automatically given, and windowing is fixed to Hann.

A UGen that takes concurrent pitch tracker paths, and conditions them for the Viterbi algorithm. The inputs are typically taken from AutoCorrelationPitches, and from this a suitable add signal is produced to be used in the Viterbi UGen. The output are matrices of size (numIn + 1).squared.

'''Warning:''' This is still not thoroughly tested.

Debugging utility that plots 1D "windows" of the input data.