(load "ps6.owl.scm")
(define ones (cons-stream 1 ones))
(define integers (cons-stream 1 (add-streams ones integers)))
;(print-stream integers)
;([STREAM] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 


(define 4b-sig (car (make-test-signal 3)))

;Making a signal...
;distances are = 25.472571947050266 44.73419361520165
;time onsets are = 37. 57.
;signals are = 30823.673837251634 9994.262901307811
;Value: 4b-sig


;(print-stream 4b-sig)
;([STREAM] 1 2 1 2 1 1 2 1 2 2 0 0 2 0 2 1 0 1 1 0 1 0 0 1 2 0 1 2 0 1 1 2 0 2 1 1 2 30825.673837251634 30824.673837251634 

(define (noise-stream lower-bound upper-bound)
  (let ((difference (- upper-bound lower-bound)))
    (cons-stream (+ lower-bound (random difference))
		 (noise-stream lower-bound upper-bound))))

;(print-stream (noise-stream 3 8))
;([STREAM] 4 6 3 5 6 5 6 7 7 4 6 3 4 3 6 5 3 5 4 5 3 3 3 3 7 5 3 5


(define (diff st)
  (add-streams (tail st)
	      (scale-stream -1 st)))

;(print-stream (diff integers))
;([STREAM] 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 

(define (smooth stream)
  (scale-stream 0.5 (add-streams stream (tail stream))))

(define (repeated f n)
  (if (= n 0)
      (lambda (z) z)
      (compose f (repeated f (- n 1)))))

(define (compose f g)
  (lambda (x) (f (g x))))


(define (smooth-n stream n)
  ((repeated smooth n) stream))

;(print-stream (smooth-n integers 3))
(define 4b-sig (car (make-test-signal 3)))
(define smooth-4b-sig (smooth-n 4b-sig 4))
(define diff-4b-sig (diff 4b-sig))

(define (mark smooth-diff-stream mean dev)
  (map (lambda (elt) (if (> (abs (- elt mean)) (* 3 dev))
			 1
			 0))
       smooth-diff-stream))


(define smooth-diff (smooth-n diff-4b-sig 4))

;(print-stream (mark smooth-diff mean dev))

(define (combine-streams proc s1 s2)
  (cond ((empty-stream? s1) s2)
	((empty-stream? s2) s1)
	(else
	 (cons-stream (proc (head s1) (head s2))
		      (combine-streams proc (tail s1) (tail s2))))))

(define (mult-streams st1 st2)
  (combine-streams * st1 st2))

(define (get-signal-strength marked-st smooth-st)
  (mult-streams marked-st (smooth smooth-st)))

;(print-stream (mult-streams integers integers))

;([STREAM] 1 4 9 16 25 36 49 64 81 100 121 144 169 196 225 ....


(define punt6 (get-signal-strength (mark integers 0 2)
				   (smooth-n integers 3)))
(define punt9 (get-signal-strength (mark integers 0 3) (smooth-n integers 3)))

;(print-stream punt6)
;([STREAM] 0 0 0 0 0 0 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 

(define (dev-posns str)
  (filter (lambda (x) (not (= (car x) 0)))
	  (combine-streams cons str integers)))

(define (posn-value devposnstr) (car devposnstr))

(define (posn-time devposnstr) (car devposnstr))

;(print-stream (dev-posns punt6))

;([STREAM] (9. . 7) (10. . 8) (11. . 9) (12. . 10) (13. . 11) (14. . 12) (15. . 13)

(define (measure-time-spread-and-signals l-str r-str)
  (combine-streams (lambda (event1 event2)
		     (list (- (posn-time event1) (posn-time event2))
			   (posn-value event1)
			   (posn-value event2)))
		   l-str
		   r-str))

(define time-shift car)
(define left-value cadr)
(define right-value caddr)
;(print-stream (measure-time-spread-and-signals (dev-posns punt6) (dev-posns punt9)))

;([STREAM] (-3. 9. 12.) (-3. 10. 13.) (-3. 11. 14.) (-3. 12. 15.) (-3. 13. 16.) (-3. 14. 17.) (-3. 15. 18.)

(define mean 0)
(define dev 20)


(define (process-signal str smooth-factor)
  (let ((smoothed-str (smooth-n str smooth-factor)))
    (dev-posns (get-signal-strength (mark (diff smoothed-str) mean dev)
				    smoothed-str))))

(define (simulate l-str r-str smooth-factor v b)
  (map (lambda (spread-n-sigs) (compute-distance-and-angle (time-shift spread-n-sigs)
							   (left-value spread-n-sigs)
							   (right-value spread-n-sigs)
							   v b))
       (measure-time-spread-and-signals (process-signal l-str smooth-factor)
					(process-signal r-str smooth-factor))))


(define signals (make-test-signal 2))
;Making a signal...
;distances are = 25.472571947050266 44.73419361520165
;time onsets are = 38. 58.
;signals are = 30823.673837251634 9994.262901307811
;Value: signals


(define left-signal (car signals))
(define right-signal (cdr signals))
(head (simulate left-signal right-signal 2 signal-velocity baseline))
;Value 11: (-4745.443890212434 -.7854129135703237)