Due: Mon, Feb. 25, 11:59PM.

For this fifth assignment, we are going to consider not only the fabric structure and rigging, but the software which provides the affordances for animation. Our expectation is that fully realizing the kinetic potential of the fabric and rigging will require customizing the human interface and automation. In this way we hope you can create a kinetic instrument a human can both perform and choreograph.

The assignment will also be performed in assigned pairings. We would like each member of the pair to make their own fabric structure, then compose them into a single animated scene in which the movement considers the relation between the pieces. You are welcome to use the samples we pleated together in class as your fabric pieces or to create new fabric samples on your own.

The emphasis is on the possibilities of pleating, but all previous techniques (boning, cordage, shirring, etc.) are also available.

As before, please begin by manually puppeting the fabric pieces to explore movement ideas. Then carefully consider both a rigging design and the kinds of motor movements which will activate it. Using the software simulator, create a customized input mapping to enable your choreography. After the choreography has evolved, please move to the capstan bench and create an automated version. Please carefully document the resulting performance.

Please document your discoveries and points of interest.

Interface Inspirations

Here are a couple of ideas for performance interface improvements to stimulate your thinking:

  1. Map particular pads to parameter presets, e.g., one that configures the motors for slow, smooth motion, and one for fast oscillations.
  2. Map a pad to randomize the parameters.
  3. Map one or more pads to produce coordinated motions, e.g. simultaneous move multiple motors in some fixed ratio.
  4. Map a pad to start playing back a fixed sequence of motion commands over time.
  5. Map knobs to set the frequency and damping for individual motors rather than just the whole ensemble.
  6. Map a pad to trigger a rhythmic sequence of motions that ‘pumps’ the oscillatory motion, along with a knob to adjust the pumping frequency and a knob to adjust the oscillator resonant frequency.
  7. Add an algorithmic pattern generator to produce movement patterns, then map knobs and pads to adjust the algorithm parameters and trigger modes.

Resources

Sample code is now available incorporating both the hardware interface and the simulator, please download exercise5.zip. The course software is documented under Software Resources.

Assignment Specifics

For this exercise, please:

  1. create a fabric sample using pleating techniques
  2. create two, three or four tendon attachment points for actuation
  3. experiment to find movement points of interest
  4. record a short (no more than a minute) demo video of the effect of the movement (s) using the capstan bench
  5. post a short blog entry with the video and a paragraph or two explaining your explorations.
  6. new this time: please include a drawing of your rigging design.
  7. new this time: please post your modified code. You must use the correct syntax highlighting so it is legible, please see below. Please omit as much of the standard code as is reasonable, e.g., if you modify the ControlLogic class, please just include the full definition for the class but leave out the GUI and MainApp classes.

Deliverables

To be uploaded as a post to the course blog:

  1. A brief paragraph outlining your explorations: intended effect, surprises, discoveries, successes.
  2. Modified code samples, posted using syntax highlighting (see example below).
  3. Rigging drawing.
  4. Short video clip (no more than a minute). Please shoot from a stable camera, not handheld; we have tripods and Magic Arms available at Lending, or you may use a laptop resting on a table. Please embed the video so it can be directly viewed; you may either upload an MP4 file to our server (up to 16 MB) or use supported third-party hosting. N.B. hosted .mov files cannot be embedded; please convert to MP4.

We will review your posts prior to class and select one or more to discuss at the start of our next class.

Grading rubric.

When you go to run the hardware, the exercise 1 lab notes will help.

Syntax Highlighting Example

The following code sample was included by inserting a block of type “SyntaxHighlighter Code”, selecting Python from the Code Language combo box under Settings on the right panel, then inserting the plain text of the code using cut and paste. It is important that indentation and original line lengths be preserved for legibility. 

class ControlLogic(kf.midi.MIDIProcessor):
    """Core performance logic for processing MIDI input into winch commands."""
    def __init__(self):
        super(ControlLogic,self).__init__()
        self.winches = None
        self.display = None
        
        self.frequency = 1.0
        self.damping_ratio = 1.0
        self.winch_dir = [0,0,0,0]  # array to keep track of currently moving winches for aftertouch control

        return

    def connect_winches(self, winches):
        """Attach a winch output device to the performance logic, either physical or simulated."""
        self.winches = winches

    def connect_display(self, display):
        """Attach a console status output device to the performance logic."""
        self.display = display

    #---- methods to process MIDI messages -------------------------------------
    def note_on(self, channel, key, velocity):
        """Process a MIDI Note On event."""
        log.debug("ControlLogic received note on: %d, %d", key, velocity)
        row, col, bank = self.decode_mpd218_key(key)

        # Each column maps to a specific winch.
        # Rows 0 and 1 move forward, rows 2 and 3 move backward.
        # The middle rows make small motions, the outer rows make larger motions.
        delta = 5 * velocity if row <= 1 else -5 * velocity
        if row == 0 or row == 3:
            delta = delta * 8
        self.winches.increment_target(col, delta)
        self.winch_dir[col] = 1 if delta > 0 else -1 if delta < 0 else 0
        return

    def note_off(self, channel, key, velocity):
        """Process a MIDI Note Off event."""        
        log.debug("ControlLogic received note off: %d, %d", key, velocity)
        row, col, bank = self.decode_mpd218_key(key)
        self.winch_dir[col] = 0
        self.winches.set_velocity(col, 0)

    def control_change(self, channel, cc, value):
        """Process a MIDI Control Change event."""        
        if cc == 3: # Knob #1 on MPD218, use to control resonant frequency
            self.frequency = 0.05 + 0.1 * value

        elif cc == 9: # Knob #2 on on MPD218, use to control damping ratio
            self.damping_ratio = 0.05 + 0.01 * value

        self.winches.set_freq_damping(self.frequency, self.damping_ratio)
        self.display.set_status("Frequency: %f, damping ratio: %f" % (self.frequency, self.damping_ratio))        

    def channel_pressure(self, channel, pressure):
        """Process a MIDI Channel Pressure event."""                
        log.info("aftertouch: %d", pressure)
        velocities = [direction * 10 * pressure for direction in self.winch_dir]
        self.winches.set_velocities(velocities)