The materials prepared for the workshop are based on the program FScape that I have been developing since many years, and which is now embedded in the computer music environment Mellite. Mellite is an open source application that we will be using during the workshop to explore these algorithms.

Link to Mellite : this is the front page with links to some tutorials and download and installation instruction (read them carefully). Direct downloads are available from https://archive.org/download/Mellite - use the "universal" zip for all platforms. Extract it, the application is in the 'bin' directory. Check the main page for additional requirements (Java 8, SuperCollider). Also download the FScape-modules.zip separately, it contains a couple of programs that we might be using.

Link Source Code of workshop examples


Prepared programs:

Apart from some standard FScape modules, we use custom programs made for the workshop and available as a downloadable Mellite workspace.

 

Two other programs that may come handy:

(Again you can use the universal-zip downloads)

Materials Hanns Holger Rutz

Motion study. Differential phase correlation between successive frames of a moving image. Rendered with FScape, using cosh amplitude mapping.

Plot study. The classical Logistic Map rendered with FScape, using its PenImage UGen. The recursive nature of the formula poses an interesting challenges to its implementation, as there are currently no means to produce single sample feedback.

[hhr 190404]
David was asking if it was possible to render something like the logistic map in FScape. At first I thought that the problem might be the block-size and recursive graph, but thinking about it, one anyway quits the iteration at a maximum number of steps, so we can just "expand" the recursion a number of times. We'd need a complement for ScanImage; now investigating if we could thus use interpolation as well, and then we'd have alpha components (interpolation weights) and something like Porter Duff composite could come handy. Since the easiest is to handle all channels independently (through multi-channel expansion), we might add the constraint that Ad (alpha component of destination) is constant 1.0, and will also not be updated. Then the 12 Porter Duff rules essentially reduce to 6. But if we allow other binary operators to stand in place of the usual addition in the chroma calculation, we can "interpret" the formerly redundant 6 rules by flipping the operands, which would make sense for non-commutative binary operators (e.g. subtraction or division).

[hhr 190404]
Logistic map would look something like this:


// logistic function
def fun: (GE, GE) => GE  =
  (x, r) => r * x * (1 - x)

val xa    = 2.9
val xb    = 4.0
val w     = 240
val h     = 500
val maxIt = 200
val y0    = 0.0
val y1    = 1.0

val itH   = maxIt/2 
val hm    = h - 1

val i = ArithmSeq(0, step = 1, length = w)
val r = xa + (xb - xa) * i / (w - 1)

var x = 0.5: GE
for (j <- 0 until maxIt) {
  x = fun(x, r)  // recursion
 
  ???
//  if (j > itH && x >= y0 && x <= y1) {
//    val xs = x.linLin(y0, y1, 0, 1)
//    wr.setSample(i, ((1 - xs) * hm).toInt, 0, 0)
//  }

}