• Turn off or delete all unused or irrelevant layers.
• Merge all adjustment layers or masks into regular layers.  Masked layers or groups cannot be used!
• Layer effects are OK!  However, if you turn one off and don’t plan on using it at all, make sure you remove the effect by dragging it onto the trash icon in the Layers palette.
• Vector graphics are always preferred!  If you are using Illustrator to design any assets, please provide the Illustrator file too, as Flash cannot import Smart Vector Objects.
• Vector graphics are especially preferred for layers intended to be animated.  Imported bitmaps will often look shoddy and low-resolution when moving around and rotating.
• If an Illustrator file can’t be provided, rasterize any Smart Vector Objects or other non-standard layers.
• Keep groups and layers orderly and named accurately whenever possible

Error #2078: The name property of a Timeline-placed object cannot be modified.

…even though I had no code addressing any Timeline-placed objects. What gived? I was trying to give an instance name of “name” to the object. Change it and you’re good. Word to the wise!

int byteSlice(byte input, byte startIndex, byte endIndex){

  // generates an integer value from an arbitrary slice of a byte
  // Example:
  //
  // index:   01234567
  // input = B01101100 (int 108)
  //
  // startIndex = 1
  // endIndex = 4
  // slice = B1101
  // returns int 13

  byte output;

  // shift left to shave off bits before startIndex
  output = input << startIndex;
  // shift right to shave off bits after endIndex
  output = output >> (7-endIndex) + startIndex;

  return int(output);
}

This basically takes out a chunk of a byte and gives you the integer representation of its bits.  The input index byte datatypes are a neurotic memory optimization, since the indices can’t be greater than 7. Example Arduino implementation:

void setup(){

  Serial.begin(9600);
  byte in = 108;

  Serial.print(in, DEC);
  Serial.print("\t");
  Serial.println(in, BIN);
  Serial.println("----------------");
  Serial.print(byteSlice(in, 0, 7), DEC);
  Serial.print("\t");
  Serial.println(byteSlice(in, 0, 7), BIN);
  Serial.println("----------------");
  Serial.print(byteSlice(in, 1, 4), DEC);
  Serial.print("\t");
  Serial.println(byteSlice(in, 1, 4), BIN);
  Serial.println("----------------");
  Serial.print(byteSlice(in, 3, 6), DEC);
  Serial.print("\t");
  Serial.println(byteSlice(in, 3, 6), BIN);
}

void loop(){
}

byte arrayToByte(int arr[], int len){
  // Convert -1 to 0 and pack the array into a byte
  int i;
  byte result = 0;

  for(i=len-1; i>=0; i--){
    if(arr[i] == -1){
      result &= ~(0 << i);
    } else {
      result |= (1 << i);
    }
  }
  return result;
}

int* byteToArray(byte in){
  int i, temp, out[8];

  for(i=0; i<8; i++){     temp = (in >> i) & 1;
    if(temp == 0) temp = -1;
    out[i] = temp;
  }
  return out;
}

The first function takes in an array of up to 8 integers valued 1 or -1 and generates a corresponding byte; the second does the reverse.  Easy to modify for other integer values.

The network consists of an input and output layer (and optional “hidden” layers in between) with weighted connections between all of them.  To train a perceptron, you present an input pattern and the output pattern it should learn to output.  Then you step through each pair of neurons in each pair of layers and modify their weights with this equation:

∆w_i = c (d – sign( ∑x_iw_i)) x_i

…where w_i is the ith weight (real-valued), c is the learning constant (i.e. 0.1), d is the desired output for this node (1 or -1), and x_i is the input activation (1 or -1).  The input activation term indicates that the input node in question “contributes” to the output or “inhibits” it.  sign() is given by:

sign(x) = 1 if x ≥ 0, else -1

Here’s a C++ implementation from my Neuroduino Arduino library:

int Neuroduino::signThreshold(double sum){
	if (sum >= _net.Theta) {
		return 1;
	} else {
		return -1;
	}
}

double Neuroduino::weightedSum(int l, int node){
	// calculates input activation for a particular neuron
	int i;
	double currentWeight, sum = 0.0;

	for (i=0; i<_net.Layer[l-1]->Units; i++) {
		currentWeight = _net.Layer[l]->Weight[node][i];
		sum += currentWeight * _net.Layer[l-1]->Output[i];
	}

	return sum;
}

void Neuroduino::adjustWeights(int trainArray[]){
	int l,i,j;
	int in,out, error;
	int activation;	// for each "rightmost" node
	double delta;

	for (l=1; l<_numLayers; l++) {
		// cycle through each pair of nodes
		for (i=0; i<_net.Layer[l]->Units; i++) {
			// "rightmost" layer
			// calculate current activation of this output node
			activation = signThreshold(weightedSum(l,i));
			out = trainArray[i];	// correct activation
			error = out - activation;	// -2, 2, or 0

			for (j=0; j<_net.Layer[l-1]->Units; j++) {
				// "leftmost" layer

				in = _net.Layer[l-1]->Output[j];

				delta = _net.Eta * in * error;
				_net.Layer[l]->Weight[i][j] += delta;
			}
		}
	}
}

void Neuroduino::simulateNetwork(){
	/*****
	 Calculate activations of each output node
	 *****/
	int l,j;

	for (l=_numLayers-1; l>0; l--) {
		// step backwards through layers
		// TODO: this will only work for _numLayers = 2!
		for (j=0; j < _net.Layer[l]->Units; j++) {
			_output[j] = signThreshold(weightedSum(1, j));
		}
	}
}

function gcd(a, b){
	// Euclidean algorithm
	var t;
	while (b != 0){
		t = b;
		b = a % b;
		a = t;
	}
	return a;
}

function lcm(a, b){
	return (a * b / gcd(a, b));
}

function lcmm(args){
	// Recursively iterate through pairs of arguments
	// i.e. lcm(args[0], lcm(args[1], lcm(args[2], args[3])))

	if(args.length == 2){
		return lcm(args[0], args[1]);
	} else {
		var arg0 = args[0];
		args.shift();
		return lcm(arg0, lcmm(args));
	}
}

Just pass in an array like so:

trace(lcmm([1,2,3,4]));

Fixing the locating problems yielded these:

I then decided to move towards a continuous, single line composed of Bezier segments:

This could easily pave the way for a recursive sketching algorithm that composes each Bezier segment from n number of smaller Bezier segments down to a predefined number of levels.  The larger question, in this investigation, remains: what determines the high-level gestures?

Finally last night I realized you could change that in the /etc/mpd.conf file.  Here’s what I used in mine:

############################# MIXER ############################
#
# MPD needs to know what mixer settings to change when you
# adjust the volume. If you don't specify one here, MPD will
# pick one based on which ones it was compiled with support for.
#
# An example for controlling an ALSA mixer:
#
mixer_type "alsa"
mixer_device "default"
mixer_control "Master"

Now it works perfectly; I can control the system volume from any of my clients (Pitchfork being the one that gets used the most).

It’s taken a week or two of solid hacking and research.  First I heard about a Python module to do it, which turned out to be really old, then I turned to Perl and, though I did get connected via Mail::IMAPClient (which I recommend), I then discovered a class called emailtodb for PHP.

This class turned out to be really busted; unless I’m missing some crazy PHP principles, it was bizarrely illogical.  I have heavily modified it and it’s a lot faster.  Download my zip of the class and example usage.  I haven’t really documented it, but leave a comment if you are confused about something.

So!  Here’s how you connect to Gmail IMAP with PHP:

$mbox = imap_open ("{imap.gmail.com:993/imap/ssl/novalidate-cert}[Gmail]/All Mail", "user_id", "password");

Here I’m connecting to the “All Mail” mailbox since I wanted to offload ALL the messages on the server.  You can also replace that with INBOX, which is the more typical usage.  I discovered /novalidate-cert by trial and error; I’m guessing you don’t need it if your client domain is SSL certified (or something? I still don’t really get SSL).

The biggest challenge was dealing with multipart MIME messages.  In the end it turned out to be fairly simple but the original code looks like it was written on crack, so I had to spend a lot of time fixing it.

Efficiency: Although I’m sure I could optimize the hell out of it, right now it goes at about .3 seconds on average for non-multipart messages and anywhere from 1-2 seconds or more for multipart messages (which usually just means it’s extracting an embedded attachment like an image).

From their site:

As of Mac OS X version 10.4.8 Apple do no longer support the com.apple.audio.midi java package, which on previous OS X versions allowed java applications to easily access the CoreMIDI system. mmj steps into that hole by providing a universal binary JNI wrapper to CoreMIDI, that is deployable accross system versions and processor architectures. If you need to work with Midi from java on both PowerPC and Intel Macs with all Java runtimes >= 1.4, this is what you need.

Here’s what you do:

1. Download the library here.
2. Look for /Library/Java/Extensions on your harddisk.  If the path doesn’t exist, go ahead and make it.
3. Copy libmmj.jnilib and mmj.jar from the zip file to that extensions path.
4. If you want to send or receive MIDI from within your computer, you’ll need a software bus.  On OS X Leopard (not sure if this is on previous versions?), this is REALLY easy, and instructions follow.  On Windows I think you have to use MidiOx/Yoke or something similar.
   1. Open the Audio/MIDI Setup program in /Applications/Utilities.
   2. Double click on the red IAC Driver button.
   3. Check “Device is online.”
   4. Click “Apply” if possible, on mine it is grayed out but it doesn’t seem to matter.
5. Now when you run your midiIO.printDevices(); command you will see:

input 0 : IAC Driver - Bus 1
output 0 : IAC Driver - Bus 1

…or whatever you named the bus (that is the default), and usually the “Java Sound Synthesizer” as well.  Bingo!  Now you just set your other program (like Ableton Live, etc.) to use that same bus and you can start to send MIDI back and forth.  Enjoy!