/// <summary> /// Initializes a new major <see cref="Tetrachord"/>. /// </summary> public Tetrachord() { Name = chordType.majorTetra.ToString(); currentChordType = chordType.majorTetra; offset = interval.maj2nd; Intervals = ChordSpellings.intervalsIn[currentChordType]; }
/// <summary> /// Parses the root intervals. /// </summary> /// <returns>The root chord.</returns> public interval[] ParseRootChord() //TODO make this generic? { int chordSize = 0; for (int i = 0; i < scaleSize; i++) { if (i % 2 == 0) { chordSize++; } } interval[] tempIntervals = new interval[chordSize]; int intervalPosition = 0; for (int i = 0; i < scaleSize - 1; i++) { if (i % 2 == 0) { tempIntervals [intervalPosition] = Intervals [i]; intervalPosition++; } } return(tempIntervals); }
/// <summary> /// Initializes a new <see cref="Tetrachord"/>. /// </summary> /// <param name="_chord">Desired Chord Type.</param> /// <param name="_offset">Desired offset if upper.</param> public Tetrachord(chordType desiredChordType, interval desiredOffset) { Name = desiredChordType.ToString(); currentChordType = desiredChordType; offset = desiredOffset; Intervals = ChordSpellings.intervalsIn[currentChordType]; }
private interval[] readTextGridIntervals(string[] lines, int iterador, int numberGrids) { interval[] res = new interval[numberGrids]; double xmin = 0; double xmax = 0; string xminString = "xmin = "; string xmaxString = "xmax = "; string intervalTextString = "text = \""; string intervalText = ""; for (int i = 0; i < numberGrids; i++) { xmin = Convert.ToDouble((lines[iterador + ((i * 4) + 1)].Substring((lines[iterador + ((i * 4) + 1)].IndexOf(xminString) + xminString.Length)).Replace('.', ','))); xmax = Convert.ToDouble((lines[iterador + ((i * 4) + 2)].Substring((lines[iterador + ((i * 4) + 2)].IndexOf(xmaxString) + xmaxString.Length)).Replace('.', ','))); intervalText = lines[iterador + ((i * 4) + 3)].Substring((lines[iterador + ((i * 4) + 3)].IndexOf(intervalTextString) + intervalTextString.Length)); intervalText = intervalText.Substring(0, intervalText.Length - 1); res[i] = new interval(xmin, xmax, intervalText); } return(res); }
public Payment(string n, DateTime dp, int t, double cfp, bool rep, interval inter, string com) { if (Account.payments.Count == 0) { code = 0; } else { code = Account.payments.Last().code + 1; } name = n; dayp = dp; type = t; inf.costforpoint = cfp; repeated = rep; payed = false; interv = inter; if (repeated == false) { interv.days = 0; interv.month = 0; interv.years = 0; } inf.curstat = 1; inf.prevstat = 0; cost = Math.Round(inf.costforpoint * (inf.curstat - inf.prevstat), 2); comments = com; }
static void MergeIntervals(interval[] intervals) { intervals = intervals.OrderBy(o => o.start).ToArray(); Console.WriteLine("Intervals after sorting: "); foreach (interval i in intervals) { Console.WriteLine("({0}, {1})", i.start, i.end); } Stack<interval> stk = new Stack<interval>(); stk.Push(intervals[0]); for (int i = 1; i < intervals.Length; i++) { if (stk.Count > 0) { if (stk.Peek().end < intervals[i].start) stk.Push(intervals[i]); else if (stk.Peek().end < intervals[i].end) stk.Peek().end = intervals[i].end; else if (stk.Peek().end > intervals[i].end) continue; } else stk.Push(intervals[i]); } Console.WriteLine("\nIntervals after merging: "); while(stk.Count > 0) { interval inter = stk.Pop(); Console.WriteLine("({0}, {1})", inter.start, inter.end); } }
/// <summary> /// Initializes a new instance of the <see cref="Tetrachord"/> class. /// </summary> /// <param name="desiredChordType">Desired chord type.</param> public Tetrachord(chordType desiredChordType) { //Debug.Log ("Lower Tetra ininialized"); offset = interval.root; currentChordType = desiredChordType; //upper or lower Intervals = ChordSpellings.intervalsIn[desiredChordType]; }
/// <summary> /// Initializes a new diatonic <see cref="Note"/>. /// </summary> /// <param name="newNote">Desired Note</param> /// <param name="currentDiatonicInterval">Position in scale</param> public Note(note newNote, interval currentDiatonicInterval) { duration = Beat.quarter; key = theory.AdjustForScale(key - (int)currentDiatonicInterval); octave = 0; name = newNote.ToString() + octave.ToString(); diatonicInterval = currentDiatonicInterval; frequencyKey = GetFrequencyKey(currentDiatonicInterval); }
int IComparable.CompareTo(object obj) { interval other = obj as interval; if (other != null) { // muss ja immer sein // die Intervalle sind immer nicht überlappend return(min.CompareTo(other.min)); } return(-1); }
/// <summary> /// Adjusts for scale. /// </summary> /// <returns>The for scale.</returns> /// <param name="scalePosition">Scale position.</param> public interval AdjustForScale(interval scalePosition) { while (scalePosition > (interval)TOTAL_NOTES) { scalePosition -= TOTAL_NOTES; } while (scalePosition < 0) { scalePosition += TOTAL_NOTES; } return(scalePosition); }
/// <summary> /// Initializes an A Major scale. /// </summary> public Scale() //TODO do something about these constructors dude. { Key = note.A; ModalKey = note.A; currentMode = modes.ionian; Name = note.A.ToString() + " " + scaleType.major.ToString(); AssignUpperAndLower(ScaleBook.allScales [scaleType.major]); upperTetraOffset = upperTetra.Offset; Intervals = CombineTetrachords(lowerTetra, upperTetra, upperTetraOffset); Notes = GenerateNotes(ModalKey, Intervals); scaleSize = Intervals.Length; }
/// <summary> /// Initializes a scale by key and type, adds the id to name. /// </summary> /// <param name="inKey">Desired Key.</param> /// <param name="type">Desired Scale Type.</param> /// <param name="id">Identifier.</param> public Scale(note inKey, scaleType type, int id) { Key = inKey; ModalKey = inKey; currentMode = modes.ionian; Name = inKey.ToString() + " " + type.ToString() + " _" + id.ToString(); AssignUpperAndLower(ScaleBook.allScales [type]); upperTetraOffset = upperTetra.Offset; Intervals = CombineTetrachords(lowerTetra, upperTetra, upperTetraOffset); Notes = GenerateNotes(Key, Intervals); scaleSize = Intervals.Length; }
public static void ConjugateGradientMethod(double[] X0, ref double[] res, double intervalStep) { double[] destinationVect = new double[N]; double skalarWeight; double[] xNow = new double[N]; double[] xPrev = new double[N]; double[] gradNow = new double[N]; double[] gradPrev = new double[N]; double t = 0.0; interval inter = new interval(); for (int i = 0; i < N; i++) { X0[i] = xNow[i]; } do { //for(int l = 0; l<2000;l++){ for (int i = 0; i < N; i++) { destinationVect[i] = -xNow[i]; } for (int k = 0; k <= N; k++) { inter = Swan(0, intervalStep, xNow, destinationVect); t = GoldenMethod(inter.a, inter.b, xNow, destinationVect); Console.WriteLine("t = {0}", t); for (int i = 0; i < N; i++) { xPrev[i] = xNow[i]; xNow[i] = xPrev[i] + t * destinationVect[i]; Console.Write("X[{0}] = {1} ", i, xNow[i]); } Console.WriteLine(); gradient(xNow, ref gradNow); gradient(xPrev, ref gradPrev); skalarWeight = fletcher(gradNow, gradPrev); for (int i = 0; i < N; i++) { destinationVect[i] = -gradNow[i] + skalarWeight * destinationVect[i]; Console.Write("dest[{0}] = {1} ", i, destinationVect[i]); } Console.WriteLine(); } } while (Math.Abs(f(xNow) - f(xPrev)) / f(xNow) > eps); }
private static CallCosts CreateCallCostsRequest(string userID) { CallCosts request = new CallCosts(); // Required fields request.ItemElementName = ItemChoiceType35.userID; request.Item = userID; interval callCostsInterval = new interval(); callCostsInterval.startDate = System.DateTime.Parse("2011-03-01"); callCostsInterval.endDate = System.DateTime.Parse("2011-04-01"); request.Items = new object[] { callCostsInterval }; request.ItemsElementName = new ItemsChoiceType8[] { ItemsChoiceType8.interval }; return(request); }
public void TransposeInPlace(CollectionOfNotes originalSet, interval interval, direction direction) { note key = originalSet.Key; //Note[] notes = originalSet.Notes; //interval[] intervals = originalSet.Intervals; if (direction == direction.sharp) { key += theory.AdjustForScale((int)interval); } else { key -= theory.AdjustForScale((int)interval); } //notes = originalSet.GenerateNotes (key, intervals); originalSet.ModalKey = key; }
//http://www.geeksforgeeks.org/stock-buy-sell/ //Buy and Sell as many time as possible to get maximum profit static void N_MaxProfit(int[] prices) { int n = prices.Length; interval[] sell_buy_Pairs = new interval[(n / 2) + 1]; int c = 0; int i = 0; while (i < n - 1) { //Find local minima from i. We can go up to max n-2 becuase we are checking with next element while (i < n - 1 && prices[i + 1] <= prices[i]) { i++; } if (i == n - 1) //We reached end of the array. So, no chance of buying { break; } sell_buy_Pairs[c].Buy = i; i++; //Find next local maxima from i. We can go up to max n-1 becuase we are checking with previous element while (i < n && prices[i - 1] <= prices[i]) { i++; } sell_buy_Pairs[c].Sell = i - 1; c++; } Console.WriteLine("Here are buy and sell indices"); int totalProfit = 0; for (int k = 0; k < c; k++) { Console.WriteLine($"({k + 1}) BUY at : {prices[sell_buy_Pairs[k].Buy]} and SELL at :{prices[sell_buy_Pairs[k].Sell]} "); totalProfit += prices[sell_buy_Pairs[k].Sell] - prices[sell_buy_Pairs[k].Buy]; } Console.WriteLine($"Total Profit:{totalProfit}"); }
/// <summary> /// Combines tetrachords into a fully qualified scale /// </summary> /// <returns>The tetrachords.</returns> /// <param name="lower">Lower.</param> /// <param name="upper">Upper.</param> /// <param name="upperOffset">The distance between lower.notes[0] and upper.notes[0]</param> interval[] CombineTetrachords(Tetrachord lower, Tetrachord upper, interval upperOffset) { interval[] tempIntervals = new interval[lowerTetra.Intervals.Length + upperTetra.Intervals.Length]; for (int i = 0; i < tempIntervals.Length; i++) { int offset = i; if (offset < lowerTetra.Intervals.Length) { tempIntervals [offset] = lowerTetra.Intervals [offset]; } else { offset = i - lowerTetra.Intervals.Length; tempIntervals [i] = theory.AdjustForScale(upperTetra.Intervals [offset] + (int)upperOffset); } } Debug.Log("New Scale Size: " + tempIntervals.Length); return(tempIntervals); }
private void buttonOk_Click(object sender, EventArgs e) { try { dataGridView1.Rows.Clear(); interval x = new interval(UInt32.Parse(LeftIntBox.Text), UInt32.Parse(RightIntBox.Text)); PrimaryInInterval arg; arg.Int = x; arg.ThreadNumber = byte.Parse(StreamBox.Text); backgroundWorker1.RunWorkerAsync(arg); buttonOk.Enabled = false; } catch (Exception ex) { MessageBox.Show(ex.Message, "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error); ErrFlag = true; } }
public string AddBoldTag(string s, string[] words) { var list = new List <interval>(); var sb = new StringBuilder(); for (int i = 0; i < s.Length; i++) { foreach (string w in words) { if (s.Substring(i).StartsWith(w)) { var str = new interval(i, i + w.Length - 1); // add if (list.Count > 0 && i <= list[list.Count - 1].end + 1) { list[list.Count - 1].end = Math.Max(list[list.Count - 1].end, str.end); continue; } list.Add(str); } } } int j = 0; for (int i = 0; i < s.Length; i++) { if (j < list.Count && i == list[j].start) { sb.Append("<b>"); } sb.Append(s[i]); if (j < list.Count && i == list[j].end) { sb.Append("</b>"); j++; } } return(sb.ToString()); }
/// <summary> /// Changes the mode in place; does not transpose. /// </summary> /// <param name="newMode">DesiredMode</param> public void ChangeMode(modes newMode) //TODO this should be in TheoryManager { currentMode = newMode; Intervals = CombineTetrachords(lowerTetra, upperTetra, upperTetraOffset); //Reset the scale!! ModalKey = Key + (int)Intervals[(int)newMode]; interval[] newIntervals = new interval[scaleSize]; int offset; for (int i = 0; i < scaleSize; i++) { offset = i + (int)newMode; if (offset >= scaleSize) { offset -= scaleSize - 1; } newIntervals [i] = theory.AdjustForScale(Intervals [offset] - (int)Intervals[(int)newMode]); } newIntervals [newIntervals.Length - 1] = interval.octave; Intervals = newIntervals; Notes = GenerateNotes(ModalKey, Intervals); }
public Payment(string n, DateTime dp, int t, bool rep, interval inter, string com, double cfp, double ps, double cs) { if (Account.payments.Count == 0) { code = 0; } else { int c = 0; foreach (Payment pa in Account.payments) { if (pa.code > c) { c = pa.code; } } code = c + 1; } name = n; dayp = dp; type = t; repeated = rep; payed = false; interv = inter; if (repeated == false) { interv.days = 0; interv.month = 0; interv.years = 0; } inf.costforpoint = cfp; inf.prevstat = ps; inf.curstat = cs; cost = Math.Round(inf.costforpoint * (inf.curstat - inf.prevstat), 2); comments = com; }
//static void Main(string[] args) //{ // FindDays(new int[] { 180, 100, 260, 310, 40, 535, 600 }); //} static void FindDays(int[] arr) { int n = arr.Length; var i = 0; var solution = new List <interval>(); while (i < n - 1) { while (i < n - 1 && arr[i + 1] <= arr[i]) { i++; } if (i == n - 1) { break; } var inte = new interval(); inte.buy = i; i++; while (i < n && arr[i - 1] <= arr[i]) { i++; } inte.sell = i - 1; solution.Add(inte); } foreach (var item in solution) { Console.WriteLine(item.buy + "___" + item.sell); } }
private interval[] readTextGridIntervals(string[] lines, int iterador, int numberGrids) { interval[] res = new interval[numberGrids]; double xmin = 0; double xmax = 0; string xminString = "xmin = "; string xmaxString = "xmax = "; string intervalTextString = "text = \""; string intervalText = ""; for (int i = 0; i < numberGrids; i++) { if (System.Globalization.NumberFormatInfo.CurrentInfo.NumberDecimalSeparator.ToString().Equals(",")) { xmin = Convert.ToDouble((lines[iterador + ((i * 4) + 1)].Substring((lines[iterador + ((i * 4) + 1)].IndexOf(xminString) + xminString.Length)).Replace('.', ','))); xmax = Convert.ToDouble((lines[iterador + ((i * 4) + 2)].Substring((lines[iterador + ((i * 4) + 2)].IndexOf(xmaxString) + xmaxString.Length)).Replace('.', ','))); } else if (System.Globalization.NumberFormatInfo.CurrentInfo.NumberDecimalSeparator.ToString().Equals(".")) { xmin = Convert.ToDouble((lines[iterador + ((i * 4) + 1)].Substring((lines[iterador + ((i * 4) + 1)].IndexOf(xminString) + xminString.Length)))); xmax = Convert.ToDouble((lines[iterador + ((i * 4) + 2)].Substring((lines[iterador + ((i * 4) + 2)].IndexOf(xmaxString) + xmaxString.Length)))); } intervalText = lines[iterador + ((i * 4) + 3)].Substring((lines[iterador + ((i * 4) + 3)].IndexOf(intervalTextString) + intervalTextString.Length)); intervalText = intervalText.Substring(0, intervalText.Length - 1); intervalText = intervalText.Replace("\" ",""); res[i] = new interval(xmin, xmax, intervalText); } return res; }
private string calculateRMS( interval[] uncorrected, interval[] corrected, string tagType, string tagTypeNum ) { string outputLine = ""; string[] previousPhone = new string[uncorrected.Length]; string[] followingPhone = new string[uncorrected.Length]; //string[] previousWord = new string[uncorrected.Length]; //string[] followingWord = new string[uncorrected.Length]; double[] diffStartPhonemes = new double[uncorrected.Length]; double[] rmsDiffStartPhonemes = new double[uncorrected.Length]; double[] diffEndPhonemes = new double[uncorrected.Length]; double[] rmsDiffEndPhonemes = new double[uncorrected.Length]; double tempDiffStart = 0; double tempRMSDiffStart = 0; double tempDiffEnd = 0; double tempRMSDiffEnd = 0; double uncorrLen = 0; double corrLen = 0; double diffLen = 0; double RMSdiffLen = 0; String textOfTheGrid = ""; for (int i = 0; i < uncorrected.Length; i++) { textOfTheGrid = uncorrected[i].text.Replace("\"", ""); textOfTheGrid = textOfTheGrid.TrimEnd(' '); Console.WriteLine(textOfTheGrid); Console.WriteLine(uncorrected[i].text); if (textOfTheGrid.Equals("sp") == false && textOfTheGrid.Equals("_") ==false && textOfTheGrid.Equals("") == false) { tempDiffStart = corrected[i].xmin - uncorrected[i].xmin; tempRMSDiffStart = Math.Sqrt(Math.Pow(tempDiffStart, 2)); diffStartPhonemes[i] = tempDiffStart; rmsDiffStartPhonemes[i] = tempRMSDiffStart; tempDiffEnd = corrected[i].xmax - uncorrected[i].xmax; tempRMSDiffEnd = Math.Sqrt(Math.Pow(tempDiffEnd, 2)); diffEndPhonemes[i] = tempDiffEnd; rmsDiffEndPhonemes[i] = tempRMSDiffEnd; uncorrLen = uncorrected[i].xmax - uncorrected[i].xmin; corrLen = corrected[i].xmax - corrected[i].xmin; diffLen = uncorrLen - corrLen; RMSdiffLen = Math.Sqrt(Math.Pow(diffLen, 2)); if (i != 0) { previousPhone[i] = corrected[i - 1].text; } else { previousPhone[i] = ""; } if ((i + 1) != uncorrected.Length) { followingPhone[i] = corrected[i + 1].text; } else { followingPhone[i] = ""; } outputLine += corrected[i].text.Replace("\"","") + "\t"; outputLine += tagType + "\t"; outputLine += tagTypeNum + "\t"; outputLine += (i+1).ToString() + "\t"; /*Console.WriteLine("El texto corregido es: " + corrected[i].text); Console.WriteLine("I es: " + i.ToString()); Console.WriteLine("La longitud del vector previousPhone es: " + previousPhone.Length.ToString()); Console.WriteLine("La segunda línea es: " + previousPhone[1]); Console.WriteLine("La primera línea es: " + previousPhone[0]);*/ outputLine += previousPhone[i].Replace("\"","") + "\t"; outputLine += followingPhone[i].Replace("\"", "") + "\t"; outputLine += uncorrected[i].xmin.ToString() + "\t"; outputLine += corrected[i].xmin.ToString() + "\t"; outputLine += tempDiffStart.ToString() + "\t"; outputLine += tempRMSDiffStart.ToString() + "\t"; outputLine += tempRMSDiffStart / uncorrLen + "\t"; outputLine += uncorrected[i].xmax.ToString() + "\t"; outputLine += corrected[i].xmax.ToString() + "\t"; outputLine += tempDiffEnd.ToString() + "\t"; outputLine += tempRMSDiffEnd.ToString() + "\t"; outputLine += tempRMSDiffEnd / uncorrLen + "\t"; outputLine += uncorrLen.ToString() + "\t"; outputLine += corrLen.ToString() + "\t"; outputLine += diffLen.ToString() + "\t"; outputLine += RMSdiffLen.ToString() + "\t"; outputLine += RMSdiffLen / uncorrLen + "\r\n"; } } return outputLine; }
private string printPraatIntervalsFromLists(int numberRows, List<interval> items) { string res = ""; interval[] temp = new interval[items.Count]; for ( int i = 0; i < items.Count; i++ ) { temp[i] = items[i]; } res = printPraatIntervals(numberRows, temp); return res; }
public void Transpose(Scale managedScale, interval transVal, direction dir) { transposeOffset += (int)transVal; TransposeInPlace(managedScale, transVal, dir); FrequencyManager.AssignFrequencyKeys(managedScale, transposeOffset); }
private string printPraatIntervals(int numberRows, interval[] items) { string res = ""; for (int i = 0; i < numberRows; i++) { res += "\t\t\t" + "intervals [" + (i + 1).ToString() + "]:\n"; res += "\t\t\t\t" + "xmin = " + items[i].xmin.ToString().Replace(',', '.') + "\n"; res += "\t\t\t\t" + "xmax = " + items[i].xmax.ToString().Replace(',', '.') + "\n"; res += "\t\t\t\t" + "text = \"" + items[i].text + "\"\n"; } return res; }
static void ConjugateGradient(double[] X0, ref double[] res, double tau) { double[] gradFNow = new double[N]; double[] result = new double[N]; double[] xNow = new double[N]; double[] xPrev = new double[N]; double t = 0; double[] grDirection = new double[N]; double[] grDirectionPrev = new double[N]; double[] gradFPrev = new double[N]; double grBk; double count = 0; int k = 0; for (int i = 0; i < N; i++) { xNow[i] = X0[i]; } //for(int s = 0; s< 1000; s++) do { gradient(xNow, ref gradFNow); //****************************** if (k == N || k == 0) { for (int i = 0; i < N; i++) { grDirection[i] = -gradFNow[i]; } k = 0; } else { for (int i = 0; i < N; i++) { grDirectionPrev[i] = grDirection[i]; } gradient(xPrev, ref gradFPrev); grBk = fletcher(gradFNow, gradFPrev); direction(gradFNow, grDirectionPrev, grBk, ref grDirection); } //**************************************** interval segment = Swan(0, tau, xNow, grDirection); double ser = (segment.b + segment.a) / 2; t = GoldenMethod(segment.a, segment.b, xNow, grDirection); Console.WriteLine("a = {0}, b = {1}, t = {2}", segment.a, segment.b, t); for (int i = 0; i < N; i++) { xPrev[i] = xNow[i]; } for (int i = 0; i < N; i++) { xNow[i] = xPrev[i] + t * grDirection[i]; Console.Write("xNow {0} ", xNow[i]); } Console.WriteLine(); Console.WriteLine("F = {0} ", Math.Round(f(xNow), 6, MidpointRounding.AwayFromZero)); k++; count++; //проверка на возрастание /*if(f(xNow) > f(xPrev)){ * Console.WriteLine("Функция возрастает"); * break; * }*/ } //while (Math.Abs(f(xNow) -f(xPrev))>=eps); while (Math.Abs(f(xNow) - f(xPrev)) / f(xNow) > eps); Console.WriteLine(count); for (int i = 0; i < N; i++) { res[i] = xNow[i]; } }
int GetFrequencyKey(interval intervalToGrab) { return((int)intervalToGrab + (octave * Theory.TOTAL_NOTES)); }
public readTextGrid(interval[] inPhonemes, interval[] inWords, string inPhonemeHeader, string inWordHeader) { phonemes = inPhonemes; words = inWords; phonemeHeader = inPhonemeHeader; wordHeader = inWordHeader; }
this.Change(ref interval, value);
private string convertDataGrid(string fileTextGrid, string fileDictionary) { string res = ""; int iterador = 0; string intervalString = "intervals: size = "; string textGridPhonemesHeader = ""; string textGridWordsHeader = ""; // Codificaciones: https://msdn.microsoft.com/en-us/library/windows/desktop/dd317756(v=vs.85).aspx int fileEncodingDictionary = 1252; string text = File.ReadAllText(fileTextGrid); string[] lines = text.Split('\n'); //------------------------------------------------------------ // Primero, voy a construir el diccionario. Este contiene // las palabras en ortografía normal, en arpabet, y en // los fonos que queremos en el textGrid //------------------------------------------------------------ string dictText = File.ReadAllText(fileDictionary, Encoding.GetEncoding(fileEncodingDictionary)); string[] dictLines = dictText.Split('\n'); string[] dictTabElements; dictWord[] dictionary = new dictWord[dictLines.Length]; for (int i = 0; i < dictLines.Length; i++) { dictTabElements = dictLines[i].Split('\t'); dictionary[i] = new dictWord(dictTabElements[0], dictTabElements[1], dictTabElements[2].Trim('\n', '\r')); } //------------------------------------------------------------ // Luego, voy a construir dos listas, una que contenga // la información de los intervalos que contienen fonemas, // y otra que contenga la información de los intervalos // que contienen palabras //------------------------------------------------------------ while (lines[iterador].Contains(intervalString) == false) { textGridPhonemesHeader += lines[iterador] + "\n"; iterador++; } textGridPhonemesHeader += lines[iterador] + "\n"; // Ver cuántos fonos hay en el textGrid //Console.WriteLine(lines[iterador]); string stringNumberGridsInFirstRow = lines[iterador].Substring((lines[iterador].IndexOf(intervalString) + intervalString.Length)); int numberGridsInFirstRow = Convert.ToInt16(stringNumberGridsInFirstRow); // Construir la lista de intervalos para los fonemas interval[] phonemes = new interval[numberGridsInFirstRow]; iterador = iterador + 1; phonemes = readTextGridIntervals(lines, iterador, numberGridsInFirstRow); Console.WriteLine(phonemes.Length.ToString()); // Construir la lista de intervalos para las palabras // Encontrar la línea que marca el inicio de los intervalos // que contienen las palabras iterador = iterador + numberGridsInFirstRow * 4; while (lines[iterador].Contains(intervalString) == false) { //Console.WriteLine(iterador.ToString()); textGridWordsHeader += lines[iterador] + "\n"; iterador++; } textGridWordsHeader += lines[iterador] + "\n"; // Ver cuántos fonos hay en el textGrid //Console.WriteLine(lines[iterador]); string stringNumberGridsInSecondRow = lines[iterador].Substring((lines[iterador].IndexOf(intervalString) + intervalString.Length)); int numberGridsInSecondRow = Convert.ToInt16(stringNumberGridsInSecondRow); // Leer el TextGrid para extraer las palabras interval[] words = new interval[numberGridsInSecondRow]; iterador = iterador + 1; words = readTextGridIntervals(lines, iterador, numberGridsInSecondRow); Console.WriteLine(words[0].xmin.ToString()); Console.WriteLine(words[0].xmax.ToString()); Console.WriteLine(words.Length.ToString()); //------------------------------------------------------------ //------------------------------------------------------------ // para cada palabra, buscar todos los fonemas que están dentro de ese índice de tiempo // buscar los índices de tiempo en los que ocurre una palabra (puede ocurrir varias veces en el texto) double currentWordXmin = 0; double currentWordXmax = 0; string currentWord = ""; string[] currentWordOutputVector = new string[0]; string currentWordJoinedArpabet = ""; string iteratingWordJoinedArpabet = ""; List <int> intervalPosition = new List <int>(); for (int i = 0; i < numberGridsInSecondRow; i++) { if (words[i].text.Equals("sp") == false) { intervalPosition = new List <int>(); currentWordOutputVector = new string[0]; iteratingWordJoinedArpabet = ""; currentWord = words[i].text; currentWordXmin = words[i].xmin; currentWordXmax = words[i].xmax; /*Console.WriteLine("este es el diccionario"); * for (int j = 0; j < dictionary.Length; j++) { * Console.WriteLine(dictionary[j].word + " - " + dictionary[j].wordArpabet + " - " + dictionary[j].wordOutput); * } * Console.WriteLine("-----------------------");*/ // Encontrar la palabra en el diccionario for (int j = 0; j < dictionary.Length; j++) { if (dictionary[j].word.ToLower().Equals(currentWord.ToLower()) == true) { currentWordOutputVector = dictionary[j].outputLetters; currentWordJoinedArpabet = dictionary[j].wordArpabet; } } // Encontrar los índices de los intervalos que corresponden a los // fonemas de la palabra actual for (int j = 0; j < numberGridsInFirstRow; j++) { if (phonemes[j].xmin >= currentWordXmin && phonemes[j].xmax <= currentWordXmax) { intervalPosition.Add(j); iteratingWordJoinedArpabet += phonemes[j].text; } } // cambiar las letras arpabet en eltextgrid por las letras que queremos if (currentWordJoinedArpabet.ToLower().Equals(iteratingWordJoinedArpabet.ToLower()) == true && currentWordOutputVector.Length == intervalPosition.Count) { for (int j = 0; j < intervalPosition.Count; j++) { phonemes[intervalPosition[j]].text = currentWordOutputVector[j]; } } else { Console.Write("Hubo un error al tratar de alinear " + currentWord + "porque "); if (currentWordJoinedArpabet.Equals(iteratingWordJoinedArpabet) == false) { Console.Write(" la palabra arpabet ( " + currentWordJoinedArpabet + " ) no es igual a la palabra actual (" + iteratingWordJoinedArpabet + ")\n"); } /*if (currentWordOutputVector.Length != intervalPosition.Count) { * Console.Write(" las palabras tienen diferente número de letras\n"); * }*/ } } } res = textGridPhonemesHeader; // Construir los intervalos de los fonemas for (int i = 0; i < numberGridsInFirstRow; i++) { res += "\t\t\t" + "intervals [" + (i + 1).ToString() + "]:\n"; res += "\t\t\t\t" + "xmin = " + phonemes[i].xmin.ToString().Replace(',', '.') + "\n"; res += "\t\t\t\t" + "xmax = " + phonemes[i].xmax.ToString().Replace(',', '.') + "\n"; res += "\t\t\t\t" + "text = \"" + phonemes[i].text + "\"\n"; } res += textGridWordsHeader; for (int i = 0; i < numberGridsInSecondRow; i++) { res += "\t\t\t" + "intervals [" + (i + 1).ToString() + "]:\n"; res += "\t\t\t\t" + "xmin = " + words[i].xmin.ToString().Replace(',', '.') + "\n"; res += "\t\t\t\t" + "xmax = " + words[i].xmax.ToString().Replace(',', '.') + "\n"; res += "\t\t\t\t" + "text = \"" + words[i].text + "\"\n"; } //Console.WriteLine(res); return(res); }
private string processRMS(string uncorrectedGrid, string correctedGrid) { Console.WriteLine("entré a procesar RMS"); string res = ""; int iterador = 0; string intervalString = "intervals: size = "; string text = File.ReadAllText(uncorrectedGrid); string[] lines = text.Split('\n'); //------------------------------------------------------------ // Voy a construir dos listas, una que contenga // la información de los intervalos que contienen fonemas, // y otra que contenga la información de los intervalos // que contienen palabras //------------------------------------------------------------ while (lines[iterador].Contains(intervalString) == false) { iterador++; } Console.WriteLine("voy a ver cuántos fonos hay en el textgrid"); // Ver cuántos fonos hay en el textGrid string stringNumberGridsInFirstRow = lines[iterador].Substring((lines[iterador].IndexOf(intervalString) + intervalString.Length)); int numberGridsInFirstRow = Convert.ToInt16(stringNumberGridsInFirstRow); // Construir la lista de intervalos para los fonemas interval[] uncorrectedPhonemes = new interval[numberGridsInFirstRow]; iterador = iterador + 1; uncorrectedPhonemes = readTextGridIntervals(lines, iterador, numberGridsInFirstRow); // Construir la lista de intervalos para las palabras iterador = iterador + numberGridsInFirstRow * 4; while (lines[iterador].Contains(intervalString) == false) { iterador++; } // Ver cuántos fonos hay en el textGrid string stringNumberGridsInSecondRow = lines[iterador].Substring((lines[iterador].IndexOf(intervalString) + intervalString.Length)); int numberGridsInSecondRow = Convert.ToInt16(stringNumberGridsInSecondRow); // Leer el TextGrid para extraer las palabras interval[] uncorrectedWords = new interval[numberGridsInSecondRow]; iterador = iterador + 1; uncorrectedWords = readTextGridIntervals(lines, iterador, numberGridsInSecondRow); //------------------------------------------------------------ // Leer la lista de palabras corregidas //------------------------------------------------------------ iterador = 0; text = File.ReadAllText(correctedGrid); lines = text.Split('\n'); while (lines[iterador].Contains(intervalString) == false) { iterador++; } // Ver cuántos fonos hay en el textGrid stringNumberGridsInFirstRow = lines[iterador].Substring((lines[iterador].IndexOf(intervalString) + intervalString.Length)); numberGridsInFirstRow = Convert.ToInt16(stringNumberGridsInFirstRow); // Construir la lista de intervalos para los fonemas interval[] correctedPhonemes = new interval[numberGridsInFirstRow]; iterador = iterador + 1; correctedPhonemes = readTextGridIntervals(lines, iterador, numberGridsInFirstRow); // Construir la lista de intervalos para las palabras iterador = iterador + numberGridsInFirstRow * 4; while (lines[iterador].Contains(intervalString) == false) { iterador++; } // Ver cuántos fonos hay en el textGrid stringNumberGridsInSecondRow = lines[iterador].Substring((lines[iterador].IndexOf(intervalString) + intervalString.Length)); numberGridsInSecondRow = Convert.ToInt16(stringNumberGridsInSecondRow); // Leer el TextGrid para extraer las palabras interval[] correctedWords = new interval[numberGridsInSecondRow]; iterador = iterador + 1; correctedWords = readTextGridIntervals(lines, iterador, numberGridsInSecondRow); if (uncorrectedPhonemes.Length == correctedPhonemes.Length && uncorrectedWords.Length == correctedWords.Length) { Console.WriteLine("todos los vectores son del mismo tamaño"); string header = ""; header += "textoIntervalo\t"; header += "tipoIntervalo\t"; header += "tipoIntervaloNum\t"; header += "numIntervalo\t"; header += "inicioAuto\t"; header += "inicioCorr\t"; header += "difInicio\t"; header += "difInicioRMS\t"; header += "difInicioPorciento\t"; header += "finalAuto\t"; header += "finalCorr\t"; header += "difFinal\t"; header += "difFinalRMS\t"; header += "difFinalPorciento\t"; header += "tamañoAuto\t"; header += "tamañoCorr\t"; header += "difTamaño\t"; header += "difTamañoRMS\t"; header += "difTamañoPorciento\r\n"; res += header; res += calculateRMS(uncorrectedPhonemes, correctedPhonemes, "fonema", "1"); res += calculateRMS(uncorrectedWords, correctedWords, "palabra", "2"); } else { MessageBox.Show("Los dos TextGrids no tienen el mismo contenido. No se puede calcular la comparación."); } return(res); }
await Task.Delay(interval ?? TimeSpan.FromMilliseconds(1));
private readTextGrid processPhonemesWords(string fileTextGrid) { int iterador = 0; string intervalString = "intervals: size = "; string textGridPhonemesHeader = ""; string textGridWordsHeader = ""; string text = File.ReadAllText(fileTextGrid); string[] lines = text.Split('\n'); while (lines[iterador].Contains(intervalString) == false) { textGridPhonemesHeader += lines[iterador] + "\n"; iterador++; } textGridPhonemesHeader += lines[iterador] + "\n"; // Ver cuántos fonos hay en el textGrid //Console.WriteLine(lines[iterador]); string stringNumberGridsInFirstRow = lines[iterador].Substring((lines[iterador].IndexOf(intervalString) + intervalString.Length)); int numberGridsInFirstRow = Convert.ToInt16(stringNumberGridsInFirstRow); // Construir la lista de intervalos para los fonemas interval[] phonemes = new interval[numberGridsInFirstRow]; iterador = iterador + 1; phonemes = readTextGridIntervals(lines, iterador, numberGridsInFirstRow); Console.WriteLine(phonemes.Length.ToString()); // Construir la lista de intervalos para las palabras // Encontrar la línea que marca el inicio de los intervalos // que contienen las palabras iterador = iterador + numberGridsInFirstRow * 4; while (lines[iterador].Contains(intervalString) == false) { //Console.WriteLine(iterador.ToString()); textGridWordsHeader += lines[iterador] + "\n"; iterador++; } textGridWordsHeader += lines[iterador] + "\n"; // Ver cuántos fonos hay en el textGrid //Console.WriteLine(lines[iterador]); string stringNumberGridsInSecondRow = lines[iterador].Substring((lines[iterador].IndexOf(intervalString) + intervalString.Length)); int numberGridsInSecondRow = Convert.ToInt16(stringNumberGridsInSecondRow); // Leer el TextGrid para extraer las palabras interval[] words = new interval[numberGridsInSecondRow]; iterador = iterador + 1; words = readTextGridIntervals(lines, iterador, numberGridsInSecondRow); readTextGrid retItems = new readTextGrid(phonemes, words, textGridPhonemesHeader, textGridWordsHeader); return retItems; }
private string processRMS(string uncorrectedGrid, string correctedGrid) { string res = ""; int iterador = 0; string intervalString = "intervals: size = "; string text = File.ReadAllText(uncorrectedGrid); string[] lines = text.Split('\n'); //------------------------------------------------------------ // Voy a construir dos listas, una que contenga // la información de los intervalos que contienen fonemas, // y otra que contenga la información de los intervalos // que contienen palabras //------------------------------------------------------------ while (lines[iterador].Contains(intervalString) == false) { iterador++; } // Ver cuántos fonos hay en el textGrid string stringNumberGridsInFirstRow = lines[iterador].Substring((lines[iterador].IndexOf(intervalString) + intervalString.Length)); int numberGridsInFirstRow = Convert.ToInt16(stringNumberGridsInFirstRow); // Construir la lista de intervalos para los fonemas interval[] uncorrectedPhonemes = new interval[numberGridsInFirstRow]; iterador = iterador + 1; uncorrectedPhonemes = readTextGridIntervals(lines, iterador, numberGridsInFirstRow); // aquí ocupo avanzar tantos intervalos como tenga que para llegar a las palabras iterador = iterador + numberGridsInFirstRow * 4; // seguir pasando hasta encontrarse con item [X]: // Construir la lista de intervalos para las palabras String rowItemString = "item ["+txt_wordRow.Text.ToString()+"]"; Console.WriteLine(lines[iterador]); Console.WriteLine(rowItemString); while (lines[iterador].Contains(rowItemString) == false) { iterador++; } // Construir la lista de intervalos para las palabras while (lines[iterador].Contains(intervalString) == false) { iterador++; } // Ver cuántas palabras hay en el textGrid string stringNumberGridsInSecondRow = lines[iterador].Substring((lines[iterador].IndexOf(intervalString) + intervalString.Length)); int numberGridsInSecondRow = Convert.ToInt16(stringNumberGridsInSecondRow); // Leer el TextGrid para extraer las palabras interval[] uncorrectedWords = new interval[numberGridsInSecondRow]; iterador = iterador + 1; uncorrectedWords = readTextGridIntervals(lines, iterador, numberGridsInSecondRow); //------------------------------------------------------------ // Leer la lista de palabras corregidas //------------------------------------------------------------ iterador = 0; text = File.ReadAllText(correctedGrid); lines = text.Split('\n'); while (lines[iterador].Contains(intervalString) == false) { iterador++; } // Ver cuántos fonos hay en el textGrid stringNumberGridsInFirstRow = lines[iterador].Substring((lines[iterador].IndexOf(intervalString) + intervalString.Length)); numberGridsInFirstRow = Convert.ToInt16(stringNumberGridsInFirstRow); // Construir la lista de intervalos para los fonemas interval[] correctedPhonemes = new interval[numberGridsInFirstRow]; iterador = iterador + 1; correctedPhonemes = readTextGridIntervals(lines, iterador, numberGridsInFirstRow); // Construir la lista de intervalos para las palabras iterador = iterador + numberGridsInFirstRow * 4; // seguir pasando hasta encontrarse con item [X]: Console.WriteLine(lines[iterador]); Console.WriteLine(rowItemString); while (lines[iterador].Contains(rowItemString) == false) { iterador++; } while (lines[iterador].Contains(intervalString) == false) { iterador++; } // Ver cuántos fonos hay en el textGrid stringNumberGridsInSecondRow = lines[iterador].Substring((lines[iterador].IndexOf(intervalString) + intervalString.Length)); numberGridsInSecondRow = Convert.ToInt16(stringNumberGridsInSecondRow); // Leer el TextGrid para extraer las palabras interval[] correctedWords = new interval[numberGridsInSecondRow]; iterador = iterador + 1; correctedWords = readTextGridIntervals(lines, iterador, numberGridsInSecondRow); if (uncorrectedPhonemes.Length == correctedPhonemes.Length && uncorrectedWords.Length == correctedWords.Length) { Console.WriteLine("todos los vectores son del mismo tamaño"); string header = ""; header += "textoIntervalo\t"; header += "tipoIntervalo\t"; header += "tipoIntervaloNum\t"; header += "numIntervalo\t"; header += "fonoPrevio\t"; header += "fonoSiguiente\t"; header += "inicioAuto\t"; header += "inicioCorr\t"; header += "difInicio\t"; header += "difInicioRMS\t"; header += "difInicioPorciento\t"; header += "finalAuto\t"; header += "finalCorr\t"; header += "difFinal\t"; header += "difFinalRMS\t"; header += "difFinalPorciento\t"; header += "tamañoAuto\t"; header += "tamañoCorr\t"; header += "difTamaño\t"; header += "difTamañoRMS\t"; header += "difTamañoPorciento\r\n"; res += header; res += calculateRMS(uncorrectedPhonemes, correctedPhonemes, "fonema", "1"); res += calculateRMS(uncorrectedWords, correctedWords, "palabra", "2"); } else { MessageBox.Show("Los dos TextGrids no tienen el mismo contenido. No se puede calcular la comparación:\n"+uncorrectedPhonemes.Length.ToString()+"!="+correctedPhonemes.Length.ToString()+"\n"+uncorrectedWords.Length+"!="+correctedWords.Length); } return res; }
private string generarTextGridNasal(string filename) { string res = ""; //------------------------------------------------------------------------- // Primer paso: construir una lista de todos los intervalos de fonemas, // y de la palabra correspondiente a cada intervalo //------------------------------------------------------------------------- readTextGrid filecontents = processPhonemesWords(filename); interval[] phonemes = filecontents.phonemes; interval[] words = filecontents.words; string textGridPhonemesHeader = filecontents.phonemeHeader; string textGridWordsHeader = filecontents.wordHeader; int numberGridsInFirstRow = phonemes.Count(); int numberGridsInSecondRow = words.Count(); List<string> wordsInNasalWordTier = new List<string>(); string tempPalabra = ""; for ( int i = 0; i < phonemes.Count(); i++ ) { for ( int j = 0; j < words.Count(); j++ ) { if ( tempPalabra == "" && phonemes[i].xmin >= words[j].xmin && phonemes[i].xmax <= words[j].xmax ) { tempPalabra = words[j].text; } } wordsInNasalWordTier.Add(tempPalabra); tempPalabra = ""; } //---------------------------------------------------------------------------- // Segundo, construir una nueva lista de intervalos, en la que solo aparezcan // vocales y espacios en blanco //---------------------------------------------------------------------------- List<interval> nasalPhonemes = new List<interval>(); List<interval> nasalWords = new List<interval>(); interval tempIntervalo = new interval(); double tempXMin = 0; double tempXMax = 0; string tempTexto = ""; int salirDelCicloConsonantes = 0; int intervalosALaDerechaDelIterador = 1; for ( int i = 0; i < phonemes.Count(); i++ ) { if (tipoLetraMephaa(phonemes[i].text) == "vocal") { nasalPhonemes.Add(phonemes[i]); //Console.WriteLine("1. " + phonemes[i].xmin.ToString() + "\t-\t" + phonemes[i].text); } else { if ( i+1 < phonemes.Count() ) { if (tipoLetraMephaa(phonemes[i + intervalosALaDerechaDelIterador].text) == "vocal") { tempIntervalo = new interval(phonemes[i].xmin, phonemes[i].xmax, ""); nasalPhonemes.Add(tempIntervalo); //Console.WriteLine("2. " + phonemes[i].xmin.ToString() + "\t-\t" + phonemes[i].xmax.ToString() + "\t-\t" + phonemes[i].text); } else { tempXMin = phonemes[i].xmin; tempXMax = phonemes[i].xmax; intervalosALaDerechaDelIterador++; while ( salirDelCicloConsonantes == 0 && i+ intervalosALaDerechaDelIterador < phonemes.Count()) { if (tipoLetraMephaa(phonemes[i + intervalosALaDerechaDelIterador].text) == "vocal") { tempXMax = phonemes[i + intervalosALaDerechaDelIterador - 1].xmax; tempIntervalo = new interval(tempXMin, tempXMax, ""); nasalPhonemes.Add(tempIntervalo); salirDelCicloConsonantes = 1; //Console.WriteLine("3. " + tempXMin.ToString() + "\t-\t" + tempXMax.ToString()); } else { intervalosALaDerechaDelIterador++; } } i = i + intervalosALaDerechaDelIterador - 1; salirDelCicloConsonantes = 0; intervalosALaDerechaDelIterador = 1; } } else { // intervalo final, y si llegué aquí es pq el intervalo final no es una vocal tempIntervalo = new interval(phonemes[i].xmin, phonemes[i].xmax, ""); nasalPhonemes.Add(tempIntervalo); //Console.WriteLine("**** topé con el intervalo final **** "); } } } tempIntervalo = new interval(nasalPhonemes[nasalPhonemes.Count()-1].xmax, phonemes[phonemes.Count() - 1].xmax, ""); nasalPhonemes.Add(tempIntervalo); //---------------------------------------------------------------------------- // Tercero, construir una nueva de lista de intervalos, basada en la anterior // en la que solo aparezcan palabras y espacios en blanco //---------------------------------------------------------------------------- string tempPalabraNasal = ""; for ( int i = 0; i < nasalPhonemes.Count(); i++ ) { tempPalabraNasal = ""; if (nasalPhonemes[i].text != "" ) { for (int j = 0; j < words.Count(); j++) { if (nasalPhonemes[i].xmin >= words[j].xmin && nasalPhonemes[i].xmax <= words[j].xmax) { tempPalabraNasal = words[j].text; } } } nasalWords.Add(new interval(nasalPhonemes[i].xmin, nasalPhonemes[i].xmax, tempPalabraNasal)); } //---------------------------------------------------------------------------- // Cuarto, formatear estas dos listas como un TextGrid de Praat //---------------------------------------------------------------------------- string newHeader = "File type = \"ooTextFile\"\r"; newHeader += "Object class = \"TextGrid\"\r"; newHeader += "xmin = 0\r"; newHeader += "xmax = " + (phonemes[phonemes.Count() - 1].xmax).ToString().Replace(',', '.') + "\r"; newHeader += "tiers? <exists>\r"; newHeader += "size = 2\r"; newHeader += "item []:\r"; newHeader += "\titem [1]:\r"; newHeader += "\t\tclass = \"IntervalTier\"\r"; newHeader += "\t\tname = \"phon\"\r"; newHeader += "\t\txmin = 0\r"; newHeader += "\t\txmax = " + (phonemes[phonemes.Count() - 1].xmax).ToString().Replace(',', '.') + "\r"; newHeader += "\tintervals: size = "+nasalPhonemes.Count()+"\r"; string newWordHeader = "\titem [2]:\r"; newWordHeader += "\t\tclass = \"IntervalTier\"\r"; newWordHeader += "\t\tname = \"word\"\r"; newWordHeader += "\t\txmin = 0\r"; newWordHeader += "\t\txmax = " + (phonemes[phonemes.Count() - 1].xmax).ToString().Replace(',', '.') + "\r"; newWordHeader += "\tintervals: size = " + nasalPhonemes.Count() + "\r"; res = newHeader; res += printPraatIntervalsFromLists(nasalPhonemes.Count(), nasalPhonemes); res += newWordHeader; res += printPraatIntervalsFromLists(nasalWords.Count(), nasalWords); //Console.WriteLine(res); return res; }