/// <summary>
        /// Get word text for number domain.
        /// </summary>
        /// <param name="word">Given ScriptWord.</param>
        /// <param name="sentenceId">Sentence Id.</param>
        /// <param name="wordIndex">Word index.</param>
        /// <param name="digitals">Digital words.</param>
        /// <returns>Word text.</returns>
        private static string GetNumberDomainWordText(ScriptWord word, string sentenceId,
            int wordIndex, Dictionary<string, DigitalWordItem> digitals)
        {
            string text = word.Grapheme.ToUpperInvariant();

            string key = DigitalWordItem.GetKey(sentenceId, wordIndex);
            if (digitals.ContainsKey(key))
            {
                text += "@" + digitals[key].Group.ToString(System.Globalization.CultureInfo.InvariantCulture);
            }
            else
            {
                if (word.Break > TtsBreak.Word)
                {
                    text += "#3";
                }
                else
                {
                    text += "#1";
                }
            }

            return text;
        }
示例#2
0
        /// <summary>
        /// Calculate PosInSentence feature for a given word
        /// Change it to public for code re-use in script sentence.
        /// </summary>
        /// <param name="preWord">Previous word of target word to calculate.</param>
        /// <param name="word">Target word to calculate.</param>
        /// <returns>PosInSentence feature.</returns>
        public static PosInSentence CalculatePosInSentence(ScriptWord preWord, ScriptWord word)
        {
            int row = (int)((preWord == null) ? TtsBreak.Sentence : preWord.Break) - (int)TtsBreak.Word;
            int column = (int)word.Break - (int)TtsBreak.Word;

            // #0, a word is connected with the word following it. Like the liason in French
            // Here treat it as word boundary
            column = column < 0 ? 0 : column;
            row = row < 0 ? 0 : row;

            PosInSentence pis = _posInSentenceTrans[row][column];

            return pis;
        }
示例#3
0
        /// <summary>
        /// Get script words from utterance.
        /// </summary>
        /// <param name="utt">Utterance.</param>
        /// <param name="isOovWord">Return whether each word is oov.</param>
        /// <returns>Script words.</returns>
        public Collection<ScriptWord> GetScriptWords(SP.TtsUtterance utt, Collection<bool> isOovWord)
        {
            if (utt == null)
            {
                throw new ArgumentNullException("utt");
            }

            Collection<ScriptWord> words = new Collection<ScriptWord>();
            for (int i = 0; i < utt.Words.Count; ++i)
            {
                SP.TtsWord word = utt.Words[i];
                if (IsCommonWord(word))
                {
                    ScriptWord scriptWord = new ScriptWord();

                    // Currently runtime will append a punctuation word for the sentence that has no 
                    // punctuation at the end.
                    if (string.IsNullOrEmpty(word.WordText) && (i == utt.Words.Count - 1) &&
                        word.WordType == SP.TtsWordType.WT_PUNCTUATION)
                    {
                        // Don't add the word to keep consistence with original input text.
                        continue;
                    }

                    scriptWord.Grapheme = word.WordText;
                    if (!string.IsNullOrEmpty(word.Pronunciation))
                    {
                        scriptWord.Pronunciation = word.Pronunciation.ToLowerInvariant();
                    }

                    ushort posTaggerPos = _engine.PosTable.GetPOSTaggerPOS(checked((ushort)word.Pos));
                    scriptWord.PosString = _engine.PosTable.IdToString(posTaggerPos);
                    scriptWord.DetailedPosString = _engine.PosTable.IdToString(checked((ushort)word.Pos));
                    scriptWord.NETypeText = word.NETypeText;
                    scriptWord.OffsetInString = (int)word.TextOffset;
                    scriptWord.LengthInString = (int)word.TextLength;
                    scriptWord.PronSource = (TtsPronSource)word.PronSource;
                    scriptWord.RegularText = word.WordRegularText;

                    switch (word.WordType)
                    {
                        case SP.TtsWordType.WT_NORMAL:
                        case SP.TtsWordType.WT_SPELLOUT:
                            scriptWord.WordType = WordType.Normal;
                            break;
                        case SP.TtsWordType.WT_PUNCTUATION:
                            scriptWord.WordType = WordType.Punctuation;
                            break;
                    }

                    switch (word.Emphasis)
                    {
                        case SP.TtsEmphasis.EMPH_YES:
                            scriptWord.Emphasis = TtsEmphasis.Yes;
                            break;
                        case SP.TtsEmphasis.EMPH_NONE:
                            scriptWord.Emphasis = TtsEmphasis.None;
                            break;
                    }

                    switch (word.BreakLevel)
                    {
                        case SP.TtsBreakLevel.BK_IDX_SYLLABLE:
                            scriptWord.Break = TtsBreak.Syllable;
                            break;
                        case SP.TtsBreakLevel.BK_IDX_INTERM_PHRASE:
                            scriptWord.Break = TtsBreak.InterPhrase;
                            break;
                        case SP.TtsBreakLevel.BK_IDX_INTONA_PHRASE:
                            scriptWord.Break = TtsBreak.IntonationPhrase;
                            break;
                        case SP.TtsBreakLevel.BK_IDX_SENTENCE:
                            scriptWord.Break = TtsBreak.Sentence;
                            break;
                    }

                    if (word.ToBIFinalBoundaryTone != (uint)TtsTobiBoundary.NoBoundaryTone)
                    {
                        Offline.TtsTobiBoundaryToneSet boundarySet = new Offline.TtsTobiBoundaryToneSet();
                        scriptWord.TobiFinalBoundaryTone = TobiLabel.Create(boundarySet.IdItems[(uint)word.ToBIFinalBoundaryTone]);
                    }

                    words.Add(scriptWord);
                    isOovWord.Add(IsOov(word));
                }
            }

            return words;
        }
        /// <summary>
        /// Dump the data in the words.
        /// </summary>
        /// <param name="sentence">The script sentence which to store the data dumped from the words.</param>
        /// <param name="utt">The utterance.</param>
        /// <param name="ttsEngine">The object ttsEngine to help to convert the Pos and get sentence id.</param>
        /// <param name="scriptLanguage">The language of the script.</param>
        private static void DumpWords(ScriptSentence sentence, SP.TtsUtterance utt,
            SP.TtsEngine ttsEngine, Language scriptLanguage)
        {
            Debug.Assert(sentence != null, "Sentence should not be null");
            Debug.Assert(utt != null, "Utt should not be null");
            Debug.Assert(ttsEngine != null, "ttsEngine should not be null");

            // Phone index to mark the phone in the Utt.Phones
            int phoneIndex = 0;

            // F0 index to mark the start position in the Utt.Sccoustic.F0s
            int f0StartIndex = 0;

            // Unit index to mark the unit in the Utt.Units
            int unitIndex = 0;

            // Word index to mark the position in the Utt.Words
            int wordIndex = 0;

            foreach (SP.TtsWord word in utt.Words)
            {
                if (word.WordText != null)
                {
                    ScriptWord scriptWord = new ScriptWord();

                    // Tag the language to the word level if there is not single language in the utt.
                    // The major language (the most word count with this language) will be tag on the 
                    // script level, others tag on the word level. 
                    if ((Language)word.LangId != scriptLanguage)
                    {
                        scriptWord.Language = (Language)word.LangId;
                    }

                    // According to the schema, if the word is "silence", there should be not
                    // value in the scriptWord pronunciation. Means: <w v=""
                    if (word.WordType != TtsWordType.WT_SILENCE)
                    {
                        scriptWord.Grapheme = word.WordText;
                    }

                    if (!string.IsNullOrEmpty(word.Pronunciation))
                    {
                        scriptWord.Pronunciation = word.Pronunciation.ToLowerInvariant();
                    }

                    scriptWord.WordType = ConvertWordType(word);

                    // Dump the Part-Of-Speech.
                    // If the word is "sil", the word text is " ", the pos id is 65535, out of boundary.
                    // In this case, will not dump the pos.
                    if (!string.IsNullOrEmpty(word.WordText.Trim()))
                    {
                        scriptWord.PosString = ttsEngine.PosTable.IdToString(word.Pos);
                    }

                    scriptWord.Break = (TtsBreak)word.BreakLevel;
                    scriptWord.Emphasis = (TtsEmphasis)word.Emphasis;
                    scriptWord.TobiFinalBoundaryTone = ConvertTobiFBT(word.ToBIFinalBoundaryTone);
                    scriptWord.PronSource = (TtsPronSource)word.PronSource;
                    scriptWord.OffsetInString = (int)word.TextOffset;
                    scriptWord.LengthInString = (int)word.TextLength;
                    DumpSyllables(scriptWord, utt, word, ref phoneIndex, ref unitIndex, ref f0StartIndex, ttsEngine);
                    sentence.Words.Add(scriptWord);
                }
                else
                {
                    string message = Helper.NeutralFormat("The word text of word [{0}]: \"{1}\" in the" +
                        "utterance is empty.", wordIndex, word.WordText);
                    throw new InvalidDataException(message);
                }

                wordIndex++;
            }
        }
示例#5
0
        /// <summary>
        /// Syllabify one tts word entry.
        /// </summary>
        /// <param name="word">Word to syllabify.</param>
        /// <returns>Sliced word pronunciation.</returns>
        public string SliceWord(ScriptWord word)
        {
            if (word == null)
            {
                throw new ArgumentNullException("word");
            }

            if (string.IsNullOrEmpty(word.Grapheme))
            {
                string message = string.Format(CultureInfo.InvariantCulture,
                    "word.Grapheme should not be null or empty.");
                throw new ArgumentNullException("word", message);
            }

            string pron = word.GetPronunciation(_phoneSet);
            string slicePron = string.Empty;
            if (!string.IsNullOrEmpty(pron))
            {
                slicePron = RewritePhones2Units(_sliceData, pron);
                if (!string.IsNullOrEmpty(slicePron))
                {
                    slicePron = Regex.Replace(slicePron, @"\.\s+\.", ".");
                }
            }

            return slicePron;
        }
        /// <summary>
        /// Appends a punctuation word in the end of given utterance.
        /// </summary>
        /// <param name="utterance">
        /// The given utterance.
        /// </param>
        /// <param name="scriptWord">
        /// The script word.
        /// </param>
        /// <returns>
        /// The phoneme count of the given word.
        /// </returns>
        /// <exception cref="InvalidDataException">
        /// Exception.
        /// </exception>
        private int AppendPunctuationWord(TtsUtterance utterance, ScriptWord scriptWord)
        {
            TtsWord word = utterance.AppendNewWord();
            word.LangId = (ushort)scriptWord.Language;
            word.BreakLevel = (TtsBreakLevel)scriptWord.Break;
            word.Emphasis = (TtsEmphasis)scriptWord.Emphasis;
            word.WordText = scriptWord.Grapheme;
            word.NETypeText = scriptWord.NETypeText;
            word.WordType = TtsWordType.WT_PUNCTUATION;

            // There is no phoneme for punctuation word.
            return 0;
        }
示例#7
0
        /// <summary>
        /// Read and parse word data from the XML text reader to utterance.
        /// </summary>
        /// <param name="reader">XML text reader to read data from.</param>
        /// <param name="utterance">Target utterance to save result words.</param>
        private static void ProcessWord(XmlTextReader reader, TtsUtterance utterance)
        {
            ScriptWord word = new ScriptWord(utterance.Script.Language);
            word.Grapheme = reader.GetAttribute("val");

            if (reader.GetAttribute("p") != null)
            {
                word.Pronunciation = reader.GetAttribute("p");
            }

            if (reader.GetAttribute("pos") != null)
            {
                word.Pos = (PartOfSpeech)Enum.Parse(typeof(PartOfSpeech), reader.GetAttribute("pos"));
            }

            if (reader.GetAttribute("emphasis") != null)
            {
                word.Emphasis =
                    (TtsEmphasis)Enum.Parse(typeof(TtsEmphasis), reader.GetAttribute("emphasis"));
            }

            if (reader.GetAttribute("break") != null)
            {
                word.Break = (TtsBreak)Enum.Parse(typeof(TtsBreak), reader.GetAttribute("break"));
            }

            if (reader.GetAttribute("type") != null)
            {
                word.WordType = (WordType)Enum.Parse(typeof(WordType), reader.GetAttribute("type"));
            }

            utterance.Script.Words.Add(word);
            reader.Skip();
        }
示例#8
0
        /// <summary>
        /// Build syllable collection for a given word.
        /// </summary>
        /// <param name="word">Word to process.</param>
        private static void BuildSyllables(ScriptWord word)
        {
            if (word == null)
            {
                throw new ArgumentNullException("word");
            }

            if (word.Pronunciation == null)
            {
                throw new ArgumentException("word.Pronunciation is null");
            }

            word.Syllables.Clear();

            string[] syllableTexts = Core.Pronunciation.SplitIntoSyllables(word.Pronunciation);
            for (int syllableIndex = 0; syllableIndex < syllableTexts.Length; syllableIndex++)
            {
                ScriptSyllable syllable = new ScriptSyllable();

                syllable.Text = syllableTexts[syllableIndex];

                syllable.TtsBreak = (syllableIndex == syllableTexts.Length - 1) ?
                    word.Break : TtsBreak.Syllable;
                syllable.Stress = Core.Pronunciation.GetStress(syllable.Text);
                syllable.TtsEmphasis = (syllable.Stress != TtsStress.None) ?
                    word.Emphasis : TtsEmphasis.None;

                word.Syllables.Add(syllable);
            }
        }
示例#9
0
        /// <summary>
        /// Load the attributes for a given word.
        /// </summary>
        /// <param name="word">ScriptWord.</param>
        /// <param name="reader">XmlTextReader.</param>
        /// <param name="scriptLanguage">The language of the script.</param>
        private static void LoadWordAttributes(ScriptWord word, XmlTextReader reader,
            Language scriptLanguage)
        {
            Debug.Assert(word != null);
            Debug.Assert(reader != null);

            string wordLanguage = reader.GetAttribute("language");
            if (!string.IsNullOrEmpty(wordLanguage) &&
                Localor.StringToLanguage(wordLanguage) != scriptLanguage)
            {
                word.Language = Localor.StringToLanguage(wordLanguage);
            }

            word.Grapheme = reader.GetAttribute("v");

            string pron = reader.GetAttribute("p");
            if (!string.IsNullOrEmpty(pron))
            {
                word.Pronunciation = pron;
            }

            word.AcceptGrapheme = reader.GetAttribute("av");
            string acceptPron = reader.GetAttribute("ap");
            if (!string.IsNullOrEmpty(acceptPron))
            {
                word.AcceptPronunciation = acceptPron;
            }

            string type = reader.GetAttribute("type");
            if (!string.IsNullOrEmpty(type))
            {
                word.WordType = ScriptWord.StringToWordType(type);
            }

            if (word.Grapheme == null || word.Grapheme.Length == 0)
            {
                if (word.WordType != WordType.Silence &&
                    word.WordType != WordType.Punctuation)
                {
                    throw new InvalidDataException(Helper.NeutralFormat(
                        "Line [{0}]: only silence word, prosody boundary or punctuation can have null/empty word grapheme",
                        reader.LineNumber));
                }
            }
            else
            {
                if (word.WordType == WordType.Silence)
                {
                    throw new InvalidDataException(Helper.NeutralFormat(
                        "Line [{0}]: silence word or prosody boundary should have empty word grapheme",
                        reader.LineNumber));
                }
            }

            string pos = reader.GetAttribute("pos");
            if (!string.IsNullOrEmpty(pos))
            {
                word.PosString = pos;
            }

            string expansion = reader.GetAttribute("exp");
            if (!string.IsNullOrEmpty(expansion))
            {
                word.Expansion = expansion;
            }

            string emphasis = reader.GetAttribute("em");
            if (!string.IsNullOrEmpty(emphasis))
            {
                word.Emphasis = ScriptWord.StringToEmphasis(emphasis);
            }

            string breakLevel = reader.GetAttribute("br");
            if (!string.IsNullOrEmpty(breakLevel))
            {
                word.Break = ScriptWord.StringToBreak(breakLevel);
            }

            string breakAskLevel = reader.GetAttribute("bra");
            if (!string.IsNullOrEmpty(breakAskLevel))
            {
                word.BreakAsk = ScriptWord.StringToBreak(breakAskLevel);
            }
            else
            {
                word.BreakAsk = ScriptWord.UndefinedBreakAsk;
            }

            string breakProb = reader.GetAttribute("brp");
            if (!string.IsNullOrEmpty(breakProb))
            {
                word.BreakProb = float.Parse(breakProb, CultureInfo.InvariantCulture);
            }
            else
            {
                word.BreakProb = ScriptWord.DefaultProbability;
            }

            string wordTone = reader.GetAttribute("wt");
            if (!string.IsNullOrEmpty(wordTone))
            {
                word.WordTone = ScriptWord.StringToWordTone(wordTone);
            }

            string tobiibt = reader.GetAttribute("tobiibt");
            if (!string.IsNullOrEmpty(tobiibt))
            {
                word.TobiInitialBoundaryTone = new TobiLabel(tobiibt);
            }

            string tobifbt = reader.GetAttribute("tobifbt");
            if (!string.IsNullOrEmpty(tobifbt))
            {
                word.TobiFinalBoundaryTone = new TobiLabel(tobifbt);
            }

            string domain = reader.GetAttribute("domain");
            if (!string.IsNullOrEmpty(domain))
            {
                word.AcousticDomainTag = domain;
            }

            string nusTag = reader.GetAttribute("nus");
            if (!string.IsNullOrEmpty(nusTag))
            {
                word.NusTag = nusTag;
            }

            string regularText = reader.GetAttribute("regularText");
            if (!string.IsNullOrEmpty(regularText))
            {
                word.RegularText = regularText;
            }

            string sp = reader.GetAttribute("sp");
            if (!string.IsNullOrEmpty(sp))
            {
                word.ShallowParseTag = sp;
            }

            string tcgppScore = reader.GetAttribute("tcgppScore");
            if (!string.IsNullOrEmpty(tcgppScore))
            {
                word.TcgppScores = tcgppScore;
            }

            string pronSource = reader.GetAttribute("pronSource");
            if (!string.IsNullOrEmpty(pronSource))
            {
                word.PronSource = ScriptWord.StringToPronSource(pronSource);
            }

            string netype = reader.GetAttribute("netype");
            if (!string.IsNullOrEmpty(netype))
            {
                word.NETypeText = netype;
            }

            if (word.WordType != WordType.Silence)
            {
                string offset = reader.GetAttribute("offset");
                if (!string.IsNullOrEmpty(offset))
                {
                    word.OffsetInString = int.Parse(offset);
                }

                string length = reader.GetAttribute("length");
                if (!string.IsNullOrEmpty(length))
                {
                    word.LengthInString = int.Parse(length);
                }
            }
        }
示例#10
0
        /// <summary>
        /// Load one script word from the xmltextreader.
        /// </summary>
        /// <param name="reader">XmlTextReader.</param>
        /// <param name="contentController">ContentControler.</param>
        /// <param name="language">The language of the script.</param>
        /// <returns>ScriptWord that read.</returns>
        public static ScriptWord LoadWord(XmlTextReader reader, object contentController, Language language)
        {
            Debug.Assert(reader != null);

            ContentControler scriptContentController = new ContentControler();
            if (contentController is ContentControler)
            {
                scriptContentController = contentController as ContentControler;
            }
            else if (contentController != null)
            {
                throw new ArgumentException("Invalid contentController type");
            }

            ScriptWord word = new ScriptWord(language);

            // load attributes
            LoadWordAttributes(word, reader, language);

            // load syllables
            // remember that word can have no syllable list
            if (!reader.IsEmptyElement)
            {
                while (reader.Read())
                {
                    if (reader.NodeType == XmlNodeType.Element && reader.Name == "syls")
                    {
                        while (reader.Read())
                        {
                            if (reader.NodeType == XmlNodeType.Element && reader.Name == "syl")
                            {
                                ScriptSyllable syllable = LoadSyllable(reader, language);
                                syllable.Word = word;
                                word.Syllables.Add(syllable);
                            }
                            else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "syls")
                            {
                                break;
                            }
                        }
                    }
                    else if (reader.NodeType == XmlNodeType.Element && reader.Name == "acoustics")
                    {
                        word.Acoustics = new ScriptAcoustics();
                        word.Acoustics.ParseFromXml(reader);
                    }
                    else if (reader.NodeType == XmlNodeType.Element && reader.Name == "comments")
                    {
                        if (scriptContentController.LoadComments)
                        {
                            word.TtsXmlComments.Parse(reader);
                            word.TtsXmlComments.Tag = word;
                        }
                        else
                        {
                            reader.Skip();
                        }
                    }
                    else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "w")
                    {
                        break;
                    }
                }
            }

            return word;
        }
示例#11
0
        /// <summary>
        /// Sync word text to item text.
        /// </summary>
        /// <param name="scriptWord">Script word to be synced.</param>
        public static void SyncWordChangesToItem(ScriptWord scriptWord)
        {
            if (scriptWord == null)
            {
                throw new ArgumentNullException("scriptWord");
            }

            if (scriptWord.Sentence == null)
            {
                throw new ArgumentException("scriptWord.Sentence is null");
            }

            if (scriptWord.Sentence.ScriptItem == null)
            {
                throw new ArgumentException("scriptWord.Sentence.ScriptItem is null");
            }

            SyncItemTextFromWordList(scriptWord.Sentence.ScriptItem);
        }
示例#12
0
        /// <summary>
        /// Scritp word to be displayed.
        /// </summary>
        /// <param name="word">Script word.</param>
        /// <returns>String.</returns>
        public static string BuildDisplayedWordText(ScriptWord word)
        {
            if (word == null)
            {
                throw new ArgumentNullException("word");
            }

            if (string.IsNullOrEmpty(word.Grapheme))
            {
                throw new ArgumentException("word.Grapheme");
            }

            StringBuilder displayedWordText = new StringBuilder();
            displayedWordText.AppendFormat("{0}", word.Grapheme);
            if (word.Emphasis == TtsEmphasis.Yes)
            {
                displayedWordText.Append(" *");
            }

            string breakString = ScriptWord.BreakToString(word.Break);
            if (!string.IsNullOrEmpty(breakString))
            {
                if (word.Break == TtsBreak.Syllable)
                {
                    displayedWordText.Append(" _");
                }
                else
                {
                    displayedWordText.Append(" #");
                }

                displayedWordText.Append(breakString);
            }

            return displayedWordText.ToString();
        }
示例#13
0
        /// <summary>
        /// Get word text for acronym domain.
        /// </summary>
        /// <param name="word">Given ScriptWord.</param>
        /// <param name="sentenceId">Sentence Id.</param>
        /// <param name="wordIndex">Word index.</param>
        /// <param name="acronyms">Acronym words.</param>
        /// <returns>Word text.</returns>
        private static string GetAcronymDomainWordText(ScriptWord word, string sentenceId,
            int wordIndex, Dictionary<string, AcronymWordItem> acronyms)
        {
            string key = AcronymWordItem.GetKey(sentenceId, wordIndex);

            string text = acronyms[key].Word.ToUpperInvariant();
            
            text += "@" + acronyms[key].Group.ToString(System.Globalization.CultureInfo.InvariantCulture);

            return text;
        }
示例#14
0
        /// <summary>
        /// Find previos word, which is normal word
        /// Change it to public for code re-use in script sentence.
        /// </summary>
        /// <param name="words">Word collection to search.</param>
        /// <param name="word">Word to find previous word for.</param>
        /// <returns>Found word.</returns>
        public static ScriptWord FindPreviousWord(Collection<ScriptWord> words, ScriptWord word)
        {
            if (words == null)
            {
                throw new ArgumentNullException("words");
            }

            if (word == null)
            {
                throw new ArgumentNullException("word");
            }

            int index = words.IndexOf(word);
            if (index == -1)
            {
                throw new ArgumentOutOfRangeException("word");
            }

            while (index - 1 >= 0)
            {
                if (words[index - 1].WordType == WordType.Normal)
                {
                    return words[index - 1];
                }

                --index;
            }

            return null;
        }
示例#15
0
        /// <summary>
        /// Converts one word instance to script named entity.
        /// </summary>
        /// <param name="word">The word instance to convert.</param>
        /// <returns>The converted script named entity instance.</returns>
        private ScriptNamedEntity ToScriptNamedEntity(ScriptWord word)
        {
            Helper.ThrowIfNull(word);
            if (string.IsNullOrEmpty(word.NamedEntityTypeString))
            {
                throw new InvalidDataException(Helper.NeutralFormat(
                    "The type of the named entity [{0}] should not be empty.", word.NamedEntityTypeString));
            }

            ScriptNamedEntity entity = new ScriptNamedEntity();

            entity.Text = word.Grapheme;
            entity.PosString = word.PosString;
            entity.Type = word.NamedEntityTypeString;

            entity.Start = word.SubWords[0];
            entity.End = word.SubWords[word.SubWords.Count - 1];

            return entity;
        }
示例#16
0
 /// <summary>
 /// Fix the ending punctuation of the sentence, this is, to make sure 
 /// The sentence end with Period punctuation.
 /// </summary>
 /// <param name="words">Word collection of the sentence.</param>
 /// <param name="language">Language of the sentence.</param>
 private static void FixEndingPunctuation(Collection<ScriptWord> words, Language language)
 {
     if (words.Count > 0)
     {
         ScriptWord lastWord = words[words.Count - 1];
         if (lastWord.WordType == WordType.Normal)
         {
             ScriptWord word = new ScriptWord(language);
             word.Grapheme = ".";
             word.WordType = WordType.Period;
             word.Break = Localor.MapWordType2Break(word.WordType);
             words.Add(word);
         }
         else if (lastWord.WordType == WordType.OtherPunctuation)
         {
             // upgrade this word break level
             lastWord.WordType = WordType.Period;
             lastWord.Break = Localor.MapWordType2Break(lastWord.WordType);
         }
     }
 }
示例#17
0
        /// <summary>
        /// Converts one named entity to script word instance.
        /// </summary>
        /// <param name="entity">The named entity instance to convert.</param>
        /// <returns>The converted word instance.</returns>
        private ScriptWord ToScriptWord(ScriptNamedEntity entity)
        {
            Helper.ThrowIfNull(entity);
            if (string.IsNullOrEmpty(entity.Type))
            {
                throw new InvalidDataException(Helper.NeutralFormat(
                    "The type of the named entity [{0}] should not be empty.", entity.Text));
            }

            ScriptWord word = new ScriptWord(entity.Start.Language);

            word.Break = entity.End.Break;

            word.Grapheme = entity.Text;
            word.PosString = entity.PosString;

            if (word.PosString == ScriptNamedEntity.DefaultEmptyPosString)
            {
                word.PosString = ScriptNamedEntity.DefaultEntityPosString;
            }

            word.NamedEntityTypeString = entity.Type;
            word.Sentence = entity.Start.Sentence;

            word.SubWords = new Collection<ScriptWord>();
            StringBuilder pronunciation = new StringBuilder();
            for (int i = Words.IndexOf(entity.Start); i <= Words.IndexOf(entity.End); i++)
            {
                word.SubWords.Add(Words[i]);
                if (!string.IsNullOrEmpty(Words[i].Pronunciation))
                {
                    if (pronunciation.Length != 0)
                    {
                        pronunciation.AppendFormat(" {0} ", Pronunciation.WordPronBoundaryString);
                    }

                    pronunciation.Append(Words[i].Pronunciation);
                }
            }

            word.Pronunciation = pronunciation.ToString();

            return word;
        }
示例#18
0
        /// <summary>
        /// Previos word building, process one token of word.
        /// </summary>
        /// <param name="words">Result word list.</param>
        /// <param name="language">Language of the sentence.</param>
        /// <param name="tokenMatch">Token matched.</param>
        /// <param name="wordIndex">Word index of current word.</param>
        /// <returns>Word index of next word.</returns>
        private int PreBuildWord(Collection<ScriptWord> words, Language language,
            Match tokenMatch, int wordIndex)
        {
            bool tagged = true;

            // 0 is the whole "((\S+)/(\S+))|(\S+)"
            // 1 is "((\S+)/(\S+))|"
            // 2 is "(\S+)/"
            // 3 is "/(\S+)"
            // 4 is "|(\S+)"
            string content = tokenMatch.Groups[1].Value;

            if (string.IsNullOrEmpty(content))
            {
                tagged = false;
                content = tokenMatch.Groups[4].Value;
            }
            else
            {
                content = tokenMatch.Groups[2].Value;
            }

            Match breakMatch = Regex.Match(content, @"^#([0|1|2|3|4])([FfcRr]?)$");
            Match wordToneMatch = Regex.Match(content, @"^#([FfcRr])$");
            Match emphasisMatch = Regex.Match(content, @"^\*[234]?$");
            Match puncMatch = Regex.Match(content, @"^" + PunctuationPattern + "$");

            if (emphasisMatch.Success)
            {
                if (wordIndex >= 0)
                {
                    words[wordIndex].Emphasis = TtsEmphasis.Yes;
                    words[wordIndex].EmphasisTag = content;
                }
            }
            else if (wordToneMatch.Success)
            {
                if (wordIndex >= 0)
                {
                    words[wordIndex].WordTone =
                        ScriptItem.LabelToWordTone(wordToneMatch.Groups[1].Value);
                    words[wordIndex].WordToneTag = content;
                }
            }
            else if (breakMatch.Success)
            {
                if (wordIndex >= 0)
                {
                    // Upgrade one level for #1 for word break level.
                    words[wordIndex].Break =
                        (TtsBreak)(int.Parse(breakMatch.Groups[1].Value,
                                   CultureInfo.InvariantCulture) + 1);
                    words[wordIndex].BreakTag = content;

                    if (!string.IsNullOrEmpty(breakMatch.Groups[2].Value))
                    {
                        words[wordIndex].WordTone =
                            ScriptItem.LabelToWordTone(breakMatch.Groups[2].Value);
                        words[wordIndex].WordToneTag = content;
                    }
                }
            }
            else if (puncMatch.Success)
            {
                ScriptWord word = new ScriptWord(language);
                word.Grapheme = content;
                word.WordType = Localor.MapPunctuation(puncMatch.Groups[1].Value,
                    PunctuationPattern);
                word.Break = Localor.MapWordType2Break(word.WordType);
                if (tagged)
                {
                    word.PosTag = tokenMatch.Groups[3].Value;
                }

                words.Add(word);
            }
            else
            {
                ScriptWord word = new ScriptWord(language);
                word.Grapheme = content;
                if (tagged)
                {
                    word.PosTag = tokenMatch.Groups[3].Value;
                }

                word.AccessingUnits += delegate
                {
                    RefreshUnits();
                };

                words.Add(word);
                wordIndex = words.Count - 1;
            }

            return wordIndex;
        }
示例#19
0
 /// <summary>
 /// Get intonation phrase of the word.
 /// </summary>
 /// <param name="word">Script word.</param>
 /// <returns>Intonation phrase.</returns>
 public ScriptIntonationPhrase GetIntonationPhrase(ScriptWord word)
 {
     ScriptIntermediatePhrase intermediatePhrase = GetIntermediatePhrase(word);
     return intermediatePhrase == null ? null : intermediatePhrase.IntonationPhrase;
 }
        /// <summary>
        /// Insert silence word to script.
        /// </summary>
        /// <param name="scriptSentence">Script sentence.</param>
        /// <param name="wordIndex">To be insert word's position.</param>
        /// <param name="phoneme">The phoneme string.</param>
        public static void InsertSilenceWord(ScriptSentence scriptSentence, int wordIndex, string phoneme)
        {
            Debug.Assert(Phoneme.IsSilenceFeature(phoneme), "The phoneme should have silence feature");

            ScriptWord silenceWord = new ScriptWord();
            silenceWord.WordType = WordType.Silence;
            silenceWord.Pronunciation = Phoneme.ToRuntime(phoneme);
            silenceWord.Sentence = scriptSentence;
            ScriptSyllable silenceSyllable = new ScriptSyllable();
            silenceSyllable.Word = silenceWord;
            silenceWord.Syllables.Add(silenceSyllable);
            ScriptPhone silencePhone = new ScriptPhone(phoneme);
            silencePhone.Syllable = silenceSyllable;
            silenceWord.Syllables[0].Phones.Add(silencePhone);

            scriptSentence.Words.Insert(wordIndex, silenceWord);
        }
示例#21
0
        /// <summary>
        /// Get intermediate phrase.
        /// </summary>
        /// <param name="word">Script word.</param>
        /// <returns>Intermediate phrase.</returns>
        public ScriptIntermediatePhrase GetIntermediatePhrase(ScriptWord word)
        {
            ScriptIntermediatePhrase intermediatePhrase = null;
            foreach (ScriptIntonationPhrase phrase in IntonationPhrases)
            {
                intermediatePhrase = phrase.GetIntermediatePhrase(word);
                if (intermediatePhrase != null)
                {
                    break;
                }
            }

            return intermediatePhrase;
        }
        /// <summary>
        /// Appends a normal word in the end of given utterance.
        /// </summary>
        /// <param name="utterance">
        /// The given utterance.
        /// </param>
        /// <param name="scriptWord">
        /// The script word.
        /// </param>
        /// <returns>
        /// The phoneme count of the given word.
        /// </returns>
        /// <exception cref="InvalidDataException">
        /// Exception.
        /// </exception>
        private int AppendNormalWord(TtsUtterance utterance, ScriptWord scriptWord)
        {
            TtsWord word = utterance.AppendNewWord();
            word.LangId = (ushort)scriptWord.Language;
            word.BreakLevel = (TtsBreakLevel)scriptWord.Break;
            word.Emphasis = (TtsEmphasis)scriptWord.Emphasis;
            word.WordText = scriptWord.Grapheme;
            word.NETypeText = scriptWord.NETypeText;
            word.WordRegularText = scriptWord.RegularText;
            word.WordType = TtsWordType.WT_NORMAL;
            word.AcousticDomain = DomainExtension.MapToEnum(scriptWord.AcousticDomainTag);
            word.WordExpansion = scriptWord.Expansion;
            word.ReadablePronunciation = scriptWord.Pronunciation;
            if (!string.IsNullOrEmpty(scriptWord.Pronunciation))
            {
                word.PhoneIds = Phoneme.PronunciationToPhoneIds(Pronunciation.RemoveUnitBoundary(scriptWord.Pronunciation));
            }

            if (NeedPos)
            {
                // Checks pos.
                if (string.IsNullOrEmpty(scriptWord.PosString))
                {
                    throw new InvalidDataException(
                        Helper.NeutralFormat("No POS found in sentence \"{0}\" for word \"{1}\"",
                            scriptWord.Sentence.ScriptItem.Id, scriptWord.Grapheme));
                }

                // Sets pos value.
                word.Pos = (ushort)PosSet.Items[scriptWord.PosString];
                string taggingPos = PosSet.CategoryTaggingPOS[scriptWord.PosString];
                word.POSTaggerPos = (ushort)PosSet.Items[taggingPos];
            }

            // Gets the normal phoneme count.
            ErrorSet errorSet = new ErrorSet();
            int count = scriptWord.GetNormalPhoneNames(PhoneSet, errorSet).Count;
            if (errorSet.Count > 0)
            {
                throw new InvalidDataException(
                    Helper.NeutralFormat("Invalid phone found in sentence \"{0}\" for word \"{1}\"",
                        scriptWord.Sentence.ScriptItem.Id, scriptWord.Grapheme));
            }

            word.TextOffset = (uint)scriptWord.OffsetInString;
            word.TextLength = (uint)scriptWord.LengthInString;

            return count;
        }
示例#23
0
        /// <summary>
        /// Delete word from the sentence.
        /// For example: A, B, C, D, E.
        /// Current status: C, and D have been deleted.then word after word dict store: C->D, D->E.
        /// After deleting B, then deleted word after word will store: B->C, C->D, D->E.
        /// </summary>
        /// <param name="scriptWord">Word to be deleted.</param>
        /// <returns>Deleted word position.</returns>
        public int DeleteWord(ScriptWord scriptWord)
        {
            if (scriptWord == null)
            {
                throw new ArgumentNullException("scriptWord");
            }

            int position = _words.IndexOf(scriptWord);

            if (position >= 0)
            {
                _words.Remove(scriptWord);
                _needBuildUnits = true;
            }

            return position;
        }
示例#24
0
        /// <summary>
        /// Generate script item from raw text(only generate to word level).
        /// </summary>
        /// <param name="text">Plain text.</param>
        /// <returns>ScriptItem.</returns>
        public ScriptItem GenerateScriptItem(string text)
        {
            if (string.IsNullOrEmpty(text))
            {
                throw new ArgumentNullException("text");
            }

            // this function should contain "ProcessMode.TextProcess"
            if ((_mode & ProcessMode.TextProcess) == 0)
            {
                throw new InvalidOperationException("Process mode can only be ProcessMode.TextProcess");
            }

            ScriptItem item = new ScriptItem();
            item.Text = text;

            foreach (SP.TtsUtterance utt in EspUtterances(text))
            {
                using (utt)
                {
                    if (utt.Words.Count == 0)
                    {
                        continue;
                    }

                    ScriptSentence sentence = new ScriptSentence();
                    foreach (SP.TtsWord word in utt.Words)
                    {
                        if (!string.IsNullOrEmpty(word.WordText))
                        {
                            ScriptWord scriptWord = new ScriptWord();
                            scriptWord.Grapheme = word.WordText;

                            if (!string.IsNullOrEmpty(word.Pronunciation))
                            {
                                scriptWord.Pronunciation = word.Pronunciation.ToLowerInvariant();
                            }

                            scriptWord.WordType = WordType.Normal;
                            if (word.WordType == SP.TtsWordType.WT_PUNCTUATION)
                            {
                                scriptWord.WordType = WordType.Punctuation;
                            }

                            scriptWord.PronSource = (TtsPronSource)word.PronSource;

                            sentence.Words.Add(scriptWord);
                        }
                    }

                    sentence.Text = sentence.BuildTextFromWords();
                    item.Sentences.Add(sentence);
                }
            }

            return item;
        }
示例#25
0
        /// <summary>
        /// Insert word to the position.
        /// </summary>
        /// <param name="scriptWord">Word to be insert.</param>
        /// <param name="position">Position to be inserted.</param>
        public void InsertWord(ScriptWord scriptWord, int position)
        {
            if (scriptWord == null)
            {
                throw new ArgumentNullException("scriptWord");
            }

            if (position < 0 || position > _words.Count)
            {
                throw new ArgumentException(Helper.NeutralFormat(
                    "Invalid position {0}, should between 0 and {1}.", position, _words.Count));
            }

            _words.Insert(position, scriptWord);
            scriptWord.Sentence = this;
            _needBuildUnits = true;
        }
示例#26
0
        /// <summary>
        /// Dump the data in the syllable.
        /// </summary>
        /// <param name="scriptWord">The script word to store the data dumped from the syllables.</param>
        /// <param name="utt">The utterance.</param>
        /// <param name="word">The word which contains the these syllables.</param>
        /// <param name="phoneIndex">Phone index to mark the phone in the Utt.Phones.</param>
        /// <param name="unitIndex">Unit index to mark the unit in the Utt.Units.</param>
        /// <param name="f0StartIndex">F0 index to mark the start position in the F0s.</param>
        /// <param name="ttsEngine">The object ttsEngine to help to convert the Pos and get sentence id.</param>
        private static void DumpSyllables(ScriptWord scriptWord, SP.TtsUtterance utt,
            SP.TtsWord word, ref int phoneIndex, ref int unitIndex, ref int f0StartIndex, SP.TtsEngine ttsEngine)
        {
            Debug.Assert(scriptWord != null, "ScriptWord should not be null");
            Debug.Assert(utt != null, "Utt should not be null");
            Debug.Assert(word != null, "Word should not be null");
            Debug.Assert(phoneIndex >= 0, "PhoneIndex should not be less than 0");
            Debug.Assert(f0StartIndex >= 0, "f0StartIndex should not be less than 0");
            Debug.Assert(ttsEngine != null, "ttsEngine should not be null");

            // Go through each syllable in the word.
            SP.TtsSyllable syllable = word.FirstSyllable;
            while (syllable != null)
            {
                ScriptSyllable scriptSyllable = new ScriptSyllable();
                TtsTobiAccentSet tobiAccentSet = new TtsTobiAccentSet();
                if (syllable.ToBIAccent != SP.TtsTobiAccent.K_NOACC)
                {
                    scriptSyllable.TobiPitchAccent = TobiLabel.Create(tobiAccentSet.IdItems[(uint)syllable.ToBIAccent]);
                }

                scriptSyllable.Stress = (TtsStress)syllable.Stress;
                DumpPhones(scriptSyllable, utt, syllable, ref phoneIndex, ref unitIndex, ref f0StartIndex, ttsEngine);
                scriptWord.Syllables.Add(scriptSyllable);
                if (syllable == word.LastSyllable)
                {
                    break;
                }

                syllable = syllable.Next;
            }
        }
示例#27
0
        /// <summary>
        /// Get pronunciation id string for letter domain.
        /// </summary>
        /// <param name="word">Given ScriptWord.</param>
        /// <returns>Pronunciation id string.</returns>
        private static string GetPhoneIds(ScriptWord word)
        {
            Phoneme phoneme = Localor.GetPhoneme(word.Language);
            string[] phones = word.Pronunciation.Split(new char[] { ' ' },
                StringSplitOptions.RemoveEmptyEntries);

            StringBuilder phoneIds = new StringBuilder();
            foreach (string phone in phones)
            {
                if (phone == TtsUnit.UnitDelimiter)
                {
                    continue;
                }

                if (phoneme.TtsPhoneIds.ContainsKey(phone))
                {
                    phoneIds.Append((char)phoneme.TtsPhoneIds[phone]);
                }
            }

            return phoneIds.ToString();
        }