Merge pull request #17951 from mike-spa/restsImprovement

Rests improvement

Author: RomanPudashkin

src/engraving/layout/v0/chordlayout.cpp

@@ -2736,14 +2736,16 @@ void ChordLayout::resolveVerticalRestConflicts(Score* score, Segment* segment, s
 
     collectChordsAndRest(segment, staffIdx, chords, rests);
 
-    for (Rest* rest : rests) {
-        rest->verticalClearance().reset();
-    }
-
     if (rests.empty()) {
         return;
     }
 
+    collectChordsOverlappingRests(segment, staffIdx, chords);
+
+    for (Rest* rest : rests) {
+        rest->verticalClearance().reset();
+    }
+
     if (!chords.empty()) {
         resolveRestVSChord(rests, chords, score, segment, staffIdx);
     }
@@ -2763,7 +2765,7 @@ void ChordLayout::resolveRestVSChord(std::vector<Rest*>& rests, std::vector<Chor
     int lines = staff->lines(tick);
     double spatium = staff->spatium(tick);
     double lineDistance = staff->lineDistance(tick) * spatium;
-    const double minRestToChordClearance = 0.35 * spatium;
+    double minRestToChordClearance = 0.35 * spatium;
 
     for (Rest* rest : rests) {
         if (!rest->visible() || !rest->autoplace()) {
@@ -2774,14 +2776,25 @@ void ChordLayout::resolveRestVSChord(std::vector<Rest*>& rests, std::vector<Chor
             if (!chord->visible() || !chord->autoplace()) {
                 continue;
             }
+
             bool restAbove = rest->voice() < chord->voice() || (chord->slash() && !(rest->voice() % 2));
             int upSign = restAbove ? -1 : 1;
             double restYOffset = rest->offset().y();
             bool ignoreYOffset = (restAbove && restYOffset > 0) || (!restAbove && restYOffset < 0);
             PointF offset = ignoreYOffset ? PointF(0, restYOffset) : PointF(0, 0);
+
+            double clearance = 0.0;
             Shape restShape = rest->shape().translated(rest->pos() - offset);
-            Shape chordShape = chord->shape().translated(chord->pos());
-            double clearance = restAbove ? restShape.verticalClearance(chordShape) : chordShape.verticalClearance(restShape);
+            if (chord->segment() == rest->segment()) {
+                Shape chordShape = chord->shape().translated(chord->pos());
+                clearance = restAbove ? restShape.verticalClearance(chordShape) : chordShape.verticalClearance(restShape);
+            } else {
+                Note* limitNote = restAbove ? chord->upNote() : chord->downNote();
+                Shape noteShape = limitNote->shape().translate(limitNote->pos());
+                clearance = restAbove ? noteShape.top() - restShape.bottom() : restShape.top() - noteShape.bottom();
+                minRestToChordClearance = 0.0;
+            }
+
             double margin = clearance - minRestToChordClearance;
             int marginInSteps = floor(margin / lineDistance);
             if (restAbove) {
@@ -2792,6 +2805,7 @@ void ChordLayout::resolveRestVSChord(std::vector<Rest*>& rests, std::vector<Chor
             if (margin > 0) {
                 continue;
             }
+
             rest->verticalClearance().setLocked(true);
             bool isWholeOrHalf = rest->isWholeRest() || rest->durationType() == DurationType::V_HALF;
             bool outAboveStaff = restAbove && restShape.bottom() + margin < minRestToChordClearance;

src/engraving/libmscore/utils.cpp

@@ -35,6 +35,7 @@
 #include "page.h"
 #include "part.h"
 #include "pitchspelling.h"
+#include "rest.h"
 #include "score.h"
 #include "segment.h"
 #include "sig.h"
@@ -1226,4 +1227,51 @@ void collectChordsAndRest(Segment* segment, staff_idx_t staffIdx, std::vector<Ch
         }
     }
 }
+
+void collectChordsOverlappingRests(Segment* segment, staff_idx_t staffIdx, std::vector<Chord*>& chords)
+{
+    // Check if previous segments contain chords in other voices
+    // whose duration overlaps with rests on this segment
+
+    track_idx_t startTrack = staffIdx * VOICES;
+    track_idx_t endTrack = startTrack + VOICES;
+
+    std::set<track_idx_t> tracksToCheck;
+    for (track_idx_t track = startTrack; track < endTrack; ++track) {
+        EngravingItem* item = segment->elementAt(track);
+        if (!item || !item->isRest()) {
+            tracksToCheck.insert(track);
+        }
+    }
+
+    Fraction curTick = segment->rtick();
+    for (Segment* prevSeg = segment->prev(); prevSeg; prevSeg = prevSeg->prev()) {
+        if (!prevSeg->isChordRestType()) {
+            continue;
+        }
+        Fraction prevSegTick = prevSeg->rtick();
+        for (track_idx_t track : tracksToCheck) {
+            EngravingItem* e = prevSeg->elementAt(track);
+            if (!e || !e->isChord()) {
+                continue;
+            }
+            Chord* chord = toChord(e);
+            Fraction chordEndTick = prevSegTick + chord->actualTicks();
+            if (chordEndTick <= curTick) {
+                continue;
+            }
+            Measure* measure = segment->measure();
+            Segment* endSegment = measure->findSegmentR(SegmentType::ChordRest, chordEndTick);
+            if (!endSegment) {
+                continue;
+            }
+            EngravingItem* endItem = endSegment->elementAt(track);
+            if (!endItem || !endItem->isChord()) {
+                continue;
+            }
+
+            chords.push_back(chord);
+        }
+    }
+}
 }

src/engraving/libmscore/utils.h

@@ -86,6 +86,7 @@ extern bool allowRemoveWhenRemovingStaves(EngravingItem* item, staff_idx_t start
 extern bool moveDownWhenAddingStaves(EngravingItem* item, staff_idx_t startStaff, staff_idx_t endStaff = 0);
 
 extern void collectChordsAndRest(Segment* segment, staff_idx_t staffIdx, std::vector<Chord*>& chords, std::vector<Rest*>& rests);
+extern void collectChordsOverlappingRests(Segment* segment, staff_idx_t staffIdx, std::vector<Chord*>& chords);
 
 extern Interval ornamentIntervalToGeneralInterval(OrnamentInterval interval);
 } // namespace mu::engraving