binimal

Harmonic BPF Comb 36 beta is a VST plugin that lets you do custom bandpass comb filtering with some automatic rules regarding the tuning.
36 high Q (up to selfoscillation) RBJ bandpass filters are divided amongst 8 octaves. The fundamental gets one BPF, and each octave adds one more BPF (1+2+3+4+5+6+7+8~36).
Frequencies are controlled either in detail by UI or in less-detail but with micro-tuning with MIDI-IN (up to 4 poly).
If using MIDI-IN – select microtuning, if using UI pitch – blend between 2 frequency sets (blue/black text input fields).
Change values by holding left mouse and dragging up/down, double click to reset default.
Warning: most LFO features (especially mass spring and pitch) are badly implemented and may lead to high frequency self-oscillation or complete lockup.

Harmonic BPF Comb 36 beta VST demo – static (ui)pitch fed with assorted percussion:

Drone-Regen using Harmonic BPF Comb 36 beta to carve out harmonics of a fieldrecording:

Depending on input signal this plugin can produce sinewaves at extreme frequencies that possibly blow up your speaker and/or damage your ears – watch volumes.

License is “use-at-own-risk” regarding the general concept and usage of this dll to treat signals, and “no-selling-but-otherwise-unrestricted-distribution” regarding this specific download.

download:
Harmonic_BPF_Comb_36_vst.zip (3.6mb)

Somethings with a high interpretational entropy, whose sum of expressions is biased towards intuition, are like a Sun for any concept. Throw criteria in and let them burn, (do not) expect new ones.

Somethings with a low interpretational entropy, whose sum of expressions is biased towards concept, are like a Comet for any intuition. Throw observations onto and let them fly, (do not) expect them to return.

Ton-Bild-Datenüberlufttragung
audiovisual translation by air
Installation with passive interaction at Rundgang 2012
Atelier Hausig, HBK Saar

how it works:

uses pyglet to draw opengl.points and pyaudio to read the audio stream.
calculate how many samples to draw each frame:
init: num_samples=samplerate/framerate
call audiostream for num_samples each frame and put data to 1d array ##flaky
audio_data  = fromstring(stream.read(num_samples), dtype=short)
reformat audio_data array to be drawn as opengl point list, whereas audio sample value gets assigned to color_array(b/w),
and current frame gets translated to where to draw these points.
pyglet.graphics.draw(num_samples, pyglet.gl.GL_POINTS,('v2i', position_array),('c3B', color_array))
antialias filter the frame to compensate for framerate/samplerate instabilities

Pre-rendered with python scripts and post processed in after effects for “Virtuelle Bühne” (virtual stage), course teached by Florian Penner and Ralph Schneider.
Public showing from 12.2011 to 02.2012 at Medienfassade, HBK Saar

how it works:

## create 2d array by iteration of a 2d chaotic attractor (also randomly tested derivatives):
a = random float(0-1)
while count < maxiter:
    count += 1
    xnew = (a*xold+(2*(1-a)*xold*xold)/(1+xold*xold))+yold
    ynew = xnew-xold
    xold=xnew
    yold=ynew
    put each iterated xnew and ynew value to array_xy[maxiter:maxiter] and return

## create 3rd dimension by normalizing the index (timeline) value of the 2d array
for each index in array_xy[] count j:
array_z[j] = float(j/maxiter)*2-1
j += 1
merge array_xy[:,:] and array_z[:] to array_xyz[:,:,:]

## draw 3d pixels with rotation and set blending over x interpolated images
## useful parts out of the rendering script:
## bipolar waveshaper applied to linear interpolated blend set amount (by Patrice Tarrabia): 0(linear) to 1(slow start, fast mid, slow end) to -1(fast start, slow mid, fast end)
morph_curve=0.75
morph=(float(current_interpolation_step_index)/(interpolation_resolution-1))*2-1
k = 2*morph_curve/(1-morph_curve)
morph=(1+k)*morph/(1+k*np.abs(morph))
# scaling to 0-1 set multiplicators
morph1=1-(morph*0.5+0.5)
morph2=(morph*0.5+0.5)
#####################################################
3d array rotation
## factor is 2 for a 360 degree rotation, 1 for 180 and so on
import math
import numpy as np
factor_x = factor_y = factor_z = 0.0
xyz_array = np.array([[x_coordinates[index]],[y_coordinates[index]],[z_coordinates[index]]])
rotx=math.pi*factor_x
roty=math.pi*factor_y
rotz=math.pi*factor_z
# rotation matrix
Pz = np.array([[math.cos(rotz),math.sin(rotz),0],[-1*math.sin(rotz),math.cos(rotz),0],[0,0,1]])
Px = np.array([[1,0,0],[0,math.cos(rotx),math.sin(rotx)],[0,-1*math.sin(rotx),math.cos(rotx)],])
Py = np.array([[math.cos(roty),0,math.sin(roty)],[0,1,0],[-1*math.sin(roty),0,math.cos(roty)],])
# dot matrix multiplication
rotator=np.dot(Py,np.dot(Px,Pz))
rotated_xyz_array=np.dot(rotator,xyz_array)
# before pixel drawing, the rotated array needs to be sorted by depth (z, axis 2)
xyz_depthsorted=rotated_xyz_array[:,rotated_xyz_array[2,:].argsort()]
######################################################
draw pixels, save image, next interpolated step

Add to your observation by listening to what atoms would sound like if they were 2**40 times bigger and pulsating in air at their formerly visual electromagnetic resonant frequencies. Depending on element, up to 160 of the strongest peaks are calculated in realtime with sinewave oscillators. Choose audio driver, lightspeed factor, max and min peak intensity thresholds, linear or exponential amplitude array, vacuum (incomplete) or air measurement data and between saturated [I] and singly-ionized [II] spectrum. Move mouse up/down while holding left button to change values, double click to reset default.

PTE Spectra Audition – lithium ionized with summernight by Chopin in pyramid tuning:

This conceptual sketch was exported out of software from http://synthmaker.co.uk/, needs a sse2 cpu, a vsthost and windows or linux wine.
Depending on settings and volume, this plugin can produce sinewaves at extreme frequencies that possibly blow up your speaker and/or damage your ears – watch volumes.

License is “use-at-own-risk” regarding the general concept and usage of this dll to treat signals, and “no-selling-but-otherwise-unrestricted-distribution” regarding this specific download.

download windows  exe (also works on linux wine with winetricks gdiplus.dll and corefonts), 1.75mb:
PTE_-_Atomic_Spectra_Audition_standalone.zip

download vst2.3 plugin version, 1.75mb:
PTE_-_Atomic_Spectra_Audition_vst_instrument.zip

from http://www.nist.gov/pml/data/handbook/index.cfm import pte_handbook
for each element in pte_handbook create array[freq_angstroem, amplitude(normalized (ui)(linear or exponential))]
in pte_handbook[array] convert freq_angstroem to normalized_frequency:
normalized_frequency=(2.9979246*9.9999998e+017*(ui)lightspeed_factor)*(1/freq_angstroem)*(1/(2**40))*(2/samplerate)
##(ui)lightspeed_factor translates to a linear +/- shift of the whole frequency array
depending on (ui)element_choice:
for each [normalized_freqency,normalized_amplitude] in element_choice create sinewave oscillator at samplerate (max 160)
feed element_data[normalized_freqency,normalized_amplitude] to each sinewave_oscillator if (amplitude > (ui)min_intensity) and (amplitude < (ui)max_intensity) mix even indexed oscillators to left channel mix odd indexed oscillators to right channel 

define culture::current sum of(art)
define art::self aware being(expression(concept) times expression(intuition))
define self aware being::function that lessens local entropy by using(expression)
define expression::output function of self aware being(the pattern of correlation between (last_culture and last_observation))
define intuition::subclass of entropy, sum of (nondescriptive emergent impulses)
define concept::subclass of emergence, a formal descriptive architecture that builds over (interpretation)
define entropy::intuitive subclass of spacetime
define emergence::conceptual subclass of spacetime
import spacetime
define interpretation::emergent function of (self aware being(the pattern of correlation between (criteria and observation)))
define criteria::partial set of a (self aware beings(concept)) choosen by the correlation of (intuition and observation)
criteria follows binary_procedure
define binary::structure of concept
define observation::input function of a (self aware beings(intuition)) choosen by the correlation of (concept and last_observation)
observation follows gradual_procedure
define gradual::structure of intuition
define bias::gradual function of (binary)
define manipulation::influencing another (self aware beings(intuition<>concept)) system by using an expression with (concept>>intuition) to induce (criteria)
define socialisation::influencing another (self aware beings(intuition<>concept)) system by using an expression with (intuition>>concept) to induce (observation)
define charisma::art of (manipulating | socialising) other ((self aware beings))
define obscurism::subclass of interpretation caused by bias of (criteria and observation) towards (criteria)
define scientism::subclass of interpretation caused by bias of (criteria and observation) towards (observation)
define conceptual_art::subclass of art with compressed expressions## leads to problems with observation if unpack instructions are not given
define minimal_art::subclass of art with simple expressions, observed as conceptual_art if (obscurism)
define postmodern::set of subclasses of (modern) that contain subsets of (concept)
define modern::subclass of (culture) where the corresponding set of (art) is biased towards (concept)
define poetry::expression of(intuition of (concept))
define prose::expression of(concept of (intuition))
define biased_art_detector::
((1/(normalized_entropy of(set of all interpretations)))-1)*(1-normalized_manipulation)**(amount of interpretations)

# Bifurcation diagram of the logistic map
# FB - 201007235
import math
from PIL import Image
imgx = 4920
imgy = 2080
image = Image.new("RGB", (imgx, imgy))

xa = 2.9
xb = 4.0
maxit = 10000

for i in range(imgx):
  r = xa + (xb - xa) * float(i) / (imgx - 1)
  x = 0.5
  for j in range(maxit):
    x = r * x * (1 - x)
    if j > maxit / 2:
      image.putpixel((i, int(x * imgy)), (255, 255, 255))

image.save("Bifurcation.png", "PNG")