Update of /project/gsharp/cvsroot/gsharp
In directory common-lisp:/tmp/cvs-serv5433
Modified Files:
buffer.lisp drawing.lisp measure.lisp
Log Message:
Removed some dead code.
Prepared Gsharp for handling timelines and measures of zero duration.
This conversion is not entirely finished yet, but there is not much
left.
Date: Sat Jan 21 17:39:16 2006
Author: rstrandh
Index: gsharp/buffer.lisp
diff -u gsharp/buffer.lisp:1.28 gsharp/buffer.lisp:1.29
--- gsharp/buffer.lisp:1.28 Thu Jan 5 13:14:45 2006
+++ gsharp/buffer.lisp Sat Jan 21 17:39:16 2006
@@ -495,6 +495,14 @@
(defmethod print-object :after ((b bar) stream)
(format stream ":elements ~W " (elements b)))
+;;; The duration of a bar is simply the sum of durations
+;;; of its elements. We might want to improve on the
+;;; implementation of this method so that it uses some
+;;; kind of cache, in order to avoid looping over each
+;;; element and computing the duration of each one each time.
+(defmethod duration ((bar bar))
+ (reduce #'+ (mapcar #'duration (elements bar))))
+
(defgeneric make-bar-for-staff (staff &rest args &key elements))
(defmethod nb-elements ((bar bar))
@@ -935,7 +943,7 @@
(staves :initform (list (make-fiveline-staff))
:initarg :staves :accessor staves)
;; the min width determines the preferred geographic distance after the
- ;; timetlime with the shortest duration on a line.
+ ;; timeline with the shortest duration on a line.
(min-width :initform *default-min-width* :initarg :min-width :accessor min-width)
;; the spacing style of the buffer determines the how geographic distance
;; between adjacent timelines is related to temporal distance.
Index: gsharp/drawing.lisp
diff -u gsharp/drawing.lisp:1.55 gsharp/drawing.lisp:1.56
--- gsharp/drawing.lisp:1.55 Tue Jan 3 08:25:46 2006
+++ gsharp/drawing.lisp Sat Jan 21 17:39:16 2006
@@ -82,37 +82,8 @@
(defun final-absolute-accidental-xoffset (note)
(+ (final-absolute-element-xoffset (cluster note)) (final-relative-accidental-xoffset note)))
-(defun line-cost (measures method)
- (reduce (lambda (x y) (combine-cost method x y)) measures :initial-value nil))
-
-(defun compute-compress-factor (measures method)
- (compress-factor method (line-cost measures method)))
-
-(defun red-width (method coeff min-dist)
- (* coeff (min-width method) (expt (/ min-dist) (spacing-style method))))
-
-(defun compute-reduced-width (method coeff min-dist)
- (if (zerop min-dist) 0 (red-width method coeff min-dist)))
-
-(defun nat-width (method coeff min-dist)
- (+ (red-width method coeff min-dist) (min-width method)))
-
(defvar *cursor* nil)
-(defun compute-min-dist (measures)
- (let ((min-dists (mapcar (lambda (measure)
- (reduce #'min (gsharp-measure::abs-rel
- (measure-start-times measure))))
- measures)))
- (reduce #'min min-dists)))
-
-(defun compute-widths (measures method)
- (let ((compress (compute-compress-factor measures method))
- (min-dist (compute-min-dist measures)))
- (loop for measure in measures
- collect (/ (nat-width method (measure-coeff measure) min-dist)
- compress))))
-
;;; Compute the elasticity of each timeline in each measure of the
;;; measures of a system (line) by taking its duration to the power of
;;; the spaceing style. This metric is arbitrarily normalized to the
@@ -316,9 +287,7 @@
finally (setf (elasticity-function measure) result)))
(reduce #'add-elasticities measures :key #'elasticity-function))
-;;; eventually replace the existing compute-measure-coordinates
-;;; by this one
-(defun new-compute-measure-coordinates (measure x y force)
+(defun compute-measure-coordinates (measure x y force)
(loop with timelines = (timelines measure)
for i from 0 below (flexichain:nb-elements timelines)
for timeline = (flexichain:element* timelines i)
@@ -330,28 +299,6 @@
(loop for bar in (measure-bars measure)
do (compute-bar-coordinates bar x y (size-at-force (elasticity-function measure) force))))
-(defun compute-measure-coordinates (measure min-dist compress x y method)
- (let* ((width (/ (nat-width method (measure-coeff measure) min-dist)
- compress))
- (time-alist (cons (cons 0 (/ (min-width method) compress))
- (loop for start-time in (measure-start-times measure)
- and old-start-time = 0 then start-time
- with coeff = 0
- do (incf coeff (expt (- start-time old-start-time)
- (spacing-style method)))
- collect (cons start-time
- (/ (+ (min-width method)
- (compute-reduced-width
- method
- coeff min-dist))
- compress))))))
-;; (setf (system-y-position measure) y
-;; (final-absolute-measure-xoffset measure) x
-;; (final-width measure) width)
- (loop for bar in (measure-bars measure) do
- (compute-bar-coordinates bar x y width)
- (compute-element-x-positions bar x time-alist))))
-
(defun draw-measure (pane measure)
(loop for bar in (measure-bars measure) do
(if (gsharp-cursor::cursors (slice bar))
@@ -366,21 +313,11 @@
(+ y (- (score-pane:staff-step 8)))
(+ y (staff-yoffset (car (last staves))))))))
-;;; eventually remove the existing compute-system-coordinates
-;;; and rename this one
-(defun new-compute-system-coordinates (measures x y force)
+(defun compute-system-coordinates (measures x y force)
(loop for measure in measures
- do (new-compute-measure-coordinates measure x y force)
+ do (compute-measure-coordinates measure x y force)
do (incf x (size-at-force (elasticity-function measure) force))))
-(defun compute-system-coordinates (measures x y widths method)
- (let ((compress (compute-compress-factor measures method))
- (min-dist (compute-min-dist measures)))
- (loop for measure in measures
- for width in widths do
- (compute-measure-coordinates measure min-dist compress x y method)
- (incf x width))))
-
(defun draw-system (pane measures)
(loop for measure in measures do
(draw-measure pane measure)))
@@ -407,7 +344,6 @@
(right-edge (right-edge buffer)))
(loop for staff in staves
for offset from 0 by 90 do
-;; for offset downfrom 0 by 90 do
(setf (staff-yoffset staff) offset))
(let ((yy y))
(gsharp-measure::new-map-over-obseq-subsequences
@@ -421,25 +357,20 @@
(force (if (> (zero-force-size e-fun) (line-width method))
0
(force-at-size e-fun (line-width method)))))
- (new-compute-system-coordinates measures
- (+ x (left-offset buffer) timesig-offset) yy
- force)
- )
- (let ((widths (compute-widths measures method)))
-;; (compute-system-coordinates measures
-;; (+ x (left-offset buffer) timesig-offset) yy
-;; widths method)
- (draw-system pane measures)
- (score-pane:draw-bar-line pane x
- (+ yy (- (score-pane:staff-step 8)))
- (+ yy (staff-yoffset (car (last staves)))))
- (loop for staff in staves do
- (score-pane:with-vertical-score-position (pane yy)
- (if (member staff (staves (layer (slice (bar *cursor*)))))
- (draw-staff-and-clef pane staff x right-edge)
- (score-pane:with-light-glyphs pane
- (draw-staff-and-clef pane staff x right-edge))))
- (incf yy 90))))
+ (compute-system-coordinates measures
+ (+ x (left-offset buffer) timesig-offset) yy
+ force))
+ (draw-system pane measures)
+ (score-pane:draw-bar-line pane x
+ (+ yy (- (score-pane:staff-step 8)))
+ (+ yy (staff-yoffset (car (last staves)))))
+ (loop for staff in staves do
+ (score-pane:with-vertical-score-position (pane yy)
+ (if (member staff (staves (layer (slice (bar *cursor*)))))
+ (draw-staff-and-clef pane staff x right-edge)
+ (score-pane:with-light-glyphs pane
+ (draw-staff-and-clef pane staff x right-edge))))
+ (incf yy 90)))
buffer)))))
(define-added-mixin velement () melody-element
Index: gsharp/measure.lisp
diff -u gsharp/measure.lisp:1.22 gsharp/measure.lisp:1.23
--- gsharp/measure.lisp:1.22 Thu Jan 5 13:14:45 2006
+++ gsharp/measure.lisp Sat Jan 21 17:39:16 2006
@@ -413,7 +413,7 @@
(defclass timeline (flexichain:element-rank-mixin)
((start-time :initarg :start-time :reader start-time)
(elements :initform '() :accessor elements)
- (duration :initarg :duration :reader duration)
+ (duration :initarg :duration :accessor duration)
(elasticity :accessor elasticity)
;; the minimum x offset from this timeline to the next, or, if this
;; is the last timeline, from this one to the end of the measure
@@ -433,9 +433,6 @@
;; the coefficient of a measure is the sum of d_i^k where d_i
;; is the duration of the i:th timeline, and k is the spacing style
(coeff :initarg :coeff :reader measure-coeff)
- ;; a list of unique rational numbers, sorted by increasing numeric value,
- ;; of the start time of the time lines of the measure
- (start-times :initarg :start-times :reader measure-start-times)
;; the position of a measure in the sequence of measures
;; of a buffer is indicated by two numbers, the position
;; of the segment to which the measure belongs within the
@@ -452,9 +449,8 @@
;; is applied to it
(elasticity-function :accessor elasticity-function)))
-(defun make-measure (min-dist coeff start-times seg-pos bar-pos bars)
+(defun make-measure (min-dist coeff seg-pos bar-pos bars)
(make-instance 'measure :min-dist min-dist :coeff coeff
- :start-times start-times
:seg-pos seg-pos :bar-pos bar-pos :bars bars))
(defmethod print-object ((obj measure) stream)
@@ -492,6 +488,7 @@
(defmethod measures :before ((segment rsegment))
(when (modified-p segment)
(compute-measures segment (spacing-style (buffer-cost-method (buffer segment))))
+ ;; avoid an infinite computation by using slot-value here
(mapc #'compute-timelines (slot-value segment 'measures))
(setf (modified-p segment) nil)))
@@ -536,17 +533,26 @@
(let ((elements (elements bar)))
(if elements
(rel-abs (mapcar #'duration elements))
- '(1))))
+ '(0))))
;;; Combine the list of start times of two bars into a single list
-;;; of start times. Don't worry about duplicated elements which will
-;;; be removed ultimately.
+;;; of start times. If any of the list contains duplicate start
+;;; times, then the resulting list will contain as many duplicates
+;;; as the maximum number of duplicates of the two lists.
;;; Treat the last start time (which is really the duration of the
;;; bar) specially and only keep the largest one
(defun combine-bars (bar1 bar2)
- (append (merge 'list (butlast bar1) (butlast bar2) #'<)
- (list (max (car (last bar1)) (car (last bar2))))))
-
+ (labels ((combine (l1 l2)
+ (cond ((null l1) l2)
+ ((null l2) l1)
+ ((< (car l1) (car l2))
+ (cons (car l1) (combine (cdr l1) l2)))
+ ((< (car l2) (car l1))
+ (cons (car l2) (combine (cdr l2) l1)))
+ (t (cons (car l1) (combine (cdr l1) (cdr l2)))))))
+ (append (combine (butlast bar1) (butlast bar2))
+ (list (max (car (last bar1)) (car (last bar2)))))))
+
;;; given a group of notes (i.e. a list of notes, all displayed on the
;;; same staff, compute their final x offsets. This is a question of
;;; determining whether the note goes to the right or to the left of
@@ -654,7 +660,7 @@
do (compute-beam-group-parameters group)))
;;; From a list of simultaneous bars (and some other stuff), create a
-;;; measure. The `other stuff' is the spacing style, which is neded
+;;; measure. The `other stuff' is the spacing style, which is needed
;;; in order to compute the coefficient of the measure, the position
;;; of the segment to which the bars belong in the sequence of
;;; segments of the buffer, and the position of the bars in the
@@ -667,38 +673,54 @@
do (when (modified-p bar)
(compute-bar-parameters bar)
(setf (modified-p bar) nil)))
- (let* ((start-times (remove-duplicates
- (reduce #'combine-bars
- (mapcar #'start-times bars))))
+ (let* ((start-times (reduce #'combine-bars
+ (mapcar #'start-times bars)))
(durations (abs-rel start-times))
- (min-dist (reduce #'min durations))
+ ;; elements with zero duration do not intervene
+ ;; in the computation of the min-dist.
+ ;; Choose a large default value for min-dist.
+ (min-dist (reduce #'min (remove 0 durations) :initial-value 10000))
(coeff (loop for duration in durations
sum (expt duration spacing-style))))
- (make-measure min-dist coeff start-times seg-pos bar-pos bars))))
+ (make-measure min-dist coeff seg-pos bar-pos bars))))
(defun compute-timelines (measure)
- (let ((timelines (timelines measure))
- (durations (abs-rel (measure-start-times measure))))
- ;; create a timeline for each start time of the measure
- (loop for duration in durations
- and start-time = 0 then (+ start-time duration)
- for i from 0
- do (let ((timeline (make-instance 'timeline
- :start-time start-time
- :duration duration)))
- (flexichain:insert* timelines i timeline)))
- ;; link each timeline to its elements and each element of a
- ;; timeline to the timeline
- (loop for bar in (measure-bars measure)
- do (loop with timeline-index = 0
- for element in (elements bar)
- and start-time = 0 then (+ start-time (duration element))
- do (loop while (< (start-time (flexichain:element* timelines timeline-index))
- start-time)
- do (incf timeline-index))
- do (let ((timeline (flexichain:element* timelines timeline-index)))
- (push element (elements timeline))
- (setf (timeline element) timeline))))))
+ (let ((timelines (timelines measure)))
+ (flet ((compute-bar-timelines (bar)
+ (loop with timeline-index = 0
+ for element in (elements bar)
+ and start-time = 0 then (+ start-time (duration element))
+ do (loop until (= timeline-index (flexichain:nb-elements timelines))
+ for timeline = (flexichain:element* timelines timeline-index)
+ until (or (> (start-time timeline) start-time)
+ (and (= (start-time timeline) start-time)
+ (or (zerop (duration element))
+ ;; either none or every element of a timline
+ ;; has zero duration, so we only have to test
+ ;; the first one.
+ (not (zerop (duration (car (elements timeline))))))))
+ do (incf timeline-index))
+ do (when (or (= timeline-index (flexichain:nb-elements timelines))
+ (> (start-time (flexichain:element* timelines timeline-index))
+ start-time))
+ (let ((timeline (make-instance 'timeline
+ :start-time start-time)))
+ (flexichain:insert* timelines timeline-index timeline)))
+ do (let ((timeline (flexichain:element* timelines timeline-index)))
+ (push element (elements timeline))
+ (setf (timeline element) timeline)))))
+ (loop for bar in (measure-bars measure)
+ do (compute-bar-timelines bar)))
+ ;; compute the duration of each timeline except the last one
+ (loop for i from 0 below (1- (flexichain:nb-elements timelines))
+ do (setf (duration (flexichain:element* timelines i))
+ (- (start-time (flexichain:element* timelines (1+ i)))
+ (start-time (flexichain:element* timelines i)))))
+ ;; compute the duration of the last timeline, if any
+ (unless (zerop (flexichain:nb-elements timelines))
+ (let ((measure-duration (reduce #'max (measure-bars measure) :key #'duration))
+ (last-timeline (flexichain:element* timelines (1- (flexichain:nb-elements timelines)))))
+ (setf (duration last-timeline) (- measure-duration (start-time last-timeline)))))))
;;; Compute all the measures of a segment by stepping through all the
;;; bars in parallel as long as there is at least one simultaneous bar.
