mstowell_jpoulin.tar

mstowell_jpoulin/ 40777      0      0           0 12331325314   7500 5mstowell_jpoulin/arpeggiator.rkt100777      0      0        7314 12330316000  12622 0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; SchArpeggio                                          ;;;
;;; Music Library                                        ;;;
;;; Jeremy Poulin                                        ;;;
;;;                                                      ;;;
;;; Class that contains all the musical magic that       ;;;
;;; goes on in the arpeggiator.                          ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;#lang racket
;(require racket/include)
;(include "objects.rkt")

;; start up SuperCollider server with: scsynth -u 57110 -D 0
; start the server's node list
(display "Super Collider initialized: ")
(with-sc3 (lambda (fd) (send fd (g-new1 1 add-to-tail 0))))

;;;;;; Notes to self ;;;;;;;
; out is function with 2 params       :channel :sound
; mul is function with 2 params       :sound   :volume
; sin-osc is a function with 3 params :func    :freq    :phase-offset
;

;; reset
(define (rsc3-stop) (with-sc3 reset))

; balance out the tone between earbuds
(define (even-out length note sound)
  (if (and (audition (out 0 (mul sound .25)))
           (audition (out 1 (mul sound .25))))
      (begin
        (sleep length)
        (rsc3-stop)
        note)
      #f))

; loops through chords objects and plays them sucessfully
(define (play-chord-progression prog)
  (play-chord (car prog))
  (play-chord-progression (append (cdr prog) (list (car prog)))))


; plays a chord with a given chord object
(define (play-chord c)
  (let ([num-notes (length (c 'notes))]
        [length (hash-ref note-length (c 'speed))])
    (play-note-in-chord c (modulo 0 num-notes))
    (if (< length (hash-ref note-length whole))
        (begin (play-note-in-chord c (modulo 1 num-notes))
               (if (< length (hash-ref note-length half))
                   (begin
                     (play-note-in-chord c (modulo 2 num-notes))
                     (play-note-in-chord c (modulo 3 num-notes))
                     (if (< length (hash-ref note-length quarter))
                         (begin
                           (play-note-in-chord c (modulo 4 num-notes))
                           (play-note-in-chord c (modulo 5 num-notes))
                           (play-note-in-chord c (modulo 6 num-notes))
                           (play-note-in-chord c (modulo 7 num-notes))
                           (if (< length (hash-ref note-length eighth))
                               (begin
                                 (play-note-in-chord c (modulo 8 num-notes))
                                 (play-note-in-chord c (modulo 9 num-notes))
                                 (play-note-in-chord c (modulo 10 num-notes))
                                 (play-note-in-chord c (modulo 11 num-notes))
                                 (play-note-in-chord c (modulo 12 num-notes))
                                 (play-note-in-chord c (modulo 13 num-notes))
                                 (play-note-in-chord c (modulo 14 num-notes))
                                 (play-note-in-chord c (modulo 15 num-notes)))
                               #t))
                         #t))
                   #t))
        #t)))

;; play note from a chord
(define (play-note-in-chord chord note-ref)
  (draw-note (list-ref (chord 'notes) note-ref) (chord 'speed))
  (define sound-func
    (cond ((eq? (chord 'sound-font) triangle-wave) lf-tri)
          ((eq? (chord 'sound-font) saw-wave) lf-saw)
          (else sin-osc)))
  (even-out
   (hash-ref note-length (chord 'speed))
   ((list-ref (chord 'notes) note-ref) 'name)
   (sound-func
    ar
    ((hash-ref note-with-name ((list-ref (chord 'notes) note-ref) 'name)) 'freq) 0)))

mstowell_jpoulin/drawing.rkt100777      0      0       27401 12331204036  11776 0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; SchArpeggio                                          ;;;
;;; Drawing Program                                      ;;;
;;; Mike Stowell                                         ;;;
;;;                                                      ;;;
;;; Class that contains the Turtle library               ;;;
;;; implementation to draw the musical staves and        ;;;
;;; other notes to complement the remainder of the       ;;;
;;; arpeggiator.                                         ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; include statements and lang - commented out to allow driver to run
;#lang racket
;(require graphics/turtles)
;(require racket/include)
;(include "objects.rkt")

; path to save the dynamic music sheet
(define file-path "")

; save the dynamic sheet at the path, passed in by the driver
(define (save-music-sheet)
  (save-turtle-bitmap (string-append file-path ".png") 'png)
)

; variable that remembers how many staves have been created
(define num-staves 0)

; variable that remembers how many notes are on a staff
(define cur-staff-weight 0)

; hash to represent the weighting of each note on a staff
; a total weight of 16 is allowed per staff
(define note-weight (hash
  whole     16
  half      8
  quarter   4
  eighth    2
  sixteenth 1
))

; basic method to draw a new music staff
(define (draw-new-staff . is-right-staff?)
  (let ((draw-right (and (not (null? is-right-staff?)) is-right-staff?)))
    (if draw-right
      (next-right-staff-start #f)
      (next-left-staff-start #t))
    (split* 
            ; treble clef
            (move-offset 0 20)  (move-offset 0 30) (move-offset 0 40)
            (move-offset 0 50)  (move-offset 0 60)
            ; bass clef
            (move-offset 0 80)  (move-offset 0 90) (move-offset 0 100)
            (move-offset 0 110) (move-offset 0 120))
    (if draw-right
      (draw 215)
      (draw 510))
    (if draw-right
      (next-right-staff-start #t)
      (next-left-staff-start #f))
  )
  (draw-treble-clef)
  (draw-bass-clef)
  (move-offset 10 0)
)

; draw the treble clef on the staff
(define (draw-treble-clef)
  (move-offset 0 48)
  (draw-offset 5 -7)
  (draw-offset 5 0)
  (draw-offset 5 7)
  (draw-offset -5 7)
  (draw-offset -12 0)
  (draw-offset -4 -7)
  (draw-offset 22 -27)
  (draw-offset 0 -4)
  (draw-offset -5 -5)
  (draw-offset -5 5)
  (draw-offset 0 55)
  (draw-offset -7 -7)
  (draw-offset 5 0)
  (move-offset -4 -65)
)

; draw the bass clef on the staff
(define (draw-bass-clef)
  (move-offset 4 92)
  (draw-offset 0 5)
  (draw-offset -3 3)
  (draw-offset -4 0)
  (draw-offset -3 -3)
  (draw-offset 0 -8)
  (draw-offset 3 -4)
  (draw-offset 13 0)
  (draw-offset 3 4)
  (draw-offset 0 10)
  (draw-offset -5 7)
  (draw-offset -14 9)
  (move-offset 25 -25)
  (draw-offset 0 2)
  (move-offset 0 2)
  (draw-offset 0 2)
  (move-offset -18 -96)
)

; draw the repeat symbol on the sheet
(define (draw-repeat)
  (home)
  (move-offset 245 225)
  (draw-offset 30 0)
  (draw-offset 0 -30)
  (draw-offset -30 0)
  (draw-offset 0 15)
  (draw-offset 5 -5)
  (move-offset -5 5)
  (draw-offset -5 -5)
)

; get the turtle off the screen so we can enjoy the music sheet
; without an obstruction
(define (disappear)
  (move-offset 1000 1000)
)

; position the turtle in place to draw a right staff.
; boolean indicates whether or not to position 10 more pixels
; over to begin drawing notes
(define (next-right-staff-start bool)
  (home)
  (move-offset 165 -375)
  (if bool
      (move-offset 10 0)
      (nothing))
)

; go to the next left staff starting location.
; boolean indicates whether or not to increment num-staves
(define (next-left-staff-start bool)
  (home)
  (move-offset -375 (+ -375 (* num-staves 160)))
  (if bool
      (set! num-staves (+ num-staves 1))
      (move-offset 10 -160))
)

; draw the notes from the progression passed in by the driver
; on a right-sided staff, and save the file path
(define (draw-progression progression path)
  (set! file-path path)
  (draw-new-staff #t)
  (progression-helper progression)
  (draw-repeat)
)

(define (progression-helper progression)
  (if (null? progression)
      (nothing)
      (begin
        (draw-chord (car progression))
        (progression-helper (cdr progression))
      )
  )
)

; draws all the notes in a chord object
(define (draw-chord chord)
  (draw-chord-helper (chord 'notes))
  (move-offset 30 0)
)

(define (draw-chord-helper rest)
  (if (eq? rest '())
      (nothing)
      (begin
        (draw-note (car rest) whole #t)
        (move-offset -30 0)
        (draw-chord-helper (cdr rest))
      )
  )
)

; Method to be called either by the draw-chord procedure
; internally or by Jeremy's arpegiator library to draw
; notes on the staves.  This is the bulk of the application.
(define (draw-note note speed . is-chord?)
  ; if we have already drew the max amount of staves,
  ; short circuit out of the function
  (if (> num-staves 4)
      (nothing)
      (let ((should-draw-note? #t))
        ; first check if we need to draw a new staff yet
        (if (> cur-staff-weight 15)
            (begin
              ; may have reached end - save music sheet
              (if (= num-staves 4)
                  (begin
                    (save-music-sheet)
                    (set! num-staves (+ num-staves 1))
                    (set! should-draw-note? #f)
                    (disappear)
                  )
                  (draw-new-staff)
              )
              (set! cur-staff-weight 0)
             )
             (nothing)
        )
        ; draw note only if cleared to
        (if should-draw-note?
            (begin
              ; update the staff weight for this note, unless
              ; this note is a chord
              (if (and (not (null? is-chord?)) is-chord?)
                  (nothing)
                  (set! cur-staff-weight 
                        (+ cur-staff-weight
                           (hash-ref note-weight speed))))
              ; move the turtle in place
              (move-offset 30 (note 'height))
              ; draw the circle
              (make-note-circle 36)
              ; draw the appropriate note flag
              (draw-flag (note 'flag-pos-up?) speed)
              ; draw an extra staff line(s) as needed
              (draw-extra-staff-line (note 'name))
              ; fill in the note if needed
              (draw-fill-in speed)
              ; draw sharp symbol if note is sharp
              (draw-sharp (note 'sharp?))
              ; prepare to draw next note by resetting turtle height
              (move-offset 0 (- 0 (note 'height)))
              ; based on weight of note, move the turtle further 
              ; right on the staff to even out the notes per measure
              (cond ((equal? speed half)    (move-offset 210 0))
                    ((equal? speed quarter) (move-offset 90 0))
                    ((equal? speed eighth)  (move-offset 30 0)))
            )
            (nothing)
        )
     )
  )
)

; draws the flag if needed on the note
(define (draw-flag flag-up speed)
  ; if whole, no need to draw any flag
  (if (not (equal? speed whole))
    (if flag-up
        (begin
          (move-offset 5 -7)
          (draw-offset 0 -30)
          ; if eighth or sixteenth, we have more flag lines to draw
          (cond ((eq? speed eighth)
                 (eighth-flag-up))
                ((eq? speed sixteenth)
                 (sixteenth-flag-up))
                (else
                 (move-offset -5 37)))
        )
        (begin
          (move-offset -6 -7)
          (draw-offset 0 30)
          ; if eighth or sixteenth, we have more flag lines to draw
          (cond ((eq? speed eighth)
                 (eighth-flag-down))
                ((eq? speed sixteenth)
                 (sixteenth-flag-down))
                (else
                 (move-offset 6 -23)))
        )
    )
    (nothing)
  )
)

; draw a flag up on the eighth note
(define (eighth-flag-up)
  (draw-offset 10 0)
  (move-offset -15 37)
)

; draw a flag up on the sixteenth note
(define (sixteenth-flag-up)
  (eighth-flag-up)
  (move-offset 5 -33)
  (draw-offset 10 0)
  (move-offset -15 33)
)

; draw a flag down on the eighth note
(define (eighth-flag-down)
  (draw-offset -10 0)
  (move-offset 16 -23)
)

; draw a flag down on the sixteenth note
(define (sixteenth-flag-down)
  (eighth-flag-down)
  (move-offset -6 19)
  (draw-offset -10 0)
  (move-offset 16 -19)
)

; draws the extra staff line if needed for the note
(define (draw-extra-staff-line name)
  ; extra line through the note
  (cond ((or (equal? name 'c4)
             (equal? name 'c#4)
             (equal? name 'e2)
             (equal? name 'a5)
             (equal? name 'a#5))
        (line-through))
      ; extra line below the note
      ((equal? name 'b5)
        (line-below))
      ; extra line above the note
      ((or (equal? name 'd2)
           (equal? name 'd#2))
        (line-above))
      ; extra line through and below the note
      ((equal? name 'c6)
        (begin
          (line-through)
          (line-far-below)
        ))
      ; extra line through and above the note
      ((or (equal? name 'c2)
           (equal? name 'c#2))
        (begin
          (line-through)
          (line-far-above)
        ))
      ; no extra line
      (else nothing)
  )
)

; draws a line through the note
(define (line-through)
  (move-offset 0 -5)
  (draw-offset 10 0)
  (move-offset -10 0)
  (draw-offset -12 0)
  (move-offset 12 5)
)

; draws a line below the note
(define (line-below)
  (draw-offset 10 0)
  (move-offset -10 0)
  (draw-offset -12 0)
  (move-offset 12 0)
)

; draws a line above the note
(define (line-above)
  (move-offset 0 -11)
  (draw-offset 10 0)
  (move-offset -10 0)
  (draw-offset -12 0)
  (move-offset 12 11)
)

; draws a line far below the note
(define (line-far-below)
  (move-offset 0 5)
  (draw-offset 10 0)
  (move-offset -10 0)
  (draw-offset -12 0)
  (move-offset 12 -5)
)

; draws a line far above the note
(define (line-far-above)
  (move-offset 0 -15)
  (draw-offset 10 0)
  (move-offset -10 0)
  (draw-offset -12 0)
  (move-offset 12 15)
)
  
; fill in the note if needed
(define (draw-fill-in speed)
  (if (or (equal? speed quarter)
          (equal? speed eighth)
          (equal? speed sixteenth))
      (begin
        (move-offset 0 -1)
        (fill-in-helper 5)
        (move-offset 0 1)
      )
      (nothing)
  )
)

(define (fill-in-helper level)
  (if (= level 0)
      (nothing)
      (begin
        (draw-offset level (- 0 level))
        (draw-offset (- 0 level) (- 0 level))
        (draw-offset (- 0 level) level)
        (draw-offset level level)
        (fill-in-helper (- level 1))
      )
  )
)

; draw the sharp on the note if needed
(define (draw-sharp is-sharp)
  (if is-sharp
      (begin
        (move-offset -14 -11)
        (draw-offset 0 10)
        (move-offset 4 0)
        (draw-offset 0 -10)
        (move-offset 2 2)
        (draw-offset -8 2)
        (move-offset 0 3)
        (draw-offset 8 -2)
        (move-offset 8 6)
      )
      (nothing)
  )
)

; helper function to draw the note circle
(define (make-note-circle remaining)
  (turn 10)
  (draw 1)
  (if (= (- remaining 1) 0)
      (nothing)
      (make-note-circle (- remaining 1)))
)

; ease-of-use command to do nothing - turn the drawing
; turtle 0 degrees
(define (nothing)
  (turn 0)
)

; reset the drawing board
(define (reset-music-sheet)
  (clear)
  (home)
  (set! num-staves 0)
  (set! cur-staff-weight 0)
  (turtles #f)
)mstowell_jpoulin/driver.rkt100777      0      0       13702 12331201457  11641 0#lang racket
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; SchArpeggio                                          ;;;
;;; Driver Program                                       ;;;
;;; Mike Stowell, some modifications by Jeremy Poulin    ;;;
;;;                                                      ;;;
;;; Class that contains the main driver to run the       ;;;
;;; SchArpeggiator program in addition to the global     ;;;
;;; object types required by the several components of   ;;;
;;; the overall program.                                 ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; #region Requirements

(require racket/file)
(require racket/string)
(require racket/include)

; requirements for objects
(include "objects.rkt")

; requirements for music
(require rsc3)
(include "arpeggiator.rkt")

; requirements for drawing
(require graphics/turtles)
(include "drawing.rkt")

;; #endregion


;; #region Running the driver

; list of chord objects - the progession
(define progression '())

; the music thread
(define music-thread (void))

; stops and resets the driver
(define (stop)
  (kill-thread music-thread)
  (reset-music-sheet)
  (rsc3-stop)
  (run))

; number of chords in the progression
(define num-chords 0)

; path to save the user's file to
(define path "")

; procedure to start the driver up
(define (run)
  ;reset the progression and chord number
  (set! num-chords 0)
  (set! progression '())
 
  (display (string-append 
            "Welcome to SchArpeggio!\n"              
            "You will be asked to enter 1 to 4 chord configurations.\n"
            "The setup will guide you through this process.\n\n\n"))
  
  (get-file-save-path)
  (get-new-chords)
  
  (send-chord-config-draw)  
  (set! music-thread (thread (lambda () (send-chord-config-music progression)))))

(define (get-file-save-path)
  (set! path
    (prompt-for-and-return 
      (string-append
        "\nEnter a full path for SchArpeggio to save your dynamic\n"
        "music sheet to.  The full path must include the filename to\n"
        "save as well, without the file extension (which will be .png).\n"
        "Path: "))))

(define (get-new-chords)
  (set! num-chords (+ num-chords 1))
  
  (define chord  (ask-for-chord))
  (define option (ask-for-option))
  (define speed  (ask-for-speed))
  (define flavor (ask-for-flavor))
  (define range  (ask-for-range))
  (define sound-font (ask-for-sound-font))
  
  (define chord-config (make-chord
                        chord 
                        option 
                        speed
                        flavor
                        range
                        sound-font))
  
  (if (= num-chords 4)       
      ; user hit max num chords per progression
      (add-to-progression chord-config)
      (begin
        ; ask for additional chords
        (if (equal? (prompt-for-and-return (string-append
                  "\n\nWould you like to enter another chord?\n"
                  "Enter Y for yes, N for no: ")) "Y")
            (begin 
              ; if yes, prompt for another chord
              (add-to-progression chord-config)
              (display "\n\n")
              (get-new-chords))
            ; otherwise, just add the last chord to the progression
            (add-to-progression chord-config)))))

; adds the chord to our list
(define (add-to-progression chord)
  (set! progression (append progression (list chord))))

; prompt the user for the chord
(define (ask-for-chord)
  (prompt-for-and-return 
   (string-append 
    "--- Chord #: " (number->string num-chords) " ---\n\n"
    "Please input a chord progression.\n"
    "Up to 4 chords are allowed.\n"
    "Enter the root chord as a single lowercase letter: ")))

; prompt the user for the option
(define (ask-for-option)
  (prompt-for-and-return 
   (string-append
    "\n\nPlease input an option to play the arpeggio.\n"
    "a) Down to Up\n"
    "b) Up to Down\n"
    "c) Random Order\n"
    "Select a choice (lower case letters only): ")))

; prompt the user for the speed
(define (ask-for-speed)
  (prompt-for-and-return 
   (string-append
    "\n\nPlease input a speed for the arpeggio.\n"
    "a) whole\n"
    "b) half\n"
    "c) quarter\n"
    "d) eighth\n"
    "e) sixteenth\n"
    "Select a choice (lower case letters only): ")))

; prompt the user for the flavor
(define (ask-for-flavor)
  (prompt-for-and-return 
   (string-append
    "\n\nPlease input a flavor for the chord.\n"
    "a) major\n"
    "b) minor\n"
    "Select a choice (lower case letters only): ")))

; prompt the user for the range
(define (ask-for-range)
  (prompt-for-and-return 
   (string-append
    "\n\nPlease input a range for the notes in the chord.\n"
    "a) root\n"
    "b) dom\n"
    "c) third\n"
    "d) high root\n"
    "e) low dom\n"
    "f) low third\n"
    "g) low root\n"
    "Select a choice (lower case letters only): ")))

; prompt the user for the sound font
(define (ask-for-sound-font)
  (prompt-for-and-return 
   (string-append
    "\n\nPlease input a sound-font for the notes in the chord.\n"
    "a) triangle-wave\n"
    "b) saw-wave\n"
    "c) sine-wave\n"
    "Select a choice (lower case letters only): ")))

; send the chord-config off to the music library
(define (send-chord-config-music chord-config)
  (play-chord-progression chord-config))

; send the chord-config off to the drawing library
(define (send-chord-config-draw)
  ; turn on the drawing board
  (turtles #t)
  ; draw the chord progression
  (draw-progression progression path)
  (draw-new-staff))

;; #endregion

;; #region User input

; generic prompt procedure to print a message and ask for input
(define (prompt-for-and-return msg)
  (display msg)
  (read-line my-in-port))

; input port
(define my-in-port (current-input-port))

;; #endregion

; Test code
;(define c (make-chord "c" "a" "a" "a" "a"))
(run)
mstowell_jpoulin/objects.rkt100777      0      0       34655 12330316000  11777 0; NOTE - remove this line when ready to port over.  
; Uncomment when developing to avoid errors
;#lang racket

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; SchArpeggio                                          ;;;
;;; Objects File                                         ;;;
;;; Mike Stowell and Jeremy Poulin                       ;;;
;;;                                                      ;;;
;;; Class that contains all the major objects that must  ;;;
;;; be shared between the driver, music library, and     ;;;
;;; drawing library                                      ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; #region Objects by Mike

; global values for the enums of option, speed, flavor, and range
(define down-to-up 'down-to-up)
(define up-to-down 'up-to-down)
(define random-order 'random-order)
(define whole 'whole)
(define half 'half)
(define quarter 'quarter)
(define eighth 'eighth)
(define sixteenth 'sixteenth)
(define major 'major)
(define minor 'minor)
(define root 'root)
(define dom 'dom)
(define third 'third)
(define high-root 'high-root)
(define low-dom 'low-dom)
(define low-third 'low-third)
(define low-root 'low-root)
(define saw-wave 'saw-wave)
(define triangle-wave 'triangle-wave)
(define sine-wave 'sine-wave)

; enum for option
(define (make-option in)
  (cond ((equal? in "a") down-to-up)
        ((equal? in "b") up-to-down)
        (else         random-order)))

; enum for speed
(define (make-speed in)
  (cond ((equal? in "a") whole)
        ((equal? in "b") half)
        ((equal? in "c") quarter)
        ((equal? in "d") eighth)
        (else         sixteenth)))

; enum for flavor
(define (make-flavor in)
  (if (equal? in "a")
      major
      minor))

; enum for range
(define (make-range in)
  (cond ((equal? in "a") root)
        ((equal? in "b") dom)
        ((equal? in "c") third)
        ((equal? in "d") high-root)
        ((equal? in "e") low-dom)
        ((equal? in "f") low-third)
        (else         low-root)))

; enum for sound-font
(define (make-sound-font in)
  (cond ((equal? in "a") triangle-wave)
        ((equal? in "b") saw-wave)
        (else sine-wave)))


; convert the string input to our internal chord list
(define (chord-string->note str)
  (note-sym-to-note-obj (string->symbol (notes-to-g3-through-f4 str))))

; the message passing style chord object
(define (make-chord c o s f r sf)
  ; save the chord options
  (define root-note (chord-string->note c))
  (define option (make-option o))
  (define speed (make-speed s))
  (define flavor (make-flavor f))
  (define range (make-range r))
  (define sound-font (make-sound-font sf))
  (define notes (get-notes-from-root root-note range flavor option))
  
  ; root note
  (define (get-root-note) root-note)
  (define (set-root-note arg) (set! root-note arg))
  
  ; option for the chord
  (define (get-option) option)
  (define (set-option arg) (set! option arg))
  
  ; speed to play the chord
  (define (get-speed) speed)
  (define (set-speed arg) (set! speed arg))
  
  ; flavor of the chord
  (define (get-flavor) flavor)
  (define (set-flavor arg) (set! flavor arg))
  
  ; amount of notes in arpeggio
  (define (get-range) range)
  (define (set-range arg) (set! range arg))
    
  ; sound font of chord
  (define (get-sound-font) sound-font)
  (define (set-sound-font arg) (set! sound-font arg))
  
  ; all of the notes in the chord
  (define (get-notes) notes)
  (define (set-notes arg) (set! notes arg))
    
  ; dispatch procedure
  ; if arg == null, then we're requesting a getter
  ; otherwise, we want to use a setter with that argument
  (define (dispatch sym . arg)
    (if (null? arg)
        (cond ((eq? sym 'root-note) (get-root-note))
          ((eq? sym 'option) (get-option))
          ((eq? sym 'speed) (get-speed))
          ((eq? sym 'flavor) (get-flavor))
          ((eq? sym 'range) (get-range))
          ((eq? sym 'notes) (get-notes))
          ((eq? sym 'sound-font) (get-sound-font))
          (else (error 
                 (string-append "NO SUCH GETTER METHOD: " 
                                (symbol->string sym)))))
        (cond ((eq? sym 'root-note) (set-root-note arg))
          ((eq? sym 'option) (set-option arg))
          ((eq? sym 'speed) (set-speed arg))
          ((eq? sym 'flavor) (set-flavor arg))
          ((eq? sym 'range) (set-range arg))
          ((eq? sym 'notes) (set-notes arg))
          ((eq? sym 'sound-font) (set-sound-font arg))
          (else (error 
                 (string-append "NO SUCH SETTER METHOD: " 
                                (symbol->string sym)))))))
  dispatch)

(define (note-sym-to-note-obj sym)
   (hash-ref note-with-name sym))
  
; convert notes to appropriate representation
(define (notes-to-g3-through-f4 str)
  (cond ((equal? str "a")   "a3")
        ((equal? str "a#") "a#3")
        ((equal? str "b")   "b3")
        ((equal? str "c")   "c4")
        ((equal? str "c#") "c#4")
        ((equal? str "d")   "d4")
        ((equal? str "d#") "d#4")
        ((equal? str "e")   "e4")
        ((equal? str "f")   "f4")
        ((equal? str "f#") "f#4")
        ((equal? str "g")   "g3")
        (else              "g#3")))

;; #endregion

;; #region Objects by Mike and Jeremy

; Note definition
(define (make-note name frequency position height sharp flag-pos-up)
  (define (dispatch msg)
    (cond ((eq? msg 'name) name)
          ((eq? msg 'freq) frequency)
          ((eq? msg 'position) position)
          ((eq? msg 'height) height)
          ((eq? msg 'sharp?) sharp)
          ((eq? msg 'flag-pos-up?) flag-pos-up)
          (else (error 
                 (string-append "NO SUCH NOTE METHOD: " 
                                (symbol->string msg))))))
  dispatch)

; Global hash set of notes -----------------------------------

; Mark the position of each note relative to c4
(define (make-position-itr)
  (define n -12.5)
  (define (dispatch . msg)
    (cond ((and (pair? msg) (eq? (car msg) 'reset)) (set! n -12.5))
          (else (begin (set! n (+ n 0.5))
                       n))))
  dispatch)
(define cur-position (make-position-itr))

; Mike - give notes a draw height
(define (make-draw-height-itr)
  (define n 150)
  (define (dispatch . msg)
    (cond ((and (pair? msg) (eq? (car msg) 'sharp)) n)
          (else (begin (set! n (- n 5))
                       n))))
  dispatch)
(define cur-draw-height (make-draw-height-itr))

; Notes themselves (Jer and Mike)
(define note-with-name (hash
                'c2 (make-note  'c2    65.40 (cur-position) (cur-draw-height)        #f #t)
               'c#2 (make-note 'c#2    69.29 (cur-position) (cur-draw-height 'sharp) #t #t)
                'd2 (make-note  'd2    73.41 (cur-position) (cur-draw-height)        #f #t)
               'd#2 (make-note 'd#2    77.78 (cur-position) (cur-draw-height 'sharp) #t #t)
                'e2 (make-note  'e2    82.40 (cur-position) (cur-draw-height)        #f #t)
                'f2 (make-note  'f2    87.30 (cur-position) (cur-draw-height)        #f #t)
               'f#2 (make-note 'f#2    92.49 (cur-position) (cur-draw-height 'sharp) #t #t)
                'g2 (make-note  'g2    97.99 (cur-position) (cur-draw-height)        #f #t)
               'g#2 (make-note 'g#2   103.82 (cur-position) (cur-draw-height 'sharp) #t #t)
                'a2 (make-note  'a2   110.00 (cur-position) (cur-draw-height)        #f #t)
               'a#2 (make-note 'a#2   116.54 (cur-position) (cur-draw-height 'sharp) #t #t)
                'b2 (make-note  'b2   123.47 (cur-position) (cur-draw-height)        #f #t)
                'c3 (make-note  'c3   130.81 (cur-position) (cur-draw-height)        #f #t)
               'c#3 (make-note 'c#3   138.59 (cur-position) (cur-draw-height 'sharp) #t #t)
                'd3 (make-note  'd3   146.83 (cur-position) (cur-draw-height)        #f #f)
               'd#3 (make-note 'd#3   155.56 (cur-position) (cur-draw-height 'sharp) #t #f)
                'e3 (make-note  'e3   164.81 (cur-position) (cur-draw-height)        #f #f)
                'f3 (make-note  'f3   174.61 (cur-position) (cur-draw-height)        #f #f)
               'f#3 (make-note 'f#3   184.99 (cur-position) (cur-draw-height 'sharp) #t #f)
                'g3 (make-note  'g3   195.99 (cur-position) (cur-draw-height)        #f #f)
               'g#3 (make-note 'g#3   207.65 (cur-position) (cur-draw-height 'sharp) #t #f)
                'a3 (make-note  'a3   220.00 (cur-position) (cur-draw-height)        #f #f)
               'a#3 (make-note 'a#3   233.08 (cur-position) (cur-draw-height 'sharp) #t #f)
                'b3 (make-note  'b3   246.94 (cur-position) (cur-draw-height)        #f #f)
                'c4 (make-note  'c4   261.62 (cur-position) (cur-draw-height)        #f #f)
               'c#4 (make-note 'c#4   277.18 (cur-position) (cur-draw-height 'sharp) #t #f)
                'd4 (make-note  'd4   293.66 (cur-position) (cur-draw-height)        #f #f)
               'd#4 (make-note 'd#4   311.12 (cur-position) (cur-draw-height 'sharp) #t #f)
                'e4 (make-note  'e4   329.63 (cur-position) (cur-draw-height)        #f #t)
                'f4 (make-note  'f4   349.22 (cur-position) (cur-draw-height)        #f #t)
               'f#4 (make-note 'f#4   369.99 (cur-position) (cur-draw-height 'sharp) #t #t)
                'g4 (make-note  'g4   391.99 (cur-position) (cur-draw-height)        #f #t)
               'g#4 (make-note 'g#4   415.30 (cur-position) (cur-draw-height 'sharp) #t #t)
                'a4 (make-note  'a4   440.00 (cur-position) (cur-draw-height)        #f #t)
               'a#4 (make-note 'a#4   466.16 (cur-position) (cur-draw-height 'sharp) #t #t)
                'b4 (make-note  'b4   493.88 (cur-position) (cur-draw-height)        #f #t)
                'c5 (make-note  'c5   523.25 (cur-position) (cur-draw-height)        #f #f)
               'c#5 (make-note 'c#5   554.36 (cur-position) (cur-draw-height 'sharp) #t #f)
                'd5 (make-note  'd5   587.33 (cur-position) (cur-draw-height)        #f #f)
               'd#5 (make-note 'd#5   622.25 (cur-position) (cur-draw-height 'sharp) #t #f)
                'e5 (make-note  'e5   659.25 (cur-position) (cur-draw-height)        #f #f)
                'f5 (make-note  'f5   698.45 (cur-position) (cur-draw-height)        #f #f)
               'f#5 (make-note 'f#5   739.98 (cur-position) (cur-draw-height 'sharp) #t #f)
                'g5 (make-note  'g5   783.99 (cur-position) (cur-draw-height)        #f #f)
               'g#5 (make-note 'g#5   830.60 (cur-position) (cur-draw-height 'sharp) #t #f)
                'a5 (make-note  'a5   880.00 (cur-position) (cur-draw-height)        #f #f)
               'a#5 (make-note 'a#5   932.32 (cur-position) (cur-draw-height 'sharp) #t #f)
                'b5 (make-note  'b5   987.76 (cur-position) (cur-draw-height)        #f #f)
                'c6 (make-note  'c6  1046.50 (cur-position) (cur-draw-height)        #f #f)))

;; #endregion

;; #region Objects by Jeremy

; Relative positions
(cur-position 'reset)
(define note-at-position
  (hash (cur-position)  'c2
        (cur-position) 'c#2
        (cur-position)  'd2
        (cur-position) 'd#2
        (cur-position)  'e2
        (cur-position)  'f2
        (cur-position) 'f#2
        (cur-position)  'g2
        (cur-position) 'g#2
        (cur-position)  'a2
        (cur-position) 'a#2
        (cur-position)  'b2
        (cur-position)  'c3
        (cur-position) 'c#3
        (cur-position)  'd3
        (cur-position) 'd#3
        (cur-position)  'e3
        (cur-position)  'f3
        (cur-position) 'f#3
        (cur-position)  'g3
        (cur-position) 'g#3
        (cur-position)  'a3
        (cur-position) 'a#3
        (cur-position)  'b3
        (cur-position)  'c4
        (cur-position) 'c#4
        (cur-position)  'd4
        (cur-position) 'd#4
        (cur-position)  'e4
        (cur-position)  'f4
        (cur-position) 'f#4
        (cur-position)  'g4
        (cur-position) 'g#4
        (cur-position)  'a4
        (cur-position) 'a#4
        (cur-position)  'b4
        (cur-position)  'c5
        (cur-position) 'c#5
        (cur-position)  'd5
        (cur-position) 'd#5
        (cur-position)  'e5
        (cur-position)  'f5
        (cur-position) 'f#5
        (cur-position)  'g5
        (cur-position) 'g#5
        (cur-position)  'a5
        (cur-position) 'a#5
        (cur-position)  'b5
        (cur-position)  'c6))

(define note-length
  (hash whole  2
        half   1
        quarter .5
        eighth  .25
        sixteenth .125))
  
(define (get-notes-from-root root-note range flavor option)
  (define get-dom (hash-ref note-with-name (hash-ref note-at-position (+ 3.5 (root-note 'position)))))
  (define get-third (hash-ref note-with-name (hash-ref note-at-position (+ (if (eq? flavor major) 2.0 1.5) (root-note 'position)))))
  (define get-high-root (hash-ref note-with-name (hash-ref note-at-position (+ 6.0 (root-note 'position)))))
  (define get-low-dom (hash-ref note-with-name (hash-ref note-at-position (+ -2.5 (root-note 'position)))))
  (define get-low-third (hash-ref note-with-name (hash-ref note-at-position (+ (if (eq? flavor major) -4.0 -4.5) (root-note 'position)))))
  (define get-low-root (hash-ref note-with-name (hash-ref note-at-position (+ -6.0 (root-note 'position)))))
  (begin 
    (define standard
      (cond
        ((eq? range root) (list root-note))
        ((eq? range dom) (list root-note get-dom))
        ((eq? range third) (list root-note get-third get-dom))
        ((eq? range high-root) (list root-note get-third get-dom get-high-root))
        ((eq? range low-dom) (list get-low-dom root-note get-third get-dom get-high-root))
        ((eq? range low-third) (list get-low-third get-low-dom root-note get-third get-dom get-high-root))
        ((eq? range low-root) (list get-low-root get-low-third get-low-dom root-note get-third get-dom get-high-root))
        (else (error 
               (string-append "NO SUCH NOTE RANGE " 
                              (symbol->string range))))))
    ; Mix notes according to chord option
    (cond ((eq? option up-to-down) (reverse standard))
          ((eq? option random-order) (shuffle standard))
          (else standard))))

;; #endregion

; Testing functions
;(define c (make-chord "c" 'a 'a 'a 'a))
;(map (lambda (n) (n 'name)) (c 'notes))
                        mstowell_jpoulin/README.txt100777      0      0       17667 12331325234  11340 0SchArpeggio - A Scheme Music Arpeggiator
Jeremy Poulin and Mike Stowell

______________________________________________________________________________
Code:

- driver.rkt
- arpeggiator.rkt
- drawing.rkt
- objects.rkt

______________________________________________________________________________
Overall structure:

The user interacts with driver.rkt providing input for both a path to
save the dynamic sheet and the chord configurations to arpeggiate over.
The chord configurations, defined in objects.rkt along with many additional
objects and hash references, are then sent to drawing.rkt and
arpeggiator.rkt.  Drawing.rkt draws out the chord configuration and saves
the file path defined by the user in the driver.  Arpeggiator.rkt performs
music synthesis and plays out the sound, constantly sending drawing.rkt
single notes to draw as the music is playing.

______________________________________________________________________________
Who worked on what:

Mike was responsible for the majority of the driver code, some of the objects,
and the entirety of the drawing file.  Jeremy was responsible for extending the
driver, many additional objects, and the entirety of the arpeggiator.
Code comments are left in the objects file to point out who worked on what.

______________________________________________________________________________
How the code exhibits key ideas of the course:

>> Mike <<

- Data abstraction and message passing are used in many objects like the 
	chord-configuration.
- String and symbolic manipulation is used to transform user input into 
	something our program can understand.
- Notes are drawn using a recursive function.
- Heavy use of let statements prevent tedious code repetitions in the 
	drawing program.
- Hash tables are kept to perform lookups on notes and their properties.
- Lists are utilized to allow easy passing of multiple chord configurations.
- Optional arguments allow procedures like that which draws a musical staff 
	behave differently on different input.
- Begin is used heavily in the draw-note procedure to allow multiple 
	s-expressions to be evaluated in one if-block. 

>> Jeremy <<

- Data abstraction and message passing are used to interface with notes objects.
- Strings and symbolic manipulation are used to transform user input into 
	options/commands the arpeggiator understands.
- Progressions are played in a recursive fashion.
- A let statement provides internal variables for the play-chord function.
- Hash tables are used to organize both notes and their relative positions.
- Lists are manipulated to allow the user to play notes in different orders.
- If and cond statements allow configuration for different sounds.
- Begin is the foundation of the core functionality for playing multiple notes 
	in the same chord.
- A lambda function provides a handle for multi-threading. 

______________________________________________________________________________
How to run the code:

- install qjackctl, jack, and supercollider
- reroute pulseaudio to dump its output to jack
- run a startup script to make jack your default sound provider
- download the source for rsc3
- install the source for rsc3 into drracket using raco
- start qjackctl
- start the supercollider server
- reconnect the sound ports so that the supercollider gives its outpt 
	to jack and jack gives its input to supercollider
- run our code
- and finally, reinstall linux at your convenience to undo the horrible things
	 you just did to your sound set-up

In other words, it is inadvisable to run our code. I've tried to make a youtube
video demo of our project, but I can't because Ubuntu's desktop recording applications
are as broken as the rest of the operating system. Cheers!

______________________________________________________________________________
Code blocks we are happy with:

>> Mike <<

I am quite content with this block of code in drawing.rkt:
; fill in the note if needed
(define (draw-fill-in speed)
  (if (or (equal? speed quarter)
          (equal? speed eighth)
          (equal? speed sixteenth))
      (begin
        (move-offset 0 -1)
        (fill-in-helper 5)
        (move-offset 0 1)
      )
      (nothing)
  )
)

(define (fill-in-helper level)
  (if (= level 0)
      (nothing)
      (begin
        (draw-offset level (- 0 level))
        (draw-offset (- 0 level) (- 0 level))
        (draw-offset (- 0 level) level)
        (draw-offset level level)
        (fill-in-helper (- level 1))
      )
  )
)

Programming in Scheme has made me think recursively a lot more often than
I would have.  Had this have been any other language, I likely would have a
for or while loop.  What draw-fill-in does is it fills in a note circle if
it is required (i.e. if it is a quarter, eighth, or sixteenth note).
The fill-in-helper was my clever way to recursively color in a note using
straight line.  The draw-offset call draw a straight line up-right, up-left,
down-left, and finally down-right for "level" amount of pixels.  This fills
in the note with a square rotated 45 degrees.  The recursive call then
decrements the level and continues to draw concentric squares to fill in the
note.

I was also quite happy with how our giant hash table in objects.rkt came out.
This shared hash table is essentially the backbone to our entire application.


>> Jeremy <<

;; play note from a chord
(define (play-note-in-chord chord note-ref)
  (draw-note (list-ref (chord 'notes) note-ref) (chord 'speed))
  (define sound-func
    (cond ((eq? (chord 'sound-font) triangle-wave) lf-tri)
          ((eq? (chord 'sound-font) saw-wave) lf-saw)
          (else sin-osc)))
  (even-out
   (hash-ref note-length (chord 'speed))
   ((list-ref (chord 'notes) note-ref) 'name)
   (sound-func
    ar
    ((hash-ref note-with-name ((list-ref (chord 'notes) note-ref) 'name)) 'freq) 0)))

This block of code is the core of the arpeggiator - it not only allows configurable
sound wave selection, but also hands off the note information to Mike's drawing library.
Even-out is an function I made to make sure the sound output would go to both speakers - 
otherwise it would just go the the left. Note-ref tells you which note in the chord to play,
and the hash tables provide the actual frequency and note information.

My second favorite code block is as follows:

; loops through chords objects and plays them sucessfully
(define (play-chord-progression prog)
  (play-chord (car prog))
  (play-chord-progression (append (cdr prog) (list (car prog)))))

This is my clever infinite loop control block that keeps the chords playing.
Essentially, I play the first chord, and then call the function recursively with the 
car of the list appended to the cdr of the list.  This ends up being an infite cycle, 
which is wonderfully recursive. While it is possible to write functions like this
in other languages, I feel like this function truly exemplifies how racket changed
the way I code.


______________________________________________________________________________
Annoyances:

>> Mike <<

Drawing when you only have 3 basic functions - move, draw, and turn - is
quite difficult when you want circular objects.  When browsing through the
drawing code, it may become obvious why some of the numbers were also
particularly annoying to deal with.  Just 1 pixel off and everything gets
messed up.

>> Jeremy <<

Rsc3 is the worst sound library in the history of mankind. It is missing a key
feature of actual SuperCollider, namely patterns.  Patterns would have increased
the sound quality of my arpeggiator, and most importantly allowed me to play notes
seperately instead of having a thread sleep and resetting the server to create 
seperate notes from sound waves. I'm also note particularly fond of my play-chord
function. I could have made it recursive but chose not to because I was in a rush.


______________________________________________________________________________