source file of the GNU LilyPond music typesetter
- (c) 1997--2007 Han-Wen Nienhuys <hanwen@xs4all.nl>
+ (c) 1997--2008 Han-Wen Nienhuys <hanwen@xs4all.nl>
Jan Nieuwenhuizen <janneke@gnu.org>
*/
Grob *stem = first_normal_stem (me);
/*
- ugh: stems[0] case happens for chord tremolo.
+ This happens for chord tremolos.
*/
- dir = to_dir ((stem ? stem : stems[0])->get_property ("default-direction"));
+ if (!stem)
+ stem = stems[0];
+
+ if (is_direction (stem->get_property_data ("direction")))
+ dir = to_dir (stem->get_property_data ("direction"));
+ else
+ dir = to_dir (stem->get_property ("default-direction"));
}
}
return best_start;
}
-MAKE_SCHEME_CALLBACK(Beam, calc_beaming, 1)
+MAKE_SCHEME_CALLBACK (Beam, calc_beaming, 1)
SCM
Beam::calc_beaming (SCM smob)
{
Position_stem_segments_map stem_segments;
Real lt = me->layout ()->get_dimension (ly_symbol2scm ("line-thickness"));
+ /* There are two concepts of "rank" that are used in the following code.
+ The beam_rank is the vertical position of the beam (larger numbers are
+ closer to the noteheads). Beam_stem_segment.rank_, on the other hand,
+ is the horizontal position of the segment (this is incremented by two
+ for each stem; the beam segment on the right side of the stem has
+ a higher rank (by one) than its neighbour to the left). */
Slice ranks;
-
for (vsize i = 0; i < stems.size (); i++)
{
Grob *stem = stems[i];
Direction d = LEFT;
do
{
+ // Find the maximum and minimum beam ranks.
+ // Given that RANKS is never reset to empty, the interval will always be
+ // smallest for the left beamlet of the first stem, and then it might grow.
+ // Do we really want this? (It only affects the tremolo gaps) --jneem
for (SCM s = index_get_cell (beaming, d);
scm_is_pair (s); s = scm_cdr (s))
{
Beam_stem_segment seg;
seg.stem_ = stem;
seg.stem_x_ = stem_x;
- seg.rank_ = 2 * i + (d+1)/2;
+ seg.rank_ = 2 * i + (d+1)/2;
seg.width_ = stem_width;
seg.stem_index_ = i;
seg.dir_ = d;
Beam_segment current;
+ // Iterate over all of the segments of the current beam rank,
+ // merging the adjacent Beam_stem_segments into one Beam_segment
+ // when appropriate.
int vertical_count = (*i).first;
for (vsize j = 0; j < segs.size (); j++)
{
- /*
- event_dir == LEFT: left edge of a beamsegment.
- */
+ // Keeping track of the different directions here is a little tricky.
+ // segs[j].dir_ is the direction of the beam segment relative to the stem
+ // (ie. segs[j].dir_ == LEFT if the beam segment sticks out to the left of
+ // its stem) whereas event_dir refers to the edge of the beam segment that
+ // we are currently looking at (ie. if segs[j].dir_ == event_dir then we
+ // are looking at that edge of the beam segment that is furthest from its
+ // stem).
Direction event_dir = LEFT;
+ Beam_stem_segment const& seg = segs[j];
do
{
- bool on_bound = (event_dir == LEFT) ? j == 0 :
- j == segs.size() - 1;
-
+ Beam_stem_segment const& neighbor_seg = segs[j + event_dir];
+ // TODO: make names clearer? --jneem
+ // on_line_bound: whether the current segment is on the boundary of the WHOLE beam
+ // on_beam_bound: whether the current segment is on the boundary of just that part
+ // of the beam with the current beam_rank
+ bool on_line_bound = (seg.dir_ == LEFT) ? seg.stem_index_ == 0
+ : seg.stem_index_ == stems.size() - 1;
+ bool on_beam_bound = (event_dir == LEFT) ? j == 0 :
+ j == segs.size () - 1;
bool inside_stem = (event_dir == LEFT)
- ? segs[j].stem_index_ > 0
- : segs[j].stem_index_ + 1 < stems.size () ;
+ ? seg.stem_index_ > 0
+ : seg.stem_index_ + 1 < stems.size () ;
- bool event = on_bound
- || abs (segs[j].rank_ - segs[j+event_dir].rank_) > 1
- || (abs (vertical_count) >= segs[j].max_connect_
- || abs (vertical_count) >= segs[j + event_dir].max_connect_);
+ bool event = on_beam_bound
+ || abs (seg.rank_ - neighbor_seg.rank_) > 1
+ || (abs (vertical_count) >= seg.max_connect_
+ || abs (vertical_count) >= neighbor_seg.max_connect_);
if (!event)
+ // Then this edge of the current segment is irrelevent because it will
+ // be connected with the next segment in the event_dir direction.
continue;
current.vertical_count_ = vertical_count;
- current.horizontal_[event_dir] = segs[j].stem_x_;
- if (segs[j].dir_ == event_dir)
+ current.horizontal_[event_dir] = seg.stem_x_;
+ if (seg.dir_ == event_dir)
+ // then we are examining the edge of a beam segment that is furthest
+ // from its stem.
{
- if (on_bound
+ if (on_line_bound
&& me->get_bound (event_dir)->break_status_dir ())
{
current.horizontal_[event_dir]
- = (me->get_bound (event_dir)->extent (commonx, X_AXIS)[RIGHT]
+ = (robust_relative_extent (me->get_bound (event_dir),
+ commonx, X_AXIS)[RIGHT]
+ event_dir * break_overshoot[event_dir]);
}
else
{
- Real notehead_width =
- Stem::duration_log (segs[j].stem_) == 1
- ? 1.98
- : 1.32; // URG.
-
+ Grob *stem = stems[seg.stem_index_];
+ Drul_array<Real> beamlet_length =
+ robust_scm2interval (stem->get_property ("beamlet-default-length"), Interval (1.0, 1.0));
+ Drul_array<Real> max_proportion =
+ robust_scm2interval (stem->get_property ("beamlet-max-length-proportion"), Interval (0.5, 0.5));
+ Real length = beamlet_length[seg.dir_];
if (inside_stem)
{
- Grob *neighbor_stem = stems[segs[j].stem_index_ + event_dir];
+ Grob *neighbor_stem = stems[seg.stem_index_ + event_dir];
Real neighbor_stem_x = neighbor_stem->relative_coordinate (commonx, X_AXIS);
- notehead_width = min (notehead_width,
- fabs (neighbor_stem_x - segs[j].stem_x_)/2);
+ length = min (length,
+ fabs (neighbor_stem_x - seg.stem_x_) * max_proportion[seg.dir_]);
}
- current.horizontal_[event_dir] += event_dir * notehead_width;
+ current.horizontal_[event_dir] += event_dir * length;
}
}
else
+ // we are examining the edge of a beam segment that is closest
+ // (ie. touching, unless there is a gap) its stem.
{
- current.horizontal_[event_dir] += event_dir * segs[j].width_/2;
- if (segs[j].gapped_)
- current.horizontal_[event_dir] -= event_dir * gap_length;
+ current.horizontal_[event_dir] += event_dir * seg.width_/2;
+ if (seg.gapped_)
+ {
+ current.horizontal_[event_dir] -= event_dir * gap_length;
+
+ if (Stem::is_invisible (seg.stem_))
+ {
+ /*
+ Need to do this in case of whole notes. We don't want the
+ heads to collide with the beams.
+ */
+ extract_grob_set (seg.stem_, "note-heads", heads);
+
+ for (vsize k = 0; k < heads.size (); k ++)
+ current.horizontal_[event_dir]
+ = event_dir * min (event_dir * current.horizontal_[event_dir],
+ - gap_length/2
+ + event_dir
+ * heads[k]->extent (commonx,
+ X_AXIS)[-event_dir]);
+ }
+ }
}
if (event_dir == RIGHT)
{
segments.push_back (current);
- current = Beam_segment();
+ current = Beam_segment ();
}
}
while (flip (&event_dir) != LEFT);
return segments;
}
-MAKE_SCHEME_CALLBACK(Beam, print, 1);
+MAKE_SCHEME_CALLBACK (Beam, print, 1);
SCM
Beam::print (SCM grob)
{
}
#if (DEBUG_BEAM_SCORING)
- SCM quant_score = me->get_property ("quant-score");
- SCM debug = me->layout ()->lookup_variable (ly_symbol2scm ("debug-beam-scoring"));
- if (to_boolean (debug) && scm_is_string (quant_score))
+ SCM annotation = me->get_property ("annotation");
+ if (!scm_is_string (annotation))
+ {
+ SCM debug = me->layout ()->lookup_variable (ly_symbol2scm ("debug-beam-scoring"));
+ if (to_boolean (debug))
+ annotation = me->get_property ("quant-score");
+ }
+
+ if (scm_is_string (annotation))
{
extract_grob_set (me, "stems", stems);
Direction stem_dir = stems.size () ? to_dir (stems[0]->get_property ("direction")) : UP;
Stencil score = *unsmob_stencil (Text_interface::interpret_markup
- (me->layout ()->self_scm (), properties, quant_score));
+ (me->layout ()->self_scm (), properties, annotation));
if (!score.is_empty ())
- the_beam.add_at_edge (Y_AXIS, stem_dir, score, 1.0);
+ {
+ score.translate_axis (me->relative_coordinate(commonx, X_AXIS), X_AXIS);
+ the_beam.add_at_edge (Y_AXIS, stem_dir, score, 1.0);
+ }
}
#endif
-MAKE_SCHEME_CALLBACK(Beam, calc_stem_shorten, 1)
+MAKE_SCHEME_CALLBACK (Beam, calc_stem_shorten, 1)
SCM
Beam::calc_stem_shorten (SCM smob)
{
}
+Interval
+Beam::no_visible_stem_positions (Grob *me, Interval default_value)
+{
+ extract_grob_set (me, "stems", stems);
+ if (stems.empty ())
+ return default_value;
+
+ Interval head_positions;
+ Slice multiplicity;
+ for (vsize i = 0; i < stems.size(); i++)
+ {
+ head_positions.unite (Stem::head_positions (stems[i]));
+ multiplicity.unite (Stem::beam_multiplicity (stems[i]));
+ }
+
+ Direction dir = get_grob_direction (me);
+ Real y = head_positions[dir]
+ * 0.5 * Staff_symbol_referencer::staff_space (me)
+ + dir * get_beam_translation (me) * (multiplicity.length () + 1);
+
+ y /= Staff_symbol_referencer::staff_space (me);
+ return Interval (y,y);
+}
+
/*
Compute a first approximation to the beam slope.
*/
MAKE_SCHEME_CALLBACK (Beam, calc_least_squares_positions, 2);
SCM
-Beam::calc_least_squares_positions (SCM smob, SCM posns)
+Beam::calc_least_squares_positions (SCM smob, SCM /* posns */)
{
- (void) posns;
-
Grob *me = unsmob_grob (smob);
int count = normal_stem_count (me);
Interval pos (0,0);
if (count < 1)
- return ly_interval2scm (pos);
+ return ly_interval2scm (no_visible_stem_positions (me, pos));
vector<Real> x_posns;
extract_grob_set (me, "normal-stems", stems);
in POS for stem S. This Y position is relative to S. */
Real
Beam::calc_stem_y (Grob *me, Grob *stem, Grob **common,
- Real xl, Real xr,
+ Real xl, Real xr, Direction feather_dir,
Drul_array<Real> pos, bool french)
{
Real beam_translation = get_beam_translation (me);
+ Direction stem_dir = get_grob_direction (stem);
- Real r = stem->relative_coordinate (common[X_AXIS], X_AXIS) - xl;
- Real dy = pos[RIGHT] - pos[LEFT];
Real dx = xr - xl;
- Real stem_y_beam0 = (dy && dx
- ? r / dx
- * dy
- : 0) + pos[LEFT];
+ Real relx = dx ? (stem->relative_coordinate (common[X_AXIS], X_AXIS) - xl)/dx : 0;
+ Real xdir = 2*relx-1;
+
+ Real stem_y = linear_combination(pos, xdir);
- Direction my_dir = get_grob_direction (stem);
SCM beaming = stem->get_property ("beaming");
- Real stem_y = stem_y_beam0;
- if (french)
- {
- Slice bm = where_are_the_whole_beams (beaming);
- if (!bm.is_empty ())
- stem_y += beam_translation * bm[-my_dir];
- }
- else
- {
- Slice bm = Stem::beam_multiplicity (stem);
- if (!bm.is_empty ())
- stem_y += bm[my_dir] * beam_translation;
- }
+ Slice beam_slice (french
+ ? where_are_the_whole_beams (beaming)
+ : Stem::beam_multiplicity (stem));
+ if (beam_slice.is_empty ())
+ beam_slice = Slice (0,0);
+ Interval beam_multiplicity(beam_slice[LEFT],
+ beam_slice[RIGHT]);
+ /*
+ feather dir = 1 , relx 0->1 : factor 0 -> 1
+ feather dir = 0 , relx 0->1 : factor 1 -> 1
+ feather dir = -1, relx 0->1 : factor 1 -> 0
+ */
+ Real feather_factor = 1;
+ if (feather_dir > 0)
+ feather_factor = relx;
+ else if (feather_dir < 0)
+ feather_factor = 1 - relx;
+
+ stem_y += feather_factor * beam_translation
+ * beam_multiplicity[Direction(((french) ? DOWN : UP)*stem_dir)];
Real id = me->relative_coordinate (common[Y_AXIS], Y_AXIS)
- stem->relative_coordinate (common[Y_AXIS], Y_AXIS);
Hmm. At this time, beam position and slope are determined. Maybe,
stem directions and length should set to relative to the chord's
position of the beam. */
-MAKE_SCHEME_CALLBACK(Beam, set_stem_lengths, 1);
+MAKE_SCHEME_CALLBACK (Beam, set_stem_lengths, 1);
SCM
Beam::set_stem_lengths (SCM smob)
{
Real xl = fvs ? fvs->relative_coordinate (common[X_AXIS], X_AXIS) : 0.0;
Real xr = lvs ? lvs->relative_coordinate (common[X_AXIS], X_AXIS) : 0.0;
+ Direction feather_dir = to_dir (me->get_property ("grow-direction"));
for (vsize i = 0; i < stems.size (); i++)
{
bool french = to_boolean (s->get_property ("french-beaming"));
Real stem_y = calc_stem_y (me, s, common,
- xl, xr,
+ xl, xr, feather_dir,
pos, french && s != lvs && s!= fvs);
/*
for normal beams, but for tremolo beams it looks silly otherwise.
*/
if (gap
- && !Stem::is_invisible (s))
+ && !Stem::is_invisible (s))
stem_y += thick * 0.5 * get_grob_direction (s);
/*
rest -> stem -> beam -> interpolate_y_position ()
*/
-MAKE_SCHEME_CALLBACK_WITH_OPTARGS (Beam, rest_collision_callback, 2, 1);
+MAKE_SCHEME_CALLBACK_WITH_OPTARGS (Beam, rest_collision_callback, 2, 1, "");
SCM
Beam::rest_collision_callback (SCM smob, SCM prev_offset)
{
return false;
}
-MAKE_SCHEME_CALLBACK (Beam, cross_staff, 1)
+MAKE_SCHEME_CALLBACK (Beam, calc_cross_staff, 1)
SCM
-Beam::cross_staff (SCM smob)
+Beam::calc_cross_staff (SCM smob)
{
return scm_from_bool (is_cross_staff (unsmob_grob (smob)));
}
}
ADD_INTERFACE (Beam,
-
- "A beam. \n\n"
- "The @code{thickness} property is the weight of beams, "
- "measured in staffspace. The @code{direction} "
- "property is not user-serviceable. Use "
- "the @code{direction} property of @code{Stem} instead. "
-
- ,
+ "A beam.\n"
+ "\n"
+ "The @code{thickness} property is the weight of beams,"
+ " measured in staffspace. The @code{direction} property is"
+ " not user-serviceable. Use the @code{direction} property"
+ " of @code{Stem} instead.",
/* properties */
+ "annotation "
"auto-knee-gap "
"beamed-stem-shorten "
"beaming "
"concaveness "
"damping "
"details "
- "direction "
+ "direction "
"gap "
"gap-count "
"grow-direction "