2 beam.cc -- implement Beam
4 source file of the GNU LilyPond music typesetter
6 (c) 1997--2003 Han-Wen Nienhuys <hanwen@cs.uu.nl>
7 Jan Nieuwenhuizen <janneke@gnu.org>
13 * Use Number_pair i.s.o Interval to represent (yl, yr).
15 - Determine auto knees based on positions if it's set by the user.
21 - Stems run to the Y-center of the beam.
23 - beam_translation is the offset between Y centers of the beam.
28 #include <math.h> // tanh.
30 #include "molecule.hh"
31 #include "directional-element-interface.hh"
35 #include "least-squares.hh"
37 #include "paper-def.hh"
39 #include "group-interface.hh"
40 #include "staff-symbol-referencer.hh"
46 #define DEBUG_QUANTING 0
50 #include "text-item.hh" // debug output.
51 #include "font-interface.hh" // debug output.
56 Beam::add_stem (Grob *me, Grob *s)
58 Pointer_group_interface::add_grob (me, ly_symbol2scm ("stems"), s);
60 s->add_dependency (me);
62 assert (!Stem::get_beam (s));
63 s->set_grob_property ("beam", me->self_scm ());
65 add_bound_item (dynamic_cast<Spanner*> (me), dynamic_cast<Item*> (s));
70 Beam::get_thickness (Grob * me)
72 SCM th = me->get_grob_property ("thickness");
74 return gh_scm2double (th)* Staff_symbol_referencer::staff_space (me);
79 /* Return the translation between 2 adjoining beams. */
81 Beam::get_beam_translation (Grob *me)
83 SCM func = me->get_grob_property ("space-function");
84 SCM s = gh_call2 (func, me->self_scm (), scm_int2num (get_beam_count (me)));
85 return gh_scm2double (s);
88 /* Maximum beam_count. */
90 Beam::get_beam_count (Grob *me)
93 for (SCM s = me->get_grob_property ("stems"); gh_pair_p (s); s = ly_cdr (s))
95 Grob *stem = unsmob_grob (ly_car (s));
96 m = m >? (Stem::beam_multiplicity (stem).length () + 1);
103 Space return space between beams.
105 MAKE_SCHEME_CALLBACK (Beam, space_function, 2);
107 Beam::space_function (SCM smob, SCM beam_count)
109 Grob *me = unsmob_grob (smob);
111 Real staff_space = Staff_symbol_referencer::staff_space (me);
112 Real line = me->get_paper ()->get_var ("linethickness");
113 Real thickness = get_thickness (me);
115 Real beam_translation = gh_scm2int (beam_count) < 4
116 ? (2*staff_space + line - thickness) / 2.0
117 : (3*staff_space + line - thickness) / 3.0;
119 return gh_double2scm (beam_translation);
123 /* After pre-processing all directions should be set.
124 Several post-processing routines (stem, slur, script) need stem/beam
126 Currenly, this means that beam has set all stem's directions.
127 [Alternatively, stems could set its own directions, according to
128 their beam, during 'final-pre-processing'.] */
129 MAKE_SCHEME_CALLBACK (Beam, before_line_breaking, 1);
131 Beam::before_line_breaking (SCM smob)
133 Grob *me = unsmob_grob (smob);
135 /* Beams with less than 2 two stems don't make much sense, but could happen
140 For a beam that only has one stem, we try to do some disappearance magic:
141 we revert the flag, and move on to The Eternal Engraving Fields. */
143 int count = visible_stem_count (me);
146 me->warning (_ ("beam has less than two visible stems"));
148 SCM stems = me->get_grob_property ("stems");
149 if (scm_ilength (stems) == 1)
151 me->warning (_ ("Beam has less than two stems. Removing beam."));
153 unsmob_grob (gh_car (stems))->set_grob_property ("beam", SCM_EOL);
156 return SCM_UNSPECIFIED;
158 else if (scm_ilength (stems) == 0)
161 return SCM_UNSPECIFIED;
166 Direction d = get_default_dir (me);
168 consider_auto_knees (me);
169 set_stem_directions (me, d);
173 set_stem_shorten (me);
181 We want a maximal number of shared beams, but if there is choice, we
182 take the one that is closest to the end of the stem. This is for situations like
195 position_with_maximal_common_beams (SCM left_beaming, SCM right_beaming,
199 Slice lslice = int_list_to_slice (gh_cdr (left_beaming));
203 for (int i = lslice[-left_dir];
204 (i - lslice[left_dir])* left_dir <= 0 ; i+= left_dir)
207 for ( SCM s = gh_car (right_beaming); gh_pair_p (s); s = gh_cdr (s))
209 int k = - right_dir * gh_scm2int (gh_car (s)) + i;
210 if (scm_memq (scm_int2num (k), left_beaming) != SCM_BOOL_F)
214 if (count >= best_count)
225 Beam::connect_beams (Grob *me)
227 Link_array<Grob> stems=
228 Pointer_group_interface__extract_grobs (me, (Grob*)0, "stems");
231 last_int.set_empty();
232 SCM last_beaming = SCM_EOL;
233 Direction last_dir = CENTER;
234 for (int i = 0; i< stems.size(); i++)
236 Grob *this_stem = stems[i];
237 SCM this_beaming = this_stem->get_grob_property ("beaming");
239 Direction this_dir = Directional_element_interface::get(this_stem);
240 if (gh_pair_p (last_beaming) && gh_pair_p (this_beaming))
242 int start_point = position_with_maximal_common_beams
243 (last_beaming, this_beaming,
250 if (d == RIGHT && i == stems.size()-1)
253 new_slice.set_empty();
254 SCM s = index_get_cell (this_beaming, d);
255 for (; gh_pair_p (s); s = gh_cdr (s))
258 start_point - this_dir * gh_scm2int (gh_car (s));
260 new_slice.add_point (new_beam_pos);
261 gh_set_car_x (s, scm_int2num (new_beam_pos));
266 while (flip (&d) != LEFT);
268 if (!new_slice.empty_b())
269 last_int = new_slice;
273 gh_set_car_x ( this_beaming, SCM_EOL);
274 SCM s = gh_cdr (this_beaming);
275 for (; gh_pair_p (s); s = gh_cdr (s))
277 int np = - this_dir * gh_scm2int (gh_car(s));
278 gh_set_car_x (s, scm_int2num (np));
279 last_int.add_point (np);
283 if (i == stems.size () -1)
285 gh_set_cdr_x (this_beaming, SCM_EOL);
288 if (scm_ilength (gh_cdr (this_beaming)) > 0)
290 last_beaming = this_beaming;
296 MAKE_SCHEME_CALLBACK (Beam, brew_molecule, 1);
298 Beam::brew_molecule (SCM grob)
300 Grob *me = unsmob_grob (grob);
301 Link_array<Grob> stems=
302 Pointer_group_interface__extract_grobs (me, (Grob*)0, "stems");
303 Grob* xcommon = common_refpoint_of_array (stems, me, X_AXIS);
306 if (visible_stem_count (me))
308 // ugh -> use commonx
309 x0 = first_visible_stem (me)->relative_coordinate (xcommon, X_AXIS);
310 dx = last_visible_stem (me)->relative_coordinate (xcommon, X_AXIS) - x0;
314 x0 = stems[0]->relative_coordinate (xcommon, X_AXIS);
315 dx = stems.top ()->relative_coordinate (xcommon, X_AXIS) - x0;
318 SCM posns = me->get_grob_property ("positions");
320 if (!ly_number_pair_p (posns))
322 programming_error ("No beam posns");
323 pos = Interval (0,0);
326 pos= ly_scm2interval (posns);
328 Real dy = pos.delta ();
329 Real dydx = dy && dx ? dy/dx : 0;
331 Real thick = get_thickness (me);
332 Real bdy = get_beam_translation (me);
334 SCM last_beaming = SCM_EOL;;
335 Real last_xposn = -1;
336 Real last_width = -1 ;
339 SCM gap = me->get_grob_property ("gap");
341 Real lt = me->get_paper ()->get_var ("linethickness");
343 for (int i = 0; i<= stems.size(); i++)
345 Grob * st = (i < stems.size()) ? stems[i] : 0;
347 SCM this_beaming = st ? st->get_grob_property ("beaming") : SCM_EOL;
348 Real xposn = st ? st->relative_coordinate (xcommon, X_AXIS) : 0.0;
349 Real stem_width = st ? gh_scm2double (st->get_grob_property ("thickness")) *lt : 0 ;
352 We do the space left of ST, with lfliebertjes pointing to the
353 right from the left stem, and rfliebertjes pointing left from
356 SCM left = (i>0) ? gh_cdr (last_beaming) : SCM_EOL;
357 SCM right = st ? gh_car (this_beaming) : SCM_EOL;
359 Array<int> fullbeams;
360 Array<int> lfliebertjes;
361 Array<int> rfliebertjes;
364 gh_pair_p (s); s =gh_cdr (s))
366 int b = gh_scm2int (gh_car (s));
367 if (scm_memq (gh_car(s), right) != SCM_BOOL_F)
373 lfliebertjes.push (b);
377 gh_pair_p (s); s =gh_cdr (s))
379 int b = gh_scm2int (gh_car (s));
380 if (scm_memq (gh_car(s), left) == SCM_BOOL_F)
382 rfliebertjes.push (b);
387 how much to stick out for beams across linebreaks
389 Real break_overshoot = 3.0;
390 Real w = (i>0 && st)? xposn - last_xposn : break_overshoot;
391 Real stem_offset = 0.0;
392 Real width_corr = 0.0;
395 stem_offset -= last_width/2;
396 width_corr += last_width/2;
399 if (i == stems.size() -1)
401 width_corr += stem_width/2;
404 if (gh_number_p (gap))
406 Real g = gh_scm2double (gap);
411 Molecule whole = Lookup::beam (dydx, w + width_corr, thick);
412 for (int j = fullbeams.size(); j--;)
415 b.translate_axis (last_xposn - x0 + stem_offset, X_AXIS);
416 b.translate_axis (dydx * (last_xposn - x0) + bdy * fullbeams[j], Y_AXIS);
417 the_beam.add_molecule (b);
420 if (lfliebertjes.size() || rfliebertjes.size())
426 int t = Stem::duration_log (st);
428 SCM proc = me->get_grob_property ("flag-width-function");
429 SCM result = gh_call1 (proc, scm_int2num (t));
430 nw_f = gh_scm2double (result);
433 nw_f = break_overshoot;
435 /* Half beam should be one note-width,
436 but let's make sure two half-beams never touch */
437 Real w = (i>0 && st) ? (xposn - last_xposn) : break_overshoot;
440 Molecule half = Lookup::beam (dydx, w, thick);
441 for (int j = lfliebertjes.size(); j--;)
444 b.translate_axis (last_xposn - x0, X_AXIS);
445 b.translate_axis (dydx * (last_xposn-x0) + bdy * lfliebertjes[j], Y_AXIS);
446 the_beam.add_molecule (b);
448 for (int j = rfliebertjes.size(); j--;)
451 b.translate_axis (xposn - x0 - w , X_AXIS);
452 b.translate_axis (dydx * (xposn-x0 -w) + bdy * rfliebertjes[j], Y_AXIS);
453 the_beam.add_molecule (b);
459 last_width = stem_width;
460 last_beaming = this_beaming;
463 the_beam.translate_axis (x0 - me->relative_coordinate (xcommon, X_AXIS), X_AXIS);
464 the_beam.translate_axis (pos[LEFT], Y_AXIS);
469 This code prints the demerits for each beam. Perhaps this
470 should be switchable for those who want to twiddle with the
476 str += to_string (gh_scm2int (me->get_grob_property ("best-idx")));
479 str += to_string (gh_scm2double (me->get_grob_property ("quant-score")),
482 SCM properties = Font_interface::font_alist_chain (me);
485 Molecule tm = Text_item::text2molecule (me, scm_makfrom0str (str.to_str0 ()), properties);
486 the_beam.add_at_edge (Y_AXIS, UP, tm, 5.0, 0);
492 return the_beam.smobbed_copy();
499 Beam::get_default_dir (Grob *me)
501 Drul_array<int> total;
502 total[UP] = total[DOWN] = 0;
503 Drul_array<int> count;
504 count[UP] = count[DOWN] = 0;
507 Link_array<Grob> stems=
508 Pointer_group_interface__extract_grobs (me, (Grob*)0, "stems");
510 for (int i=0; i <stems.size (); i++)
513 Direction sd = Directional_element_interface::get (s);
515 int center_distance = int(- d * Stem::head_positions (s) [-d]) >? 0;
516 int current = sd ? (1 + d * sd)/2 : center_distance;
523 } while (flip (&d) != DOWN);
525 SCM func = me->get_grob_property ("dir-function");
526 SCM s = gh_call2 (func,
527 gh_cons (scm_int2num (count[UP]),
528 scm_int2num (count[DOWN])),
529 gh_cons (scm_int2num (total[UP]),
530 scm_int2num (total[DOWN])));
532 if (gh_number_p (s) && gh_scm2int (s))
535 /* If dir is not determined: get default */
536 return to_dir (me->get_grob_property ("neutral-direction"));
540 /* Set all stems with non-forced direction to beam direction.
541 Urg: non-forced should become `without/with unforced' direction,
542 once stem gets cleaned-up. */
544 Beam::set_stem_directions (Grob *me, Direction d)
546 Link_array<Grob> stems
547 =Pointer_group_interface__extract_grobs (me, (Grob*) 0, "stems");
549 for (int i=0; i <stems.size (); i++)
553 SCM forcedir = s->get_grob_property ("direction");
554 if (!to_dir (forcedir))
555 Directional_element_interface::set (s, d);
560 A union of intervals in the real line.
562 Abysmal performance (quadratic) for large N, hopefully we don't have
563 that large N. In any case, this should probably be rewritten to use
568 Array<Interval> allowed_regions_;
577 allowed_regions_.clear();
580 allowed_regions_.push (s);
583 void remove_interval (Interval rm)
585 for (int i = 0; i < allowed_regions_.size(); )
589 s.intersect (allowed_regions_[i]);
593 Interval before = allowed_regions_[i];
594 Interval after = allowed_regions_[i];
596 before[RIGHT] = s[LEFT];
597 after[LEFT] = s[RIGHT];
599 if (!before.empty_b() && before.length () > 0.0)
601 allowed_regions_.insert (before, i);
604 allowed_regions_.del (i);
605 if (!after.empty_b () && after.length () > 0.0)
607 allowed_regions_.insert (after, i);
619 Only try horizontal beams for knees. No reliable detection of
620 anything else is possible here, since we don't know funky-beaming
621 settings, or X-distances (slopes!) People that want sloped
622 knee-beams, should set the directions manually.
625 Beam::consider_auto_knees (Grob* me)
627 SCM scm = me->get_grob_property ("auto-knee-gap");
628 if (!gh_number_p (scm))
631 Real threshold = gh_scm2double (scm);
637 Link_array<Grob> stems=
638 Pointer_group_interface__extract_grobs (me, (Grob*)0, "stems");
640 Grob *common = common_refpoint_of_array (stems, me, Y_AXIS);
641 Real staff_space = Staff_symbol_referencer::staff_space (me);
643 Array<Interval> hps_array;
644 for (int i=0; i < stems.size (); i++)
646 Grob* stem = stems[i];
647 if (Stem::invisible_b (stem))
650 Interval hps = Stem::head_positions (stem);
655 hps *= staff_space * 0.5 ;
658 We could subtract beam Y position, but this routine only
659 sets stem directions, a constant shift does not have an
663 hps += stem->relative_coordinate (common, Y_AXIS);
665 if (to_dir (stem->get_grob_property ("direction")))
667 Direction stemdir = to_dir (stem->get_grob_property ("direction"));
668 hps[-stemdir] = - stemdir * infinity_f;
671 hps_array.push (hps);
673 gaps.remove_interval (hps);
677 Real max_gap_len =0.0;
679 for (int i = gaps.allowed_regions_.size() -1; i >= 0 ; i--)
681 Interval gap = gaps.allowed_regions_[i];
684 the outer gaps are not knees.
686 if (isinf (gap[LEFT]) || isinf(gap[RIGHT]))
689 if (gap.length () >= max_gap_len)
691 max_gap_len = gap.length();
696 if (max_gap_len > threshold)
699 for (int i = 0; i < stems.size(); i++)
701 Grob* stem = stems[i];
702 if (Stem::invisible_b (stem))
705 Interval hps = hps_array[j++];
708 Direction d = (hps.center () < max_gap.center()) ?
711 stem->set_grob_property ("direction", scm_int2num (d));
713 hps.intersect (max_gap);
714 assert (hps.empty_b () || hps.length () < 1e-6 );
721 /* Set stem's shorten property if unset.
724 take some y-position (chord/beam/nearest?) into account
725 scmify forced-fraction
727 This is done in beam because the shorten has to be uniform over the
732 Beam::set_stem_shorten (Grob *me)
735 shortening looks silly for x staff beams
740 Real forced_fraction = 1.0 * forced_stem_count (me)
741 / visible_stem_count (me);
743 int beam_count = get_beam_count (me);
745 SCM shorten_list = me->get_grob_property ("beamed-stem-shorten");
746 if (shorten_list == SCM_EOL)
749 Real staff_space = Staff_symbol_referencer::staff_space (me);
752 robust_list_ref (beam_count -1, shorten_list);
753 Real shorten_f = gh_scm2double (shorten_elt) * staff_space;
755 /* your similar cute comment here */
756 shorten_f *= forced_fraction;
759 me->set_grob_property ("shorten", gh_double2scm (shorten_f));
762 /* Call list of y-dy-callbacks, that handle setting of
766 MAKE_SCHEME_CALLBACK (Beam, after_line_breaking, 1);
768 Beam::after_line_breaking (SCM smob)
770 Grob *me = unsmob_grob (smob);
772 /* Copy to mutable list. */
773 SCM s = ly_deep_copy (me->get_grob_property ("positions"));
774 me->set_grob_property ("positions", s);
776 if (ly_car (s) == SCM_BOOL_F)
779 // one wonders if such genericity is necessary --hwn.
780 SCM callbacks = me->get_grob_property ("position-callbacks");
781 for (SCM i = callbacks; gh_pair_p (i); i = ly_cdr (i))
782 gh_call1 (ly_car (i), smob);
785 set_stem_lengths (me);
786 return SCM_UNSPECIFIED;
791 Compute a first approximation to the beam slope.
793 MAKE_SCHEME_CALLBACK (Beam, least_squares, 1);
795 Beam::least_squares (SCM smob)
797 Grob *me = unsmob_grob (smob);
799 int count = visible_stem_count (me);
804 me->set_grob_property ("positions", ly_interval2scm (pos));
805 return SCM_UNSPECIFIED;
809 Array<Real> x_posns ;
810 Link_array<Grob> stems=
811 Pointer_group_interface__extract_grobs (me, (Grob*)0, "stems");
812 Grob *commonx = common_refpoint_of_array (stems, me, X_AXIS);
813 Grob *commony = common_refpoint_of_array (stems, me, Y_AXIS);
815 Real my_y = me->relative_coordinate (commony, Y_AXIS);
817 Grob *fvs = first_visible_stem (me);
818 Grob *lvs = last_visible_stem (me);
820 Interval ideal (Stem::get_stem_info (fvs).ideal_y_
821 + fvs->relative_coordinate (commony, Y_AXIS) -my_y,
822 Stem::get_stem_info (lvs).ideal_y_
823 + lvs->relative_coordinate (commony, Y_AXIS) - my_y);
825 Real x0 = first_visible_stem (me)->relative_coordinate (commonx, X_AXIS);
826 for (int i=0; i < stems.size (); i++)
830 Real x = s->relative_coordinate (commonx, X_AXIS) - x0;
833 Real dx = last_visible_stem (me)->relative_coordinate (commonx, X_AXIS) - x0;
841 Interval chord (Stem::chord_start_y (first_visible_stem (me)),
842 Stem::chord_start_y (last_visible_stem (me)));
844 /* Simple beams (2 stems) on middle line should be allowed to be
847 However, if both stems reach middle line,
848 ideal[LEFT] == ideal[RIGHT] and ideal.delta () == 0.
850 For that case, we apply artificial slope */
851 if (!ideal[LEFT] && chord.delta () && count == 2)
854 Direction d = (Direction) (sign (chord.delta ()) * UP);
855 pos[d] = gh_scm2double (me->get_grob_property ("thickness")) / 2;
869 Array<Offset> ideals;
870 for (int i=0; i < stems.size (); i++)
873 if (Stem::invisible_b (s))
875 ideals.push (Offset (x_posns[i],
876 Stem::get_stem_info (s).ideal_y_
877 + s->relative_coordinate (commony, Y_AXIS)
880 minimise_least_squares (&dydx, &y, ideals);
883 me->set_grob_property ("least-squares-dy", gh_double2scm (dy));
884 pos = Interval (y, (y+dy));
887 me->set_grob_property ("positions", ly_interval2scm (pos));
889 return SCM_UNSPECIFIED;
894 We can't combine with previous function, since check concave and
895 slope damping comes first.
897 MAKE_SCHEME_CALLBACK (Beam, shift_region_to_valid, 1);
899 Beam::shift_region_to_valid (SCM grob)
901 Grob *me = unsmob_grob (grob);
905 Array<Real> x_posns ;
906 Link_array<Grob> stems=
907 Pointer_group_interface__extract_grobs (me, (Grob*)0, "stems");
908 Grob *commonx = common_refpoint_of_array (stems, me, X_AXIS);
909 Grob *commony = common_refpoint_of_array (stems, me, Y_AXIS);
911 Grob *fvs = first_visible_stem (me);
914 return SCM_UNSPECIFIED;
916 Real x0 =fvs->relative_coordinate (commonx, X_AXIS);
917 for (int i=0; i < stems.size (); i++)
921 Real x = s->relative_coordinate (commonx, X_AXIS) - x0;
925 Grob *lvs = last_visible_stem (me);
927 return SCM_UNSPECIFIED;
929 Real dx = lvs->relative_coordinate (commonx, X_AXIS) - x0;
931 Interval pos = ly_scm2interval ( me->get_grob_property ("positions"));
932 Real dy = pos.delta();
938 Shift the positions so that we have a chance of finding good
939 quants (i.e. no short stem failures.)
941 Interval feasible_left_point;
942 feasible_left_point.set_full ();
943 for (int i=0; i < stems.size (); i++)
946 if (Stem::invisible_b (s))
949 Direction d = Stem::get_direction (s);
952 Stem::get_stem_info (s).shortest_y_
953 - dydx * x_posns [i];
956 left_y is now relative to the stem S. We want relative to
957 ourselves, so translate:
960 + s->relative_coordinate (commony, Y_AXIS)
961 - me->relative_coordinate (commony, Y_AXIS);
967 feasible_left_point.intersect (flp);
970 if (feasible_left_point.empty_b())
972 warning (_("Not sure that we can find a nice beam slope (no viable initial configuration found)."));
974 else if (!feasible_left_point.elem_b(y))
976 if (isinf (feasible_left_point[DOWN]))
977 y = feasible_left_point[UP] - REGION_SIZE;
978 else if (isinf (feasible_left_point[UP]))
979 y = feasible_left_point[DOWN]+ REGION_SIZE;
981 y = feasible_left_point.center ();
983 pos = Interval (y, (y+dy));
984 me->set_grob_property ("positions", ly_interval2scm (pos));
985 return SCM_UNSPECIFIED;
989 MAKE_SCHEME_CALLBACK (Beam, check_concave, 1);
991 Beam::check_concave (SCM smob)
993 Grob *me = unsmob_grob (smob);
995 Link_array<Grob> stems =
996 Pointer_group_interface__extract_grobs (me, (Grob*) 0, "stems");
998 for (int i = 0; i < stems.size ();)
1000 if (Stem::invisible_b (stems[i]))
1006 if (stems.size () < 3)
1007 return SCM_UNSPECIFIED;
1010 /* Concaveness #1: If distance of an inner notehead to line between
1011 two outer noteheads is bigger than CONCAVENESS-GAP (2.0ss),
1012 beam is concave (Heinz Stolba).
1014 In the case of knees, the line connecting outer heads is often
1015 not related to the beam slope (it may even go in the other
1016 direction). Skip the check when the outer stems point in
1017 different directions. --hwn
1020 bool concaveness1 = false;
1021 SCM gap = me->get_grob_property ("concaveness-gap");
1022 if (gh_number_p (gap)
1023 && Stem::get_direction(stems.top ())
1024 == Stem::get_direction(stems[0]))
1026 Real r1 = gh_scm2double (gap);
1027 Real dy = Stem::chord_start_y (stems.top ())
1028 - Stem::chord_start_y (stems[0]);
1031 Real slope = dy / (stems.size () - 1);
1033 Real y0 = Stem::chord_start_y (stems[0]);
1034 for (int i = 1; i < stems.size () - 1; i++)
1036 Real c = (Stem::chord_start_y (stems[i]) - y0) - i * slope;
1039 concaveness1 = true;
1046 /* Concaveness #2: Sum distances of inner noteheads that fall
1047 outside the interval of the two outer noteheads.
1049 We only do this for beams where first and last stem have the same
1053 Note that "convex" stems compensate for "concave" stems.
1054 (is that intentional?) --hwn.
1057 Real concaveness2 = 0;
1058 SCM thresh = me->get_grob_property ("concaveness-threshold");
1059 Real r2 = infinity_f;
1060 if (!concaveness1 && gh_number_p (thresh)
1061 && Stem::get_direction(stems.top ())
1062 == Stem::get_direction(stems[0]))
1064 r2 = gh_scm2double (thresh);
1066 Direction dir = Stem::get_direction(stems.top ());
1068 Interval iv (Stem::chord_start_y (stems[0]),
1069 Stem::chord_start_y (stems.top ()));
1071 if (iv[MAX] < iv[MIN])
1074 for (int i = 1; i < stems.size () - 1; i++)
1076 Real f = Stem::chord_start_y (stems[i]);
1077 concave += ((f - iv[MAX] ) >? 0) +
1078 ((f - iv[MIN] ) <? 0);
1081 concaveness2 = concave / (stems.size () - 2);
1085 ugh: this is the a kludge to get
1086 input/regression/beam-concave.ly to behave as
1092 huh? we're dividing twice (which is not scalable) meaning that
1093 the longer the beam, the more unlikely it will be
1094 concave. Maybe you would even expect the other way around??
1099 concaveness2 /= (stems.size () - 2);
1102 /* TODO: some sort of damping iso -> plain horizontal */
1103 if (concaveness1 || concaveness2 > r2)
1105 Interval pos = ly_scm2interval (me->get_grob_property ("positions"));
1106 Real r = pos.linear_combination (0);
1107 me->set_grob_property ("positions", ly_interval2scm (Interval (r, r)));
1108 me->set_grob_property ("least-squares-dy", gh_double2scm (0));
1111 return SCM_UNSPECIFIED;
1114 /* This neat trick is by Werner Lemberg,
1115 damped = tanh (slope)
1116 corresponds with some tables in [Wanske] CHECKME */
1117 MAKE_SCHEME_CALLBACK (Beam, slope_damping, 1);
1119 Beam::slope_damping (SCM smob)
1121 Grob *me = unsmob_grob (smob);
1123 if (visible_stem_count (me) <= 1)
1124 return SCM_UNSPECIFIED;
1126 SCM s = me->get_grob_property ("damping");
1127 int damping = gh_scm2int (s);
1131 Interval pos = ly_scm2interval (me->get_grob_property ("positions"));
1132 Real dy = pos.delta ();
1134 Grob *fvs = first_visible_stem (me);
1135 Grob *lvs = last_visible_stem (me);
1137 Grob *commonx = fvs->common_refpoint (lvs, X_AXIS);
1140 Real dx = last_visible_stem (me)->relative_coordinate (commonx, X_AXIS)
1141 - first_visible_stem (me)->relative_coordinate (commonx, X_AXIS);
1142 Real dydx = dy && dx ? dy/dx : 0;
1143 dydx = 0.6 * tanh (dydx) / damping;
1145 Real damped_dy = dydx * dx;
1146 pos[LEFT] += (dy - damped_dy) / 2;
1147 pos[RIGHT] -= (dy - damped_dy) / 2;
1149 me->set_grob_property ("positions", ly_interval2scm (pos));
1151 return SCM_UNSPECIFIED;
1155 Report slice containing the numbers that are both in (car BEAMING)
1159 where_are_the_whole_beams(SCM beaming)
1163 for( SCM s = gh_car (beaming); gh_pair_p (s) ; s = gh_cdr (s))
1165 if (scm_memq (gh_car (s), gh_cdr (beaming)) != SCM_BOOL_F)
1167 l.add_point (gh_scm2int (gh_car (s)));
1173 /* Return the Y position of the stem-end, given the Y-left, Y-right
1174 in POS for stem S. This Y position is relative to S. */
1176 Beam::calc_stem_y (Grob *me, Grob* s, Grob ** common,
1178 Interval pos, bool french)
1180 Real beam_translation = get_beam_translation (me);
1183 Real r = s->relative_coordinate (common[X_AXIS], X_AXIS) - xl;
1184 Real dy = pos.delta ();
1186 Real stem_y_beam0 = (dy && dx
1191 Direction my_dir = Directional_element_interface::get (s);
1192 SCM beaming = s->get_grob_property ("beaming");
1194 Real stem_y = stem_y_beam0;
1197 Slice bm = where_are_the_whole_beams (beaming);
1199 stem_y += beam_translation * bm[-my_dir];
1203 Slice bm = Stem::beam_multiplicity(s);
1205 stem_y +=bm[my_dir] * beam_translation;
1208 Real id = me->relative_coordinate (common[Y_AXIS], Y_AXIS)
1209 - s->relative_coordinate (common[Y_AXIS], Y_AXIS);
1215 Hmm. At this time, beam position and slope are determined. Maybe,
1216 stem directions and length should set to relative to the chord's
1217 position of the beam. */
1219 Beam::set_stem_lengths (Grob *me)
1221 Link_array<Grob> stems=
1222 Pointer_group_interface__extract_grobs (me, (Grob*)0, "stems");
1224 if (stems.size () <= 1)
1228 for (int a = 2; a--;)
1229 common[a] = common_refpoint_of_array (stems, me, Axis(a));
1231 Interval pos = ly_scm2interval (me->get_grob_property ("positions"));
1232 Real staff_space = Staff_symbol_referencer::staff_space (me);
1236 if (gh_number_p (me->get_grob_property ("gap"))
1237 &&gh_scm2double (me->get_grob_property ("gap")))
1240 thick = get_thickness(me);
1243 // ugh -> use commonx
1244 Grob * fvs = first_visible_stem (me);
1245 Grob *lvs = last_visible_stem (me);
1247 Real xl = fvs ? fvs->relative_coordinate (common[X_AXIS], X_AXIS) : 0.0;
1248 Real xr = lvs ? lvs->relative_coordinate (common[X_AXIS], X_AXIS) : 0.0;
1250 for (int i=0; i < stems.size (); i++)
1253 if (Stem::invisible_b (s))
1257 bool french = to_boolean (s->get_grob_property ("french-beaming"));
1258 Real stem_y = calc_stem_y (me, s, common,
1260 pos, french && i > 0&& (i < stems.size () -1));
1263 Make the stems go up to the end of the beam. This doesn't matter
1264 for normal beams, but for tremolo beams it looks silly otherwise.
1267 stem_y += thick * 0.5 * Directional_element_interface::get(s);
1269 Stem::set_stemend (s, 2* stem_y / staff_space);
1274 Beam::set_beaming (Grob *me, Beaming_info_list *beaming)
1276 Link_array<Grob> stems=
1277 Pointer_group_interface__extract_grobs (me, (Grob *)0, "stems");
1280 for (int i=0; i < stems.size (); i++)
1283 Don't overwrite user settings.
1288 /* Don't set beaming for outside of outer stems */
1289 if ((d == LEFT && i == 0)
1290 ||(d == RIGHT && i == stems.size () -1))
1293 Grob *st = stems[i];
1294 SCM beaming_prop = st->get_grob_property ("beaming");
1295 if (beaming_prop == SCM_EOL ||
1296 index_get_cell (beaming_prop, d) == SCM_EOL)
1298 int b = beaming->infos_.elem (i).beams_i_drul_[d];
1300 && i < stems.size() -1
1301 && Stem::invisible_b (st))
1302 b = b <? beaming->infos_.elem(i).beams_i_drul_[-d];
1304 Stem::set_beaming (st, b, d);
1307 while (flip (&d) != LEFT);
1312 Beam::forced_stem_count (Grob *me)
1314 Link_array<Grob>stems =
1315 Pointer_group_interface__extract_grobs (me, (Grob*) 0, "stems");
1317 for (int i=0; i < stems.size (); i++)
1321 if (Stem::invisible_b (s))
1324 /* I can imagine counting those boundaries as a half forced stem,
1325 but let's count them full for now. */
1326 if (abs (Stem::chord_start_y (s)) > 0.1
1327 && (Stem::get_direction (s) != Stem::get_default_dir (s)))
1337 Beam::visible_stem_count (Grob *me)
1339 Link_array<Grob>stems =
1340 Pointer_group_interface__extract_grobs (me, (Grob*) 0, "stems");
1342 for (int i = stems.size (); i--;)
1344 if (!Stem::invisible_b (stems[i]))
1351 Beam::first_visible_stem (Grob *me)
1353 Link_array<Grob>stems =
1354 Pointer_group_interface__extract_grobs (me, (Grob*) 0, "stems");
1356 for (int i = 0; i < stems.size (); i++)
1358 if (!Stem::invisible_b (stems[i]))
1365 Beam::last_visible_stem (Grob *me)
1367 Link_array<Grob>stems =
1368 Pointer_group_interface__extract_grobs (me, (Grob*) 0, "stems");
1369 for (int i = stems.size (); i--;)
1371 if (!Stem::invisible_b (stems[i]))
1381 handle rest under beam (do_post: beams are calculated now)
1382 what about combination of collisions and rest under beam.
1386 rest -> stem -> beam -> interpolate_y_position ()
1388 MAKE_SCHEME_CALLBACK (Beam, rest_collision_callback, 2);
1390 Beam::rest_collision_callback (SCM element_smob, SCM axis)
1392 Grob *rest = unsmob_grob (element_smob);
1393 Axis a = (Axis) gh_scm2int (axis);
1395 assert (a == Y_AXIS);
1397 Grob *st = unsmob_grob (rest->get_grob_property ("stem"));
1400 return gh_double2scm (0.0);
1401 Grob *beam = unsmob_grob (stem->get_grob_property ("beam"));
1403 || !Beam::has_interface (beam)
1404 || !Beam::visible_stem_count (beam))
1405 return gh_double2scm (0.0);
1407 Interval pos (0, 0);
1408 SCM s = beam->get_grob_property ("positions");
1409 if (gh_pair_p (s) && gh_number_p (ly_car (s)))
1410 pos = ly_scm2interval (s);
1412 Real dy = pos.delta ();
1413 // ugh -> use commonx
1414 Real x0 = first_visible_stem (beam)->relative_coordinate (0, X_AXIS);
1415 Real dx = last_visible_stem (beam)->relative_coordinate (0, X_AXIS) - x0;
1416 Real dydx = dy && dx ? dy/dx : 0;
1418 Direction d = Stem::get_direction (stem);
1419 Real stem_y = (pos[LEFT]
1420 + (stem->relative_coordinate (0, X_AXIS) - x0) * dydx)
1423 Real beam_translation = get_beam_translation (beam);
1424 Real beam_thickness = gh_scm2double (beam->get_grob_property ("thickness"));
1425 int beam_count = get_direction_beam_count (beam, d);
1426 Real height_of_my_beams = beam_thickness
1427 + (beam_count - 1) * beam_translation;
1428 Real beam_y = stem_y - height_of_my_beams + beam_thickness / 2.0;
1430 Real staff_space = Staff_symbol_referencer::staff_space (rest);
1432 /* Better calculate relative-distance directly, rather than using
1434 Grob *common_x = rest->common_refpoint (beam, Y_AXIS);
1435 Real rest_dim = rest->extent (common_x, Y_AXIS)[d] / staff_space * d;
1437 Real minimum_distance = gh_scm2double
1438 (rest->get_grob_property ("minimum-beam-collision-distance"));
1440 Real distance = beam_y - rest_dim;
1443 shift = minimum_distance - distance;
1444 else if (minimum_distance > distance)
1445 shift = minimum_distance - distance;
1447 int stafflines = Staff_symbol_referencer::line_count (rest);
1449 /* Always move discretely by half spaces */
1450 Real discrete_shift = ceil (shift * 2.0) / 2.0;
1452 /* Inside staff, move by whole spaces*/
1453 if ((rest->extent (common_x, Y_AXIS)[d] + discrete_shift) * d
1455 ||(rest->extent (common_x, Y_AXIS)[-d] + discrete_shift) * -d
1457 discrete_shift = ceil (discrete_shift);
1459 return gh_double2scm (-d * discrete_shift);
1463 Beam::knee_b (Grob* me)
1465 SCM k = me->get_grob_property ("knee");
1466 if (gh_boolean_p (k))
1467 return gh_scm2bool (k);
1471 for (SCM s = me->get_grob_property ("stems"); gh_pair_p (s); s = ly_cdr (s))
1473 Direction dir = Directional_element_interface::get
1474 (unsmob_grob (ly_car (s)));
1483 me->set_grob_property ("knee", gh_bool2scm (knee));
1489 Beam::get_direction_beam_count (Grob *me, Direction d )
1491 Link_array<Grob>stems =
1492 Pointer_group_interface__extract_grobs (me, (Grob*) 0, "stems");
1495 for (int i = stems.size (); i--;)
1498 Should we take invisible stems into account?
1500 if (Stem::get_direction (stems[i]) == d)
1501 bc = bc >? (Stem::beam_multiplicity (stems[i]).length () + 1);
1508 ADD_INTERFACE (Beam, "beam-interface",
1511 "#'thickness= weight of beams, in staffspace "
1514 "We take the least squares line through the ideal-length stems, and "
1515 "then damp that using "
1517 " damped = tanh (slope) \n"
1519 "this gives an unquantized left and right position for the beam end. "
1520 "Then we take all combinations of quantings near these left and right "
1521 "positions, and give them a score (according to how close they are to "
1522 "the ideal slope, how close the result is to the ideal stems, etc.). We "
1523 "take the best scoring combination. "
1525 "knee position-callbacks concaveness-gap concaveness-threshold dir-function quant-score auto-knee-gap gap chord-tremolo beamed-stem-shorten shorten least-squares-dy damping flag-width-function neutral-direction positions space-function thickness");