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