Ejemplo n.º 1
0
 /**
  * <summary> Constructor of VectorizedNerInstanceGenerator which takes input a {@link VectorizedDictionary}, a window size
  * and a word format and sets corresponding attributes with these inputs.</summary>
  * <param name="fsm">Morphological analyzer used to create multi-word expressions.</param>
  * <param name="wordNet">WordNet for checking multii-word and single-word expressions.</param>
  * <param name="dictionary">Dictionary in the vector form. Each word is stored in vector form in this dictionary.</param>
  * <param name="windowSize">Number of previous (next) words to be considered in adding attributes.</param>
  * <param name="format">Word vector format.</param>
  */
 public VectorizedSemanticInstanceGenerator(FsmMorphologicalAnalyzer fsm, WordNet.WordNet wordNet,
                                            VectorizedDictionary dictionary, int windowSize, WordFormat format) : base(fsm, wordNet)
 {
     this._format     = format;
     this._dictionary = dictionary;
     this.windowSize  = windowSize;
 }
Ejemplo n.º 2
0
 public string GetRandomWord(LongRandom rand, string subtype, string className, WordFormat format)
 {
     int subIndex = LookForSubtype(subtype);
     if (subIndex == -1)
     {
         return Error("SubtypeNotFound->"+subtype);
     }
     int index = PickByWeight(className, rand);
     if (className == "")
     {
         if (subIndex > Words[index].Length - 1)
         {
             return Error("SubtypeOutOfRange");
         }
         return Format(Words[index][subIndex], format);
     }
     else
     {
         if (!this.Classes.ContainsKey(className))
         {
             return Error("ClassNotFound->"+className);
         }
         return Format(Words[this.Classes[className][index]][subIndex], format);
     }
 }
Ejemplo n.º 3
0
 /**
  * <summary> Constructor of VectorizedNerInstanceGenerator which takes input a {@link VectorizedDictionary}, a window size
  * and a word format and sets corresponding attributes with these inputs.</summary>
  * <param name="dictionary">Dictionary in the vector form. Each word is stored in vector form in this dictionary.</param>
  * <param name="windowSize">Number of previous (next) words to be considered in adding attributes.</param>
  * <param name="format">Word vector format.</param>
  */
 public VectorizedShallowParseInstanceGenerator(VectorizedDictionary dictionary, int windowSize,
                                                WordFormat format)
 {
     this._format     = format;
     this._dictionary = dictionary;
     this.windowSize  = windowSize;
 }
    public void importRuleButtonPressed(int buttonIndex)
    {
        if (buttonIndex >= otherPartOfSpeech.Length)
        {
            return;
        }

        GameObject template = otherPartOfSpeech[buttonIndex];

        Debug.Log(template.transform.childCount);
        for (int i = 0; i < template.transform.childCount; i++)
        {
            RuleBannerPageSix bannerScriptOld = template.transform.GetChild(i).GetComponent <RuleBannerPageSix>();
            GameObject        instanceBanner  = (GameObject)Instantiate(prefabedBanner, thisPanel.transform);
            RuleBannerPageSix bannerScriptNew = instanceBanner.GetComponent <RuleBannerPageSix>();
            bannerScriptNew.description.text = bannerScriptOld.description.text;

            WordFormat newWordFormat = new WordFormat();
            // Copy the fields that is primary type or need not deep copy
            newWordFormat.numOfSyllable          = bannerScriptOld.format.numOfSyllable;
            newWordFormat.arabicStyle            = bannerScriptOld.format.arabicStyle;
            newWordFormat.consonantWithSemivowel = bannerScriptOld.format.consonantWithSemivowel;
            newWordFormat.specialVowel           = bannerScriptOld.format.specialVowel;
            newWordFormat.specialConsonant       = bannerScriptOld.format.specialConsonant;
            newWordFormat.vowelHolders           = bannerScriptOld.format.vowelHolders;

            // Deep copy other field
            Phoneme newLeading = new Phoneme();
            newLeading.addPhone(bannerScriptOld.format.specialLeading);
            Phoneme newEnding = new Phoneme();
            newEnding.addPhone(bannerScriptOld.format.specialEnding);
            newWordFormat.specialLeading = newLeading;
            newWordFormat.specialEnding  = newEnding;

            // Deep copy accent rules
            if (bannerScriptOld.format.accentRules != null && bannerScriptOld.format.accentRules.Length > 0)
            {
                WordFormat.AccentRule[] newAccentRuleList = new WordFormat.AccentRule[bannerScriptOld.format.accentRules.Length];
                for (int j = 0; j < newAccentRuleList.Length; j++)
                {
                    WordFormat.AccentRule newAccentRule = new WordFormat.AccentRule();
                    WordFormat.AccentRule oldAccentRule = bannerScriptOld.format.accentRules[j];
                    newAccentRule.backword = oldAccentRule.backword;
                    newAccentRule.position = oldAccentRule.position;
                    newAccentRule.accents  = new AccentPhone[oldAccentRule.accents.Length];

                    for (int k = 0; k < newAccentRule.accents.Length; k++)
                    {
                        newAccentRule.accents[k] = oldAccentRule.accents[k];
                    }

                    newAccentRuleList[j] = newAccentRule;
                }
                newWordFormat.accentRules = newAccentRuleList;
            }

            bannerScriptNew.format = newWordFormat;
        }
    }
Ejemplo n.º 5
0
        public static string GetExtention(WordFormat WordFormatType)
        {
            string result = string.Empty;

            foreach (var i in WordFormatDictionary)
            {
                if (i.Key.ToString().Contains(WordFormatType.ToString()))
                {
                    result = i.Value;
                }
            }
            return(result);
        }
Ejemplo n.º 6
0
    private Morphome[] getOnePartOfSpeech(GameObject panel)
    {
        List <Morphome> result = new List <Morphome>();

        for (int i = 0; i < panel.transform.childCount; i++)
        {
            Transform         go     = panel.transform.GetChild(i);
            RuleBannerPageSix script = go.GetComponent <RuleBannerPageSix>();
            WordFormat        format = script.format;
            result.Add(getFormat(format));
        }

        return(result.ToArray());
    }
Ejemplo n.º 7
0
        /// <summary>
        /// Converts MS Doc type to other formats.
        /// </summary>
        /// <param name="WordDocFilePath"></param>
        /// <param name="OutPutFileFormat"></param>
        public static void ConvertWord(string WordDocFilePath, WordFormat OutPutFileFormat)
        {
            Word.Application WordApp  = new Word.Application();
            Object           FilePath = WordDocFilePath;
            Object           ReadOnly = true;
            Object           Missing  = Type.Missing; //This will be passed when ever we don’t want to pass value

            //Open document from file
            Word.Document WordDoc = WordApp.Documents.Open(ref FilePath, ref Missing, ref ReadOnly, ref Missing, ref Missing,
                                                           ref Missing, ref Missing, ref Missing, ref Missing, ref Missing, ref Missing, ref Missing, ref Missing,
                                                           ref Missing, ref Missing, ref Missing);

            WordDoc.SaveAs2(FilePath + DictionaryLib.GetExtention(OutPutFileFormat), (Word.WdSaveFormat)OutPutFileFormat, ref Missing, ref Missing, ref Missing, ref Missing,
                            ref Missing, ref Missing, ref Missing, ref Missing, ref Missing, ref Missing, ref Missing, ref Missing, ref Missing,
                            ref Missing, ref Missing);

            Object SaveChanges = false;

            WordDoc.Close(ref SaveChanges, ref Missing, ref Missing);

            //Quit the word application
            WordApp.Quit(ref Missing, ref Missing, ref Missing);
        }
Ejemplo n.º 8
0
 public static string Capitalize(this string str, WordFormat capFormat)
 {
     if (capFormat == WordFormat.Proper)
     {
         char[] temp = new char[str.Length];
         char prev = ' ';
         char c = ' ';
         for (int i = 0; i < str.Length; i++)
         {
             prev = c;
             c = str[i];
             if (prev.PermitsCap() && char.IsLetter(c))
             {
                 temp[i] = char.ToUpper(c);
             }
             else
             {
                 temp[i] = c;
             }
         }
         return new string(temp);
     }
     else if (capFormat == WordFormat.Capitalized)
     {
         if (str.Length > 1) return str.Substring(0, 1).ToUpper() + str.Substring(1);
         return str.ToUpper();
     }
     else if (capFormat == WordFormat.AllCaps)
     {
         return str.ToUpper();
     }
     else
     {
         return str;
     }
 }
Ejemplo n.º 9
0
 public string GetRandomWordMultiClass(LongRandom rand, string subtype, WordFormat format, params string[] classNames)
 {
     int subIndex = LookForSubtype(subtype);
     if (subIndex == -1)
     {
         return Error("SubtypeNotFound->" + subtype);
     }
     for (int i = 0; i < classNames.Length; i++)
     {
         if (!this.Classes.ContainsKey(classNames[i]))
         {
             return Error("ClassNotFound->" + classNames[i]);
         }
     }
     List<int> mcList = GetMultiClassList(classNames);
     if (mcList.Count == 0)
     {
         return Error("EmptyMultiClass");
     }
     int index = PickByWeight(mcList, rand);
     return Format(Words[mcList[index]][subIndex], format);
 }
Ejemplo n.º 10
0
 private string Format(string input, WordFormat format)
 {
     switch (format)
     {
         case WordFormat.AllCaps:
             return input.ToUpper();
         case WordFormat.Proper:
             return input.Substring(0, 1).ToUpper() + input.Substring(1);
         case WordFormat.None:
         default:
             return input;
     }
 }
Ejemplo n.º 11
0
        public string GetWordByIndex(int index, string subtype, WordFormat format)
        {
            int subIndex = LookForSubtype(subtype);

            if (subIndex == -1)
            {
                return Error("SubtypeNotFound->" + subtype);
            }
            if (subIndex > Words[index].Length - 1)
            {
                return Error("InadequateSubtypeCount");
            }
            return Format(Words[index][subIndex], format);
        }
Ejemplo n.º 12
0
 /// <summary>
 ///     Retuns the string representation of this Word in specified format
 /// </summary>
 public string ToString(WordFormat format)
 {
     return(format.Format(this));
 }
Ejemplo n.º 13
0
    private Morphome getFormat(WordFormat format)
    {
        Morphome result = new Morphome();

        result.SyllableNumber = format.numOfSyllable;

        // Get info if the format is in arabic style
        if (format.arabicStyle)
        {
            result.AfroAsian            = true;
            result.Affixed              = false;
            result.SpecialPhone         = false;
            result.SemivoweledConsonant = format.consonantWithSemivowel;
            result.ClusteredConsonant   = format.consonantCluster;
            result.HolderVowels         = convertPhonemes(format.vowelHolders);
        }

        // Get info if the format is not arabic style
        else
        {
            result.AfroAsian            = false;
            result.SemivoweledConsonant = false;
            result.ClusteredConsonant   = false;
            result.Affixed      = false;
            result.SpecialPhone = false;

            // Set affix
            if (format.specialLeading != null && format.specialLeading.phones.Length > 0)
            {
                result.Affixed = true;
                result.Prefix  = convertPhoneme(format.specialLeading);
            }
            if (format.specialEnding != null && format.specialEnding.phones.Length > 0)
            {
                result.Affixed = true;
                result.Suffix  = convertPhoneme(format.specialEnding);
            }

            // Set special phone
            if (format.specialVowel != null && format.specialVowel.Length > 0)
            {
                result.SpecialPhone  = true;
                result.SpecialVowels = convertPhonemes(format.specialVowel);
            }
            if (format.specialConsonant != null && format.specialConsonant.Length > 0)
            {
                result.SpecialPhone      = true;
                result.SpecialConsonants = convertPhonemes(format.specialConsonant);
            }

            // Set accent rule
            if (format.accentRules != null && format.accentRules.Length > 0)
            {
                List <Morphome.ToneRequiement> ruleList = new List <Morphome.ToneRequiement>();
                for (int k = 0; k < format.accentRules.Length; k++)
                {
                    WordFormat.AccentRule   accentRule = format.accentRules[k];
                    Morphome.ToneRequiement tone       = new Morphome.ToneRequiement();

                    if (accentRule.backword)
                    {
                        int position = result.SyllableNumber - accentRule.position;
                        tone.Position = position;
                    }
                    else
                    {
                        tone.Position = accentRule.position;
                    }
                    if (tone.Position <= 0 || tone.Position > result.SyllableNumber)
                    {
                        continue;
                    }

                    Phone[] potentials = new Phone[accentRule.accents.Length];
                    for (int kk = 0; kk < potentials.Length; kk++)
                    {
                        Phone potential = new Phone();
                        potential.converProtoPhone(accentRule.accents[kk]);
                        potentials[kk] = potential;
                    }
                    tone.Accents = potentials;

                    ruleList.Add(tone);
                }
                result.Tones = ruleList.ToArray();
            }
        }

        return(result);
    }
    // Save the newly created rule
    public void onSaveButtonPressed()
    {
        aFormat = new WordFormat();
        aFormat.numOfSyllable = syllableNum;

        if (arabicFormatToggle.isOn)
        {
            aFormat.arabicStyle            = true;
            aFormat.consonantWithSemivowel = useSemivoweledConsonant.isOn;
            aFormat.consonantCluster       = useClusteredConsonant.isOn;

            List <Phoneme> forVowelHolder = new List <Phoneme>();
            for (int i = 0; i < arabicFormatContent.transform.childCount; i++)
            {
                ToBePickedScript script = arabicFormatContent.transform.GetChild(i).GetComponent <ToBePickedScript>();
                if (script.aVowelPhoneme == null)
                {
                    aFormat.arabicStyle            = false;
                    aFormat.consonantWithSemivowel = false;
                    aFormat.consonantCluster       = false;
                    break;
                }
                forVowelHolder.Add(script.aVowelPhoneme);
            }
            aFormat.vowelHolders = forVowelHolder.ToArray();
        }
        else
        {
            aFormat.arabicStyle = false;

            // Get accent rules
            if (accentNum > 0)
            {
                List <WordFormat.AccentRule> aList = new List <WordFormat.AccentRule>();
                for (int i = 0; i < accentPanel.transform.childCount; i++)
                {
                    AddAccentPageSix      script = accentPanel.transform.GetChild(i).GetComponent <AddAccentPageSix>();
                    WordFormat.AccentRule wfar   = new WordFormat.AccentRule();

                    if (script.coundBack.options.ToArray()[script.coundBack.value].text.Equals("Backward"))
                    {
                        wfar.backword = true;
                    }
                    else
                    {
                        wfar.backword = false;
                    }

                    try
                    {
                        if (script.positionField.text.Equals(""))
                        {
                            wfar.position = int.Parse(script.holder.text);
                        }
                        else
                        {
                            wfar.position = int.Parse(script.positionField.text);
                        }
                        if (wfar.position > syllableNum)
                        {
                            continue;
                        }

                        Manager         manager         = UnityEngine.Object.FindObjectOfType <Manager>();
                        LanguageManager languageManager = manager.languageManager;
                        AccentPhone[]   accents         = languageManager.accents;

                        if (script.accentType.value.Equals("all"))
                        {
                            wfar.accents = accents;
                        }
                        else
                        {
                            List <AccentPhone> potentialAccent = new List <AccentPhone>();
                            foreach (AccentPhone actp in accents)
                            {
                                string value   = script.accentType.options.ToArray()[script.accentType.value].text;
                                string IPA     = actp.IPA;
                                string contour = actp.Contour;
                                string level   = actp.Level;
                                if (value.Equals(IPA) || value.Equals(contour) || value.Equals(level))
                                {
                                    potentialAccent.Add(actp);
                                }
                            }
                            wfar.accents = potentialAccent.ToArray();
                        }
                        aList.Add(wfar);
                    }
                    catch (Exception e)
                    {
                        continue;
                    }
                }
                aFormat.accentRules = aList.ToArray();
            }

            // Get special affix
            if (specialAffixToggle.isOn)
            {
                if (specialPrefixToggle.isOn && prefixPhoneme != null && prefixPhoneme.phones.Length > 0)
                {
                    aFormat.specialLeading = prefixPhoneme;
                }
                if (specialSuffixToggle.isOn && suffixPhoneme != null && suffixPhoneme.phones.Length > 0)
                {
                    aFormat.specialEnding = suffixPhoneme;
                }
            }

            // Get special phone
            if (specialPhoneToggle.isOn)
            {
                if (specialVowelToggle.isOn && specialPickedVowel != null && specialPickedVowel.Length > 0)
                {
                    aFormat.specialVowel = specialPickedVowel;
                }

                if (specialConsonantToggle.isOn && specialPickedConsonant != null && specialPickedConsonant.Length > 0)
                {
                    aFormat.specialConsonant = specialPickedConsonant;
                }
            }

            // Create a rule banner
            // prefabedRuleBanner
            // RuleBannerPageSix
        }

        if (oldBanner != null)
        {
            oldBanner.format           = aFormat;
            oldBanner.description.text = aFormat.getDescription();
        }
        if (oldBanner == null && fromThisPanel != null)
        {
            GameObject        instanceBanner = (GameObject)Instantiate(prefabedRuleBanner, fromThisPanel.transform);
            RuleBannerPageSix instanceScript = instanceBanner.GetComponent <RuleBannerPageSix>();
            instanceScript.format           = aFormat;
            instanceScript.description.text = aFormat.getDescription();
        }


        Destroy(this.transform.gameObject);
    }