public override Pattern Generate()
{
var endTimeData = HitObject as IHasEndTime;
var positionData = HitObject as IHasColumn;
int column = positionData.Column;
var pattern = new Pattern();
if (endTimeData != null)
{
pattern.Add(new HoldNote {
StartTime = HitObject.StartTime,
Duration = endTimeData.Duration,
Column = column,
//Head = { Samples = sampleInfoListAt(HitObject.StartTime) },
//Tail = { Samples = sampleInfoListAt(endTimeData.EndTime) },
});
}
else if (positionData != null)
{
pattern.Add(new Note {
StartTime = HitObject.StartTime,
Samples = HitObject.Samples,
Column = column
});
}
return(pattern);
}
private Pattern generate()
{
var positionData = HitObject as IHasXPosition;
int column = GetColumn(positionData?.X ?? 0);
var pattern = new Pattern();
if (HitObject is IHasDuration endTimeData)
{
pattern.Add(new HoldNote
{
StartTime = HitObject.StartTime,
Duration = endTimeData.Duration,
Column = column,
Samples = HitObject.Samples,
NodeSamples = (HitObject as IHasRepeats)?.NodeSamples ?? defaultNodeSamples
});
}
else if (HitObject is IHasXPosition)
{
pattern.Add(new Note
{
StartTime = HitObject.StartTime,
Samples = HitObject.Samples,
Column = column
});
}
return(pattern);
}
private Pattern generate()
{
var endTimeData = HitObject as IHasEndTime;
var positionData = HitObject as IHasXPosition;
int column = GetColumn(positionData?.X ?? 0);
var pattern = new Pattern();
if (endTimeData != null)
{
pattern.Add(new HoldNote
{
StartTime = HitObject.StartTime,
Duration = endTimeData.Duration,
Column = column,
Head = { Samples = sampleInfoListAt(HitObject.StartTime) },
Tail = { Samples = sampleInfoListAt(endTimeData.EndTime) },
});
}
else if (positionData != null)
{
pattern.Add(new Note
{
StartTime = HitObject.StartTime,
Samples = HitObject.Samples,
Column = column
});
}
return(pattern);
}
public Pattern GetPatternAt(int segment)
{
var pattern = new Pattern(StaccatoElementsFactory.CreateTrackElement(9));
int layerCounter = 0;
foreach (string layer in GetLayersAt(segment))
{
pattern.Add(StaccatoElementsFactory.CreateLayerElement(layerCounter));
layerCounter++;
pattern.Add(GetStaccatoStringForRhythm(layer));
}
return(pattern);
}
// Merge two patterns to one.
private void convolute_basic(Pattern target, Pattern source1, Pattern source2)
{
target.Clear();
int g_n = source1.Count;
int f_n = source2.Count;
if (g_n == 0 || f_n == 0)
{
return;
}
for (int k = 0; k < g_n + f_n - 1; k++)
{
double sumweight = 0, summass = 0;
int start = k < (f_n - 1) ? 0 : k - f_n + 1; // max(0, k-f_n+1)
int end = k < (g_n - 1) ? k : g_n - 1; // min(g_n - 1, k)
for (int i = start; i <= end; i++)
{
double weight = source1[i].Intensity * source2[k - i].Intensity;
double mass = source1[i].Mz + source2[k - i].Mz;
sumweight += weight;
summass += weight * mass;
}
Peak p = new Peak();
if (sumweight == 0)
{
p.Mz = DUMMY_MASS;
}
else
{
p.Mz = summass / sumweight;
}
p.Intensity = sumweight;
target.Add(p);
}
}
private void ParsePattern(XmlReader r)
{
if (!r.ReadToDescendant("pattern"))
{
return;
}
do
{
if (r.IsEmptyElement)
{
continue;
}
string name = r.GetAttribute("name"); // this.reader["name"];
if (string.IsNullOrEmpty(name))
{
continue;
}
var pat = new Pattern(name);
using (var rr = r.ReadSubtree()) {
rr.Read();
while (rr.Read())
{
switch (rr.NodeType)
{
case XmlNodeType.Element:
if (rr.Name.Equals("factor", StringComparison.Ordinal))
{
string s = rr.GetAttribute("value") ?? string.Empty;
try {
pat.Add(XmlConvert.ToDouble(s));
}
catch (FormatException) {
LogException(ErrorCode.Err202, rr.ReadInnerXml());
}
}
break;
case XmlNodeType.Comment:
pat.Comment = rr.Value;
break;
}
}
}
try {
net.Patterns.Add(pat);
}
catch (ArgumentException) {
LogException(ErrorCode.Err215, pat.Name);
}
} while (r.ReadToNextSibling("pattern"));
}
public Pattern GetPattern()
{
Pattern pattern = new Pattern();
foreach (Chord chord in GetChords())
{
pattern.Add(chord);
}
if (allSequence != null)
{
pattern = ReplacementFormatUtil.ReplaceDollarsWithCandidates(allSequence, GetChords(),
new Pattern(GetChords()));
}
if (eachSequence != null)
{
Pattern p2 = new Pattern();
foreach (var chordString in pattern.ToString().Split(' '))
{
Chord chord = new Chord(chordString);
p2.Add(ReplacementFormatUtil.ReplaceDollarsWithCandidates(eachSequence, chord.GetNotes(), chord));
}
pattern = p2;
}
return(pattern);
}
/// <summary>
/// Constructs and adds a note to a pattern.
/// </summary>
/// <param name="pattern">The pattern to add to.</param>
/// <param name="column">The column to add the note to.</param>
/// <param name="startTime">The start time of the note.</param>
/// <param name="endTime">The end time of the note (set to <paramref name="startTime"/> for a non-hold note).</param>
private void addToPattern(Pattern pattern, int column, double startTime, double endTime)
{
ManiaHitObject newObject;
if (startTime == endTime)
{
newObject = new Note
{
StartTime = startTime,
Samples = sampleInfoListAt(startTime),
Column = column
};
}
else
{
var holdNote = new HoldNote
{
StartTime = startTime,
Column = column,
Duration = endTime - startTime,
Head = { Samples = sampleInfoListAt(startTime) },
Tail = { Samples = sampleInfoListAt(endTime) }
};
newObject = holdNote;
}
pattern.Add(newObject);
}
/// <summary>
/// Constructs and adds a note to a pattern.
/// </summary>
/// <param name="pattern">The pattern to add to.</param>
/// <param name="column">The column to add the note to.</param>
/// <param name="holdNote">Whether to add a hold note.</param>
private void addToPattern(Pattern pattern, int column, bool holdNote)
{
ManiaHitObject newObject;
if (holdNote)
{
var hold = new HoldNote
{
StartTime = HitObject.StartTime,
Column = column,
Duration = endTime - HitObject.StartTime
};
hold.Head.Samples.Add(new SampleInfo
{
Name = SampleInfo.HIT_NORMAL
});
hold.Tail.Samples = HitObject.Samples;
newObject = hold;
}
else
{
newObject = new Note
{
StartTime = HitObject.StartTime,
Samples = HitObject.Samples,
Column = column
};
}
pattern.Add(newObject);
}
public override IEnumerable <Pattern> Generate()
{
var originalPattern = generate();
if (originalPattern.HitObjects.Count() == 1)
{
yield return(originalPattern);
yield break;
}
// We need to split the intermediate pattern into two new patterns:
// 1. A pattern containing all objects that do not end at our EndTime.
// 2. A pattern containing all objects that end at our EndTime. This will be used for further pattern generation.
var intermediatePattern = new Pattern();
var endTimePattern = new Pattern();
foreach (var obj in originalPattern.HitObjects)
{
if (!Precision.AlmostEquals(EndTime, obj.GetEndTime()))
{
intermediatePattern.Add(obj);
}
else
{
endTimePattern.Add(obj);
}
}
yield return(intermediatePattern);
yield return(endTimePattern);
}
/// <summary>
/// Constructs and adds a note to a pattern.
/// </summary>
/// <param name="pattern">The pattern to add to.</param>
/// <param name="column">The column to add the note to.</param>
/// <param name="holdNote">Whether to add a hold note.</param>
private void addToPattern(Pattern pattern, int column, bool holdNote)
{
ManiaHitObject newObject;
if (holdNote)
{
newObject = new HoldNote
{
StartTime = HitObject.StartTime,
Duration = endTime - HitObject.StartTime,
Column = column,
Samples = HitObject.Samples,
NodeSamples = (HitObject as IHasRepeats)?.NodeSamples
};
}
else
{
newObject = new Note
{
StartTime = HitObject.StartTime,
Samples = HitObject.Samples,
Column = column
};
}
pattern.Add(newObject);
}
private void addToPattern(Pattern pattern, int column)
{
pattern.Add(new Note
{
StartTime = HitObject.StartTime,
Samples = HitObject.Samples,
Column = column
});
}
public Pattern Calculate(FormMap fm, double limit, long charge)
{
Pattern tmp = new Pattern();
Pattern result = new Pattern();
result.Add(new Peak()
{
Mz = 0.0, Intensity = 1.0
});
foreach (var i in fm)
{
int atom_index = i.Key;
SuperAtomList sal = sad[atom_index];
int n = i.Value;
int j = 0;
while (n > 0)
{
int sz = sal.Count;
if (j == sz)
{
sal.Add(new Pattern());
convolute_basic(sal[j], sal[j - 1], sal[j - 1]);
Prune(sal[j], limit);
}
if ((n & 1) == 1)
{ // digit is 1, convolute result
convolute_basic(tmp, result, sal[j]);
Prune(tmp, limit);
result.Clear();
result.AddRange(tmp);
}
n >>= 1;
j++;
}
}
// take charge into account
foreach (var p in result)
{
if (charge > 0)
{
p.Mz = p.Mz / Math.Abs(charge) - ELECTRON_MASS;
}
else if (charge < 0)
{
p.Mz = p.Mz / Math.Abs(charge) + ELECTRON_MASS;
}
}
if (result.Count == 0)
{
throw new Exception("Calculate profile failed");
}
return(result);
}
public void PitchWheelTest()
{
Pattern pattern = new Pattern("V0 60w");
for (int i = 0; i < 16384; i += 150)
{
pattern.Add(":PW(" + i + ") 60t");
}
player.Play(pattern);
}
public Pattern GetPattern()
{
Pattern fullPattern = new Pattern();
for (int segment = 0; segment < Length; segment++)
{
fullPattern.Add(GetPatternAt(segment));
}
return(fullPattern);
}
/// <summary>
/// Generates a hold note alongside normal notes.
/// </summary>
/// <param name="startTime">The start time of notes.</param>
/// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
private Pattern generateHoldAndNormalNotes(double startTime)
{
// - - - -
// ■ x x -
// ■ - x x
// ■ x - x
// ■ - x x
var pattern = new Pattern();
int holdColumn = GetColumn((HitObject as IHasXPosition)?.X ?? 0, true);
if (convertType.HasFlag(PatternType.ForceNotStack) && PreviousPattern.ColumnWithObjects < TotalColumns)
holdColumn = FindAvailableColumn(holdColumn, PreviousPattern);
// Create the hold note
addToPattern(pattern, holdColumn, startTime, EndTime);
int nextColumn = GetRandomColumn();
int noteCount;
if (ConversionDifficulty > 6.5)
noteCount = GetRandomNoteCount(0.63, 0);
else if (ConversionDifficulty > 4)
noteCount = GetRandomNoteCount(TotalColumns < 6 ? 0.12 : 0.45, 0);
else if (ConversionDifficulty > 2.5)
noteCount = GetRandomNoteCount(TotalColumns < 6 ? 0 : 0.24, 0);
else
noteCount = 0;
noteCount = Math.Min(TotalColumns - 1, noteCount);
bool ignoreHead = !sampleInfoListAt(startTime).Any(s => s.Name == HitSampleInfo.HIT_WHISTLE || s.Name == HitSampleInfo.HIT_FINISH || s.Name == HitSampleInfo.HIT_CLAP);
var rowPattern = new Pattern();
for (int i = 0; i <= spanCount; i++)
{
if (!(ignoreHead && startTime == HitObject.StartTime))
{
for (int j = 0; j < noteCount; j++)
{
nextColumn = FindAvailableColumn(nextColumn, validation: c => c != holdColumn, patterns: rowPattern);
addToPattern(rowPattern, nextColumn, startTime, startTime);
}
}
pattern.Add(rowPattern);
rowPattern.Clear();
startTime += SegmentDuration;
}
return pattern;
}
private Pattern generateRandomPattern(double p2, double p3, double p4, double p5)
{
var pattern = new Pattern();
pattern.Add(generateRandomNotes(getRandomNoteCount(p2, p3, p4, p5)));
if (RandomStart > 0 && hasSpecialColumn)
{
addToPattern(pattern, 0);
}
return(pattern);
}
private static void GetPatternsFromDir(Pattern pattern, bool useRazor)
{
// get all patterns in this directory
foreach (var filePath in Directory.EnumerateFiles(pattern.FullDirectoryPath, (useRazor ? "*.cshtml" : "*.htm"), SearchOption.TopDirectoryOnly))
{
// We ignore patterns starting with underscore (_)
var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(filePath);
if (fileNameWithoutExtension != null && (useRazor || !fileNameWithoutExtension.StartsWith("_")))
{
pattern.Add(new Pattern(filePath, pattern.RootPath));
}
}
// get any sub directories and their patterns
foreach (var dirPath in Directory.EnumerateDirectories(pattern.FullDirectoryPath))
{
var dirPattern = new Pattern(dirPath, pattern.RootPath);
GetPatternsFromDir(dirPattern, useRazor);
pattern.Add(dirPattern);
}
}
public void MicrotonalTest()
{
Pattern normalScale = new Pattern("(A4 A#4 B4 C5 C#5 D5 D#5 E5 F5 F#5 G5 G#5 A5 A#5 B5 C6)s");
Pattern microtoneScale = new Pattern();
var preprocessor = new MicrotonePreprocessor();
for (double freq = Note.FrequencyForNote("A4"); freq < Note.FrequencyForNote("C6"); freq += 10.5)
{
microtoneScale.Add("m" + freq + "s");
}
Console.WriteLine("First, playing normal scale: " + normalScale);
player.Play(normalScale);
player.Play("Rw5");
Console.WriteLine($"Second, playing microtone scale. You should hear middle ranges in these notes: {microtoneScale}");
player.Play(microtoneScale);
Console.WriteLine("The expanded version of the microtone string is: " + preprocessor.Preprocess(microtoneScale.ToString(), null));
player.Play("Rw5");
Pattern pitchWheelDemo = new Pattern();
Console.WriteLine("Now, let's do a pitch wheel demo. Same note (Middle-C, note 60), played with 163 different pitch wheel settings, each 100 cents apart.");
for (int i = 0; i < 16383; i += 100)
{
pitchWheelDemo.Add(":PW(" + i + ") 60t");
}
Console.WriteLine("This should sound like it gradually ramps up.");
player.Play(pitchWheelDemo);
player.Play("Rw5");
Console.WriteLine("Now playing four notes. The first two should sound different from each other, and the second two should sound the same as the first two.");
string microtone = "m346.0w m356.5w";
player.Play(microtone);
player.Play(preprocessor.Preprocess(microtone, null));
}
public Pattern GetPattern()
{
Pattern pattern = new Pattern();
bool foundChord = false;
string chordName = GetChordType();
if (chordName != null)
{
StringBuilder sb = new StringBuilder();
sb.Append(InsertChordNameIntoNote(Root, chordName));
for (int i = 0; i < Inversion; i++)
{
sb.Append("^");
}
pattern.Add(sb.ToString());
foundChord = true;
}
if (!foundChord)
{
return(GetPatternWithNotes());
}
return(pattern);
}
/// <summary>
/// Generates a hold note alongside normal notes.
/// </summary>
/// <param name="startTime">The start time of notes.</param>
/// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
private Pattern generateHoldAndNormalNotes(double startTime)
{
// - - - -
// ■ x x -
// ■ - x x
// ■ x - x
// ■ - x x
var pattern = new Pattern();
int holdColumn = GetColumn((HitObject as IHasXPosition)?.X ?? 0, true);
if ((convertType & PatternType.ForceNotStack) > 0 && PreviousPattern.ColumnWithObjects < TotalColumns)
{
while (PreviousPattern.ColumnHasObject(holdColumn))
{
holdColumn = Random.Next(RandomStart, TotalColumns);
}
}
// Create the hold note
addToPattern(pattern, holdColumn, startTime, endTime);
int nextColumn = Random.Next(RandomStart, TotalColumns);
int noteCount;
if (ConversionDifficulty > 6.5)
{
noteCount = GetRandomNoteCount(0.63, 0);
}
else if (ConversionDifficulty > 4)
{
noteCount = GetRandomNoteCount(TotalColumns < 6 ? 0.12 : 0.45, 0);
}
else if (ConversionDifficulty > 2.5)
{
noteCount = GetRandomNoteCount(TotalColumns < 6 ? 0 : 0.24, 0);
}
else
{
noteCount = 0;
}
noteCount = Math.Min(TotalColumns - 1, noteCount);
bool ignoreHead = !sampleInfoListAt(startTime).Any(s => s.Name == SampleInfo.HIT_WHISTLE || s.Name == SampleInfo.HIT_FINISH || s.Name == SampleInfo.HIT_CLAP);
var rowPattern = new Pattern();
for (int i = 0; i <= spanCount; i++)
{
if (!(ignoreHead && startTime == HitObject.StartTime))
{
for (int j = 0; j < noteCount; j++)
{
while (rowPattern.ColumnHasObject(nextColumn) || nextColumn == holdColumn)
{
nextColumn = Random.Next(RandomStart, TotalColumns);
}
addToPattern(rowPattern, nextColumn, startTime, startTime);
}
}
pattern.Add(rowPattern);
rowPattern.Clear();
startTime += segmentDuration;
}
return(pattern);
}
/// <summary>
/// Adds to a search pattern an additional search by class name.
/// </summary>
/// <param name="value">The class name to search for.</param>
/// <returns>The search pattern.</returns>
public Search AndByClassName(string value)
{
Pattern.Add("className", value);
return(this);
}
/// <summary>
/// Gets the extended search pattern.
/// </summary>
/// <returns>The search pattern.</returns>
public Search AndIsVisibleOnScreen()
{
Pattern.Add("VisibleOnScreen", true);
return(this);
}
public Pattern EncodePattern(string input)
{
var pattern = new Pattern();
for (var index = 0; index < input.Length; index++)
{
var maxLength = input.Length - index;
//Maximal munch
for (var len = maxLength; len > 0; len--)
{
var bunch = input.Substring(index, len);
if (Lingon.DefaultSet.FirstOrDefault(ling => ling.Symbol == bunch) != null)
{
pattern.Add(Lingon.DefaultSet.FirstOrDefault(ling => ling.Symbol == bunch));
index += len - 1;
break;
}
else if (bunch.StartsWith("[") && bunch.EndsWith("]") && len > 2)
{
pattern.Add(new NonceSet(EncodePattern(bunch.Substring(1, bunch.Length - 2))));
index += len - 1;
break;
}
else if (bunch.Length > 1 && bunch.Substring(1).StartsWith("[") && bunch.EndsWith("]"))
{
var symbol = bunch.Substring(0, 1);
var split = bunch.Substring(1).Split("]").Where(ft => ft != "").ToList();
if (split.Any(segment => !segment.StartsWith("[")))
{
continue;
}
var features = split.Select(ft => ft.Replace("[", ""));
var hasFeatures = new List <Feature>();
var notFeatures = new List <Feature>();
if (Lingons.ContainsKey(symbol))
{
hasFeatures.AddRange(Lingons[symbol].Features);
}
else if (Categories.ContainsKey(symbol))
{
hasFeatures.AddRange(Categories[symbol].HasFeatures);
notFeatures.AddRange(Categories[symbol].NotFeatures);
}
foreach (var feature in features)
{
var add = !feature.StartsWith("-");
var name = feature.Substring(1);
(add ? hasFeatures : notFeatures).Add(Feature.AllFeatures.First(ft => String.Equals(ft.Name, name, StringComparison.CurrentCultureIgnoreCase)));
}
pattern.Add(new Category(hasFeatures, notFeatures));
index += len - 1; //Move to end of bunch
break;
}
else if (Lingons.ContainsKey(bunch))
{
pattern.Add(Lingons[bunch]);
index += len - 1; //Move to end of bunch
break;
}
else if (Categories.ContainsKey(bunch))
{
pattern.Add(Categories[bunch]);
index += len - 1; //Move to end of bunch
break;
}
else if (len == 1)
{
pattern.Add(Lingon.Unknown);
break;
}
}
}
return(pattern);
}
public EmassCalculator(string filename)
{
if (!File.Exists(filename))
{
throw new FileNotFoundException(filename);
}
IsotopicMap = new ElemMap();
using (StreamReader f = new StreamReader(filename))
{
sad.Clear();
IsotopicMap.Clear();
string line;
int elemindex = 0;
int state = 0;
while ((line = f.ReadLine()) != null)
{
string element;
switch (state)
{
case 0: // new element
var m0 = eleReg.Match(line);
element = m0.Groups[1].Value;
IsotopicMap[element] = elemindex;
var pkl = new Pattern();
var sal = new SuperAtomList();
sal.Add(pkl);
sad.Add(sal);
elemindex++;
state = 1;
break;
case 1: // isotope
var m1 = eleReg.Match(line);
if (m1.Success)
{
Peak p = new Peak();
p.Mz = MyConvert.ToDouble(m1.Groups[1].Value);
p.Intensity = MyConvert.ToDouble(m1.Groups[2].Value);
Pattern idist = sad.Last().First();
// fill the gaps in the patterns with zero abundancy peaks
if (idist.Count > 0)
{
double prevmass = idist.Last().Mz;
for (int i = 0; i < (int)(p.Mz - prevmass - 0.5); i++)
{
Peak filler = new Peak();
filler.Mz = DUMMY_MASS;
filler.Intensity = 0;
idist.Add(filler);
}
}
// insert the peak
idist.Add(p);
}
else
{
state = 0;
}
break;
}
}
}
}
