2 This file is part of LilyPond, the GNU music typesetter.
4 Copyright (C) 1996--2010 Han-Wen Nienhuys <hanwen@xs4all.nl>
5 Jan Nieuwenhuizen <janneke@gnu.org>
7 LilyPond is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 LilyPond is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with LilyPond. If not, see <http://www.gnu.org/licenses/>.
22 #include "slur-scoring.hh"
24 #include "accidental-interface.hh"
26 #include "directional-element-interface.hh"
27 #include "libc-extension.hh"
29 #include "note-column.hh"
30 #include "output-def.hh"
31 #include "paper-column.hh"
33 #include "pointer-group-interface.hh"
34 #include "slur-configuration.hh"
37 #include "staff-symbol-referencer.hh"
38 #include "staff-symbol.hh"
45 - curve around flag for y coordinate
47 - short-cut: try a smaller region first.
49 - handle non-visible stems better.
51 - try to prune number of scoring criteria
53 - take encompass-objects more into account when determining
56 - calculate encompass scoring directly after determining slur shape.
60 struct Slur_score_state
;
62 Slur_score_state::Slur_score_state ()
66 edge_has_beams_
= false;
67 has_same_beam_
= false;
75 Slur_score_state::~Slur_score_state ()
77 junk_pointers (configurations_
);
81 If a slur is broken across a line break, the direction
82 of the post-break slur must be the same as the pre-break
86 Slur_score_state::slur_direction () const
88 Grob
*left_neighbor
= slur_
->broken_neighbor (LEFT
);
90 if (left_neighbor
&& left_neighbor
->is_live ())
91 return get_grob_direction (left_neighbor
);
93 Direction dir
= get_grob_direction (slur_
);
95 if (Grob
*right_neighbor
= slur_
->broken_neighbor (RIGHT
))
96 set_grob_direction (right_neighbor
, dir
);
102 Slur_score_state::get_encompass_info (Grob
*col
) const
104 Grob
*stem
= unsmob_grob (col
->get_object ("stem"));
109 programming_error ("no stem for note column");
110 ei
.x_
= col
->relative_coordinate (common_
[X_AXIS
], X_AXIS
);
111 ei
.head_
= ei
.stem_
= col
->extent (common_
[Y_AXIS
],
115 Direction stem_dir
= get_grob_direction (stem
);
117 if (Grob
*head
= Note_column::first_head (col
))
118 ei
.x_
= head
->extent (common_
[X_AXIS
], X_AXIS
).center ();
120 ei
.x_
= col
->extent (common_
[X_AXIS
], X_AXIS
).center ();
122 Grob
*h
= Stem::extremal_heads (stem
)[Direction (dir_
)];
125 ei
.head_
= ei
.stem_
= col
->extent (common_
[Y_AXIS
], Y_AXIS
)[dir_
];
129 ei
.head_
= h
->extent (common_
[Y_AXIS
], Y_AXIS
)[dir_
];
131 if ((stem_dir
== dir_
)
132 && !stem
->extent (stem
, Y_AXIS
).is_empty ())
134 ei
.stem_
= stem
->extent (common_
[Y_AXIS
], Y_AXIS
)[dir_
];
135 if (Grob
*b
= Stem::get_beam (stem
))
136 ei
.stem_
+= stem_dir
* 0.5 * Beam::get_beam_thickness (b
);
138 Interval x
= stem
->extent (common_
[X_AXIS
], X_AXIS
);
139 ei
.x_
= x
.is_empty ()
140 ? stem
->relative_coordinate (common_
[X_AXIS
], X_AXIS
)
149 Drul_array
<Bound_info
>
150 Slur_score_state::get_bound_info () const
152 Drul_array
<Bound_info
> extremes
;
155 Direction dir
= dir_
;
159 extremes
[d
].bound_
= slur_
->get_bound (d
);
160 if (Note_column::has_interface (extremes
[d
].bound_
))
162 extremes
[d
].note_column_
= extremes
[d
].bound_
;
163 extremes
[d
].stem_
= Note_column::get_stem (extremes
[d
].note_column_
);
164 if (extremes
[d
].stem_
)
166 extremes
[d
].stem_dir_
= get_grob_direction (extremes
[d
].stem_
);
168 for (int a
= X_AXIS
; a
< NO_AXES
; a
++)
171 Interval s
= extremes
[d
].stem_
->extent (common_
[ax
], ax
);
175 do not issue warning. This happens for rests and
179 + extremes
[d
].stem_
->relative_coordinate (common_
[ax
], ax
);
181 extremes
[d
].stem_extent_
[ax
] = s
;
184 extremes
[d
].slur_head_
185 = Stem::extremal_heads (extremes
[d
].stem_
)[dir
];
186 if (!extremes
[d
].slur_head_
187 && Note_column::has_rests (extremes
[d
].bound_
))
188 extremes
[d
].slur_head_
= Note_column::get_rest (extremes
[d
].bound_
);
189 extremes
[d
].staff_
= Staff_symbol_referencer
190 ::get_staff_symbol (extremes
[d
].stem_
);
191 extremes
[d
].staff_space_
= Staff_symbol_referencer
192 ::staff_space (extremes
[d
].stem_
);
195 if (extremes
[d
].slur_head_
)
196 extremes
[d
].slur_head_x_extent_
197 = extremes
[d
].slur_head_
->extent (common_
[X_AXIS
], X_AXIS
);
201 while (flip (&d
) != LEFT
);
207 Slur_score_state::fill (Grob
*me
)
209 slur_
= dynamic_cast<Spanner
*> (me
);
211 = internal_extract_grob_array (me
, ly_symbol2scm ("note-columns"));
213 if (columns_
.empty ())
219 Slur::replace_breakable_encompass_objects (me
);
220 staff_space_
= Staff_symbol_referencer::staff_space (me
);
221 Real lt
= me
->layout ()->get_dimension (ly_symbol2scm ("line-thickness"));
222 thickness_
= robust_scm2double (me
->get_property ("thickness"), 1.0) * lt
;
224 dir_
= slur_direction ();
225 parameters_
.fill (me
);
227 extract_grob_set (me
, "note-columns", columns
);
228 extract_grob_set (me
, "encompass-objects", extra_objects
);
230 Spanner
*sp
= dynamic_cast<Spanner
*> (me
);
232 for (int i
= X_AXIS
; i
< NO_AXES
; i
++)
235 common_
[a
] = common_refpoint_of_array (columns
, me
, a
);
236 common_
[a
] = common_refpoint_of_array (extra_objects
, common_
[a
], a
);
242 If bound is not in note-columns, we don't want to know about
246 common_
[a
] = common_
[a
]->common_refpoint (sp
->get_bound (d
), a
);
248 while (flip (&d
) != LEFT
);
251 extremes_
= get_bound_info ();
252 is_broken_
= (!extremes_
[LEFT
].note_column_
253 || !extremes_
[RIGHT
].note_column_
);
256 = (extremes_
[LEFT
].stem_
&& extremes_
[RIGHT
].stem_
257 && Stem::get_beam (extremes_
[LEFT
].stem_
) == Stem::get_beam (extremes_
[RIGHT
].stem_
));
259 base_attachments_
= get_base_attachments ();
261 Drul_array
<Real
> end_ys
262 = get_y_attachment_range ();
264 configurations_
= enumerate_attachments (end_ys
);
265 for (vsize i
= 0; i
< columns_
.size (); i
++)
266 encompass_infos_
.push_back (get_encompass_info (columns_
[i
]));
268 extra_encompass_infos_
= get_extra_encompass_infos ();
276 && extremes_
[d
].slur_head_
)
278 * extremes_
[d
].slur_head_
->relative_coordinate (common_
[Y_AXIS
], Y_AXIS
);
280 while (flip (&d
) != LEFT
);
283 = (extremes_
[LEFT
].stem_
&& Stem::get_beam (extremes_
[LEFT
].stem_
))
284 || (extremes_
[RIGHT
].stem_
&& Stem::get_beam (extremes_
[RIGHT
].stem_
));
291 MAKE_SCHEME_CALLBACK (Slur
, calc_control_points
, 1)
293 Slur::calc_control_points (SCM smob
)
295 Spanner
*me
= unsmob_spanner (smob
);
297 Slur_score_state state
;
303 state
.generate_curves ();
305 SCM end_ys
= me
->get_property ("positions");
308 if (is_number_pair (end_ys
))
309 best
= state
.configurations_
[state
.get_closest_index (end_ys
)]->curve_
;
311 best
= state
.get_best_curve ();
313 SCM controls
= SCM_EOL
;
314 for (int i
= 4; i
--;)
316 Offset o
= best
.control_
[i
]
317 - Offset (me
->relative_coordinate (state
.common_
[X_AXIS
], X_AXIS
),
318 me
->relative_coordinate (state
.common_
[Y_AXIS
], Y_AXIS
));
319 controls
= scm_cons (ly_offset2scm (o
), controls
);
326 Slur_score_state::get_best_curve ()
331 #if DEBUG_SLUR_SCORING
332 bool debug_slurs
= to_boolean (slur_
->layout ()
333 ->lookup_variable (ly_symbol2scm ("debug-slur-scoring")));
334 SCM inspect_quants
= slur_
->get_property ("inspect-quants");
335 SCM inspect_index
= slur_
->get_property ("inspect-index");
337 && scm_is_integer (inspect_index
))
339 opt_idx
= scm_to_int (inspect_index
);
340 configurations_
[opt_idx
]->calculate_score (*this);
341 opt
= configurations_
[opt_idx
]->score ();
344 && scm_is_pair (inspect_quants
))
346 opt_idx
= get_closest_index (inspect_quants
);
347 configurations_
[opt_idx
]->calculate_score (*this);
348 opt
= configurations_
[opt_idx
]->score ();
353 for (vsize i
= 0; i
< configurations_
.size (); i
++)
354 configurations_
[i
]->calculate_score (*this);
355 for (vsize i
= 0; i
< configurations_
.size (); i
++)
357 if (configurations_
[i
]->score () < opt
)
359 opt
= configurations_
[i
]->score ();
365 #if DEBUG_SLUR_SCORING
371 total
= configurations_
[opt_idx
]->card ();
372 total
+= to_string (" TOTAL=%.2f idx=%d", configurations_
[opt_idx
]->score (), opt_idx
);
379 slur_
->set_property ("quant-score",
380 ly_string2scm (total
));
387 programming_error ("No optimal slur found. Guessing 0.");
390 return configurations_
[opt_idx
]->curve_
;
394 Slur_score_state::breakable_bound_item (Direction d
) const
396 Grob
*col
= slur_
->get_bound (d
)->get_column ();
398 extract_grob_set (slur_
, "encompass-objects", extra_encompasses
);
400 for (vsize i
= 0; i
< extra_encompasses
.size (); i
++)
402 Item
*item
= dynamic_cast<Item
*> (extra_encompasses
[i
]);
403 if (item
&& col
== item
->get_column ())
411 Slur_score_state::get_closest_index (SCM inspect_quants
) const
413 Drul_array
<Real
> ins
= ly_scm2interval (inspect_quants
);
417 for (vsize i
= 0; i
< configurations_
.size (); i
++)
419 Real d
= fabs (configurations_
[i
]->attachment_
[LEFT
][Y_AXIS
] - ins
[LEFT
])
420 + fabs (configurations_
[i
]->attachment_
[RIGHT
][Y_AXIS
] - ins
[RIGHT
]);
428 programming_error ("cannot find quant");
433 TODO: should analyse encompasses to determine sensible region, and
434 should limit slopes available.
438 Slur_score_state::get_y_attachment_range () const
440 Drul_array
<Real
> end_ys
;
444 if (extremes_
[d
].note_column_
)
447 * max (max (dir_
* (base_attachments_
[d
][Y_AXIS
]
448 + parameters_
.region_size_
* dir_
),
449 dir_
* (dir_
+ extremes_
[d
].note_column_
->extent (common_
[Y_AXIS
], Y_AXIS
)[dir_
])),
450 dir_
* base_attachments_
[-d
][Y_AXIS
]);
453 end_ys
[d
] = base_attachments_
[d
][Y_AXIS
] + parameters_
.region_size_
* dir_
;
455 while (flip (&d
) != LEFT
);
461 spanner_less (Spanner
*s1
, Spanner
*s2
)
467 b1
[d
] = s1
->get_bound (d
)->get_column ()->get_rank ();
468 b2
[d
] = s2
->get_bound (d
)->get_column ()->get_rank ();
470 while (flip (&d
) != LEFT
);
472 return b2
[LEFT
] <= b1
[LEFT
] && b2
[RIGHT
] >= b1
[RIGHT
]
473 && (b2
[LEFT
] != b1
[LEFT
] || b2
[RIGHT
] != b1
[RIGHT
]);
477 Slur_score_state::get_base_attachments () const
479 Drul_array
<Offset
> base_attachment
;
483 Grob
*stem
= extremes_
[d
].stem_
;
484 Grob
*head
= extremes_
[d
].slur_head_
;
488 if (extremes_
[d
].note_column_
)
492 fixme: X coord should also be set in this case.
495 && !Stem::is_invisible (stem
)
496 && extremes_
[d
].stem_dir_
== dir_
497 && Stem::get_beaming (stem
, -d
)
498 && Stem::get_beam (stem
)
499 && (!spanner_less (slur_
, Stem::get_beam (stem
))
501 y
= extremes_
[d
].stem_extent_
[Y_AXIS
][dir_
];
503 y
= head
->extent (common_
[Y_AXIS
], Y_AXIS
)[dir_
];
504 y
+= dir_
* 0.5 * staff_space_
;
506 y
= move_away_from_staffline (y
, head
);
508 Grob
*fh
= Note_column::first_head (extremes_
[d
].note_column_
);
510 = (fh
? fh
->extent (common_
[X_AXIS
], X_AXIS
)
511 : extremes_
[d
].bound_
->extent (common_
[X_AXIS
], X_AXIS
))
512 .linear_combination (CENTER
);
514 base_attachment
[d
] = Offset (x
, y
);
516 while (flip (&d
) != LEFT
);
520 if (!extremes_
[d
].note_column_
)
525 if (Grob
*g
= breakable_bound_item (d
))
527 x
= robust_relative_extent (g
, common_
[X_AXIS
], X_AXIS
)[RIGHT
];
530 x
= robust_relative_extent (extremes_
[d
].bound_
, common_
[X_AXIS
], X_AXIS
)[d
];
532 x
= slur_
->get_broken_left_end_align ();
534 Grob
*col
= (d
== LEFT
) ? columns_
[0] : columns_
.back ();
536 if (extremes_
[-d
].bound_
!= col
)
538 y
= robust_relative_extent (col
, common_
[Y_AXIS
], Y_AXIS
)[dir_
];
539 y
+= dir_
* 0.5 * staff_space_
;
541 if (get_grob_direction (col
) == dir_
542 && Note_column::get_stem (col
)
543 && !Stem::is_invisible (Note_column::get_stem (col
)))
544 y
-= dir_
* 1.5 * staff_space_
;
547 y
= base_attachment
[-d
][Y_AXIS
];
549 y
= move_away_from_staffline (y
, col
);
551 base_attachment
[d
] = Offset (x
, y
);
554 while (flip (&d
) != LEFT
);
558 for (int a
= X_AXIS
; a
< NO_AXES
; a
++)
560 Real
&b
= base_attachment
[d
][Axis (a
)];
562 if (isinf (b
) || isnan (b
))
564 programming_error ("slur attachment is inf/nan");
569 while (flip (&d
) != LEFT
);
571 return base_attachment
;
575 Slur_score_state::move_away_from_staffline (Real y
,
576 Grob
*on_staff
) const
581 Grob
*staff_symbol
= Staff_symbol_referencer::get_staff_symbol (on_staff
);
586 = (y
- staff_symbol
->relative_coordinate (common_
[Y_AXIS
],
588 * 2.0 / staff_space_
;
590 if (fabs (pos
- my_round (pos
)) < 0.2
591 && Staff_symbol_referencer::on_line (on_staff
, (int) rint (pos
))
592 && Staff_symbol_referencer::line_count (on_staff
) - 1 >= rint (pos
))
593 y
+= 1.5 * staff_space_
* dir_
/ 10;
599 Slur_score_state::generate_avoid_offsets () const
601 vector
<Offset
> avoid
;
602 vector
<Grob
*> encompasses
= columns_
;
604 for (vsize i
= 0; i
< encompasses
.size (); i
++)
606 if (extremes_
[LEFT
].note_column_
== encompasses
[i
]
607 || extremes_
[RIGHT
].note_column_
== encompasses
[i
])
610 Encompass_info
inf (get_encompass_info (encompasses
[i
]));
611 Real y
= dir_
* (max (dir_
* inf
.head_
, dir_
* inf
.stem_
));
613 avoid
.push_back (Offset (inf
.x_
, y
+ dir_
* parameters_
.free_head_distance_
));
616 extract_grob_set (slur_
, "encompass-objects", extra_encompasses
);
617 for (vsize i
= 0; i
< extra_encompasses
.size (); i
++)
619 if (Slur::has_interface (extra_encompasses
[i
]))
621 Grob
*small_slur
= extra_encompasses
[i
];
622 Bezier b
= Slur::get_curve (small_slur
);
624 Offset z
= b
.curve_point (0.5);
625 z
+= Offset (small_slur
->relative_coordinate (common_
[X_AXIS
], X_AXIS
),
626 small_slur
->relative_coordinate (common_
[Y_AXIS
], Y_AXIS
));
628 z
[Y_AXIS
] += dir_
* parameters_
.free_slur_distance_
;
631 else if (extra_encompasses
[i
]->get_property ("avoid-slur") == ly_symbol2scm ("inside"))
633 Grob
*g
= extra_encompasses
[i
];
634 Interval xe
= g
->extent (common_
[X_AXIS
], X_AXIS
);
635 Interval ye
= g
->extent (common_
[Y_AXIS
], Y_AXIS
);
639 avoid
.push_back (Offset (xe
.center (), ye
[dir_
]));
646 Slur_score_state::generate_curves () const
648 Real r_0
= robust_scm2double (slur_
->get_property ("ratio"), 0.33);
649 Real h_inf
= staff_space_
* scm_to_double (slur_
->get_property ("height-limit"));
651 vector
<Offset
> avoid
= generate_avoid_offsets ();
652 for (vsize i
= 0; i
< configurations_
.size (); i
++)
653 configurations_
[i
]->generate_curve (*this, r_0
, h_inf
, avoid
);
656 vector
<Slur_configuration
*>
657 Slur_score_state::enumerate_attachments (Drul_array
<Real
> end_ys
) const
659 vector
<Slur_configuration
*> scores
;
661 Drul_array
<Offset
> os
;
662 os
[LEFT
] = base_attachments_
[LEFT
];
663 Real minimum_length
= staff_space_
664 * robust_scm2double (slur_
->get_property ("minimum-length"), 2.0);
666 for (int i
= 0; dir_
* os
[LEFT
][Y_AXIS
] <= dir_
* end_ys
[LEFT
]; i
++)
668 os
[RIGHT
] = base_attachments_
[RIGHT
];
669 for (int j
= 0; dir_
* os
[RIGHT
][Y_AXIS
] <= dir_
* end_ys
[RIGHT
]; j
++)
671 Slur_configuration s
;
673 Drul_array
<bool> attach_to_stem (false, false);
676 os
[d
][X_AXIS
] = base_attachments_
[d
][X_AXIS
];
677 if (extremes_
[d
].stem_
678 && !Stem::is_invisible (extremes_
[d
].stem_
)
679 && extremes_
[d
].stem_dir_
== dir_
)
681 Interval stem_y
= extremes_
[d
].stem_extent_
[Y_AXIS
];
682 stem_y
.widen (0.25 * staff_space_
);
683 if (stem_y
.contains (os
[d
][Y_AXIS
]))
685 os
[d
][X_AXIS
] = extremes_
[d
].stem_extent_
[X_AXIS
][-d
]
687 attach_to_stem
[d
] = true;
689 else if (dir_
* extremes_
[d
].stem_extent_
[Y_AXIS
][dir_
]
690 < dir_
* os
[d
][Y_AXIS
]
691 && !extremes_
[d
].stem_extent_
[X_AXIS
].is_empty ())
693 os
[d
][X_AXIS
] = extremes_
[d
].stem_extent_
[X_AXIS
].center ();
696 while (flip (&d
) != LEFT
);
699 dz
= os
[RIGHT
] - os
[LEFT
];
700 if (dz
[X_AXIS
] < minimum_length
701 || fabs (dz
[Y_AXIS
] / dz
[X_AXIS
]) > parameters_
.max_slope_
)
705 if (extremes_
[d
].slur_head_
706 && !extremes_
[d
].slur_head_x_extent_
.is_empty ())
708 os
[d
][X_AXIS
] = extremes_
[d
].slur_head_x_extent_
.center ();
709 attach_to_stem
[d
] = false;
712 while (flip (&d
) != LEFT
);
715 dz
= os
[RIGHT
] - os
[LEFT
];
718 if (extremes_
[d
].slur_head_
719 && !attach_to_stem
[d
])
721 /* Horizontally move tilted slurs a little. Move
722 more for bigger tilts.
726 -= dir_
* extremes_
[d
].slur_head_x_extent_
.length ()
727 * sin (dz
.arg ()) / 3;
730 while (flip (&d
) != LEFT
);
733 s
.index_
= scores
.size ();
735 scores
.push_back (new Slur_configuration (s
));
737 os
[RIGHT
][Y_AXIS
] += dir_
* staff_space_
/ 2;
740 os
[LEFT
][Y_AXIS
] += dir_
* staff_space_
/ 2;
743 assert (scores
.size () > 0);
747 vector
<Extra_collision_info
>
748 Slur_score_state::get_extra_encompass_infos () const
750 extract_grob_set (slur_
, "encompass-objects", encompasses
);
751 vector
<Extra_collision_info
> collision_infos
;
752 for (vsize i
= encompasses
.size (); i
--;)
754 if (Slur::has_interface (encompasses
[i
]))
756 Spanner
*small_slur
= dynamic_cast<Spanner
*> (encompasses
[i
]);
757 Bezier b
= Slur::get_curve (small_slur
);
759 Offset
relative (small_slur
->relative_coordinate (common_
[X_AXIS
], X_AXIS
),
760 small_slur
->relative_coordinate (common_
[Y_AXIS
], Y_AXIS
));
762 for (int k
= 0; k
< 3; k
++)
764 Direction hdir
= Direction (k
- 1);
767 Only take bound into account if small slur starts
768 together with big slur.
770 if (hdir
&& small_slur
->get_bound (hdir
) != slur_
->get_bound (hdir
))
773 Offset z
= b
.curve_point (k
/ 2.0);
778 yext
[dir_
] = z
[Y_AXIS
] + dir_
* thickness_
* 1.0;
780 Interval
xext (-1, 1);
781 xext
= xext
* (thickness_
* 2) + z
[X_AXIS
];
782 Extra_collision_info
info (small_slur
,
786 parameters_
.extra_object_collision_penalty_
);
787 collision_infos
.push_back (info
);
792 Grob
*g
= encompasses
[i
];
793 Interval xe
= g
->extent (common_
[X_AXIS
], X_AXIS
);
794 Interval ye
= g
->extent (common_
[Y_AXIS
], Y_AXIS
);
797 Real penalty
= parameters_
.extra_object_collision_penalty_
;
798 if (Accidental_interface::has_interface (g
))
800 penalty
= parameters_
.accidental_collision_
;
802 Rational alt
= ly_scm2rational (g
->get_property ("alteration"));
803 SCM scm_style
= g
->get_property ("style");
804 if (!scm_is_symbol (scm_style
)
805 && !to_boolean (g
->get_property ("parenthesized"))
806 && !to_boolean (g
->get_property ("restore-first")))
808 /* End copy accidental.cc */
809 if (alt
== FLAT_ALTERATION
810 || alt
== DOUBLE_FLAT_ALTERATION
)
812 else if (alt
== SHARP_ALTERATION
)
814 else if (alt
== NATURAL_ALTERATION
)
819 ye
.widen (thickness_
* 0.5);
820 xe
.widen (thickness_
* 1.0);
821 Extra_collision_info
info (g
, xp
, xe
, ye
, penalty
);
822 collision_infos
.push_back (info
);
826 return collision_infos
;
829 Extra_collision_info::Extra_collision_info (Grob
*g
, Real idx
, Interval x
, Interval y
, Real p
)
832 extents_
[X_AXIS
] = x
;
833 extents_
[Y_AXIS
] = y
;
836 type_
= g
->get_property ("avoid-slur");
839 Extra_collision_info::Extra_collision_info ()