public static Model.Evidence GetEvidence(MeiElement _evd)
{
if (_evd is mei.Unclear unclear)
{
if (unclear.HasCert() == false)
{
return(Model.Evidence.Unclear_unknown);
}
else
{
string cert = "Unclear_" + unclear.GetCertValue();
if (Enum.TryParse(cert, true, out Model.Evidence evidence))
{
return(evidence);
}
else
{
return(Model.Evidence.Invalid);
}
}
}
else if (_evd is mei.Supplied)
{
return(Model.Evidence.Supplied);
}
else
{
throw new InvalidOperationException("Ops! The current element should be <unclear> or <supplied>!");
}
}
/// <summary>
/// Reads Mei-File and generates sequences per panel.
/// </summary>
/// <param name="_filedir">Path to Mei file</param>
/// <returns>List of sequence objects</returns>
public static List <Sequence> GetSequences(string _filedir)
{
MeiDocument doc = MeiImport.ImportDocument(_filedir);
MeiElement root = doc.Root;
List <Sequence> sequences = new List <Sequence>();
string piece;
//Get name of piece
try
{
piece = root.Element <MeiHead>().Element <FileDesc>().Descendants <Title>().FirstOrDefault().Value;
}
catch
{
string[] splitUri = doc.BaseUri.Split('/');
piece = splitUri[splitUri.Length - 1];
}
foreach (Panel panel in root.Descendants <Panel>())
{
List <Sequence> sequencesPerPart = SequenceHandler.GetPreConversionSequence(panel, piece);
foreach (Sequence stateSequence in sequencesPerPart)
{
sequences.Add(stateSequence);
}
}
return(sequences);
}
public void TestIDHandling()
{
XElement testelement = new XElement("ligature", new XElement("note", new XAttribute("label", "test")), new XAttribute(XNamespace.Xml + "id", "t-123"));
MeiElement test = MeiImport.XmlToMei(testelement);
Assert.AreEqual(test.GetId(), "t-123");
Assert.IsNotNull(test.Element <Note>().GetId());
}
public void GetSequencesTest()
{
int countSequences = this.testList.Count();
MeiElement root = MeiImport.ImportDocument("..\\..\\files\\VatS-13a-TuSolus.xml").Root;
int countPanel = root.Descendants <Panel>().Count();
Assert.AreEqual(countPanel, countSequences);
}
public void XmlToMeiTest()
{
XElement testelement = new XElement("ligature", new XElement("note", "bla"));
MeiElement compare = new Ligature();
MeiElement test = MeiImport.XmlToMei(testelement);
Assert.IsInstanceOfType(test, compare.GetType());
}
/// <summary>
/// Converts mei.Damage or mei.Gap into Model.Gap and sets GapType and Reason.
/// </summary>
/// <param name="_gap">Empty Model.Gap object</param>
/// <param name="_meigap">MeiElement, needs to be mei.Damage or mei.Gap</param>
/// <returns>Model.Gap object with data</returns>
public static Model.Gap ConvertGap(Model.Gap _gap, MeiElement _meigap)
{
if (_meigap is mei.Gap _gapgap)
{
_gap.GapType = Model.GapType.Gap;
_gap.Reason = _gapgap.GetReasonValue();
}
else if (_meigap is mei.Damage _damagegap)
{
_gap.GapType = Model.GapType.Damage;
_gap.Reason = _damagegap.GetAgentValue();
}
else
{
_gap.GapType = Model.GapType.Null;
}
return(_gap);
}
public void InvalidRootTest()
{
XElement testelement = new XElement("blubb", new XElement("note"));
MeiElement conversion_test = MeiImport.XmlToMei(testelement);
}
/// <summary>
/// Invokes a Sequence object for the given MEI element
/// </summary>
/// <param name="_sequence">Sequence</param>
/// <param name="layerElement">MEI Element to process</param>
internal static ObjectInSequence InvokeSequenceObject(Sequence _sequence, MeiElement layerElement, Evidence evidence = Evidence.Clear, int ligaturePos = 0, string ligForm = null)
{
ObjectInSequence obj = null;
if (layerElement is mei.Note note)
{
obj = new Model.Note();
NoteConverter.ConvertNote((Model.Note)obj, note);
//check for @lig attribute
if (note.HasLig())
{
ligForm = note.GetLigValue();
}
TinyConverters.LigatureHandler((Model.Note)obj, ligaturePos, ligForm);
}
// Ligatures needs to be be handled recursively to get their elements and store related data
else if (layerElement is mei.Ligature ligature)
{
foreach (MeiElement ligaturChild in ligature.Elements())
{
ligaturePos++;
InvokeSequenceObject(_sequence, ligaturChild, evidence, ligaturePos, ligature.GetFormValue());
}
ligaturePos = 0;
}
else if (layerElement is mei.Rest)
{
obj = new Model.Rest();
RestConverter.ConvertRest((Model.Rest)obj, (mei.Rest)layerElement);
}
else if (layerElement is Chord)
{
// We need a List of all objects in the Chord to add them to the sequence at the same position
List <ObjectInSequence> lstChordEvents = new List <ObjectInSequence>();
foreach (MeiElement noteRest in layerElement.Descendants())
{
ObjectInSequence objNoteRest = InvokeSequenceObject(null, noteRest);
if (objNoteRest != null)
{
lstChordEvents.Add(objNoteRest);
}
}
_sequence?.AddToSequence(lstChordEvents.ToArray());
}
else if (layerElement is mei.KeySig)
{
// We need a List of all KeyAccids in the KeySig to add them to the sequence at the same position
List <ObjectInSequence> lstAcids = new List <ObjectInSequence>();
foreach (KeyAccid keyAccid in layerElement.Elements())
{
lstAcids.Add(InvokeSequenceObject(null, keyAccid));
}
_sequence?.AddToSequence(lstAcids.ToArray());
}
else if (layerElement is KeyAccid)
{
obj = new Model.KeyAccidental();
AccidentalConverter.ConvertKeyAccidental((Model.KeyAccidental)obj, (mei.KeyAccid)layerElement);
}
else if (layerElement is mei.Accid)
{
obj = new Model.Accidental();
AccidentalConverter.ConvertAccidental((Model.Accidental)obj, (mei.Accid)layerElement);
}
else if (layerElement is mei.Mensur)
{
obj = new Model.Mensur();
MensurProportionConverter.ConvertMensur((Model.Mensur)obj, (mei.Mensur)layerElement);
}
else if (layerElement is mei.Proport)
{
obj = new Model.Proportion();
MensurProportionConverter.ConvertProportion((Model.Proportion)obj, (mei.Proport)layerElement);
}
else if (layerElement is mei.BarLine)
{
obj = new Model.Barline();
TinyConverters.ConvertBarline((Model.Barline)obj, (mei.BarLine)layerElement);
}
else if (layerElement is mei.Dot)
{
obj = new Model.Dot();
}
else if (layerElement is mei.Clef)
{
obj = new Model.Clef();
TinyConverters.ConvertClef((Model.Clef)obj, (mei.Clef)layerElement);
}
else if (layerElement is mei.Custos)
{
obj = new Model.Custos();
TinyConverters.ConvertCustos((Model.Custos)obj, (mei.Custos)layerElement);
}
else if (layerElement is mei.Unclear || layerElement is mei.Supplied)
{
Evidence evd = TinyConverters.GetEvidence(layerElement);
foreach (MeiElement evdChild in layerElement.Elements())
{
InvokeSequenceObject(_sequence, evdChild, evd);
}
}
else if (layerElement is mei.Damage || layerElement is mei.Gap)
{
obj = new Model.Gap();
TinyConverters.ConvertGap((Model.Gap)obj, layerElement);
}
if (obj != null)
{
//After type definition, add ID of MEI element
obj.ID = layerElement.GetId();
//Set Evidence
obj.Evidence = evidence;
//Add to sequence if defined
_sequence?.AddToSequence(obj);
}
return(obj);
}
