package graph
- Alphabetic
- Public
- Protected
Type Members
- final case class ARCWindow(in: D, size: I, lo: D = 0.0, hi: D = 1.0, lag: D = 0.96) extends SingleOut[Double] with Product with Serializable
Automatic range control UGen.
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.- in
signal to adjust
- size
window size of input
- lo
desired lower margin of output
- hi
desired upper margin of output
- lag
lag or feedback coefficient
- final case class AffineTransform2D(in: D, widthIn: I, heightIn: I, widthOut: I = 0, heightOut: I = 0, m00: D, m10: D, m01: D, m11: D, m02: D, m12: D, wrap: I = 1, rollOff: D = 0.86, kaiserBeta: D = 7.5, zeroCrossings: I = 15) extends SingleOut[Double] with Product with Serializable
An affine transformation UGen for image rotation, scaling, translation, shearing.
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.- in
the signal to resample
- widthIn
the width (number of columns) of the input matrix
- heightIn
the height (number of rows) of the input matrix
- widthOut
the width (number of columns) of the output matrix. the special value zero (default) means it is the same as
widthIn
.- heightOut
the height (number of rows) of the output matrix. the special value zero (default) means it is the same as
heightIn
.- m00
coefficient of the first column of the first row (scale-x)
- m10
coefficient of the first column of the second row (shear-y)
- m01
coefficient of the second column of the first row (shear-x)
- m11
coefficient of the second column of the second row (scale-y)
- m02
coefficient of the third column of the first row (translate-x)
- m12
coefficient of the third column of the second row (translate-y)
- wrap
if non-zero, wraps coordinates around the input images boundaries. TODO: currently
wrap = 0
is broken if using sinc interpolation!- rollOff
the FIR anti-aliasing roll-off width. Between zero and one.
- kaiserBeta
the FIR windowing function's parameter
- zeroCrossings
the number of zero-crossings in the truncated and windowed sinc FIR. If zero, algorithm uses bicubic interpolation instead.
- See also
- final case class ArithmSeq[A, L](start: GE[A] = 0, step: GE[A] = 1, length: GE[L] = Long.MaxValue)(implicit num: Num[A], numL: NumInt[L]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
A UGen that produces an arithmetic sequence of values.
A UGen that produces an arithmetic sequence of values. If both
start
andstep
are of integer type (Int
orLong
), this produces an integer output, otherwise it produces a floating point output.E.g.
ArithmSeq(start = 1, step = 2)
will produce a series1, 3, 5, 7, ...
.- start
the first output element
- step
the amount added to each successive element
- length
the number of elements to output
- final case class AudioFileIn(file: URI, numChannels: Int) extends MultiOut[Double] with Product with Serializable
- final case class AudioFileOut(in: D, file: URI, spec: AudioFileSpec) extends SingleOut[Long] with Product with Serializable
A UGen that reads in an audio file.
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.- in
the signal to write.
- file
the file to write to
- spec
the spec for the audio file, including numbers of channels and sample-rate
- final case class BinaryOp[A, B, C](op: Op[A, B, C], a: GE[A], b: GE[B]) extends SingleOut[C] with Product with Serializable
A binary operator UGen, for example two sum or multiply two signals.
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 orb
input may close early, and the last value will be remembered.- op
the operator (e.g.
BinaryOp.Times
)- a
the left operand which determines how long the UGen computes
- b
the right operand.
- final case class Biquad(in: D, b0: D = 0.0, b1: D = 0.0, b2: D = 0.0, a1: D = 0.0, a2: D = 0.0) extends SingleOut[Double] with Product with Serializable
A second order filter section (biquad) UGen.
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
isin
, andy
is the output. Note the naming and signum of the coefficients differs from SuperCollider'sSOS
. - final case class Bleach(in: D, filterLen: I = 256, feedback: D = 0.001, filterClip: D = 8.0) extends SingleOut[Double] with Product with Serializable
An adaptive filter UGen capable of removing resonances from an input signal.
An adaptive filter UGen capable of removing resonances from an input signal. It does so by continuously maintaining a filter kernel inverse to the input signal. The output is the continuous application of the current filter to the input, thus "whitening" the signal.
One can obtain a "colored" signal by subtracting the output of this UGen from the input signal.
- in
the signal to analyze and to filter
- filterLen
the length of the FIR filter
- feedback
the adaptation speed of the filter. Lower values mean it takes longer for the filter to adjust to input signal, higher values mean it is faster changing according to the input. Typical values are in the order of -60 dB.
- filterClip
a clipping threshold for the filter coefficients, to avoid that a filter "explodes". Each filter coefficient is clipped to have a magnitude no larger than the given clip value.
- See also
- final case class BleachKernel(in: D, filterLen: I = 256, feedback: D = 0.001, filterClip: D = 8.0) extends SingleOut[Double] with Product with Serializable
An UGen that outputs an adaptive filter kernel based on an input signal.
An UGen that outputs an adaptive filter kernel based on an input signal. The finite impulse response kernel can be used to remove resonances from the input signal. This UGen operates like the
Bleach
UGen, but instead of filtering the input, it outputs the raw filter coefficients. For each input sample,filterLen
output samples will be generated, representing the current kernel.If one is only interested in a "final" kernel, one can just
TakeRight
the lastfilterLen
output samples.- in
the signal to analyze
- filterLen
the length of the FIR filter
- feedback
the adaptation speed of the filter. Lower values mean it takes longer for the filter to adjust to input signal, higher values mean it is faster changing according to the input. Typical values are in the order of -60 dB.
- filterClip
a clipping threshold for the filter coefficients, to avoid that a filter "explodes". Each filter coefficient is clipped to have a magnitude no larger than the given clip value.
- See also
- final case class Blobs2D(in: D, width: I, height: I, thresh: D = 0.3, pad: I = 0) extends MultiOut[Any] with Product with Serializable
A blob detection UGen.
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 ofxMin
,xMax
,yMin
,yMax
- for each blob - 2 -numVertices
- the number of vertices (contour coordinates) for each blob - 3 -vertices
- tuples ofx
andy
for the vertices of each blob- in
the image(s) to analyse
- width
the width of the image
- height
the height of the image
- thresh
the threshold for blob detection between zero and one
- pad
size of "border" to put around input matrices. If greater than zero, a border of that size is created internally, filled with the threshold value
- final case class BufferDisk[A](in: GE[A])(implicit num: Num[A]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
- final case class BufferMemory[A](in: GE[A], size: I) extends SingleOut[A] with Product with Serializable
Inserts a buffer into the stream of up to
size
frames. - final case class ChannelProxy[A](elem: GE[A], index: Int) extends GE.Lazy[A] with Product with Serializable
Straight outta ScalaCollider.
- final case class Clip[A](in: GE[A], lo: GE[A], hi: GE[A])(implicit num: Num[A]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
- final case class CombN(in: D, maxLength: I, length: I, decay: D = 44100.0) extends SingleOut[Double] with Product with Serializable
A comb filter delay line UGen with no interpolation.
A comb filter delay line UGen with no interpolation.
- in
the signal to filter
- maxLength
the maximum delay time in sample frames. this is only read once and constrains the values of
length
- length
the delay time in sample frames. The value can be obtained from the delay time in seconds by multiplication with the sampling rate.
- decay
the feedback's -60 dB decay time in sample frames. The value can be obtained from the decay time in seconds by multiplication with the sampling rate. Negative numbers are allowed and mean that the feedback signal is phase inverted.
- final case class Complex1FFT(in: D, size: I, padding: I = 0) extends FFTFullUGen with Product with Serializable
- final case class Complex1IFFT(in: D, size: I, padding: I = 0) extends FFTFullUGen with Product with Serializable
- final case class Complex2FFT(in: D, rows: I, columns: I = 0) extends FFT2FullUGen with Product with Serializable
Warning: window parameter modulation is currently not working correctly (issue #30)
- final case class Complex2IFFT(in: D, rows: I, columns: I = 0) extends FFT2FullUGen with Product with Serializable
Warning: window parameter modulation is currently not working correctly (issue #30)
- final case class ComplexBinaryOp(op: Int, a: D, b: D) extends SingleOut[Double] with Product with Serializable
Binary operation UGen between two complex signals.
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 inputsa
orb
terminates. - final case class ComplexUnaryOp(op: Int, in: D) extends SingleOut[Double] with Product with Serializable
- final case class Concat[A](a: GE[A], b: GE[A]) extends SingleOut[A] with Product with Serializable
Concatenates two signals.
- sealed trait Const[A1] extends UGenIn[A1] with StreamIn
A scalar constant used as an input to a UGen.
- final case class ConstB(value: Boolean) extends Const[Boolean] with StreamIn with Product with Serializable
- final case class ConstD(value: Double) extends Const[Double] with DoubleLike with Product with Serializable
- final case class ConstI(value: Int) extends Const[Int] with IntLike with Product with Serializable
- final case class ConstL(value: Long) extends Const[Long] with LongLike with Product with Serializable
- final case class ConstQ(in: D, fftSize: I, minFreqN: D = 0.0008, maxFreqN: D = 0.4096, numBands: I = 432) extends SingleOut[Double] with Product with Serializable
A UGen that performs a constant Q spectral analysis, using an already FFT'ed input signal.
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.- in
the input signal which has already been windowed and FFT'ed using
Real1FFT
in mode 0 or 2. The windows should have been rotated prior to the FFT so that the time signal starts in the middle of the window and then wraps around.- fftSize
the fft size which corresponds with the window size of the input
- minFreqN
the normalized minimum frequency (frequency in Hz, divided by the sampling rate). should be greater than zero and less than or equal to 0.5.
- maxFreqN
the normalized maximum frequency (frequency in Hz, divided by the sampling rate). should be greater than zero and less than or equal to 0.5.
- numBands
the number of bands or kernels to apply, spreading them evenly (logarithmically) across the range from minimum to maximum frequency.
- final case class ControlBlockSize() extends SingleOut[Int] with Product with Serializable
A scalar information UGen that reports the control block size.
- final case class Convolution(in: D, kernel: D, kernelLen: I, kernelUpdate: B = false, mode: I = 0) extends SingleOut[Double] with Product with Serializable
A UGen that convolves an input signal with a fixed or changing filter kernel.
A UGen that convolves an input signal with a fixed or changing filter kernel.
kernelUpdate
is read synchronous within
, and while it is zero the most recent kernel is reused (making it possible to use more efficient calculation in the frequency domain). WhenkernelUpdate
becomes1
, a newkernel
is polled.For example, if you want to update the kernel every ten sample frames, then
kernelUpdate
could be given asMetro(10).tail
orMetro(10, 1)
. If the kernel is never updated, thenkernelUpdate
could be given as constant zero. If a new kernel is provided for each input sample, the value could be given as constant one.- in
the signal to be filtered
- kernel
the filter kernel. This is read in initially and when
kernelUpdate
is one.- kernelLen
the filter length in sample frames. One value is polled whenever a new kernel is required.
- kernelUpdate
a gate value read synchronous with
in
, specifying whether a new kernel is to be read in (non-zero) after the next frame, or if the previous kernel is to be reused (zero, default).- mode
currently unused; leave at zero
- final case class DC[A](in: GE[A]) extends SingleOut[A] with Product with Serializable
Creates a constant infinite signal.
- final case class DCT_II(in: D, size: I, numCoeffs: I, zero: I = 0) extends SingleOut[Double] with Product with Serializable
A UGen for type II discrete cosine transform.
A UGen for type II discrete cosine transform.
- in
input signal
- size
input signal window size
- numCoeffs
number of coefficients output
- zero
if zero (default), the zero'th coefficient is skipped in the output, if greater than zero, the zero'th coefficient is included. In any case, the output window size is
numCoeffs
.
- final case class DEnvGen[L](levels: D, lengths: GE[L], shapes: I = 1, curvatures: D = 0.0)(implicit numL: NumInt[L]) extends SingleOut[Double] with ProductWithAdjuncts with Product with Serializable
An envelope generator UGen similar to SuperCollider's DemandEnvGen.
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 oflevelScale
,levelBias
,timeScale
, and it does not providereset
andgate
functionality. Durations are given as lengths in sample frames. - case class DebugAnyPromise[A](in: GE[A], p: Promise[IndexedSeq[Any]]) extends ZeroOut with Product with Serializable
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.
- in
the signal to monitor
- case class DebugDoublePromise(in: D, p: Promise[IndexedSeq[Double]]) extends ZeroOut with Product with Serializable
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.
- in
the signal to monitor
- case class DebugIntPromise(in: I, p: Promise[IndexedSeq[Int]]) extends ZeroOut with Product with Serializable
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.
- in
the signal to monitor
- case class DebugSink[A](in: GE[A]) extends ZeroOut with Product with Serializable
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 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.- in
the element to keep inside the graph
- final case class DebugThrough[A](in: GE[A], label: String) extends SingleOut[A] with Product with Serializable
A UGen that passes through its input, and upon termination prints the number of frames seen.
A UGen that passes through its input, and upon termination prints the number of frames seen.
For convenience,
import DebugThrough._
allows to writeval sin = SinOsc(freq) <| "my-sin"
- in
the input to be pulled.
- label
an identifying label to prepend to the printing.
- final case class DelayN[A](in: GE[A], maxLength: I, length: I) extends SingleOut[A] with Product with Serializable
- final case class DetectLocalMax[A](in: GE[A], size: I)(implicit ord: Ord[A]) extends SingleOut[Boolean] with ProductWithAdjuncts with Product with Serializable
A UGen that outputs triggers for local maxima within a sliding window.
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.
- in
the signal to analyze for local maxima
- size
the sliding window size. Each two emitted triggers are spaced apart at least by
size
frames.
- final case class Differentiate[A](in: GE[A])(implicit num: Num[A]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
A UGen that outputs the differences between adjacent input samples.
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).
- final case class Distinct[A](in: GE[A])(implicit eq: Eq[A]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
A UGen that collects distinct values from the input and outputs them in the original order.
A UGen that collects distinct values from the input and outputs them in the original order.
Note: Currently keeps all seen values in memory.
- final case class Done[A](in: GE[A]) extends SingleOut[Boolean] with Product with Serializable
A UGen that outputs a single frame of
1
when the input is finished. - final case class Drop[A, L](in: GE[A], length: GE[L])(implicit numL: NumInt[L]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
- final case class DropRight[A, L](in: GE[A], length: GE[L])(implicit numL: NumInt[L]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
- final case class DropWhile[A](in: GE[A], p: B) extends SingleOut[A] with Product with Serializable
- final case class Elastic[A](in: GE[A], num: I = 1) extends SingleOut[A] with Product with Serializable
Inserts a buffer into the stream of
num
blocks. - final case class ElseGE[A](pred: IfOrElseIfThen[GE[A]], branch: Graph, result: GE[A]) extends ElseLike[GE[A]] with GE.Lazy[A] with Product with Serializable
- final case class ElseIf[+A](pred: IfOrElseIfThen[A], cond: B) extends Product with Serializable
- final case class ElseIfThen[+A](pred: IfOrElseIfThen[A], cond: B, branch: Graph, result: A) extends IfThenLike[A] with ElseOrElseIfThen[A] with Product with Serializable
- sealed trait ElseLike[+A] extends ElseOrElseIfThen[A]
- sealed trait ElseOrElseIfThen[+A] extends Then[A]
- final case class ElseUnit(pred: IfOrElseIfThen[Any], branch: Graph) extends ElseLike[Any] with Expander[Unit] with Product with Serializable
- final case class Empty[A]() extends SingleOut[A] with Product with Serializable
A single channel UGen of zero length.
- final case class ExpExp(in: D, inLow: D, inHigh: D, outLow: D, outHigh: D) extends SingleOut[Double] with Product with Serializable
- final case class ExpLin(in: D, inLow: D, inHigh: D, outLow: D, outHigh: D) extends SingleOut[Double] with Product with Serializable
- sealed trait FFT2FullUGen extends SingleOut[Double]
- sealed trait FFT2HalfUGen extends SingleOut[Double]
- sealed trait FFTFullUGen extends SingleOut[Double]
- sealed trait FFTHalfUGen extends SingleOut[Double]
- final case class Feed[A](init: GE[A]) extends GE.Lazy[A] with Product with Serializable
First stage of a feedback process.
First stage of a feedback process. This UGen outputs the signal eventually fed to it via
.back
. - final case class FilterSeq[A](in: GE[A], gate: B) extends SingleOut[A] with Product with Serializable
A UGen that filters its input, retaining only those elements in the output sequence for which the predicate
gate
holds.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.- See also
- final case class Flatten[A](elem: GE[A]) extends GE.Lazy[A] with Product with Serializable
A graph element that flattens the channels from a nested multi-channel structure.
A graph element that flattens the channels from a nested multi-channel structure.
- elem
the element to flatten
- final case class Fold[A](in: GE[A], lo: GE[A], hi: GE[A])(implicit num: Num[A]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
- final case class FoldCepstrum(in: D, size: I, crr: D, cri: D, clr: D, cli: D, ccr: D, cci: D, car: D, cai: D) extends SingleOut[Double] with Product with Serializable
We operate on a complex cepstrum (
size
is the number of complex frames).We operate on a complex cepstrum (
size
is the number of complex frames). We distinguish a leftL
(causal) and rightR
(anti-causal) half. The formulas then arereL_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 callFoldCepstrum.minPhase
for this case) - final case class Fourier[L](in: D, size: GE[L], padding: GE[L] = 0, dir: I = 1, mem: I = 131072)(implicit num: NumInt[L]) extends SingleOut[Double] with ProductWithAdjuncts with Product with Serializable
Disk-buffered (large) Fourier transform.
Disk-buffered (large) Fourier transform. Output windows will have a complex size of
(size + padding).nextPowerOfTwo
- in
input signal to transform. This must be complex (Re, Im interleaved)
- size
the (complex) window size
- padding
the (complex) zero-padding size for each window
- dir
the direction is
1
for forward and-1
for backward transform. other numbers will do funny things.- mem
the amount of frames (chunk size) to buffer in memory. this should be a power of two.
- final case class Frames[A](in: GE[A]) extends SingleOut[Long] with Product with Serializable
A UGen that generates a signal that incrementally counts the frames of its input.
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)
. - final case class Gate[A](in: GE[A], gate: B) extends SingleOut[A] with Product with Serializable
A UGen that passes through its input while the gate is open, and outputs zero while the gate is closed.
- final case class GenWindow[L](size: GE[L], shape: I, param: D = 0.0)(implicit numL: NumInt[L]) extends SingleOut[Double] with ProductWithAdjuncts with Product with Serializable
A repeated window generator UGen.
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.
- size
the window size
- shape
the identifier of the window shape, such as
GenWindow.Hann
.- param
parameter used by some window shapes, such as
GenWindow.Kaiser
- final case class GeomSeq[A, L](start: GE[A] = 1, grow: GE[A] = 2, length: GE[L] = Long.MaxValue)(implicit num: Num[A], numL: NumInt[L]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
A UGen that produces a geometric sequence of values.
A UGen that produces a geometric sequence of values. If both
start
andgrow
are of integer type (Int
orLong
), this produces an integer output, otherwise it produces a floating point output.E.g.
GeomSeq(start = 1, grow = 2)
will produce a series1, 2, 4, 8, ...
.- start
the first output element
- grow
the multiplicative factor by which each successive element will grow
- length
the number of elements to output
- final case class GimpSlur(in: D, width: I, height: I, kernel: D, kernelWidth: I, kernelHeight: I, repeat: I = 1, wrap: I = 0) extends SingleOut[Double] with Product with Serializable
A UGen similar to GIMP's Slur image filter.
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
andkernelHeight/2
.- in
image input
- width
image width
- height
image height
- kernel
normalized and integrated probability table. Like the image, the cells are read horizontally first, every
widthKernel
cell begins a new cell. The cell probabilities must have been integrated from first to last, and must be normalized so that the last cell value equals one. A new kernel signal is read once per input image. (If the signal ends, the previous kernel will be used again).- kernelWidth
width of the kernel signal. Read once per input image.
- kernelHeight
height of the kernel signal. Read once per input image.
- repeat
number of recursive application of the displacement per image. Read once per input image.
- wrap
if great than zero, wraps pixels around the image bounds, otherwise clips.
- final case class GramSchmidtMatrix(in: D, rows: I, columns: I, normalize: I = 0) extends SingleOut[Double] with Product with Serializable
A UGen that orthogonalizes an input matrix using the stabilized Gram-Schmidt algorithm.
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.
- in
the input matrices
- rows
the number of rows of the input
- columns
the number of columns of the input
- final case class HPF(in: D, freqN: D = 0.02) extends SingleOut[Double] with Product with Serializable
A second order high-pass filter UGen.
A second order high-pass filter UGen. It implements the same type of filter as the SuperCollider equivalent.
- in
the signal to filter
- freqN
the normalized cut-off frequency (frequency in Hertz divided by sampling rate)
- final case class Hash[A](in: GE[A]) extends SingleOut[Long] with Product with Serializable
A UGen that produces a continuous hash value, useful for comparisons and debugging applications.
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).- in
the signal to hash.
- final case class Histogram[A](in: GE[A], bins: I, lo: GE[A] = 0, hi: GE[A] = 1, mode: I = 0, reset: B = false)(implicit num: Num[A]) extends SingleOut[Int] with ProductWithAdjuncts with Product with Serializable
A UGen that calculates running histogram of an input signal with given boundaries and bin-size.
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.- in
the input signal
- bins
the number of bins. this is read at initialization time only or when
reset
fires- lo
the lowest bin boundary. input values below this value are clipped. this value may be updated (although that is seldom useful).
- hi
the highest bin boundary. input values above this value are clipped. this value may be updated (although that is seldom useful).
- mode
if
0
(default), outputs only afterin
has finished, if1
outputs the entire histogram for every input sample.- reset
when greater than zero, resets the count.
- See also
- final case class If(cond: B) extends Product with Serializable
Beginning of a conditional block.
Beginning of a conditional block.
- cond
the condition, which is treated as a boolean with zero being treated as
false
and non-zero astrue
. Note that multi-channel expansion does not apply here, because the branches may have side-effects which are not supposed to be repeated across channels. Instead, ifcond
expands to multiple channels, they are combined using logical|
(OR).
- See also
- sealed trait IfOrElseIfThen[+A] extends Then[A]
- final case class IfThen[+A](cond: B, branch: Graph, result: A) extends IfThenLike[A] with Product with Serializable
A side effecting conditional block.
- sealed trait IfThenLike[+A] extends IfOrElseIfThen[A] with Expander[Unit]
- final case class ImageFileIn(file: URI, numChannels: Int) extends MultiOut[Double] with Product with Serializable
- final case class ImageFileOut(in: GE[Double], file: URI, spec: Spec) extends ZeroOut with Product with Serializable
- trait ImageFilePlatform extends AnyRef
- final case class ImageFileSeqIn(template: URI, numChannels: Int, indices: GE[Int]) extends MultiOut[Double] with Product with Serializable
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 throughindices
.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 throughindices
.- template
a file which contains a single placeholder for
java.util.Formatter
syntax, such as%d
to insert an integer number. Alternatively, if the file name does not contain a%
character but a digit or a sequence of digits, those digits will be replaced by%d
to produce a valid template. Therefore, if the template isfoo-123.jpg
and the indices contain4
and5
, then the UGen will read the imagesfoo-4
andfoo-5
(the placeholder123
is irrelevant).
- final case class ImageFileSeqOut(in: D, template: URI, spec: Spec, indices: I) extends ZeroOut with Product with Serializable
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 atemplate
with a numeric argument given throughindices
.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 atemplate
with a numeric argument given throughindices
.- template
a file which contains a single placeholder for
java.util.Formatter
syntax, such as%d
to insert an integer number. Alternatively, if the file name does not contain a%
character but a digit or a sequence of digits, those digits will be replaced by%d
to produce a valid template. Therefore, if the template isfoo-123.jpg
and the indices contain4
and5
, then the UGen will write the imagesfoo-4
andfoo-5
(the placeholder123
is irrelevant).
- final case class Impulse(freqN: D, phase: D = 0.0) extends SingleOut[Boolean] with Product with Serializable
Impulse (repeated dirac) generator.
Impulse (repeated dirac) generator. For a single impulse that is never repeated, use zero.
- freqN
normalized frequency (reciprocal of frame period)
- phase
phase offset in cycles (0 to 1).
- final case class Indices[A](in: GE[A]) extends SingleOut[Long] with Product with Serializable
A UGen that generates a signal that incrementally counts the frames of its input.
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. - final case class LFSaw(freqN: D, phase: D = 0.0) extends SingleOut[Double] with Product with Serializable
Aliased sawtooth oscillator.
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 aphase
of0.5
- freqN
normalized frequency (f/sr). Note: negative values are currently broken.
- phase
phase offset from 0 to 1. Note: negative values are currently broken.
- final case class LPF(in: D, freqN: D = 0.02) extends SingleOut[Double] with Product with Serializable
A second order low-pass filter UGen.
A second order low-pass filter UGen. It implements the same type of filter as the SuperCollider equivalent.
- in
the signal to filter
- freqN
the normalized cut-off frequency (frequency in Hertz divided by sampling rate)
- final case class Latch[A](in: GE[A], gate: B) extends SingleOut[A] with Product with Serializable
A sample-and-hold UGen.
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.
- See also
- final case class LeakDC(in: D, coeff: D = 0.995) extends GE.Lazy[Double] with Product with Serializable
A filter UGen to remove very low frequency content DC offset.
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]
- in
input signal to be filtered
- coeff
the leak coefficient determines the filter strength. the value must be between zero and one (exclusive) for the filter to remain stable. values closer to one produce less bass attenuation.
- final case class Length[A](in: GE[A]) extends SingleOut[Long] with Product with Serializable
Reports the length of the input as a single value one the input has terminated.
- final case class Limiter(in: D, attack: I, release: I, ceiling: D = 1.0) extends SingleOut[Double] with Product with Serializable
A UGen that limits the amplitude of its input signal.
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.
- in
input signal
- attack
the attack duration in frames, as -60 dB point
- release
the release duration in frames, as -60 dB point
- ceiling
the maximum allowed amplitude
- final case class LinExp(in: D, inLow: D, inHigh: D, outLow: D, outHigh: D) extends SingleOut[Double] with Product with Serializable
- final case class LinKernighanTSP(init: I, weights: D, size: I, mode: I = 0, timeOut: D = 0.0) extends MultiOut[Any] with Product with Serializable
A UGen that solves the traveling salesman problem (TSP) using the Lin-Kernighan heuristic.
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- init
the initial tour, for example linear or randomized. Should consist of
size
zero-based vertex indices- weights
the symmetric edge weights, a sequence of length
size * (size - 1) / 2
, sorted as vertex connections (0,1), (0,2), (0,3), ... (0,size-1), (1,2), (1,3), ... (1,size-1), etc., until (size-2,size-1).- size
for each complete graph, the number of vertices.
- mode
currently unused and should remain at the default value of zero.
- timeOut
currently unused and should remain at the default value of zero.
- final case class LinLin(in: D, inLow: D, inHigh: D, outLow: D, outHigh: D) extends SingleOut[Double] with Product with Serializable
- final case class Line[L](start: D, end: D, length: GE[L])(implicit numL: NumInt[L]) extends SingleOut[Double] with ProductWithAdjuncts with Product with Serializable
A line segment generating UGen.
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 froma
tob
(inclusive).- start
starting value
- end
ending value
- length
length of the segment in sample frames
- final case class Loudness(in: D, sampleRate: D, size: I, spl: D = 70, diffuse: I = 1) extends SingleOut[Double] with Product with Serializable
A loudness measurement UGen, using Zwicker bands.
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.- in
the signal to analyse
- sampleRate
sample rate of the input signal
- size
the window size for which to calculate values
- spl
the reference of 0 dBFS in decibels
- diffuse
whether to assume diffuse field (
1
) or free field (0
)
- final case class Masking2D(fg: D, bg: D, rows: I, columns: I, threshNoise: D, threshMask: D, blurRows: I, blurColumns: I) extends SingleOut[Double] with Product with Serializable
- final case class MatchLen[A, B](in: GE[A], ref: GE[B]) extends SingleOut[A] with Product with Serializable
A UGen that extends or truncates its first argument to match the length of the second argument.
A UGen that extends or truncates its first argument to match the length of the second argument. If
in
is shorter thanref
, it will be padded with the zero element of its number type. Ifin
is longer, the trailing elements will be dropped. - final case class MatrixInMatrix[A](in: GE[A], rowsOuter: I, columnsOuter: I, rowsInner: I, columnsInner: I, rowStep: I = 1, columnStep: I = 1, mode: I = 0) extends SingleOut[A] with Product with Serializable
Note:
mode
is not yet implemented. - final case class MatrixOutMatrix[A](in: GE[A], rowsInner: I, columnsInner: I, columnsOuter: I, rowOff: I = 0, columnOff: I = 0, rowNum: I = 1, columnNum: I = 1) extends SingleOut[A] with Product with Serializable
A UGen that stitches together sequences of sub-matrices to a larger matrix.
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 sizerowsInner * 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.- in
the sequence of smaller matrices
- rowsInner
height of the input matrices
- columnsInner
width of input matrices
- columnsOuter
width of the output matrix. Must be an integer multiple of
columnNum
.- rowOff
offset in rows within the input matrices, where copying to the output matrix begins
- columnOff
offset in columns within the input matrices, where copying to the output matrix begins
- rowNum
number of rows to copy from each input matrix
- columnNum
number of columns to copy from each input matrix.
- final case class MelFilter(in: D, size: I, minFreq: D = 55.0, maxFreq: D = 18000.0, sampleRate: D = 44100.0, bands: I = 42) extends SingleOut[Double] with Product with Serializable
A UGen that maps short-time Fourier transformed spectra to the mel scale.
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) }
- in
magnitudes of spectra, as output by
Real1FFT(..., mode = 1).complex.abs
- size
bands in input spectrum (assumed to be
fft-size / 2
). lowest band corresponds to DC and highest to(size - 1)/size * sampleRate/2
.- minFreq
lower frequency to sample. Will be clipped between zero (inclusive) and Nyquist (exclusive).
- maxFreq
upper frequency to sample. Will be clipped between
minFreq
(inclusive) and Nyquist (exclusive).- bands
number of filter bands output
- final case class Metro[A](period: GE[A], phase: GE[A] = 0)(implicit num: NumInt[A]) extends SingleOut[Boolean] with ProductWithAdjuncts with Product with Serializable
Metronome (repeated dirac) generator.
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. UnlikeImpulse
, the phase cannot be modulated.- period
number of frames between impulses. Zero is short-hand for an infinitely long period. One value is read per output period.
- phase
phase offset in frames. One value is read per output period.
- final case class NormalizeWindow(in: D, size: I, mode: I = NormalizeWindow.Normalize) extends SingleOut[Double] with Product with Serializable
A UGen that normalizes each input window according to a mode.
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.
- in
the input signal
- size
the input's window size
- mode
0
for normalizing the amplitude to 1,1
for fitting into the range of 0 to 1,2
for fitting into the range of -1 to 1,3
for removing DC (creating a mean of zero).
- final case class NumChannels[A](in: GE[A]) extends SingleOut[Int] with Product with Serializable
A graph element that produces an integer with number-of-channels of the input element.
- final case class OffsetOverlapAdd[A](in: GE[A], size: I, step: I, offset: I, minOffset: I)(implicit num: Num[A]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
Overlapping window summation with offset (fuzziness) that can be modulated.
- final case class OnePole(in: D, coef: D) extends SingleOut[Double] with Product with Serializable
A one pole (IIR) filter UGen.
A one pole (IIR) filter UGen. Implements the formula :
out(i) = ((1 - abs(coef)) * in(i)) + (coef * out(i-1))
- in
input signal to be processed
- coef
feedback coefficient. Should be between -1 and +1
- final case class OnePoleWindow(in: D, size: I, coef: D) extends SingleOut[Double] with Product with Serializable
A one pole (IIR) filter UGen applied to windowed data.
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, andi
is the window count.- in
input signal to be processed
- size
window size
- coef
feedback coefficient. Should be between -1 and +1
- final case class OverlapAdd[A](in: GE[A], size: I, step: I)(implicit num: Num[A]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
A UGen that performs overlap-and-add operation on a stream of input windows.
A UGen that performs overlap-and-add operation on a stream of input windows. The
size
andstep
parameters are demand-rate, polled once per (input) window.- in
the non-overlapped input
- size
the window size in the input
- step
the step between successive windows in the output. when smaller than
size
, the overlapping portions are summed together. Currentlystep
values larger thansize
are clipped tosize
. This may change in the future
- See also
- final case class PeakCentroid1D(in: D, size: I, thresh1: D = 0.5, thresh2: D = 0.33, radius: I = 1) extends GE.Lazy[Double] with Product with Serializable
Warning: window parameter modulation is currently not working correctly (issue #30)
- final case class PeakCentroid2D(in: D, width: I, height: I, thresh1: D = 0.5, thresh2: D = 0.33, radius: I = 1) extends MultiOut[Double] with Product with Serializable
Warning: window parameter modulation is currently not working correctly (issue #30)
- final case class Pearson(x: D, y: D, size: I) extends SingleOut[Double] with Product with Serializable
A UGen that calculates the Pearson product-moment correlation coefficient of two input matrices.
A UGen that calculates the Pearson product-moment correlation coefficient of two input matrices.
- x
first matrix
- y
second matrix
- size
matrix or window size
- final case class PenImage(src: D = 1.0, alpha: D = 1.0, dst: D = 0.0, width: I, height: I, x: D = 0, y: D = 0, next: B = false, rule: I = PenImage.SrcOver, op: I = BinaryOp.Plus.id, wrap: I = 0, rollOff: D = 0.86, kaiserBeta: D = 7.5, zeroCrossings: I = 0) extends SingleOut[Double] with Product with Serializable
A UGen that writes the pixels of an image using an
x
andy
input signal.A UGen that writes the pixels of an image using an
x
andy
input signal. It uses either a sinc-based band-limited resampling algorithm, or bicubic interpolation, depending on thezeroCrossings
parameter.All window defining parameters (
width
,height
) are polled once per matrix. All writing and filter parameters are polled one per output pixel.- src
the source signal's amplitude or "pen color"
- alpha
the alpha component of the source signal (0.0 transparent to 1.0 opaque).
- dst
the "background" image to draw on. A
DC(0.0)
can be used, for example, to have a "black" background.- width
the width (number of columns) of the input and output matrix
- height
the height (number of rows) of the input and output matrix
- x
horizontal position of the dynamic pen signal
- y
vertical position of the dynamic pen signal
- next
a trigger that causes the UGen to emit the current image and begin a new one. An image of size
width * height
will be output, and new background data will be read fromin
.- rule
quasi-Porter-Duff rule id for composition between background (
in
) and pen foreground. It is assumed thatA_{r} = A_{d} = 1
, and instead of addition we use a custom binary operationop
. Where the constrain leads to otherwise identical rules, we flip the operand order (e.g.SrcOver
versusSrcAtop
).- op
BinaryOp.Op
identifier for the operand in the application of the Porter-Duff composition (+
in the standard definition).- wrap
if non-zero, wraps coordinates around the input images boundaries. TODO: currently
wrap = 0
is broken if using sinc interpolation!- rollOff
the FIR anti-aliasing roll-off width. Between zero and one.
- kaiserBeta
the FIR windowing function's parameter
- zeroCrossings
the number of zero-crossings in the truncated and windowed sinc FIR. If zero (default), algorithm uses bicubic interpolation instead.
- See also
- final case class PitchAC(in: D, sampleRate: D, pitchMin: D = 75.0, pitchMax: D = 600.0, numCandidates: I = 15, silenceThresh: D = 0.03, voicingThresh: D = 0.45, octaveCost: D = 0.01, octaveJumpCost: D = 0.35, voicedUnvoicedCost: D = 0.14) extends GE.Lazy[Double] with Product with Serializable
A graph element that implements Boersma's auto-correlation based pitch tracking algorithm.
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. - final case class PitchesToViterbi(lags: D, strengths: D, numIn: I = 14, peaks: D, maxLag: I, voicingThresh: D = 0.45, silenceThresh: D = 0.03, octaveCost: D = 0.01, octaveJumpCost: D = 0.35, voicedUnvoicedCost: D = 0.03) extends SingleOut[Double] with Product with Serializable
A UGen that takes concurrent pitch tracker paths, and conditions them for the Viterbi algorithm.
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 suitableadd
signal is produced to be used in theViterbi
UGen. The output are matrices of size(numIn + 1).squared
.Warning: This is still not thoroughly tested.
- lags
pitches given as sample periods, such as returned by
AutoCorrelationPitches
.- strengths
strengths corresponding to the
lags
, such as returned byAutoCorrelationPitches
.- numIn
number of paths / candidates. to this the unvoiced candidate is added
- peaks
the peak amplitude of the underlying input signal, one sample per pitch frame, used for the unvoiced candidate.
- maxLag
the maximum lag time, corresponding to the minimum pitch
- voicingThresh
threshold for determining whether window is voiced or unvoiced.
- silenceThresh
threshold for determining whether window is background or foreground.
- octaveCost
weighting factor for low versus high frequency preference.
- octaveJumpCost
costs for moving pitches up and down. to match the parameters in Praat, you should multiply the "literature" value by
0.01 * sampleRate / stepSize
(typically in the order of 0.25)- voicedUnvoicedCost
cost for transitioning between voiced and unvoiced segments. to match the parameters in Praat, the "literature" value by
0.01 * sampleRate / stepSize
(typically in the order of 0.25) see StrongestLocalMaxima see Viterbi
- final case class Plot1D[A](in: GE[A], size: I, label: String = "plot")(implicit num: Num[A]) extends ZeroOut with ProductWithAdjuncts with Product with Serializable
Debugging utility that plots 1D "windows" of the input data.
- final case class Poll[A](in: GE[A], gate: B, label: String = "poll") extends ZeroOut with Product with Serializable
A UGen that prints snapshots of its input to the console.
A UGen that prints snapshots of its input to the console. Note that arguments have different order than in ScalaCollider!
- in
the input to be pulled. If this is a constant, the UGen will close after polling it. This is to prevent a dangling
Poll
whose trigger is infinite (such asImpulse
). If you want to avoid that, you should wrap the input in aDC
.- gate
gate that causes the UGen to print a snapshot of the input when open.
- label
an identifying label to prepend to the printing.
- final case class PriorityQueue[A, B](keys: GE[A], values: GE[B], size: I)(implicit ord: Ord[A]) extends SingleOut[B] with ProductWithAdjuncts with Product with Serializable
A sorting UGen that can be thought of as a bounded priority queue.
A sorting UGen that can be thought of as a bounded priority queue. It keeps all data in memory but limits the size to the top
size
items. By its nature, the UGen only starts outputting values once the input signal (keys
) has finished.Both inputs are "hot" and the queue filling ends when either of
keys
orvalues
is finished.- keys
the sorting keys; higher values mean higher priority
- values
the values corresponding with the keys and eventually output by the UGen. It is well possible to use the same signal both for
keys
andvalues
.- size
the maximum size of the priority queue.
- final case class Progress(in: D, trig: B, label: String = "render") extends ZeroOut with Product with Serializable
A UGen that contributes to the progress monitoring of a graph.
A UGen that contributes to the progress monitoring of a graph. It is possible to instantiate multiple instances of this UGen, in which cases their individual progress reports will simply be added up (and clipped to the range from zero to one).
- in
progress fraction from zero to one
- trig
trigger that causes the UGen to submit a snapshot of the progress to the control instance.
- label
the label can be used to distinguish the contributions of different progress UGens
- final case class ProgressFrames[A, L](in: GE[A], numFrames: GE[L], label: String = "render")(implicit numL: NumInt[L]) extends ZeroOut with ProductWithAdjuncts with Product with Serializable
A variant of progress UGen for the common case where one wants to count the incoming frames of a signal.
A variant of progress UGen for the common case where one wants to count the incoming frames of a signal.
It is possible to instantiate multiple instances of this UGen, in which cases their individual progress reports will simply be added up (and clipped to the range from zero to one).
The progress update is automatically triggered, using a combination where both the progress fraction (0.2%) and elapsed time (100ms) must have increased.
- in
signal whose length to monitor
- numFrames
the expected length of the input signal
- label
the label can be used to distinguish the contributions of different progress UGens
- final case class Real1FFT(in: D, size: I, padding: I = 0, mode: I = 0) extends FFTHalfUGen with Product with Serializable
Forward short-time Fourier transform UGen for a real-valued input signal.
Forward short-time Fourier transform UGen for a real-valued input signal. The FFT size is equal to
size + padding
. The output is a succession of complex half-spectra, i.e. from DC to Nyquist. Depending onmode
, the output window size is eithersize + padding
orsize + padding + 2
.- in
the real signal to transform. If overlapping windows are desired, a
Sliding
should already have been applied to this signal, as well as multiplication with a window function.- size
the time domain input window size
- padding
amount of zero padding for each input window.
- mode
packing mode.
0
(default) is standard "packed" mode, whereby the real part of the bin at Nyquist is stored in the imaginary slot of the DC. This mode allows perfect reconstruction with aReal1IFFT
using the same mode.1
is "unpacked" mode, whereby the output windows are made two samples longer, so that the Nyquist bin is included in the very end. By definition, the imaginary parts of DC and Nyquist are zero. This mode allows perfect reconstruction with aReal1IFFT
using the same mode.2
is "discarded" mode, whereby the Nyquist bin is omitted. While it doesn't allow a perfect reconstruction, this mode is useful for analysis, because the output window size is equal to the fft-size, and the imaginary part of DC is correctly zero'ed.
- final case class Real1FullFFT(in: D, size: I, padding: I = 0) extends FFTFullUGen with Product with Serializable
- final case class Real1FullIFFT(in: D, size: I, padding: I = 0) extends FFTFullUGen with Product with Serializable
- final case class Real1IFFT(in: D, size: I, padding: I = 0, mode: I = 0) extends FFTHalfUGen with Product with Serializable
Backward or inverse short-time Fourier transform UGen for a real-valued output signal.
Backward or inverse short-time Fourier transform UGen for a real-valued output signal. The FFT size is equal to
size
. The output is a succession of time domain signals of lengthsize - padding
. Depending onmode
, the output input size is supposed to be eithersize
orsize + 2
.- in
the complex signal to transform.
- size
the frequency domain input window size (fft size)
- padding
amount of zero padding for each output window. These are the number of sample frames to drop from each output window after the FFT.
- mode
packing mode of the input signal.
0
(default) is standard "packed" mode, whereby the real part of the bin at Nyquist is stored in the imaginary slot of the DC. This mode allows perfect reconstruction with aReal1IFFT
using the same mode.1
is "unpacked" mode, whereby the output windows are made two samples longer, so that the Nyquist bin is included in the very end. By definition, the imaginary parts of DC and Nyquist are zero. This mode allows perfect reconstruction with aReal1IFFT
using the same mode.2
is "discarded" mode, whereby the Nyquist bin is omitted. While it doesn't allow a perfect reconstruction, this mode is useful for analysis, because the output window size is equal to the fft-size, and the imaginary part of DC is correctly zero'ed.
- final case class Real2FFT(in: D, rows: I, columns: I = 0, mode: I = 0) extends FFT2HalfUGen with Product with Serializable
Forward short-time Fourier transform UGen for a real-valued input signal.
Forward short-time Fourier transform UGen for a real-valued input signal. The FFT size is equal to
rows * columns
. The output is a succession of complex half-spectra, i.e. from DC to Nyquist.XXX TODO: Depending on
mode
, the output window size is eithersize + padding
orsize + padding + 2
.Warning: window parameter modulation is currently not working correctly (issue #30)
- in
the real signal to transform. If overlapping windows are desired, a
Sliding
should already have been applied to this signal, as well as multiplication with a window function.- rows
the input matrix number of rows
- columns
the input matrix number of columns
- mode
packing mode.
0
(default) is standard "packed" mode, whereby the real part of the bin at Nyquist is stored in the imaginary slot of the DC. This mode allows perfect reconstruction with aReal2IFFT
using the same mode.1
is "unpacked" mode, whereby the output windows are made two samples longer, so that the Nyquist bin is included in the very end. By definition, the imaginary parts of DC and Nyquist are zero. This mode allows perfect reconstruction with aReal2IFFT
using the same mode.2
is "discarded" mode, whereby the Nyquist bin is omitted. While it doesn't allow a perfect reconstruction, this mode is useful for analysis, because the output window size is equal to the fft-size, and the imaginary part of DC is correctly zero'ed.
- final case class Real2FullFFT(in: D, rows: I, columns: I = 0) extends FFT2FullUGen with Product with Serializable
Warning: window parameter modulation is currently not working correctly (issue #30)
- final case class Real2FullIFFT(in: D, rows: I, columns: I = 0) extends FFT2FullUGen with Product with Serializable
Warning: window parameter modulation is currently not working correctly (issue #30)
- final case class Real2IFFT(in: D, rows: I, columns: I = 0, mode: I = 0) extends FFT2HalfUGen with Product with Serializable
Warning: window parameter modulation is currently not working correctly (issue #30)
- final case class Reduce[A](elem: GE[A], op: Op[A, A, A]) extends GE.Lazy[A] with Product with Serializable
A UGen that reduces the channels of the input signal, so it become a single-channel signal.
- final case class ReduceWindow[A](in: GE[A], size: I, op: Op[A, A, A]) extends SingleOut[A] with Product with Serializable
A UGen that reduces all elements in each window to single values, for example by calculating the sum or product.
- final case class RepeatWindow[A, L](in: GE[A], size: I = 1, num: GE[L] = 2)(implicit numL: NumInt[L]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
A UGen that repeats the contents of input windows a number of times.
A UGen that repeats the contents of input windows a number of times.
- in
the input signal to group into windows of size
size
and repeatnum
times. If the input ends before a full window is filled, the last window is padded with zeroes to obtain an input window if sizesize
- size
the window size. one value is polled per iteration (outputting
num
windows of sizesize
). the minimumsize
is one (it will be clipped to this).- num
the number of repetitions of the input windows. one value is polled per iteration (outputting
num
windows of sizesize
). the minimumnum
is one (it will be clipped to this).
- final case class Resample(in: D, factor: D, minFactor: D = 0, rollOff: D = 0.86, kaiserBeta: D = 7.5, zeroCrossings: I = 15) extends SingleOut[Double] with Product with Serializable
A band-limited resampling UGen.
A band-limited resampling UGen.
It uses an internal table for the anti-aliasing filter. Table resolution is currently fixed at 4096 filter samples per zero crossing and linear interpolation in the FIR table, but the total filter length can be specified through the
zeroCrossings
parameter. Note: If filter parameters are changed, the table must be recalculated which is very expensive. However,factor
modulation is efficient.Note: Unlike most other UGens, all parameters but
in
are read at "output rate". That is particular important forfactor
modulation. For each frame output, one frame fromfactor
is consumed. Currently, modulatingrollOff
,kaiserBeta
orzeroCrossings
is not advised, as this case is not properly handled internally.- in
the signal to resample
- factor
the resampling factor, where values greater than one mean the signal is stretched (sampling-rate increases or pitch lowers) and values less than one mean the signal is condensed (sampling-rate decreases or pitch rises)
- minFactor
the minimum expected resampling factor, which controls the amount of buffering needed for the input signal. This is used at initialization time only. The default value of zero makes the UGen settles on the first
factor
value encountered. It is possible to use a value actually higher than the lowest providedfactor
, in order to limit the buffer usage. In that case, the FIR anti-aliasing filter will be truncated.- rollOff
the FIR anti-aliasing roll-off width
- kaiserBeta
the FIR windowing function's parameter
- zeroCrossings
the number of zero-crossings in the truncated and windowed sinc FIR.
- final case class ResampleWindow(in: D, size: I, factor: D, minFactor: D = 0.0, rollOff: D = 0.86, kaiserBeta: D = 7.5, zeroCrossings: I = 15) extends SingleOut[Double] with Product with Serializable
A band-limited resampling UGen for images/matrices.
A band-limited resampling UGen for images/matrices. This works like
Resample
but processes each window cell across time. Thus is is not _resampling each window by itself_, but each "pixel" or matrix cell in a window across successive windows.- in
the signal to resample
- size
the window size. Currently this is only read once upon initialization.
- factor
the resampling factor, where values greater than one mean the signal is stretched (sampling-rate increases or pitch lowers) and values less than one mean the signal is condensed (sampling-rate decreases or pitch rises)
- minFactor
the minimum expected resampling factor, which controls the amount of buffering needed for the input signal. This is used at initialization time only. The default value of zero makes the UGen settles on the first
factor
value encountered. It is possible to use a value actually higher than the lowest providedfactor
, in order to limit the buffer usage. In that case, the FIR anti-aliasing filter will be truncated.- rollOff
the FIR anti-aliasing roll-off width
- kaiserBeta
the FIR windowing function's parameter
- zeroCrossings
the number of zero-crossings in the truncated and windowed sinc FIR.
- final case class ResizeWindow[A](in: GE[A], size: I, start: I = 0, stop: I = 0) extends SingleOut[A] with Product with Serializable
A UGen that resizes the windowed input signal by trimming each windows boundaries (if
start
is greater than zero orstop
is less than zero) or padding the boundaries with zeroes (ifstart
is less than zero orstop
is greater than zero).A UGen that resizes the windowed input signal by trimming each windows boundaries (if
start
is greater than zero orstop
is less than zero) or padding the boundaries with zeroes (ifstart
is less than zero orstop
is greater than zero). The output window size is thussize - start + stop
.- in
the signal to window and resize
- size
the input window size
- start
the delta window size at the output window's beginning
- stop
the delta window size at the output window's ending
- final case class ReverseWindow[A](in: GE[A], size: I, clump: I = 1) extends SingleOut[A] with Product with Serializable
Reverses the (clumped) elements of input windows.
Reverses the (clumped) elements of input windows.
E.g.
ReverseWindow(ArithmSeq(1, 1, 9), 3)
gives7,8,9, 4,5,6, 1,2,3
. The behavior whensize % clump != 0
is to clump "from both sides" of the window, e.g.ReverseWindow(ArithmSeq(1, 1, 9), 4)
gives6,7,8,9, 5, 1,2,3,4
.- in
the window'ed signal to reverse
- size
the window size
- clump
the grouping size of window elements
- final case class RotateFlipMatrix[A](in: GE[A], rows: I, columns: I, mode: I) extends SingleOut[A] with Product with Serializable
A UGen that can apply horizontal and vertical flip and 90-degree step rotations to a matrix.
A UGen that can apply horizontal and vertical flip and 90-degree step rotations to a matrix.
Unless mode is 90-degree rotation (4 or 5) and the matrix is not square, this needs one internal matrix buffer, otherwise two internal matrix buffers are needed.
- in
the matrix / matrices to rotate
- rows
the number of rows in the input
- columns
the number of columns in the input
- mode
0: pass, 1: flip horizontally, 2: flip vertically, 3: rotate 180 degrees, 4: rotate clockwise, 8: rotate anti-clockwise. See the companion object for constants. If you combine flipping and rotation, flipping is performed first, so a mode of 5 means flip horizontally, followed by rotate clockwise.
- final case class RotateWindow[A](in: GE[A], size: I, amount: I = 0) extends SingleOut[A] with Product with Serializable
A UGen that rotates the contents of a window, wrapping around its boundaries.
A UGen that rotates the contents of a window, wrapping around its boundaries. For example, it can be used to align the phases prior to FFT so that the sample that was formerly in the centre of the window moves to the beginning of the window.
- in
the signal to window and resize
- size
the input window size
- amount
the rotation amount in sample frames. Positive values "move" the contents to the right, negative values "move" the contents to the left. The amount is taken modulus
size
.
- final case class RunningMax[A](in: GE[A], gate: B = false)(implicit ord: Ord[A]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
A UGen that tracks the maximum value seen so far, until a trigger resets it.
A UGen that tracks the maximum value seen so far, until a trigger resets it.
Note: This is different from SuperCollider's
RunningMax
UGen which outputs the maximum of a sliding window instead of waiting for a reset trigger. To track a sliding maximum, you can usePriorityQueue
.- in
the signal to track
- gate
a gate that when greater than zero (and initially) sets the the internal state is set to negative infinity.
- final case class RunningMin[A](in: GE[A], gate: B = false)(implicit ord: Ord[A]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
A UGen that tracks the minimum value seen so far, until a trigger resets it.
A UGen that tracks the minimum value seen so far, until a trigger resets it.
Note: This is different from SuperCollider's
RunningMin
UGen which outputs the maximum of a sliding window instead of waiting for a reset trigger. To track a sliding minimum, you can usePriorityQueue
.- in
the signal to track
- gate
a gate that when greater than zero (and initially) sets the the internal state is set to positive infinity.
- final case class RunningProduct[A](in: GE[A], gate: B = false)(implicit num: Num[A]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
A UGen that tracks the maximum value seen so far, until a trigger resets it.
A UGen that tracks the maximum value seen so far, until a trigger resets it.
- in
the signal to track
- gate
a gate that when greater than zero (and initially) sets the the internal state is set to one.
- final case class RunningSum[A](in: GE[A], gate: B = false)(implicit num: Num[A]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
A UGen that integrates the values seen so far, until a trigger resets it.
A UGen that integrates the values seen so far, until a trigger resets it.
Note: This is different from SuperCollider's
RunningSum
UGen which outputs the sum of a sliding window instead of waiting for a reset trigger. To track a sliding sum, you can subtract a delayed version ofRunningSum
from a non-delayedRunningSum
.- in
the signal to track
- gate
a gate that when greater than zero (an initially) sets the the internal state is set to zero.
- final case class RunningWindowMax[A](in: GE[A], size: I, gate: B = false)(implicit ord: Ord[A]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
A UGen that like
RunningMax
calculates the maximum observed value of the running input.A UGen that like
RunningMax
calculates the maximum observed value of the running input. However, it operates on entire windows, i.e. it outputs windows that contain the maximum elements of all the past windows observed.- in
the windowed signal to monitor
- size
the window size. This should normally be a constant. If modulated, the internal buffer will be re-allocated, essentially causing a reset trigger.
- gate
a gate signal that clears the internal state. When a gate is open (> 0), the currently processed window is reset altogether until its end, beginning accumulation again from the successive window.
- final case class RunningWindowMin[A](in: GE[A], size: I, gate: B = false)(implicit ord: Ord[A]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
A UGen that like
RunningMin
calculates the minimum observed value of the running input.A UGen that like
RunningMin
calculates the minimum observed value of the running input. However, it operates on entire windows, i.e. it outputs windows that contain the minimum elements of all the past windows observed.- in
the windowed signal to monitor
- size
the window size. This should normally be a constant. If modulated, the internal buffer will be re-allocated, essentially causing a reset trigger.
- gate
a gate signal that clears the internal state. When a gate is open (> 0), the currently processed window is reset altogether until its end, beginning accumulation again from the successive window.
- final case class RunningWindowProduct[A](in: GE[A], size: I, gate: B = false)(implicit num: Num[A]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
A UGen that like
RunningProduct
calculates the product of the running input.A UGen that like
RunningProduct
calculates the product of the running input. However, it operates on entire windows, i.e. it outputs windows that contain the sum elements of all the past windows observed.- in
the windowed signal to monitor
- size
the window size. This should normally be a constant. If modulated, the internal buffer will be re-allocated, essentially causing a reset trigger.
- gate
a gate signal that clears the internal state. When a gate is open (> 0), the currently processed window is reset altogether until its end, beginning accumulation again from the successive window.
- final case class RunningWindowSum[A](in: GE[A], size: I, gate: B = false)(implicit num: Num[A]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
A UGen that like
RunningSum
calculates the sum of the running input.A UGen that like
RunningSum
calculates the sum of the running input. However, it operates on entire windows, i.e. it outputs windows that contain the sum elements of all the past windows observed.- in
the windowed signal to monitor
- size
the window size. This should normally be a constant. If modulated, the internal buffer will be re-allocated, essentially causing a reset trigger.
- gate
a gate signal that clears the internal state. When a gate is open (> 0), the currently processed window is reset altogether until its end, beginning accumulation again from the successive window.
- trait SampleRate extends GE[Double]
A sample rate element simply signalizes that it refers to a sampling rate in Hertz.
A sample rate element simply signalizes that it refers to a sampling rate in Hertz. When in implicit scope, it enables extension methods on graph elements, such as
440.hertz
or2.3.seconds
. - final case class ScanImage(in: D, width: I, height: I, x: D = 0, y: D = 0, next: B = false, wrap: I = 0, rollOff: D = 0.86, kaiserBeta: D = 7.5, zeroCrossings: I = 0) extends SingleOut[Double] with Product with Serializable
A UGen that scans the pixels of an image using an
x
andy
input signal.A UGen that scans the pixels of an image using an
x
andy
input signal. It uses either a sinc-based band-limited resampling algorithm, or bicubic interpolation, depending on thezeroCrossings
parameter.All window defining parameters (
width
,height
) are polled once per matrix. All scanning and filter parameters are polled one per output pixel.- in
the image to scan
- width
the width (number of columns) of the input matrix
- height
the height (number of rows) of the input matrix
- x
horizontal position of the dynamic scanning signal
- y
vertical position of the dynamic scanning signal
- next
a trigger that causes the UGen to read in a new image from
in
.- wrap
if non-zero, wraps coordinates around the input images boundaries. TODO: currently
wrap = 0
is broken if using sinc interpolation!- rollOff
the FIR anti-aliasing roll-off width. Between zero and one.
- kaiserBeta
the FIR windowing function's parameter
- zeroCrossings
the number of zero-crossings in the truncated and windowed sinc FIR. If zero (default), algorithm uses bicubic interpolation instead.
- See also
- final case class SegModPhasor(freqN: D, phase: D = 0.0) extends SingleOut[Double] with Product with Serializable
A phasor UGen that takes new frequency values at the beginning of each cycle.
A phasor UGen that takes new frequency values at the beginning of each cycle. It can be used to implement the 'segmod' program of Döbereiner and Lorenz. In contrast to
LFSaw
which continuously reads frequency values, its output values go from zero to one, and the phase argument is only used internally (the output signal always starts at zero).To turn this, for example, into a sine oscillator, you can use
(SegModPhasor(...) * 2 * math.Pi).sin
.Warning: passing in zero frequencies will halt the process. XXX TODO
- freqN
normalized frequency (f/sr). One value per output cycle is read. Also note that the UGen terminates when the
freqN
signal ends. Thus, to use a constant frequency, wrap it in aDC
orDC(...).take
.- phase
phase offset in radians. The phase offset is only used internally to determine when to change the frequency. For example, with a phase of
0.25
, when the output phase reaches 0.25, the next frequency value is read. With the default phase of 0.0, a frequency value is read after one complete cycle (output reaches 1.0).
- final case class SetResetFF(set: B, reset: B = false) extends SingleOut[Boolean] with Product with Serializable
A flip-flop UGen with two inputs, one (set) triggering an output of 1, the other (reset) triggering an output of 0.
A flip-flop UGen with two inputs, one (set) triggering an output of 1, the other (reset) triggering an output of 0. Subsequent triggers happening within the same input slot have no effect. If both inputs receive a trigger at the same time, the reset input takes precedence.
Both inputs are "hot" and the UGen runs until both have been terminated.
- final case class Sheet1D[A](in: GE[A], size: I, label: String = "sheet") extends ZeroOut with Product with Serializable
Debugging utility that displays 1D "windows" of the input data as a spreadsheet or table view.
Debugging utility that displays 1D "windows" of the input data as a spreadsheet or table view.
Warning: window parameter modulation is currently not working correctly (issue #30)
- final case class SinOsc(freqN: D, phase: D = 0.0) extends SingleOut[Double] with Product with Serializable
Sine oscillator.
Sine 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.- freqN
normalized frequency (f/sr).
- phase
phase offset in radians
- final case class Slices[A, L](in: GE[A], spans: GE[L])(implicit num: Num[A], numL: NumInt[L]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
A UGen that assembles slices of an input signal in random access fashion.
A UGen that assembles slices of an input signal in random access fashion. It does so by buffering the input to disk.
- in
the signal to re-arrange.
- spans
successive frame start (inclusive) and stop (exclusive) frame positions determining the spans that are output by the UGen. This parameter is read on demand. First, the first two values are read, specifying the first span. Only after this span has been output, the next two values from
spans
are read, and so on. Values are clipped to zero (inclusive) and the length of the input signal (exclusive). If a start position is greater than a stop position, the span is output in reversed order.
- See also
- final case class Sliding[A](in: GE[A], size: I, step: I) extends SingleOut[A] with Product with Serializable
A UGen that produces a sliding window over its input.
A UGen that produces a sliding window over its input.
When the input terminates and the last window is not full, it will be flushed with its partial content. Otherwise, all windows are guaranteed to be zero-padded to the window length if they had been only partially filled when the input ended.
Unlike the
sliding
operation of Scala collections, the UGen always performs steps for partial windows, e.g.Sliding(ArithmSeq(1, length = 4), size = 3, step = 1)
will produce the flat output1, 2, 3, 2, 3, 4, 3, 4, 0, 4
, thus there are four windows, the first two of which are full, the third which is full by padding, and the last is partial.- in
the input to be repacked into windows
- size
the window size. this is clipped to be at least one
- step
the stepping factor in the input, between windows. This clipped to be at least one. If step size is larger than window size, frames in the input are skipped.
- See also
- final case class SlidingPercentile[A](in: GE[A], len: I = 3, frac: D = 0.5, interp: I = 0)(implicit num: Num[A]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
A UGen that reports a percentile of a sliding window across its input.
A UGen that reports a percentile of a sliding window across its input. The UGen starts outputting values immediately, even if the median window
len
is not yet reached. This is becauselen
can be modulated. If one wants to discard the initial values, use adrop
.Note that for an even median length and no interpolation, the reported median may be either the value at index
len/2
orlen/2 + 1
in the sorted window.All arguments are polled at the same rate. Changing the
frac
value may cause an internal table rebuild and can thus be expensive.- in
the input to analyze
- len
the length of the sliding median window
- frac
the percentile from zero to one. The default of 0.5 produces the median.
- interp
if zero (default), uses nearest-rank, otherwise uses linear interpolation. Note: currently not implemented, must be zero
- final case class SlidingWindowPercentile[A](in: GE[A], winSize: I, medianLen: I = 3, frac: D = 0.5, interp: I = 0)(implicit num: Num[A]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
A UGen that reports a percentile of a sliding window across every cell of a window'ed input (such as an image).
A UGen that reports a percentile of a sliding window across every cell of a window'ed input (such as an image).
The UGen starts outputting values immediately, even if the
medianLen
is not yet reached. This is becausemedianLen
can be modulated (per input window). If one wants to discard the initial values, use adrop
, for example formedianLen/2 * winSize
frames.Note that for an even median length and no interpolation, the reported median may be either the value at index
medianLen/2
ormedianLen/2 + 1
in the sorted window.All arguments but
in
are polled per input window. Changing thefrac
value may cause an internal table rebuild and can thus be expensive.- in
the window'ed input to analyze
- winSize
the size of the input windows
- medianLen
the length of the sliding median window (the filter window applied to every cell of the input window)
- frac
the percentile from zero to one. The default of 0.5 produces the median.
- interp
if zero (default), uses nearest-rank, otherwise uses linear interpolation. Note: currently not implemented, must be zero
- final case class SortWindow[A, B](keys: GE[A], values: GE[B], size: I)(implicit ord: Ord[A]) extends SingleOut[B] with ProductWithAdjuncts with Product with Serializable
A UGen that sorts the input data window by window.
A UGen that sorts the input data window by window.
- keys
the sorting keys; output will be in ascending order
- values
the values corresponding with the keys and eventually output by the UGen. It is well possible to use the same signal both for
keys
andvalues
.- size
the window size.
- final case class StrongestLocalMaxima(in: D, size: I, minLag: I, maxLag: I, thresh: D = 0.0, octaveCost: D = 0.0, num: I = 14) extends MultiOut[Double] with Product with Serializable
A peak detection UGen, useful for implementing the auto-correlation based pitch detection method of Paul Boersma (1993).
A peak detection UGen, useful for implementing the auto-correlation based pitch detection method of Paul Boersma (1993). Taking an already calculated auto-correlation of size
size
, the UGen looks for local maxima within a given range.The UGen has two outputs. The first output gives the lag times or periods of the
n
strongest peaks per window (to obtain a frequency, divide the sampling rate by these lag times). The second output gives the intensities of thesen
candidates. If there are less thann
candidates, the empty slots are output as zeroes.- in
the auto-correlation windows
- size
the size of the auto-correlation windows. must be at least 2.
- minLag
the minimum lag time in sample frames, corresponding to the maximum frequency accepted
- maxLag
the maximum lag time in sample frames, corresponding to the minimum frequency accepted
- thresh
the "voicing" threshold for considered for local maxima within
minLag
maxLag
.- octaveCost
a factor for favouring higher frequencies. use zero to turn off this feature.
- num
number of candidate periods output. This is clipped to be at least 1. see PitchesToViterbi see Viterbi
- final case class Take[A, L](in: GE[A], length: GE[L])(implicit numL: NumInt[L]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
- final case class TakeRight[A, L](in: GE[A], length: GE[L])(implicit numL: NumInt[L]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
- final case class TakeWhile[A](in: GE[A], p: B) extends SingleOut[A] with Product with Serializable
- sealed trait Then[+A] extends Lazy
- final case class Timer(trig: B) extends SingleOut[Long] with Product with Serializable
A UGen that outputs the number of sample frames passed since last triggered.
A UGen that outputs the number of sample frames passed since last triggered. If no trigger is used, it simply outputs a linearly rising ramp.
- trig
trigger signal to reset the counter. Note that the UGen shuts down when
trig
finishes, so to use a constant like0
, it has to be wrapped in aDC
, for example.
- final case class TransposeMatrix[A](in: GE[A], rows: I, columns: I) extends SingleOut[A] with Product with Serializable
A UGen that transposes 2-dimensional matrices.
A UGen that transposes 2-dimensional matrices. This is a 2-dimensional windowed process, where each window has length
rows * columns
. Input is assumed to be "left-to-right, top-to-bottom", so the first samples constitute the first row, the next samples constitute the second row, etc.Note: The UGens takes up twice the matrix size of memory.
The output matrix is transposed (rows and columns exchanged). So an input of
(a, b, c, d, e, f)
withrows = 2
andcolumns = 3
is interpreted as((a, b, c), (d, e, f))
, transposed as((a, d), (b, e), (c, f))
and output flat as(a, d, b, e, c, f)
.To rotate an image ninety degrees clockwise, you would have
rows = height
andcolumns = width
.- in
the input matrices
- rows
the number of rows of the _input_
- columns
the number of columns of the _input_
- See also
- final case class Trig[A](in: GE[A])(implicit num: Num[A]) extends SingleOut[Boolean] with ProductWithAdjuncts with Product with Serializable
A UGen that creates a trigger when input changes from non-positive to positive.
A UGen that creates a trigger when input changes from non-positive to positive. This is useful when a gate argument of another UGen should indeed be used like a single trigger, as a constant positive input will not produce a held signal.
- final case class TrigHold[L](in: B, length: GE[L], clear: B = false)(implicit numL: NumInt[L]) extends SingleOut[Boolean] with ProductWithAdjuncts with Product with Serializable
A UGen that holds an input trigger signal for a given duration.
A UGen that holds an input trigger signal for a given duration. When a trigger is received from
in
, the output changes from zero to one for the givenlength
amount of frames. If a new trigger arrives within this period, the internal length counter is reset (the high state is kept for furtherlength
frames).- in
an input trigger or gate signal. Whenever the signal is positive, the internal hold state is reset. If a strict trigger is needed instead of a gate signal, a
Trig
UGen can be inserted.- length
the number of sample frames to hold the high output once a high input is received. A new value is polled whenever
in
is high.- clear
an auxiliary trigger or gate signal that resets the output to low if there is currently no high
in
. This signal is read synchronously within.
If bothclear
andin
are high at a given point, then the UGen outputs high but has its length counter reset.
- sealed trait UGenInGroup[A] extends UGenInLike[A]
- final case class UGenOutProxy[A](ugen: MultiOut[A], outputIndex: Int) extends UGenProxy[A] with Product with Serializable
A UGenOutProxy refers to a particular output of a multi-channel UGen.
A UGenOutProxy refers to a particular output of a multi-channel UGen. A sequence of these form the representation of a multi-channel-expanded UGen.
- sealed trait UGenProxy[A] extends UGenIn[A]
- final case class UnaryOp[A, B](op: Op[A, B], in: GE[A]) extends SingleOut[B] with Product with Serializable
- final case class UnzipWindow[A](in: GE[A], size: I = 1) extends GE.Lazy[A] with Product with Serializable
- final case class UnzipWindowN[A](numOutputs: Int, in: GE[A], size: I = 1) extends MultiOut[A] with Product with Serializable
- final case class ValueBooleanSeq(elems: Boolean*) extends SingleOut[Boolean] with Product with Serializable
Loops the given values.
- final case class ValueDoubleSeq(elems: Double*) extends SingleOut[Double] with Product with Serializable
Loops the given values.
- final case class ValueIntSeq(elems: Int*) extends SingleOut[Int] with Product with Serializable
Loops the given values.
- final case class ValueLongSeq(elems: Long*) extends SingleOut[Long] with Product with Serializable
Loops the given values.
- final case class Viterbi(mul: D = 1.0, add: D, numStates: I, numFrames: I = -1) extends SingleOut[Int] with Product with Serializable
A UGen performing a generalized Viterbi algorithm.
A UGen performing a generalized Viterbi algorithm. The Viterbi algorithm tries to find the best path among sequences of states, by evaluating transition probabilities. It runs over a predefined number of frames, accumulating data of different states. It maximizes the likelihood of the terminal state, and then backtracks to reconstruct the likely path (sequence of states). The output is the sequence of state indices (from zero inclusive to
numStates
exclusive).Note: This UGen must run until
numFrames
or the inputs are exhausted, before it can begin outputting values.This implementation is generalized in the sense that instead of the canonical matrices "sequences of observations", "initial probabilities", "transition matrix", and "emission matrix", it takes two large matrices
mul
andadd
that contain the equivalent information. These two matrices allow the UGen to operate in two different modes:- multiplicative (as in the Wikipedia article) by damping the probabilities over time - accumulative (as used in Praat for pitch tracking) by adding up the weights (if you have "costs", feed in their negative values).
Basically the internal delta matrix is created by the update function
delta = (delta_prev * mul) + add
(with the corresponding matrix indices).The initial delta state is zero. Therefore, in order to provide the initial state, you obtain an initial vector
v
by providing anadd
matrix ofnumStates x numStates
cells, which is zero except for the first column filled byv
(alternatively, each row filled with the next value ofv
, or a diagonal matrix ofv
; ifv
can take negative value, make sure to fill the initialnumStates x numStates
completely by duplicatingv
).For the classical data, set
add
just to the initial matrix as explained above (multiplying emitted first observations with initial probabilities), and then use exclusivelymul
by passing in emitted observations multiplied by their transition probabilities:mul[t][i][j] = transitionProb[i][j] * emissionProb[observation[t]][i]
See https://en.wikipedia.org/wiki/Viterbi_algorithm
- mul
the generalized multiplicative matrix (combining transition probabilities, emission probabilities and observations). If only accumulation is used, set this to 1.0.
- add
the generalized accumulative matrix (combining transition probabilities, emission probabilities and observations). If only multiplication is used, set this to provide the initial state (see above), followed either by zeroes or by terminating the signal.
- numStates
the number of different states, as reflected by the inner dimensions of matrices
mul
andadd
.- numFrames
the number of observations. If
-1
, the UGen runs until the input is exhausted. This happens when bothmul
andadd
end. see StrongestLocalMaxima see PitchesToViterbi
- final case class WPE_Dereverberate(in: D, fftSize: I = 512, winStep: I = 128, delay: I = 3, taps: I = 10, alpha: D = 0.9999, psdLen: I = 0) extends D with Product with Serializable
A graph element performing end-to-end blind de-reverberation of an input signal.
A graph element performing end-to-end blind de-reverberation of an input signal. It performs the FFT/IFFT setup around invocations of
WPE_ReverbFrame
.Note: this does not yet work correctly with multi-channel input.
- in
the reverberant time domain signal
- fftSize
the fft-size
- winStep
the step size for the sliding window; typically 1/4 of
fftSize
- delay
the delay in spectral frames to avoid suppression of early reflections
- taps
the filter size in spectral frames to capture the late reverberation
- alpha
the decay factor for the filter coefficients
- psdLen
the number of preceding spectral frames to include as "context" in the psd
- final case class WPE_ReverbFrame(in: D, psd: D, bins: I, delay: I = 3, taps: I = 10, alpha: D = 0.9999) extends MultiOut[Double] with Product with Serializable
A UGen implementation of a single frame Weighted Prediction Error (WPE) de-reverberation algorithm in the frequency domain.
A UGen implementation of a single frame Weighted Prediction Error (WPE) de-reverberation algorithm in the frequency domain. It takes a DFT'ed input signal frame by frame and returns the estimated reverberated components. To actually obtain the de-reverberated signal, subtract the output from the input signal, then perform inverse FFT and overlap-add reconstruction.
The algorithm closely follows the Python package described in L. Drude, J. Heymann, Ch. Boeddeker, R. Haeb-Umbach, 'NARA-WPE: A Python package for weighted prediction error dereverberation in Numpy and Tensorflow for online and offline processing' and its Numpy implementation (MIT licensed).
Note: this does not yet work correctly with multi-channel input.
- in
the sequence of complex FFT'ed frames. Should have been obtained through
Real1FFT
withmode = 1
.- psd
the power spectrum density estimation, frame by frame corresponding with
in
. It should correspond with the shape ofin
, however being monophonic instead of multi-channel and using real instead of complex numbers (half the signal window length).- bins
the number of frequency bins (should be
fftSize / 2 + 1
)- delay
the delay in spectral frames to avoid suppression of early reflections
- taps
the filter size in spectral frames to capture the late reverberation
- alpha
the decay factor for the filter coefficients
- final case class WhiteNoise(mul: D = 1.0) extends SingleOut[Double] with Product with Serializable
Nominal signal range is
-mul
to+mul
(exclusive). - final case class WindowApply[A](in: GE[A], size: I, index: I = 0, mode: I = 0) extends SingleOut[A] with Product with Serializable
A UGen that extracts for each input window the element at a given index.
A UGen that extracts for each input window the element at a given index.
For example, the first element per window can be extracted with
index = 0
, and the last element per window can be extracted withindex = -1, mode = 1
(wrap).If the input
in
terminates before a window ofsize
is full, it will be padded with zeroes.- in
the window'ed signal to index
- size
the window size.
- index
the zero-based index into each window. One value per window is polled.
- mode
wrap mode.
0
clips indices,1
wraps them around,2
folds them,3
outputs zeroes when index is out of bounds.
- final case class WindowIndexWhere(p: B, size: I) extends SingleOut[Int] with Product with Serializable
A UGen that determines for each input window the first index where a predicate holds.
A UGen that determines for each input window the first index where a predicate holds. It outputs one integer value per window; if the predicate does not hold across the entire window or if the window size is zero, the index will be
-1
.- p
a predicate to detect the index
- size
the window size.
- final case class WindowMaxIndex[A](in: GE[A], size: I)(implicit ord: Ord[A]) extends SingleOut[Int] with ProductWithAdjuncts with Product with Serializable
A UGen that determines for each input window the index of the maximum element.
A UGen that determines for each input window the index of the maximum element. It outputs one integer value per window; if multiple elements have the same value, the index of the first element is reported (notably zero if the window contains only identical elements).
- in
the input signal.
- size
the window size.
- final case class Wrap[A](in: GE[A], lo: GE[A], hi: GE[A])(implicit num: Num[A]) extends SingleOut[A] with ProductWithAdjuncts with Product with Serializable
- final case class Zip[A](a: GE[A], b: GE[A]) extends SingleOut[A] with Product with Serializable
- final case class ZipWindow[A](a: GE[A], b: GE[A], size: I = 1) extends SingleOut[A] with Product with Serializable
- final case class ZipWindowN[A](in: GE[A], size: I = 1) extends SingleOut[A] with Product with Serializable
Value Members
- object ARCWindow extends ProductReader[ARCWindow] with Serializable
- object AffineTransform2D extends ProductReader[AffineTransform2D] with Serializable
- object ArithmSeq extends ProductReader[ArithmSeq[_, _]] with Serializable
- object AudioFileIn extends ProductReader[AudioFileIn] with Serializable
- object AudioFileOut extends ProductReader[AudioFileOut] with Serializable
- object BinaryOp extends ProductReader[SingleOut[_]] with Serializable
- object Biquad extends ProductReader[Biquad] with Serializable
- object Bleach extends ProductReader[Bleach] with Serializable
- object BleachKernel extends ProductReader[BleachKernel] with Serializable
- object Blobs2D extends ProductReader[Blobs2D] with Serializable
- object BlockSize
- object BufferDisk extends ProductReader[BufferDisk[_]] with Serializable
- object BufferMemory extends ProductReader[BufferMemory[_]] with Serializable
- object ChannelProxy extends ProductReader[ChannelProxy[_]] with Serializable
- object Clip extends ProductReader[Clip[_]] with Serializable
- object CombN extends ProductReader[CombN] with Serializable
- object Complex1FFT extends ProductReader[Complex1FFT] with Serializable
- object Complex1IFFT extends ProductReader[Complex1IFFT] with Serializable
- object Complex2FFT extends ProductReader[Complex2FFT] with Serializable
- object Complex2IFFT extends ProductReader[Complex2IFFT] with Serializable
- object ComplexBinaryOp extends ProductReader[ComplexBinaryOp] with Serializable
Binary operator assuming operands are complex signals (real and imaginary interleaved).
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, ...
- object ComplexUnaryOp extends ProductReader[ComplexUnaryOp] with Serializable
Unary operator assuming stream is complex signal (real and imaginary interleaved).
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, ...
- object Concat extends ProductReader[Concat[_]] with Serializable
- object Const
- object ConstB extends Serializable
- object ConstD extends Serializable
- object ConstI extends Serializable
- object ConstL extends Serializable
- object ConstQ extends ProductReader[ConstQ] with Serializable
- object ControlBlockSize extends ProductReader[ControlBlockSize] with Serializable
- object Convolution extends ProductReader[Convolution] with Serializable
- object DC extends ProductReader[DC[_]] with Serializable
- object DCT_II extends ProductReader[DCT_II] with Serializable
- object DEnvGen extends ProductReader[DEnvGen[_]] with Serializable
- object DebugSink extends ProductReader[DebugSink[_]] with Serializable
- object DebugThrough extends ProductReader[DebugThrough[_]] with Serializable
- object DelayN extends ProductReader[DelayN[_]] with Serializable
- object DetectLocalMax extends ProductReader[DetectLocalMax[_]] with Serializable
- object Differentiate extends ProductReader[Differentiate[_]] with Serializable
- object Distinct extends ProductReader[Distinct[_]] with Serializable
- object Done extends ProductReader[Done[_]] with Serializable
- object Drop extends ProductReader[Drop[_, _]] with Serializable
- object DropRight extends ProductReader[DropRight[_, _]] with Serializable
- object DropWhile extends ProductReader[DropWhile[_]] with Serializable
- object Elastic extends ProductReader[Elastic[_]] with Serializable
- object Else
- object ElseGE extends ProductReader[ElseGE[_]] with Serializable
- object ElseIfThen extends ProductReader[ElseIfThen[_]] with Serializable
- object ElseUnit extends ProductReader[ElseUnit] with Serializable
- object Empty extends ProductReader[Empty[_]] with Serializable
- object ExpExp extends ProductReader[ExpExp] with Serializable
- object ExpLin extends ProductReader[ExpLin] with Serializable
- object Feed extends ProductReader[Feed[_]] with Serializable
- object FilterSeq extends ProductReader[FilterSeq[_]] with Serializable
- object Flatten extends ProductReader[Flatten[_]] with Serializable
- object Fold extends ProductReader[Fold[_]] with Serializable
- object FoldCepstrum extends ProductReader[FoldCepstrum] with Serializable
- object Fourier extends ProductReader[Fourier[_]] with Serializable
- object Frames extends ProductReader[Frames[_]] with Serializable
- object Gate extends ProductReader[Gate[_]] with Serializable
- object GenWindow extends ProductReader[GenWindow[_]] with Serializable
- object GeomSeq extends ProductReader[GeomSeq[_, _]] with Serializable
- object GimpSlur extends ProductReader[GimpSlur] with Serializable
- object GramSchmidtMatrix extends ProductReader[GramSchmidtMatrix] with Serializable
- object HPF extends ProductReader[HPF] with Serializable
- object Hash extends ProductReader[Hash[_]] with Serializable
- object HilbertCurve
- object Histogram extends ProductReader[Histogram[_]] with Serializable
- object IfThen extends ProductReader[IfThen[_]] with Serializable
- object ImageFile extends ImageFilePlatform
- object ImageFileIn extends ProductReader[ImageFileIn] with Serializable
- object ImageFileOut extends ProductReader[ImageFileOut] with Serializable
- object ImageFileSeqIn extends ProductReader[ImageFileSeqIn] with Serializable
- object ImageFileSeqOut extends ProductReader[ImageFileSeqOut] with Serializable
- object Impulse extends ProductReader[Impulse] with Serializable
- object Indices extends ProductReader[Indices[_]] with Serializable
- object LFSaw extends ProductReader[LFSaw] with Serializable
- object LPF extends ProductReader[LPF] with Serializable
- object Latch extends ProductReader[Latch[_]] with Serializable
- object LeakDC extends ProductReader[LeakDC] with Serializable
- object Length extends ProductReader[Length[_]] with Serializable
- object Limiter extends ProductReader[Limiter] with Serializable
- object LinExp extends ProductReader[LinExp] with Serializable
- object LinKernighanTSP extends ProductReader[LinKernighanTSP] with Serializable
- object LinLin extends ProductReader[LinLin] with Serializable
- object Line extends ProductReader[Line[_]] with Serializable
- object Loudness extends ProductReader[Loudness] with Serializable
- object Masking2D extends ProductReader[Masking2D] with Serializable
- object MatchLen extends ProductReader[MatchLen[_, _]] with Serializable
- object MatrixInMatrix extends ProductReader[MatrixInMatrix[_]] with Serializable
- object MatrixOutMatrix extends ProductReader[MatrixOutMatrix[_]] with Serializable
- object MelFilter extends ProductReader[MelFilter] with Serializable
- object Metro extends ProductReader[Metro[_]] with Serializable
- object Mix
- object NormalizeWindow extends ProductReader[NormalizeWindow] with Serializable
- object NumChannels extends ProductReader[NumChannels[_]] with Serializable
- object OffsetOverlapAdd extends ProductReader[OffsetOverlapAdd[_]] with Serializable
- object OnePole extends ProductReader[OnePole] with Serializable
- object OnePoleWindow extends ProductReader[OnePoleWindow] with Serializable
- object OverlapAdd extends ProductReader[OverlapAdd[_]] with Serializable
- object PeakCentroid1D extends ProductReader[PeakCentroid1D] with Serializable
- object PeakCentroid2D extends ProductReader[PeakCentroid2D] with Serializable
- object Pearson extends ProductReader[Pearson] with Serializable
- object PenImage extends ProductReader[PenImage] with Serializable
- object PitchAC extends ProductReader[PitchAC] with Serializable
- object PitchesToViterbi extends ProductReader[PitchesToViterbi] with Serializable
- object Plot1D extends ProductReader[Plot1D[_]] with Serializable
- object Poll extends ProductReader[Poll[_]] with Serializable
- object PriorityQueue extends ProductReader[PriorityQueue[_, _]] with Serializable
- object Progress extends ProductReader[Progress] with Serializable
- object ProgressFrames extends ProductReader[ProgressFrames[_, _]] with Serializable
- object Real1FFT extends ProductReader[Real1FFT] with Serializable
- object Real1FullFFT extends ProductReader[Real1FullFFT] with Serializable
- object Real1FullIFFT extends ProductReader[Real1FullIFFT] with Serializable
- object Real1IFFT extends ProductReader[Real1IFFT] with Serializable
- object Real2FFT extends ProductReader[Real2FFT] with Serializable
- object Real2FullFFT extends ProductReader[Real2FullFFT] with Serializable
- object Real2FullIFFT extends ProductReader[Real2FullIFFT] with Serializable
- object Real2IFFT extends ProductReader[Real2IFFT] with Serializable
- object Reduce extends ProductReader[GE[_]] with Serializable
- object ReduceWindow extends ProductReader[GE[_]] with Serializable
- object RepeatWindow extends ProductReader[RepeatWindow[_, _]] with Serializable
- object Resample extends ProductReader[Resample] with Serializable
- object ResampleWindow extends ProductReader[ResampleWindow] with Serializable
- object ResizeWindow extends ProductReader[ResizeWindow[_]] with Serializable
- object ReverseWindow extends ProductReader[ReverseWindow[_]] with Serializable
- object RotateFlipMatrix extends ProductReader[RotateFlipMatrix[_]] with Serializable
- object RotateWindow extends ProductReader[RotateWindow[_]] with Serializable
- object RunningMax extends ProductReader[RunningMax[_]] with Serializable
- object RunningMin extends ProductReader[RunningMin[_]] with Serializable
- object RunningProduct extends ProductReader[RunningProduct[_]] with Serializable
- object RunningSum extends ProductReader[RunningSum[_]] with Serializable
- object RunningWindowMax extends ProductReader[RunningWindowMax[_]] with Serializable
- object RunningWindowMin extends ProductReader[RunningWindowMin[_]] with Serializable
- object RunningWindowProduct extends ProductReader[RunningWindowProduct[_]] with Serializable
- object RunningWindowSum extends ProductReader[RunningWindowSum[_]] with Serializable
- object SampleRate extends ProductReader[SampleRate]
- object ScanImage extends ProductReader[ScanImage] with Serializable
- object SegModPhasor extends ProductReader[SegModPhasor] with Serializable
- object SetResetFF extends ProductReader[SetResetFF] with Serializable
- object Sheet1D extends ProductReader[Sheet1D[_]] with Serializable
- object SinOsc extends ProductReader[SinOsc] with Serializable
- object Slices extends ProductReader[Slices[_, _]] with Serializable
- object Sliding extends ProductReader[Sliding[_]] with Serializable
- object SlidingPercentile extends ProductReader[SlidingPercentile[_]] with Serializable
- object SlidingWindowPercentile extends ProductReader[SlidingWindowPercentile[_]] with Serializable
- object SortWindow extends ProductReader[SortWindow[_, _]] with Serializable
- object StrongestLocalMaxima extends ProductReader[StrongestLocalMaxima] with Serializable
- object Take extends ProductReader[Take[_, _]] with Serializable
- object TakeRight extends ProductReader[TakeRight[_, _]] with Serializable
- object TakeWhile extends ProductReader[TakeWhile[_]] with Serializable
- object Then
- object Timer extends ProductReader[Timer] with Serializable
- object TransposeMatrix extends ProductReader[TransposeMatrix[_]] with Serializable
- object Trig extends ProductReader[Trig[_]] with Serializable
- object TrigHold extends ProductReader[TrigHold[_]] with Serializable
- object UGenInGroup
- object UnaryOp extends ProductReader[SingleOut[_]] with Serializable
- object UnzipWindow extends ProductReader[UnzipWindow[_]] with Serializable
- object UnzipWindowN extends ProductReader[UnzipWindowN[_]] with Serializable
- object ValueBooleanSeq extends ProductReader[ValueBooleanSeq] with Serializable
- object ValueDoubleSeq extends ProductReader[ValueDoubleSeq] with Serializable
- object ValueIntSeq extends ProductReader[ValueIntSeq] with Serializable
- object ValueLongSeq extends ProductReader[ValueLongSeq] with Serializable
- object ValueSeq
Loops the given values.
- object Viterbi extends ProductReader[Viterbi] with Serializable
- object WPE_Dereverberate extends ProductReader[WPE_Dereverberate] with Serializable
- object WPE_ReverbFrame extends ProductReader[WPE_ReverbFrame] with Serializable
- object WhiteNoise extends ProductReader[WhiteNoise] with Serializable
- object WindowApply extends ProductReader[WindowApply[_]] with Serializable
- object WindowIndexWhere extends ProductReader[WindowIndexWhere] with Serializable
- object WindowMaxIndex extends ProductReader[WindowMaxIndex[_]] with Serializable
- object Wrap extends ProductReader[Wrap[_]] with Serializable
- object Zip extends ProductReader[Zip[_]] with Serializable
- object ZipWindow extends ProductReader[ZipWindow[_]] with Serializable
- object ZipWindowN extends ProductReader[ZipWindowN[_]] with Serializable