source file of the GNU LilyPond music typesetter
- (c) 1997--2008 Han-Wen Nienhuys <hanwen@xs4all.nl>
+ (c) 1997--2009 Han-Wen Nienhuys <hanwen@xs4all.nl>
Jan Nieuwenhuizen <janneke@gnu.org>
*/
}
Real
-Beam::get_thickness (Grob *me)
+Beam::get_beam_thickness (Grob *me)
{
- return robust_scm2double (me->get_property ("thickness"), 0)
+ return robust_scm2double (me->get_property ("beam-thickness"), 0)
* Staff_symbol_referencer::staff_space (me);
}
int beam_count = get_beam_count (me);
Real staff_space = Staff_symbol_referencer::staff_space (me);
Real line = Staff_symbol_referencer::line_thickness (me);
- Real thickness = get_thickness (me);
+ Real beam_thickness = get_beam_thickness (me);
Real fract = robust_scm2double (me->get_property ("length-fraction"), 1.0);
Real beam_translation = beam_count < 4
- ? (2 * staff_space + line - thickness) / 2.0
- : (3 * staff_space + line - thickness) / 3.0;
+ ? (2 * staff_space + line - beam_thickness) / 2.0
+ : (3 * staff_space + line - beam_thickness) / 3.0;
return fract * beam_translation;
}
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++)
{
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_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_line_bound = (segs[j].dir_ == LEFT) ? segs[j].stem_index_ == 0
- : segs[j].stem_index_ == stems.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_beam_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_);
+ || 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_line_bound
&& me->get_bound (event_dir)->break_status_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.1, 1.1));
+ Drul_array<Real> max_proportion =
+ robust_scm2interval (stem->get_property ("beamlet-max-length-proportion"), Interval (0.75, 0.75));
+ Real length = beamlet_length[seg.dir_];
if (inside_stem)
{
- Grob *neighbor_stem = stems[segs[j].stem_index_ + event_dir];
- Real neighbor_stem_x
- = neighbor_stem->relative_coordinate (commonx, X_AXIS);
+ 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.5);
+ 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 * seg.width_/2;
+ if (seg.gapped_)
{
current.horizontal_[event_dir] -= event_dir * gap_length;
- if (Stem::is_invisible (segs[j].stem_))
+ 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 (segs[j].stem_, "note-heads", heads);
+ extract_grob_set (seg.stem_, "note-heads", heads);
for (vsize k = 0; k < heads.size (); k ++)
current.horizontal_[event_dir]
Real dy = pos[RIGHT] - pos[LEFT];
Real slope = (dy && span.length ()) ? dy / span.length () : 0;
- Real thick = get_thickness (me);
+ Real beam_thickness = get_beam_thickness (me);
Real beam_dy = get_beam_translation (me);
Direction feather_dir = to_dir (me->get_property ("grow-direction"));
local_slope += feather_dir * segments[i].vertical_count_ * beam_dy / span.length ();
}
- Stencil b = Lookup::beam (local_slope, segments[i].horizontal_.length (), thick, blot);
+ Stencil b = Lookup::beam (local_slope, segments[i].horizontal_.length (), beam_thickness, blot);
b.translate_axis (segments[i].horizontal_[LEFT], X_AXIS);
}
Real beam_translation = get_beam_translation (me);
- Real beam_thickness = Beam::get_thickness (me);
+ Real beam_thickness = Beam::get_beam_thickness (me);
int beam_count = Beam::get_beam_count (me);
Real height_of_beams = beam_thickness / 2
+ (beam_count - 1) * beam_translation;
*/
Real ss = Staff_symbol_referencer::staff_space (me);
- Real thickness = Beam::get_thickness (me) / ss;
+ Real beam_thickness = Beam::get_beam_thickness (me) / ss;
Real slt = Staff_symbol_referencer::line_thickness (me) / ss;
- Real sit = (thickness - slt) / 2;
+ Real sit = (beam_thickness - slt) / 2;
Real inter = 0.5;
- Real hang = 1.0 - (thickness - slt) / 2;
+ Real hang = 1.0 - (beam_thickness - slt) / 2;
*dy = sign (*dy) * max (fabs (*dy),
min (min (sit, inter), hang));
*/
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);
{
/* FIXME. -> UP */
Direction d = (Direction) (sign (chord.delta ()) * UP);
- pos[d] = get_thickness (me) / 2;
+ pos[d] = get_beam_thickness (me) / 2;
pos[-d] = -pos[d];
}
else
if (robust_scm2int (me->get_property ("gap-count"), 0))
{
gap = true;
- thick = get_thickness (me);
+ thick = get_beam_thickness (me);
}
Grob *fvs = first_normal_stem (me);
+ (stem->relative_coordinate (common, X_AXIS) - x0) * slope;
Real beam_translation = get_beam_translation (beam);
- Real beam_thickness = Beam::get_thickness (beam);
+ Real beam_thickness = Beam::get_beam_thickness (beam);
/*
TODO: this is not strictly correct for 16th knee beams.
ADD_INTERFACE (Beam,
"A beam.\n"
"\n"
- "The @code{thickness} property is the weight of beams,"
+ "The @code{beam-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.",
+ " of @code{Stem} instead.\n"
+ "\n"
+ "The following properties may be set in the @code{details}"
+ " list.\n"
+ "\n"
+ "@table @code\n"
+ "@item stem-length-demerit-factor\n"
+ "Demerit factor used for inappropriate stem lengths.\n"
+ "@item secondary-beam-demerit\n"
+ "Demerit used in quanting calculations for multiple"
+ " beams.\n"
+ "@item region-size\n"
+ "Size of region for checking quant scores.\n"
+ "@item beam-eps\n"
+ "Epsilon for beam quant code to check for presence"
+ " in gap.\n"
+ "@item stem-length-limit-penalty\n"
+ "Penalty for differences in stem lengths on a beam.\n"
+ "@item damping-direction-penalty\n"
+ "Demerit penalty applied when beam direction is different"
+ " from damping direction.\n"
+ "@item hint-direction-penalty\n"
+ "Demerit penalty applied when beam direction is different"
+ " from damping direction, but damping slope is"
+ " <= @code{round-to-zero-slope}.\n"
+ "@item musical-direction-factor\n"
+ "Demerit scaling factor for difference between"
+ " beam slope and music slope.\n"
+ "@item ideal-slope-factor\n"
+ "Demerit scaling factor for difference between"
+ " beam slope and damping slope.\n"
+ "@item round-to-zero-slope\n"
+ "Damping slope which is considered zero for purposes of"
+ " calculating direction penalties.\n"
+ "@end table\n",
/* properties */
"annotation "
"auto-knee-gap "
"beamed-stem-shorten "
"beaming "
+ "beam-thickness "
"break-overshoot "
"clip-edges "
"concaveness "
"quantized-positions "
"shorten "
"stems "
- "thickness "
);
projects / lilypond.git / blobdiff