Verovio
Source code documentation
editortoolkit_neume.h
1 // Name: editortoolkit_neume.h
3 // Author: Juliette Regimbal
4 // Created: 04/06/2019
5 // Copyright (c) Authors and others. All rights reserved.
7 
8 #ifndef __VRV_EDITOR_TOOLKIT_NEUME_H__
9 #define __VRV_EDITOR_TOOLKIT_NEUME_H__
10 
11 #include <cmath>
12 #include <string>
13 #include <utility>
14 
15 //--------------------------------------------------------------------------------
16 
17 #include "doc.h"
18 #include "editortoolkit.h"
19 #include "measure.h"
20 #include "staff.h"
21 #include "view.h"
22 #include "vrv.h"
23 #include "zone.h"
24 
25 #include "jsonxx.h"
26 
27 namespace vrv {
28 
29 //--------------------------------------------------------------------------------
30 // EditorToolkitNeume
31 //--------------------------------------------------------------------------------
32 
33 class EditorToolkitNeume : public EditorToolkit {
34 public:
35  EditorToolkitNeume(Doc *doc, View *view) : EditorToolkit(doc, view) {}
36  bool ParseEditorAction(const std::string &json_editorAction) override;
37  std::string EditInfo() override;
38 
42  bool AddSyl(std::string elementId, std::string sylText);
44  bool Chain(jsonxx::Array actions);
45  bool DisplaceClefOctave(std::string elementId, std::string direction);
46  bool Drag(std::string elementId, int x, int y, bool topLevel = true);
47  bool Insert(std::string elementType, std::string staffId, int ulx, int uly, int lrx, int lry,
48  std::vector<std::pair<std::string, std::string>> attributes);
49  bool InsertToSyllable(std::string elementId);
50  bool MatchHeight(std::string elementId);
51  bool Merge(std::vector<std::string> elementIds);
52  bool MoveOutsideSyllable(std::string elementId);
53  bool Set(std::string elementId, std::string attrType, std::string attrValue);
54  bool SetText(std::string elementId, const std::string &text);
55  bool SetClef(std::string elementId, std::string shape);
56  bool SetLiquescent(std::string elementId, std::string shape);
57  bool SortStaves();
58  bool Split(std::string elementId, int x);
59  bool SplitNeume(std::string elementId, std::string ncId);
60  bool Remove(std::string elementId);
61  bool Resize(std::string elementId, int ulx, int uly, int lrx, int lry, float resize = NAN);
62  bool Group(std::string groupType, std::vector<std::string> elementIds);
63  void UnlinkSyllable(Syllable *syllable);
64  bool Ungroup(std::string groupType, std::vector<std::string> elementIds);
65  bool ChangeGroup(std::string elementId, std::string contour);
66  bool ToggleLigature(std::vector<std::string> elementIds);
67  bool ChangeStaff(std::string elementId);
68  bool ChangeStaffTo(std::string elementId, std::string staffId);
69  bool ClefMovementHandler(Clef *clef, int x, int y);
71 protected:
75  bool ParseAddSylAction(jsonxx::Object param, std::string *elementId, std::string *sylText);
77  bool ParseDisplaceClefAction(jsonxx::Object param, std::string *elementId, std::string *direction);
78  bool ParseDragAction(jsonxx::Object param, std::string *elementId, int *x, int *y);
79  bool ParseInsertAction(jsonxx::Object param, std::string *elementType, std::string *startId, std::string *endId);
80  bool ParseInsertAction(jsonxx::Object param, std::string *elementType, std::string *staffId, int *ulx, int *uly,
81  int *lrx, int *lry, std::vector<std::pair<std::string, std::string>> *attributes);
82  bool ParseInsertToSyllableAction(jsonxx::Object param, std::string *elementId);
83  bool ParseMatchHeightAction(jsonxx::Object param, std::string *elementId);
84  bool ParseMergeAction(jsonxx::Object param, std::vector<std::string> *elementIds);
85  bool ParseMoveOutsideSyllableAction(jsonxx::Object param, std::string *elementId);
86  bool ParseSetAction(jsonxx::Object param, std::string *elementId, std::string *attrType, std::string *attrValue);
87  bool ParseSetTextAction(jsonxx::Object param, std::string *elementId, std::string *text);
88  bool ParseSetClefAction(jsonxx::Object param, std::string *elementId, std::string *shape);
89  bool ParseSetLiquescentAction(jsonxx::Object param, std::string *elementId, std::string *shape);
90  bool ParseSplitAction(jsonxx::Object param, std::string *elementId, int *x);
91  bool ParseSplitNeumeAction(jsonxx::Object param, std::string *elementId, std::string *ncId);
92  bool ParseRemoveAction(jsonxx::Object param, std::string *elementId);
93  bool ParseResizeAction(jsonxx::Object param, std::string *elementId, int *ulx, int *uly, int *lrx, int *lry);
94  bool ParseResizeRotateAction(
95  jsonxx::Object param, std::string *elementId, int *ulx, int *uly, int *lrx, int *lry, float *rotate);
96  bool ParseGroupAction(jsonxx::Object param, std::string *groupType, std::vector<std::string> *elementIds);
97  bool ParseUngroupAction(jsonxx::Object param, std::string *groupType, std::vector<std::string> *elementIds);
98  bool ParseChangeGroupAction(jsonxx::Object param, std::string *elementId, std::string *contour);
99  bool ParseToggleLigatureAction(jsonxx::Object param, std::vector<std::string> *elementIds);
100  bool ParseChangeStaffAction(jsonxx::Object param, std::string *elementId);
101  bool ParseChangeStaffToAction(jsonxx::Object param, std::string *elementId, std::string *staffId);
103 
107  bool AdjustPitchAfterDrag(Object *obj, int y = 0);
109  bool AdjustPitchFromPosition(Object *obj);
110  bool AdjustClefLineFromPosition(Clef *clef, Staff *staff = NULL);
112 };
113 
114 //--------------------------------------------------------------------------------
115 // Comparator structs
116 //--------------------------------------------------------------------------------
117 // To be used with std::sort to find the object with a closest bounding
118 // box to a point defined by the x and y parameters of ClosestBB
119 
120 struct ClosestBB {
121  int x;
122  int y;
123 
124  int distanceToBB(int ulx, int uly, int lrx, int lry, double rotate = 0)
125  {
126  int offset = (x - ulx) * tan(rotate * M_PI / 180.0);
127  uly = uly + offset;
128  lry = lry + offset;
129  int xDiff = std::max((ulx > x ? ulx - x : 0), (x > lrx ? x - lrx : 0));
130  int yDiff = std::max((uly > y ? uly - y : 0), (y > lry ? y - lry : 0));
131 
132  return sqrt(xDiff * xDiff + yDiff * yDiff);
133  }
134 
135  bool operator()(Object *a, Object *b)
136  {
137  if (!a->GetFacsimileInterface() || !b->GetFacsimileInterface()) return true;
138  Zone *zoneA = a->GetFacsimileInterface()->GetZone();
139  Zone *zoneB = b->GetFacsimileInterface()->GetZone();
140 
141  int distA = distanceToBB(zoneA->GetUlx(), zoneA->GetUly(), zoneA->GetLrx(), zoneA->GetLry(),
142  zoneA->HasRotate() ? zoneA->GetRotate() : 0);
143  int distB = distanceToBB(zoneB->GetUlx(), zoneB->GetUly(), zoneB->GetLrx(), zoneB->GetLry(),
144  zoneB->HasRotate() ? zoneB->GetRotate() : 0);
145  return (distA < distB);
146  }
147 };
148 
149 // To be used with std::stable_sort to find the position to insert a new accid / divLine
150 // TODO: use closesBB instead
151 struct ClosestNeume {
152  int x;
153  int y;
154 
155  bool operator()(Object *a, Object *b)
156  {
157  // check if neume has neume components
158  if (!a->GetFirst(NC)) {
159  LogError("Neume %s doesn't have neume components.", a->GetID().c_str());
160  return true;
161  }
162  if (!b->GetFirst(NC)) {
163  LogError("Neume %s doesn't have neume components.", b->GetID().c_str());
164  return true;
165  }
166  if (!a->GetFirst(NC)->GetFacsimileInterface()) {
167  LogError("Neume component %s doesn't have facsimile.", a->GetFirst(NC)->GetID().c_str());
168  return true;
169  }
170  if (!b->GetFirst(NC)->GetFacsimileInterface()) {
171  LogError("Neume component %s doesn't have facsimile.", b->GetFirst(NC)->GetID().c_str());
172  return true;
173  }
174  Zone *zoneA = a->GetFirst(NC)->GetFacsimileInterface()->GetZone();
175  Zone *zoneB = b->GetFirst(NC)->GetFacsimileInterface()->GetZone();
176 
177  int distA = std::abs(x - zoneA->GetUlx());
178  int distB = std::abs(x - zoneB->GetUlx());
179 
180  return (distA < distB);
181  }
182 };
183 
184 // To be used with std::stable_sort to find the position to insert a new staff
185 
186 struct StaffSort {
187  // Update 2024-04:
188  // Used only in neume lines,
189  // System->(Measure->Staff)
190  // Need to sort Measure to sort staff
191 
192  // Sort staves by:
193  // 1. Column number derived from staff@type (column1, column2, etc)
194  // 2. Within each column: left-to-right and top-to-bottom
195  bool operator()(Object *a, Object *b)
196  {
197  if (!a->Is(SYSTEM) || !b->Is(SYSTEM)) return false;
198  if (!a->FindDescendantByType(MEASURE) || !b->FindDescendantByType(MEASURE)) return false;
199 
200  Measure *measureA = dynamic_cast<Measure *>(a->FindDescendantByType(MEASURE));
201  Measure *measureB = dynamic_cast<Measure *>(b->FindDescendantByType(MEASURE));
202  if (!measureA->IsNeumeLine() || !measureB->IsNeumeLine()) return true;
203 
204  Staff *staffA = dynamic_cast<Staff *>(a->FindDescendantByType(STAFF));
205  Staff *staffB = dynamic_cast<Staff *>(b->FindDescendantByType(STAFF));
206  assert(staffA);
207  assert(staffB);
208 
209  if (staffA->HasType() && staffB->HasType()) {
210  // First compare column numbers from staff@type
211  std::string typeA = staffA->GetType();
212  std::string typeB = staffB->GetType();
213 
214  if (staffA->GetType().find("column") == 0 && staffB->GetType().find("column") == 0) {
215  int columnA = std::stoi(typeA.substr(6));
216  int columnB = std::stoi(typeB.substr(6));
217  if (columnA != columnB) {
218  return columnA < columnB;
219  }
220  }
221  }
222 
223  // If in same column, use position-based sorting logic
224  Zone *zoneA = staffA->GetFacsimileInterface()->GetZone();
225  Zone *zoneB = staffB->GetFacsimileInterface()->GetZone();
226  assert(zoneA);
227  assert(zoneB);
228 
229  int aLowest, bLowest, aHighest, bHighest;
230 
231  aLowest = zoneA->GetRotate() < 0
232  ? zoneA->GetLry()
233  : zoneA->GetLry() + (zoneA->GetLrx() - zoneA->GetUlx()) * tan(zoneA->GetRotate() * M_PI / 180.0);
234 
235  aHighest = zoneA->GetRotate() < 0
236  ? zoneA->GetUly()
237  : zoneA->GetUly() - (zoneA->GetLrx() - zoneA->GetUlx()) * tan(zoneA->GetRotate() * M_PI / 180.0);
238 
239  bLowest = zoneB->GetRotate() < 0
240  ? zoneB->GetLry()
241  : zoneB->GetLry() + (zoneB->GetLrx() - zoneB->GetUlx()) * tan(zoneB->GetRotate() * M_PI / 180.0);
242 
243  bHighest = zoneB->GetRotate() < 0
244  ? zoneB->GetUly()
245  : zoneB->GetUly() - (zoneB->GetLrx() - zoneB->GetUlx()) * tan(zoneB->GetRotate() * M_PI / 180.0);
246 
247  // Check for y intersection
248  // if the x intersection part is smaller than half of length of staffA
249  // sort by x coordinate
250  if (((aLowest <= bLowest && aLowest >= bHighest) || (aHighest <= bLowest && aHighest >= bHighest)
251  || (bLowest <= aLowest && bLowest >= aHighest) || (bHighest <= aLowest && bHighest >= aHighest))
252  && (zoneA->GetLrx() - zoneB->GetUlx() <= 0.5 * (zoneA->GetLrx() - zoneA->GetUlx()))) {
253  // sort by x center
254  return (zoneA->GetUlx() < zoneB->GetUlx());
255  }
256  else { // no intersection
257  return (zoneA->GetUly() < zoneB->GetUly());
258  }
259  }
260 };
261 
262 } // namespace vrv
263 
264 #endif
vrv::Staff
This class represents a staff in a laid-out score (Doc).
Definition: staff.h:102
vrv::Measure
This class represents a measure in a page-based score (Doc).
Definition: measure.h:37
vrv::FacsimileInterface::GetZone
Zone * GetZone()
Get the zone.
Definition: facsimileinterface.h:58
vrv::Syllable
This class models the MEI <mensur> element.
Definition: syllable.h:25
vrv::Zone
Implements the zone element in MEI.
Definition: zone.h:30
vrv::Doc
This class is a hold the data and corresponds to the model of a MVC design pattern.
Definition: doc.h:41
vrv::Object
This class represents a basic object.
Definition: object.h:59
vrv::EditorToolkitNeume
Definition: editortoolkit_neume.h:33
vrv::EditorToolkitNeume::ParseAddSylAction
bool ParseAddSylAction(jsonxx::Object param, std::string *elementId, std::string *sylText)
Parse JSON instructions for experimental editor functions.
vrv::ClosestBB
Definition: editortoolkit_neume.h:120
vrv::Clef
This class models the MEI <clef> element.
Definition: clef.h:27
vrv::EditorToolkitNeume::EditInfo
std::string EditInfo() override
Get information on the last editor function used.
vrv::StaffSort
Definition: editortoolkit_neume.h:186
vrv::ClosestNeume
Definition: editortoolkit_neume.h:151
vrv::View
This class is a drawing context and corresponds to the view of a MVC design pattern.
Definition: view.h:105
vrv::EditorToolkitNeume::ParseEditorAction
bool ParseEditorAction(const std::string &json_editorAction) override
In child classes, this parses the provided editor action and then performs the correct action.
vrv::Measure::IsNeumeLine
bool IsNeumeLine() const
Return true if the measure represents a neume (section) line.
Definition: measure.h:87
vrv::EditorToolkitNeume::AddSyl
bool AddSyl(std::string elementId, std::string sylText)
Experimental editor functions.
vrv::EditorToolkitNeume::AdjustPitchAfterDrag
bool AdjustPitchAfterDrag(Object *obj, int y=0)
Helper functions for editor actions.
vrv::EditorToolkit
Definition: editortoolkit.h:28
vrv::Object::FindDescendantByType
Object * FindDescendantByType(ClassId classId, int deepness=UNLIMITED_DEPTH, bool direction=FORWARD)
Look for a descendant with the specified type (returns NULL if not found) This method is a wrapper fo...