BubbleTonia - Sounds by Bubbles

Wie hatten den Filter BubblesToSounds in zwei Filter zerteilt: BubblesToValues und ValuesToSounds.

BubblesToSounds:

  Bubbles     Cam       Filter1        Filter2    Amplifier  Loudspeaker     Sound
              __       _________       ________                   /|           ___
  o o   o   _|  |     |         |     |        |     |\        __/ |          |   |
   o   o   |_   |_____| Bubbles |_____| Values |_____| \ _____|    |          |  O'
  o  o  o    |__|     |    to   |     |   to   |     | /      |__  |         O'  
                      |  Values |     | Sounds |     |/          \ |                |\
                      |_________|     |________|                  \|               O'

• Idee : Webcam via opencv auslesen

Den Sichtbereich habe ich noch eingeschränkt:

• Schnappschuss
• via Gimp übermalen:
  • weiß : sichtbar
  • Rest : unsichtbar
• mit imagemagick nach Text konvertiert: convert frame.png frame.txt
• aus Text-Datei zu python-Array (sog. Matrix) verarbeitet

Der bearbeitete Schanppschuss :

Der txt2py-filter:

#!/bin/bash

echo 'import numpy'   > frame.py
echo 'Matrix = [[0 for x in range(480)] for y in range(640)]'   >> frame.py

grep '^[0-9].*white$' frame.txt | sed 's/^\([0-9][0-9]*\),\([0-9][0-9]*\): .*white/Matrix[\1][\2] = 1 /g'   >> frame.py

exit

Somit ergeben sich folgende Basis-Scripte:

• common.py
• video.py
• frame.py (falls erwünscht, konvertiere ich Eure Bilder gerne)

• Bereits angepasst : lk_homography.py

Wir hatten uns für Script 1 entschieden, halte aber das Script 2 immer noch für brauchbar.

• Daher auch angepasst : motempl.py

Wir hatten drei Ansätze ersonnen:

• Ausgabe von Midi-Befehlen und Ansteuerung von extern. Midi-Geräten (Midi output)
• JACK sound server
• Play simple wav files (using external soundserver)

Gefunden unter https://ccrma.stanford.edu/~craig/articles/linuxmidi/https://ccrma.stanford.edu/~craig/articles/linuxmidi/; vielleicht nützt es ja.

//
// Programmer:    Craig Stuart Sapp <craig@ccrma.stanford.edu>
// Creation Date: Mon Dec 21 18:00:42 PST 1998
// Last Modified: Mon Dec 21 18:00:42 PST 1998
// Filename:      ...linuxmidi/output/method1.c
// Syntax:        C 
// $Smake:        gcc -O -o %b %f && strip %b
//
// Description:   This program sends out a single MIDI note (middle C)
//		  and then exits.  The MIDI driver usually turns the
//                note off automatically when the program is exited.
//

#include <linux/soundcard.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>

int main(void) {
   char* device = "/dev/sequencer";
   unsigned char devnum = 0;
   unsigned char packet[4] = {SEQ_MIDIPUTC, 0, devnum, 0};


   // step 1: open the OSS device for writing
   int fd = open(device, O_WRONLY);
   if (fd < 0) {
      printf("Error: cannot open %s\n", device);
      exit(1);
   }
			

   // step 2: write the note-on message to MIDI output
   packet[1] = 0x90;                        // note-on MIDI command
   write(fd, packet, sizeof(packet));
   packet[1] = 60;                          // kenumber: 60 = middle c
   write(fd, packet, sizeof(packet));
   packet[1] = 127;                         // attack velocity: 127 = loud
   write(fd, packet, sizeof(packet));   


   // step 3: (optional) close the device
   close(fd);


   return 0;
}

Basierend auf Craig Stuart Sapp zwei funktioirende Programme für Ausgabe (craig1) und Lesen (craig2):

// based on Craig Stuart Sapp <craig@ccrma.stanford.edu>

#include <stdio.h>
#include <unistd.h>


int i;

FILE *fd; 

int main(void) {
  fd = fopen("/dev/midi2", "w");

  fputc(0x90,fd);   fputc(48,fd);   fputc(127,fd); fflush(fd); //play note by number 48
  sleep(10); 
  fputc(0x80,fd);   fputc(48,fd);   fputc(127,fd); fflush(fd); //leave note by number 48

  fclose(fd);

  return 0;
}

// based on Craig Stuart Sapp <craig@ccrma.stanford.edu>

#include <stdio.h>


int i,j,k;
int run=1;

char c ;

FILE *fd; 

int main(void) {
  fd = fopen("/dev/midi2","rb");

while( run==1 ) {
  i=fgetc(fd) ;

  if(i==144){ //Note pressed
    j=fgetc(fd) ;
    k=fgetc(fd) ;
    if(k==64){   printf("craig2 Note >  %d\n",j); }}; //note value as number


  if(i==192){ //Instrument choosed (without 2nd line)
    j=fgetc(fd) ;
    printf("craig2 Inst >  %d\n",j); }; //instrument value

  if(i==224){ //Pitch activated
    j=fgetc(fd) ;
    k=fgetc(fd) ;
    if(j==64){   printf("craig2 Pitch >  %d\n",k); }}; //pitch value

/*   printf("craig2 >  %d\n",i);*/
    }
  fclose(fd);
   return 0;
}

• bereits vorgeführt
• Erfahrungen vorhanden
• komplexe Umsetzung des Source Codes

Ich hatte noch nach Beispielen geschaut, wie man in python wav files abspielen kann. Ich stolperte über zwei Probleme in den Skripten:

• Verwendung von Threads
• Filtereingang via read

Die Idee, alles in einem Skript zu mixen, sollte die schwer händelbaren Threads vermeiden. Alle Skripte, die ich fand, verwendeten Threads. Dann wäre aber die Frage, ob das OS nicht besser die Prozesse händelt, wie es der erprobte for-Loop mithilfe von play getättig hatte.

Der Befehl play stammt ist aus dem sox-Paketen, die als Pipe-Tools stdin und stdout erwarten. Nohup und Co. kappen aber diese IOs. Verwendung von play click.ogg -q & (q-Option) lässt play brav im Hintergrund arbeiten.

Ein mgl. Skript könnte also so aussehen:

#!/bin/bash

while read aaa
do

  case ${aaa} in
  A1) play a1.ogg -q & ; play bell.ogg -q & ;;
  C1) play c1.ogg -q & ; play chicken.ogg -q & ;;
  usw.
  esac

done

Das hat mich nun entsetzt, dass das Lesen vom Eingang (readkey) bei python derart OS-abhängig ist. Der Code muss an das OS angepasst werden.

Das Gefrickel entfällt bei obigem Bash-Skript zu Lasten der Geschwindigkeit bei der Ausführung des Programms. Oder man nutzt gleich C mit cross compiling, was dann auch zu schnellem Code führt.

Quelle : http://www.onicos.com/staff/iz/formats/midi-event.html http://www.onicos.com/staff/iz/formats/midi-event.html