2 slur-scoring.cc -- Score based slur formatting
4 source file of the GNU LilyPond music typesetter
6 (c) 1996--2006 Han-Wen Nienhuys <hanwen@xs4all.nl>
7 Jan Nieuwenhuizen <janneke@gnu.org>
11 #include "slur-scoring.hh"
13 #include "accidental-interface.hh"
15 #include "directional-element-interface.hh"
16 #include "libc-extension.hh"
18 #include "note-column.hh"
19 #include "output-def.hh"
20 #include "paper-column.hh"
22 #include "pointer-group-interface.hh"
23 #include "slur-configuration.hh"
26 #include "staff-symbol-referencer.hh"
27 #include "staff-symbol.hh"
34 - curve around flag for y coordinate
36 - short-cut: try a smaller region first.
38 - handle non-visible stems better.
40 - try to prune number of scoring criteria
42 - take encompass-objects more into account when determining
45 - calculate encompass scoring directly after determining slur shape.
49 struct Slur_score_state
;
51 Slur_score_state::Slur_score_state ()
55 edge_has_beams_
= false;
56 has_same_beam_
= false;
64 Slur_score_state::~Slur_score_state ()
66 junk_pointers (configurations_
);
70 broken_trend_y (Slur_score_state
const &state
, Direction hdir
)
72 /* A broken slur should maintain the same vertical trend
73 the unbroken slur would have had. */
75 if (Spanner
*mother
= dynamic_cast<Spanner
*> (state
.slur_
->original ()))
77 vsize k
= broken_spanner_index (state
.slur_
);
78 int j
= int (k
) + hdir
;
79 if (j
< 0 || vsize (j
) >= mother
->broken_intos_
.size ())
82 Grob
*neighbor
= mother
->broken_intos_
[j
];
83 Spanner
*common_mother
84 = dynamic_cast<Spanner
*> (state
.common_
[Y_AXIS
]->original ());
86 = broken_spanner_index (dynamic_cast<Spanner
*> (state
.common_
[Y_AXIS
]));
87 int common_j
= common_k
+ hdir
;
89 if (common_j
< 0 || vsize (common_j
) >= common_mother
->broken_intos_
.size ())
92 Grob
*common_next_system
= common_mother
->broken_intos_
[common_j
];
94 SCM last_point
= scm_car (scm_last_pair (neighbor
->get_property ("control-points")));
96 return scm_to_double (scm_cdr (last_point
))
97 + neighbor
->relative_coordinate (common_next_system
, Y_AXIS
);
103 copy slur dir forwards across line break.
106 Slur_score_state::set_next_direction ()
108 if (extremes_
[RIGHT
].note_column_
)
111 if (Spanner
*mother
= dynamic_cast<Spanner
*> (slur_
->original ()))
113 vsize j
= 1 + broken_spanner_index (slur_
);
114 if (j
>= mother
->broken_intos_
.size ())
117 Grob
*neighbor
= mother
->broken_intos_
[j
];
118 set_grob_direction (neighbor
, dir_
);
123 Slur_score_state::get_encompass_info (Grob
*col
) const
125 Grob
*stem
= unsmob_grob (col
->get_object ("stem"));
130 programming_error ("no stem for note column");
131 ei
.x_
= col
->relative_coordinate (common_
[X_AXIS
], X_AXIS
);
132 ei
.head_
= ei
.stem_
= col
->extent (common_
[Y_AXIS
],
136 Direction stem_dir
= get_grob_direction (stem
);
138 if (Grob
*head
= Note_column::first_head (col
))
139 ei
.x_
= head
->extent (common_
[X_AXIS
], X_AXIS
).center ();
141 ei
.x_
= col
->extent (common_
[X_AXIS
], X_AXIS
).center ();
143 Grob
*h
= Stem::extremal_heads (stem
)[Direction (dir_
)];
146 ei
.head_
= ei
.stem_
= col
->extent (common_
[Y_AXIS
], Y_AXIS
)[dir_
];
150 ei
.head_
= h
->extent (common_
[Y_AXIS
], Y_AXIS
)[dir_
];
152 if ((stem_dir
== dir_
)
153 && !stem
->extent (stem
, Y_AXIS
).is_empty ())
155 ei
.stem_
= stem
->extent (common_
[Y_AXIS
], Y_AXIS
)[dir_
];
156 if (Grob
*b
= Stem::get_beam (stem
))
157 ei
.stem_
+= stem_dir
* 0.5 * Beam::get_thickness (b
);
159 Interval x
= stem
->extent (common_
[X_AXIS
], X_AXIS
);
160 ei
.x_
= x
.is_empty ()
161 ? stem
->relative_coordinate (common_
[X_AXIS
], X_AXIS
)
170 Drul_array
<Bound_info
>
171 Slur_score_state::get_bound_info () const
173 Drul_array
<Bound_info
> extremes
;
176 Direction dir
= dir_
;
180 extremes
[d
].bound_
= slur_
->get_bound (d
);
181 if (Note_column::has_interface (extremes
[d
].bound_
))
183 extremes
[d
].note_column_
= extremes
[d
].bound_
;
184 extremes
[d
].stem_
= Note_column::get_stem (extremes
[d
].note_column_
);
185 if (extremes
[d
].stem_
)
187 extremes
[d
].stem_dir_
= get_grob_direction (extremes
[d
].stem_
);
189 for (int a
= X_AXIS
; a
< NO_AXES
; a
++)
192 Interval s
= extremes
[d
].stem_
->extent (common_
[ax
], ax
);
196 do not issue warning. This happens for rests and
200 + extremes
[d
].stem_
->relative_coordinate (common_
[ax
], ax
);
202 extremes
[d
].stem_extent_
[ax
] = s
;
205 extremes
[d
].slur_head_
206 = Stem::extremal_heads (extremes
[d
].stem_
)[dir
];
207 if (!extremes
[d
].slur_head_
208 && Note_column::has_rests (extremes
[d
].bound_
))
209 extremes
[d
].slur_head_
= Note_column::get_rest (extremes
[d
].bound_
);
210 extremes
[d
].staff_
= Staff_symbol_referencer
211 ::get_staff_symbol (extremes
[d
].stem_
);
212 extremes
[d
].staff_space_
= Staff_symbol_referencer
213 ::staff_space (extremes
[d
].stem_
);
216 if (extremes
[d
].slur_head_
)
217 extremes
[d
].slur_head_x_extent_
218 = extremes
[d
].slur_head_
->extent (common_
[X_AXIS
], X_AXIS
);
222 while (flip (&d
) != LEFT
);
228 Slur_score_state::fill (Grob
*me
)
230 slur_
= dynamic_cast<Spanner
*> (me
);
232 = internal_extract_grob_array (me
, ly_symbol2scm ("note-columns"));
234 if (columns_
.empty ())
240 staff_space_
= Staff_symbol_referencer::staff_space (me
);
241 Real lt
= me
->layout ()->get_dimension (ly_symbol2scm ("line-thickness"));
242 thickness_
= robust_scm2double (me
->get_property ("thickness"), 1.0) * lt
;
244 dir_
= get_grob_direction (me
);
245 parameters_
.fill (me
);
247 extract_grob_set (me
, "note-columns", columns
);
248 extract_grob_set (me
, "encompass-objects", extra_objects
);
250 Spanner
*sp
= dynamic_cast<Spanner
*> (me
);
252 for (int i
= X_AXIS
; i
< NO_AXES
; i
++)
255 common_
[a
] = common_refpoint_of_array (columns
, me
, a
);
256 common_
[a
] = common_refpoint_of_array (extra_objects
, common_
[a
], a
);
262 If bound is not in note-columns, we don't want to know about
266 common_
[a
] = common_
[a
]->common_refpoint (sp
->get_bound (d
), a
);
268 while (flip (&d
) != LEFT
);
271 extremes_
= get_bound_info ();
272 is_broken_
= (!extremes_
[LEFT
].note_column_
273 || !extremes_
[RIGHT
].note_column_
);
276 = (extremes_
[LEFT
].stem_
&& extremes_
[RIGHT
].stem_
277 && Stem::get_beam (extremes_
[LEFT
].stem_
) == Stem::get_beam (extremes_
[RIGHT
].stem_
));
279 base_attachments_
= get_base_attachments ();
281 Drul_array
<Real
> end_ys
282 = get_y_attachment_range ();
284 configurations_
= enumerate_attachments (end_ys
);
285 for (vsize i
= 0; i
< columns_
.size (); i
++)
286 encompass_infos_
.push_back (get_encompass_info (columns_
[i
]));
288 extra_encompass_infos_
= get_extra_encompass_infos ();
296 && extremes_
[d
].slur_head_
)
298 * extremes_
[d
].slur_head_
->relative_coordinate (common_
[Y_AXIS
], Y_AXIS
);
300 while (flip (&d
) != LEFT
);
303 = (extremes_
[LEFT
].stem_
&& Stem::get_beam (extremes_
[LEFT
].stem_
))
304 || (extremes_
[RIGHT
].stem_
&& Stem::get_beam (extremes_
[RIGHT
].stem_
));
306 set_next_direction ();
313 MAKE_SCHEME_CALLBACK(Slur
, calc_control_points
, 1)
315 Slur::calc_control_points (SCM smob
)
317 Spanner
*me
= unsmob_spanner (smob
);
319 Slur_score_state state
;
325 state
.generate_curves ();
327 SCM end_ys
= me
->get_property ("positions");
330 if (is_number_pair (end_ys
))
331 best
= state
.configurations_
[state
.get_closest_index (end_ys
)]->curve_
;
333 best
= state
.get_best_curve ();
335 SCM controls
= SCM_EOL
;
336 for (int i
= 4; i
--;)
338 Offset o
= best
.control_
[i
]
339 - Offset (me
->relative_coordinate (state
.common_
[X_AXIS
], X_AXIS
),
340 me
->relative_coordinate (state
.common_
[Y_AXIS
], Y_AXIS
));
341 controls
= scm_cons (ly_offset2scm (o
), controls
);
348 Slur_score_state::get_best_curve ()
353 #if DEBUG_SLUR_SCORING
354 bool debug_slurs
= to_boolean (slur_
->layout ()
355 ->lookup_variable (ly_symbol2scm ("debug-slur-scoring")));
356 SCM inspect_quants
= slur_
->get_property ("inspect-quants");
357 SCM inspect_index
= slur_
->get_property ("inspect-index");
359 && scm_is_integer (inspect_index
))
361 opt_idx
= scm_to_int (inspect_index
);
362 configurations_
[opt_idx
]->calculate_score (*this);
363 opt
= configurations_
[opt_idx
]->score ();
366 && scm_is_pair (inspect_quants
))
368 opt_idx
= get_closest_index (inspect_quants
);
369 configurations_
[opt_idx
]->calculate_score (*this);
370 opt
= configurations_
[opt_idx
]->score ();
375 for (vsize i
= 0; i
< configurations_
.size (); i
++)
376 configurations_
[i
]->calculate_score (*this);
377 for (vsize i
= 0; i
< configurations_
.size (); i
++)
379 if (configurations_
[i
]->score () < opt
)
381 opt
= configurations_
[i
]->score ();
387 #if DEBUG_SLUR_SCORING
393 total
= configurations_
[opt_idx
]->card ();
394 total
+= to_string (" TOTAL=%.2f idx=%d", configurations_
[opt_idx
]->score (), opt_idx
);
401 slur_
->set_property ("quant-score",
402 scm_makfrom0str (total
.c_str ()));
409 programming_error ("No optimal slur found. Guessing 0.");
412 return configurations_
[opt_idx
]->curve_
;
416 Slur_score_state::get_closest_index (SCM inspect_quants
) const
418 Drul_array
<Real
> ins
= ly_scm2interval (inspect_quants
);
422 for (vsize i
= 0; i
< configurations_
.size (); i
++)
424 Real d
= fabs (configurations_
[i
]->attachment_
[LEFT
][Y_AXIS
] - ins
[LEFT
])
425 + fabs (configurations_
[i
]->attachment_
[RIGHT
][Y_AXIS
] - ins
[RIGHT
]);
433 programming_error ("can't not find quant");
438 TODO: should analyse encompasses to determine sensible region, and
439 should limit slopes available.
443 Slur_score_state::get_y_attachment_range () const
445 Drul_array
<Real
> end_ys
;
449 if (extremes_
[d
].note_column_
)
452 * max (max (dir_
* (base_attachments_
[d
][Y_AXIS
]
453 + parameters_
.region_size_
* dir_
),
454 dir_
* (dir_
+ extremes_
[d
].note_column_
->extent (common_
[Y_AXIS
], Y_AXIS
)[dir_
])),
455 dir_
* base_attachments_
[-d
][Y_AXIS
]);
458 end_ys
[d
] = base_attachments_
[d
][Y_AXIS
] + parameters_
.region_size_
* dir_
;
460 while (flip (&d
) != LEFT
);
466 spanner_less (Spanner
*s1
, Spanner
*s2
)
472 b1
[d
] = s1
->get_bound (d
)->get_column ()->get_rank ();
473 b2
[d
] = s2
->get_bound (d
)->get_column ()->get_rank ();
475 while (flip (&d
) != LEFT
);
477 return b2
[LEFT
] <= b1
[LEFT
] && b2
[RIGHT
] >= b1
[RIGHT
]
478 && (b2
[LEFT
] != b1
[LEFT
] || b2
[RIGHT
] != b1
[RIGHT
]);
482 Slur_score_state::get_base_attachments () const
484 Drul_array
<Offset
> base_attachment
;
488 Grob
*stem
= extremes_
[d
].stem_
;
489 Grob
*head
= extremes_
[d
].slur_head_
;
493 if (extremes_
[d
].note_column_
)
497 fixme: X coord should also be set in this case.
500 && !Stem::is_invisible (stem
)
501 && extremes_
[d
].stem_dir_
== dir_
502 && Stem::get_beaming (stem
, -d
)
503 && Stem::get_beam (stem
)
504 && (!spanner_less (slur_
, Stem::get_beam (stem
))
506 y
= extremes_
[d
].stem_extent_
[Y_AXIS
][dir_
];
508 y
= head
->extent (common_
[Y_AXIS
], Y_AXIS
)[dir_
];
509 y
+= dir_
* 0.5 * staff_space_
;
511 y
= move_away_from_staffline (y
, head
);
513 Grob
*fh
= Note_column::first_head (extremes_
[d
].note_column_
);
515 = (fh
? fh
->extent (common_
[X_AXIS
], X_AXIS
)
516 : extremes_
[d
].bound_
->extent (common_
[X_AXIS
], X_AXIS
))
517 .linear_combination (CENTER
);
519 base_attachment
[d
] = Offset (x
, y
);
521 while (flip (&d
) != LEFT
);
525 if (!extremes_
[d
].note_column_
)
529 x
= robust_relative_extent (extremes_
[d
].bound_
, common_
[X_AXIS
], X_AXIS
)[d
];
531 x
= slur_
->get_broken_left_end_align ();
532 Grob
*col
= (d
== LEFT
) ? columns_
[0] : columns_
.back ();
534 if (extremes_
[-d
].bound_
!= col
)
536 y
= robust_relative_extent (col
, common_
[Y_AXIS
], Y_AXIS
)[dir_
];
537 y
+= dir_
* 0.5 * staff_space_
;
539 if (get_grob_direction (col
) == dir_
540 && Note_column::get_stem (col
)
541 && !Stem::is_invisible (Note_column::get_stem (col
)))
542 y
-= dir_
* 1.5 * staff_space_
;
545 y
= base_attachment
[-d
][Y_AXIS
];
547 y
= move_away_from_staffline (y
, col
);
549 base_attachment
[d
] = Offset (x
, y
);
552 while (flip (&d
) != LEFT
);
556 for (int a
= X_AXIS
; a
< NO_AXES
; a
++)
558 Real
&b
= base_attachment
[d
][Axis (a
)];
560 if (isinf (b
) || isnan (b
))
562 programming_error ("slur attachment is inf/nan");
567 while (flip (&d
) != LEFT
);
569 return base_attachment
;
573 Slur_score_state::move_away_from_staffline (Real y
,
574 Grob
*on_staff
) const
579 Grob
*staff_symbol
= Staff_symbol_referencer::get_staff_symbol (on_staff
);
584 = (y
- staff_symbol
->relative_coordinate (common_
[Y_AXIS
],
586 * 2.0 / staff_space_
;
588 if (fabs (pos
- my_round (pos
)) < 0.2
589 && Staff_symbol_referencer::on_line (on_staff
, (int) rint (pos
))
590 && Staff_symbol_referencer::line_count (on_staff
) - 1 >= rint (pos
))
591 y
+= 1.5 * staff_space_
* dir_
/ 10;
597 Slur_score_state::generate_avoid_offsets () const
599 vector
<Offset
> avoid
;
600 vector
<Grob
*> encompasses
= columns_
;
602 for (vsize i
= 0; i
< encompasses
.size (); i
++)
604 if (extremes_
[LEFT
].note_column_
== encompasses
[i
]
605 || extremes_
[RIGHT
].note_column_
== encompasses
[i
])
608 Encompass_info
inf (get_encompass_info (encompasses
[i
]));
609 Real y
= dir_
* (max (dir_
* inf
.head_
, dir_
* inf
.stem_
));
611 avoid
.push_back (Offset (inf
.x_
, y
+ dir_
* parameters_
.free_head_distance_
));
614 extract_grob_set (slur_
, "encompass-objects", extra_encompasses
);
615 for (vsize i
= 0; i
< extra_encompasses
.size (); i
++)
617 if (Slur::has_interface (extra_encompasses
[i
]))
619 Grob
*small_slur
= extra_encompasses
[i
];
620 Bezier b
= Slur::get_curve (small_slur
);
622 Offset z
= b
.curve_point (0.5);
623 z
+= Offset (small_slur
->relative_coordinate (common_
[X_AXIS
], X_AXIS
),
624 small_slur
->relative_coordinate (common_
[Y_AXIS
], Y_AXIS
));
626 z
[Y_AXIS
] += dir_
* parameters_
.free_slur_distance_
;
629 else if (extra_encompasses
[i
]->get_property ("avoid-slur") == ly_symbol2scm ("inside"))
631 Grob
*g
= extra_encompasses
[i
];
632 Interval xe
= g
->extent (common_
[X_AXIS
], X_AXIS
);
633 Interval ye
= g
->extent (common_
[Y_AXIS
], Y_AXIS
);
637 avoid
.push_back (Offset (xe
.center(), ye
[dir_
]));
644 Slur_score_state::generate_curves () const
646 Real r_0
= robust_scm2double (slur_
->get_property ("ratio"), 0.33);
647 Real h_inf
= staff_space_
* scm_to_double (slur_
->get_property ("height-limit"));
649 vector
<Offset
> avoid
= generate_avoid_offsets ();
650 for (vsize i
= 0; i
< configurations_
.size (); i
++)
651 configurations_
[i
]->generate_curve (*this, r_0
, h_inf
, avoid
);
654 vector
<Slur_configuration
*>
655 Slur_score_state::enumerate_attachments (Drul_array
<Real
> end_ys
) const
657 vector
<Slur_configuration
*> scores
;
659 Drul_array
<Offset
> os
;
660 os
[LEFT
] = base_attachments_
[LEFT
];
661 Real minimum_length
= staff_space_
662 * robust_scm2double (slur_
->get_property ("minimum-length"), 2.0);
664 for (int i
= 0; dir_
* os
[LEFT
][Y_AXIS
] <= dir_
* end_ys
[LEFT
]; i
++)
666 os
[RIGHT
] = base_attachments_
[RIGHT
];
667 for (int j
= 0; dir_
* os
[RIGHT
][Y_AXIS
] <= dir_
* end_ys
[RIGHT
]; j
++)
669 Slur_configuration s
;
671 Drul_array
<bool> attach_to_stem (false, false);
674 os
[d
][X_AXIS
] = base_attachments_
[d
][X_AXIS
];
675 if (extremes_
[d
].stem_
676 && !Stem::is_invisible (extremes_
[d
].stem_
)
677 && extremes_
[d
].stem_dir_
== dir_
)
679 Interval stem_y
= extremes_
[d
].stem_extent_
[Y_AXIS
];
680 stem_y
.widen (0.25 * staff_space_
);
681 if (stem_y
.contains (os
[d
][Y_AXIS
]))
683 os
[d
][X_AXIS
] = extremes_
[d
].stem_extent_
[X_AXIS
][-d
]
685 attach_to_stem
[d
] = true;
687 else if (dir_
* extremes_
[d
].stem_extent_
[Y_AXIS
][dir_
]
688 < dir_
* os
[d
][Y_AXIS
]
689 && !extremes_
[d
].stem_extent_
[X_AXIS
].is_empty ())
691 os
[d
][X_AXIS
] = extremes_
[d
].stem_extent_
[X_AXIS
].center ();
694 while (flip (&d
) != LEFT
);
697 dz
= os
[RIGHT
] - os
[LEFT
];
698 if (dz
[X_AXIS
] < minimum_length
699 || fabs (dz
[Y_AXIS
] / dz
[X_AXIS
]) > parameters_
.max_slope_
)
703 if (extremes_
[d
].slur_head_
704 && !extremes_
[d
].slur_head_x_extent_
.is_empty ())
706 os
[d
][X_AXIS
] = extremes_
[d
].slur_head_x_extent_
.center ();
707 attach_to_stem
[d
] = false;
710 while (flip (&d
) != LEFT
);
713 dz
= os
[RIGHT
] - os
[LEFT
];
716 if (extremes_
[d
].slur_head_
717 && !attach_to_stem
[d
])
719 /* Horizontally move tilted slurs a little. Move
720 more for bigger tilts.
724 -= dir_
* extremes_
[d
].slur_head_x_extent_
.length ()
725 * sin (dz
.arg ()) / 3;
728 while (flip (&d
) != LEFT
);
731 s
.index_
= scores
.size ();
733 scores
.push_back (new Slur_configuration (s
));
735 os
[RIGHT
][Y_AXIS
] += dir_
* staff_space_
/ 2;
738 os
[LEFT
][Y_AXIS
] += dir_
* staff_space_
/ 2;
741 assert (scores
.size () > 0);
745 vector
<Extra_collision_info
>
746 Slur_score_state::get_extra_encompass_infos () const
748 extract_grob_set (slur_
, "encompass-objects", encompasses
);
749 vector
<Extra_collision_info
> collision_infos
;
750 for (vsize i
= encompasses
.size (); i
--;)
752 if (Slur::has_interface (encompasses
[i
]))
754 Spanner
*small_slur
= dynamic_cast<Spanner
*> (encompasses
[i
]);
755 Bezier b
= Slur::get_curve (small_slur
);
757 Offset
relative (small_slur
->relative_coordinate (common_
[X_AXIS
], X_AXIS
),
758 small_slur
->relative_coordinate (common_
[Y_AXIS
], Y_AXIS
));
760 for (int k
= 0; k
< 3; k
++)
762 Direction hdir
= Direction (k
- 1);
765 Only take bound into account if small slur starts
766 together with big slur.
768 if (hdir
&& small_slur
->get_bound (hdir
) != slur_
->get_bound (hdir
))
771 Offset z
= b
.curve_point (k
/ 2.0);
776 yext
[dir_
] = z
[Y_AXIS
] + dir_
* thickness_
* 1.0;
778 Interval
xext (-1, 1);
779 xext
= xext
* (thickness_
* 2) + z
[X_AXIS
];
780 Extra_collision_info
info (small_slur
,
784 parameters_
.extra_object_collision_penalty_
);
785 collision_infos
.push_back (info
);
790 Grob
*g
= encompasses
[i
];
791 Interval xe
= g
->extent (common_
[X_AXIS
], X_AXIS
);
792 Interval ye
= g
->extent (common_
[Y_AXIS
], Y_AXIS
);
795 Real penalty
= parameters_
.extra_object_collision_penalty_
;
796 if (Accidental_interface::has_interface (g
))
798 penalty
= parameters_
.accidental_collision_
;
799 /* Begin copy accidental.cc */
801 if (to_boolean (g
->get_property ("cautionary")))
803 SCM cstyle
= g
->get_property ("cautionary-style");
804 parens
= ly_is_equal (cstyle
, ly_symbol2scm ("parentheses"));
807 SCM accs
= g
->get_property ("accidentals");
808 SCM scm_style
= g
->get_property ("style");
809 if (!scm_is_symbol (scm_style
)
811 && scm_ilength (accs
) == 1)
813 /* End copy accidental.cc */
814 switch (scm_to_int (scm_car (accs
)))
830 ye
.widen (thickness_
* 0.5);
831 xe
.widen (thickness_
* 1.0);
832 Extra_collision_info
info (g
, xp
, xe
, ye
, penalty
);
833 collision_infos
.push_back (info
);
837 return collision_infos
;
840 Extra_collision_info::Extra_collision_info (Grob
*g
, Real idx
, Interval x
, Interval y
, Real p
)
843 extents_
[X_AXIS
] = x
;
844 extents_
[Y_AXIS
] = y
;
847 type_
= g
->get_property ("avoid-slur");
850 Extra_collision_info::Extra_collision_info ()