public virtual void testFutureTense() { SPhraseSpec test = phraseFactory.createClause(); NPPhraseSpec subj = phraseFactory.createNounPhrase("I"); VPPhraseSpec verb = phraseFactory.createVerbPhrase("go"); AdvPhraseSpec adverb = phraseFactory.createAdverbPhrase("tomorrow"); test.setSubject(subj); test.VerbPhrase = verb; test.setFeature(Feature.TENSE, Tense.FUTURE); test.addPostModifier(adverb); string sentence = realiser.realiseSentence(test); Assert.AreEqual("I will go tomorrow.", sentence); SPhraseSpec test2 = phraseFactory.createClause(); NLGElement vb = phraseFactory.createWord("go", new LexicalCategory(LexicalCategory.LexicalCategoryEnum.VERB)); test2.setSubject(subj); test2.setVerb(vb); test2.setFeature(Feature.TENSE, Tense.FUTURE); test2.addPostModifier(adverb); string sentence2 = realiser.realiseSentence(test); Assert.AreEqual("I will go tomorrow.", sentence2); }
/** * Sets the vp features. * * @param wp * The xml Verb Phrase object. * @param p * the internal VP object to get features from xml object. */ private void setVPFeatures(wrapper.XmlVPPhraseSpec wp, VPPhraseSpec p) { if (wp.FORM != null) { Enum.TryParse(wp.FORM.ToString(), out Form form); p.setFeature(Feature.FORM, form); } if (wp.PERSON != null) { p.setFeature(Feature.PERSON, wp.PERSON); } if (wp.TENSE != null) { Enum.TryParse(wp.TENSE.ToString(), out Form tense); p.setFeature(Feature.TENSE, tense); } if (wp.MODAL != null) { p.setFeature(Feature.MODAL, wp.MODAL); } p.setFeature(Feature.AGGREGATE_AUXILIARY, wp.AGGREGATEAUXILIARY); p.setFeature(Feature.NEGATED, wp.NEGATED); p.setFeature(Feature.PASSIVE, wp.PASSIVE); p.setFeature(Feature.PERFECT, wp.PERFECT); p.setFeature(Feature.PROGRESSIVE, wp.PROGRESSIVE); p.setFeature(Feature.SUPPRESS_GENITIVE_IN_GERUND, wp.SUPPRESSGENITIVEINGERUND); p.setFeature(Feature.SUPRESSED_COMPLEMENTISER, wp.SUPRESSEDCOMPLEMENTISER); }
public virtual void section8_Test() { Lexicon lexicon = Lexicon.DefaultLexicon; // default simplenlg lexicon NLGFactory nlgFactory = new NLGFactory(lexicon); // factory based on lexicon Realiser realiser = new Realiser(lexicon); NPPhraseSpec subject = nlgFactory.createNounPhrase("Mary"); NPPhraseSpec @object = nlgFactory.createNounPhrase("the monkey"); VPPhraseSpec verb = nlgFactory.createVerbPhrase("chase"); subject.addModifier("fast"); SPhraseSpec p = nlgFactory.createClause(); p.setSubject(subject); p.setVerb(verb); p.setObject(@object); string outputA = realiser.realiseSentence(p); Assert.AreEqual("Fast Mary chases the monkey.", outputA); verb.addModifier("quickly"); string outputB = realiser.realiseSentence(p); Assert.AreEqual("Fast Mary quickly chases the monkey.", outputB); }
public void dwightTest() { // Rachel Dwight's test SetupForExternalTest.phraseFactory.setLexicon(SetupForExternalTest.lexicon); NPPhraseSpec noun4 = SetupForExternalTest.phraseFactory .createNounPhrase("FGFR3 gene in every cell"); noun4.setSpecifier("the"); PPPhraseSpec prep1 = SetupForExternalTest.phraseFactory.createPrepositionPhrase( "of", noun4); NPPhraseSpec noun1 = SetupForExternalTest.phraseFactory.createNounPhrase( "the", "patient's mother"); NPPhraseSpec noun2 = SetupForExternalTest.phraseFactory.createNounPhrase( "the", "patient's father"); NPPhraseSpec noun3 = SetupForExternalTest.phraseFactory .createNounPhrase("changed copy"); noun3.addPreModifier("one"); noun3.addComplement(prep1); var coordNoun1 = new CoordinatedPhraseElement( noun1, noun2); coordNoun1.setConjunction("or"); VPPhraseSpec verbPhrase1 = SetupForExternalTest.phraseFactory.createVerbPhrase("have"); verbPhrase1.setFeature(Feature.TENSE.ToString(), Tense.PRESENT); SPhraseSpec sentence1 = SetupForExternalTest.phraseFactory.createClause(coordNoun1, verbPhrase1, noun3); Assert .AreEqual( "the patient's mother or the patient's father has one changed copy of the FGFR3 gene in every cell", SetupForExternalTest.realiser.realise(sentence1).getRealisation()); // Rachel's second test noun3 = SetupForExternalTest.phraseFactory.createNounPhrase("a", "gene test"); noun2 = SetupForExternalTest.phraseFactory.createNounPhrase("an", "LDL test"); noun1 = SetupForExternalTest.phraseFactory.createNounPhrase("the", "clinic"); verbPhrase1 = SetupForExternalTest.phraseFactory.createVerbPhrase("perform"); var coord1 = new CoordinatedPhraseElement(noun2, noun3); sentence1 = SetupForExternalTest.phraseFactory.createClause(noun1, verbPhrase1, coord1); sentence1.setFeature(Feature.TENSE.ToString(), Tense.PAST); Assert .AreEqual( "the clinic performed an LDL test and a gene test", SetupForExternalTest.realiser .realise(sentence1).getRealisation()); }
/** * Creates a verb phrase wrapping the main verb given. If a * <code>String</code> is passed in then some parsing is done to see if the * verb contains a particle, for example <em>fall down</em>. The first word * is taken to be the verb while all other words are assumed to form the * particle. * * @param verb * the verb to be wrapped. * @return a <code>VPPhraseSpec</code> representing this phrase. */ public virtual VPPhraseSpec createVerbPhrase(object verb) { VPPhraseSpec phraseElement = new VPPhraseSpec(this); phraseElement.setVerb(verb); setPhraseHead(phraseElement, phraseElement.getVerb()); return(phraseElement); }
public virtual void multipleNLGElementListRealiserTest() { List <NLGElement> elements = new List <NLGElement>(); // Create test NLGElements to realize: // "The cat jumping on the counter." DocumentElement sentence1 = nlgFactory.createSentence(); NPPhraseSpec subject_1 = nlgFactory.createNounPhrase("the", "cat"); VPPhraseSpec verb_1 = nlgFactory.createVerbPhrase("jump"); verb_1.setFeature(Feature.FORM, Form.PRESENT_PARTICIPLE); PPPhraseSpec prep_1 = nlgFactory.createPrepositionPhrase(); NPPhraseSpec object_1 = nlgFactory.createNounPhrase(); object_1.setDeterminer("the"); object_1.setNoun("counter"); prep_1.addComplement(object_1); prep_1.setPreposition("on"); SPhraseSpec clause_1 = nlgFactory.createClause(); clause_1.setSubject(subject_1); clause_1.VerbPhrase = verb_1; clause_1.setObject(prep_1); sentence1.addComponent(clause_1); // "The dog running on the counter." DocumentElement sentence2 = nlgFactory.createSentence(); NPPhraseSpec subject_2 = nlgFactory.createNounPhrase("the", "dog"); VPPhraseSpec verb_2 = nlgFactory.createVerbPhrase("run"); verb_2.setFeature(Feature.FORM, Form.PRESENT_PARTICIPLE); PPPhraseSpec prep_2 = nlgFactory.createPrepositionPhrase(); NPPhraseSpec object_2 = nlgFactory.createNounPhrase(); object_2.setDeterminer("the"); object_2.setNoun("counter"); prep_2.addComplement(object_2); prep_2.setPreposition("on"); SPhraseSpec clause_2 = nlgFactory.createClause(); clause_2.setSubject(subject_2); clause_2.VerbPhrase = verb_2; clause_2.setObject(prep_2); sentence2.addComponent(clause_2); elements.Add(sentence1); elements.Add(sentence2); IList <NLGElement> realisedElements = realiser.realise(elements); Assert.IsNotNull(realisedElements); Assert.AreEqual(2, realisedElements.Count); Assert.AreEqual("The cat jumping on the counter.", realisedElements[0].Realisation); Assert.AreEqual("The dog running on the counter.", realisedElements[1].Realisation); }
public void multipleNLGElementListRealiserTest() { List <INLGElement> elements = new List <INLGElement>(); // Create test NLGElements to realize: // "The cat jumping on the counter." DocumentElement sentence1 = SetupForRealiserTest.phraseFactory.createSentence(); NPPhraseSpec subject_1 = SetupForRealiserTest.phraseFactory.createNounPhrase("the", "cat"); VPPhraseSpec verb_1 = SetupForRealiserTest.phraseFactory.createVerbPhrase("jump"); verb_1.setFeature(Feature.FORM.ToString(), Form.PRESENT_PARTICIPLE); PPPhraseSpec prep_1 = SetupForRealiserTest.phraseFactory.createPrepositionPhrase(); NPPhraseSpec object_1 = SetupForRealiserTest.phraseFactory.createNounPhrase(); object_1.setDeterminer("the"); object_1.setNoun("counter"); prep_1.addComplement(object_1); prep_1.setPreposition("on"); SPhraseSpec clause_1 = SetupForRealiserTest.phraseFactory.createClause(); clause_1.setSubject(subject_1); clause_1.setVerbPhrase(verb_1); clause_1.setObject(prep_1); sentence1.addComponent(clause_1); // "The dog running on the counter." DocumentElement sentence2 = SetupForRealiserTest.phraseFactory.createSentence(); NPPhraseSpec subject_2 = SetupForRealiserTest.phraseFactory.createNounPhrase("the", "dog"); VPPhraseSpec verb_2 = SetupForRealiserTest.phraseFactory.createVerbPhrase("run"); verb_2.setFeature(Feature.FORM.ToString(), Form.PRESENT_PARTICIPLE); PPPhraseSpec prep_2 = SetupForRealiserTest.phraseFactory.createPrepositionPhrase(); NPPhraseSpec object_2 = SetupForRealiserTest.phraseFactory.createNounPhrase(); object_2.setDeterminer("the"); object_2.setNoun("counter"); prep_2.addComplement(object_2); prep_2.setPreposition("on"); SPhraseSpec clause_2 = SetupForRealiserTest.phraseFactory.createClause(); clause_2.setSubject(subject_2); clause_2.setVerbPhrase(verb_2); clause_2.setObject(prep_2); sentence2.addComponent(clause_2); elements.add(sentence1); elements.add(sentence2); List <INLGElement> realisedElements = SetupForRealiserTest.realiser.realise(elements); Assert.IsNotNull(realisedElements); Assert.AreEqual(2, realisedElements.size()); Assert.AreEqual("The cat jumping on the counter.", realisedElements.get(0).getRealisation()); Assert.AreEqual("The dog running on the counter.", realisedElements.get(1).getRealisation()); }
public virtual void testVerbParticle() { VPPhraseSpec v = phraseFactory.createVerbPhrase("fall down"); //$NON-NLS-1$ Assert.AreEqual("down", v.getFeatureAsString(Feature.PARTICLE)); //$NON-NLS-1$ Assert.AreEqual("fall", ((WordElement)v.getVerb()).BaseForm); //$NON-NLS-1$ v.setFeature(Feature.TENSE, Tense.PAST); v.setFeature(Feature.PERSON, Person.THIRD); v.setFeature(Feature.NUMBER, NumberAgreement.PLURAL); Assert.AreEqual("fell down", realiser.realise(v).Realisation); //$NON-NLS-1$ v.setFeature(Feature.FORM, Form.PAST_PARTICIPLE); Assert.AreEqual("fallen down", realiser.realise(v).Realisation); //$NON-NLS-1$ }
public void passiveComplementTest() { NPPhraseSpec woman2 = this.phraseFactory.createNounPhrase("the", "woman"); NPPhraseSpec dog2 = this.phraseFactory.createNounPhrase("the", "dog"); VPPhraseSpec give2 = this.phraseFactory.createVerbPhrase("give"); PPPhraseSpec behindTheCurtain2 = this.phraseFactory.createPrepositionPhrase("behind"); NPPhraseSpec np52 = this.phraseFactory.createNounPhrase("the", "curtain"); behindTheCurtain2.addComplement(np52); PPPhraseSpec inTheRoom2 = this.phraseFactory.createPrepositionPhrase("in"); NPPhraseSpec np62 = this.phraseFactory.createNounPhrase("the", "room"); inTheRoom2.addComplement(np62); // add some arguments dog2.setFeature(InternalFeature.DISCOURSE_FUNCTION.ToString(), DiscourseFunction.OBJECT); woman2.setFeature(InternalFeature.DISCOURSE_FUNCTION.ToString(), DiscourseFunction.INDIRECT_OBJECT); give2.addComplement(dog2); give2.addComplement(woman2); Assert.AreEqual("gives the woman the dog", this.realiser.realise( give2).getRealisation()); // add a few premodifiers and postmodifiers give2.addPreModifier("slowly"); give2.addPostModifier(behindTheCurtain2); give2.addPostModifier(inTheRoom2); Assert.AreEqual( "slowly gives the woman the dog behind the curtain in the room", this.realiser.realise(give2).getRealisation()); // passivise: This should suppress "the dog" give2.clearComplements(); give2.addComplement(dog2); give2.addComplement(woman2); give2.setFeature(Feature.PASSIVE.ToString(), true); Assert.AreEqual( "is slowly given the woman behind the curtain in the room", this.realiser.realise(give2).getRealisation()); }
public void coordinationTest() { // simple case VPPhraseSpec kiss2 = this.phraseFactory.createVerbPhrase("kiss"); kiss2.addComplement(this.dog); VPPhraseSpec kick2 = this.phraseFactory.createVerbPhrase("kick"); kick2.addComplement(this.boy); var coord1 = new CoordinatedPhraseElement( kiss2, kick2); coord1.setFeature(Feature.PERSON.ToString(), Person.THIRD); coord1.setFeature(Feature.TENSE.ToString(), Tense.PAST); Assert.AreEqual("kissed the dog and kicked the boy", this.realiser .realise(coord1).getRealisation()); // with negation: should be inherited by all components coord1.setFeature(Feature.NEGATED.ToString(), true); this.realiser.setLexicon(this.lexicon); Assert.AreEqual("did not kiss the dog and did not kick the boy", this.realiser.realise(coord1).getRealisation()); // set a modal coord1.setFeature(Feature.MODAL.ToString(), "could"); Assert.AreEqual( "could not have kissed the dog and could not have kicked the boy", this.realiser.realise(coord1).getRealisation()); // set perfect and progressive coord1.setFeature(Feature.PERFECT.ToString(), true); coord1.setFeature(Feature.PROGRESSIVE.ToString(), true); Assert.AreEqual("could not have been kissing the dog and " + "could not have been kicking the boy", this.realiser.realise( coord1).getRealisation()); // now aggregate coord1.setFeature(Feature.AGGREGATE_AUXILIARY.ToString(), true); Assert.AreEqual( "could not have been kissing the dog and kicking the boy", this.realiser.realise(coord1).getRealisation()); }
public virtual void testModalWithPassive() { NPPhraseSpec @object = phraseFactory.createNounPhrase("the", "pizza"); AdjPhraseSpec post = phraseFactory.createAdjectivePhrase("good"); AdvPhraseSpec @as = phraseFactory.createAdverbPhrase("as"); @as.addComplement(post); VPPhraseSpec verb = phraseFactory.createVerbPhrase("classify"); verb.addPostModifier(@as); verb.addComplement(@object); SPhraseSpec s = phraseFactory.createClause(); s.VerbPhrase = verb; s.setFeature(Feature.MODAL, "can"); // s.setFeature(Feature.FORM, Form.INFINITIVE); s.setFeature(Feature.PASSIVE, true); Assert.AreEqual("the pizza can be classified as good", realiser.realise(s).Realisation); }
public virtual void setUp() { lexicon = new XMLLexicon(); // built in lexicon phraseFactory = new NLGFactory(lexicon); realiser = new Realiser(lexicon); man = phraseFactory.createNounPhrase("the", "man"); //$NON-NLS-1$ //$NON-NLS-2$ woman = phraseFactory.createNounPhrase("the", "woman"); //$NON-NLS-1$//$NON-NLS-2$ dog = phraseFactory.createNounPhrase("the", "dog"); //$NON-NLS-1$ //$NON-NLS-2$ boy = phraseFactory.createNounPhrase("the", "boy"); //$NON-NLS-1$ //$NON-NLS-2$ beautiful = phraseFactory.createAdjectivePhrase("beautiful"); //$NON-NLS-1$ stunning = phraseFactory.createAdjectivePhrase("stunning"); //$NON-NLS-1$ salacious = phraseFactory.createAdjectivePhrase("salacious"); //$NON-NLS-1$ onTheRock = phraseFactory.createPrepositionPhrase("on"); //$NON-NLS-1$ np4 = phraseFactory.createNounPhrase("the", "rock"); //$NON-NLS-1$ //$NON-NLS-2$ onTheRock.addComplement(np4); behindTheCurtain = phraseFactory.createPrepositionPhrase("behind"); //$NON-NLS-1$ np5 = phraseFactory.createNounPhrase("the", "curtain"); //$NON-NLS-1$ //$NON-NLS-2$ behindTheCurtain.addComplement(np5); inTheRoom = phraseFactory.createPrepositionPhrase("in"); //$NON-NLS-1$ np6 = phraseFactory.createNounPhrase("the", "room"); //$NON-NLS-1$ //$NON-NLS-2$ inTheRoom.addComplement(np6); underTheTable = phraseFactory.createPrepositionPhrase("under"); //$NON-NLS-1$ underTheTable.addComplement(phraseFactory.createNounPhrase("the", "table")); //$NON-NLS-1$ //$NON-NLS-2$ proTest1 = phraseFactory.createNounPhrase("the", "singer"); //$NON-NLS-1$ //$NON-NLS-2$ proTest2 = phraseFactory.createNounPhrase("some", "person"); //$NON-NLS-1$ //$NON-NLS-2$ kick = phraseFactory.createVerbPhrase("kick"); //$NON-NLS-1$ kiss = phraseFactory.createVerbPhrase("kiss"); //$NON-NLS-1$ walk = phraseFactory.createVerbPhrase("walk"); //$NON-NLS-1$ talk = phraseFactory.createVerbPhrase("talk"); //$NON-NLS-1$ getUp = phraseFactory.createVerbPhrase("get up"); //$NON-NLS-1$ fallDown = phraseFactory.createVerbPhrase("fall down"); //$NON-NLS-1$ give = phraseFactory.createVerbPhrase("give"); //$NON-NLS-1$ say = phraseFactory.createVerbPhrase("say"); //$NON-NLS-1$ }
public virtual void section10_Test() { Lexicon lexicon = Lexicon.DefaultLexicon; // default simplenlg lexicon NLGFactory nlgFactory = new NLGFactory(lexicon); // factory based on lexicon Realiser realiser = new Realiser(lexicon); NPPhraseSpec subject1 = nlgFactory.createNounPhrase("Mary"); NPPhraseSpec subject2 = nlgFactory.createNounPhrase("your", "giraffe"); // next line is not correct ~ should be nlgFactory.createCoordinatedPhrase ~ may be corrected in the API CoordinatedPhraseElement subj = nlgFactory.createCoordinatedPhrase(subject1, subject2); VPPhraseSpec verb = nlgFactory.createVerbPhrase("chase"); SPhraseSpec p = nlgFactory.createClause(); p.setSubject(subj); p.setVerb(verb); p.setObject("the monkey"); string outputA = realiser.realiseSentence(p); Assert.AreEqual("Mary and your giraffe chase the monkey.", outputA); NPPhraseSpec object1 = nlgFactory.createNounPhrase("the monkey"); NPPhraseSpec object2 = nlgFactory.createNounPhrase("George"); // next line is not correct ~ should be nlgFactory.createCoordinatedPhrase ~ may be corrected in the API CoordinatedPhraseElement obj = nlgFactory.createCoordinatedPhrase(object1, object2); obj.addCoordinate("Martha"); p.setObject(obj); string outputB = realiser.realiseSentence(p); Assert.AreEqual("Mary and your giraffe chase the monkey, George and Martha.", outputB); obj.setFeature(Feature.CONJUNCTION, "or"); string outputC = realiser.realiseSentence(p); Assert.AreEqual("Mary and your giraffe chase the monkey, George or Martha.", outputC); }
public virtual void layTest() { string lemma = "slap"; WordElement word = lexicon.lookupWord(lemma, new LexicalCategory(LexicalCategory.LexicalCategoryEnum.VERB)); InflectedWordElement inflectedWord = new InflectedWordElement(word); inflectedWord.setFeature(Feature.FORM, Form.PRESENT_PARTICIPLE); string form = realiser.realise(inflectedWord).Realisation; Assert.AreEqual("slapping", form); VPPhraseSpec v = phraseFactory.createVerbPhrase("slap"); v.setFeature(Feature.PROGRESSIVE, true); string progressive = realiser.realise(v).Realisation; Assert.AreEqual("is slapping", progressive); }
public virtual void multipleAdvPremodifiersTest() { AdvPhraseSpec adv1 = phraseFactory.createAdverbPhrase("slowly"); AdvPhraseSpec adv2 = phraseFactory.createAdverbPhrase("discretely"); // case 1: concatenated premods: should have comma VPPhraseSpec vp = phraseFactory.createVerbPhrase("run"); vp.addPreModifier(adv1); vp.addPreModifier(adv2); Assert.AreEqual("slowly, discretely runs", realiser.realise(vp).Realisation); // case 2: coordinated premods: no comma VPPhraseSpec vp2 = phraseFactory.createVerbPhrase("eat"); vp2.addPreModifier(phraseFactory.createCoordinatedPhrase(adv1, adv2)); Assert.AreEqual("slowly and discretely eats", realiser.realise(vp2).Realisation); }
public virtual void testCoordinateVPComplexSubject() { // "As a result of the procedure the patient had an adverse contrast media reaction and went into cardiogenic shock." SPhraseSpec s = phraseFactory.createClause(); s.setSubject(phraseFactory.createNounPhrase("the", "patient")); // first VP VPPhraseSpec vp1 = phraseFactory.createVerbPhrase(lexicon.getWord("have", new LexicalCategory(LexicalCategory.LexicalCategoryEnum.VERB))); NPPhraseSpec np1 = phraseFactory.createNounPhrase("a", lexicon.getWord("contrast media reaction", new LexicalCategory(LexicalCategory.LexicalCategoryEnum.NOUN))); np1.addPreModifier(lexicon.getWord("adverse", new LexicalCategory(LexicalCategory.LexicalCategoryEnum.ADJECTIVE))); vp1.addComplement(np1); // second VP VPPhraseSpec vp2 = phraseFactory.createVerbPhrase(lexicon.getWord("go", new LexicalCategory(LexicalCategory.LexicalCategoryEnum.VERB))); PPPhraseSpec pp = phraseFactory.createPrepositionPhrase("into", lexicon.getWord("cardiogenic shock", new LexicalCategory(LexicalCategory.LexicalCategoryEnum.NOUN))); vp2.addComplement(pp); // coordinate CoordinatedPhraseElement coord = phraseFactory.createCoordinatedPhrase(vp1, vp2); coord.setFeature(Feature.TENSE, Tense.PAST); Assert.AreEqual("had an adverse contrast media reaction and went into cardiogenic shock", realiser.realise(coord).Realisation); // now put this in the sentence s.VerbPhrase = coord; s.addFrontModifier("As a result of the procedure"); Assert.AreEqual( "As a result of the procedure the patient had an adverse contrast media reaction and went into cardiogenic shock", realiser.realise(s).Realisation); }
public virtual void subclausesTest() { // Once upon a time, there was an Accountant, called Jeff, who lived in a forest. // main sentence NPPhraseSpec acct = phraseFactory.createNounPhrase("a", "accountant"); // first postmodifier of "an accountant" VPPhraseSpec sub1 = phraseFactory.createVerbPhrase("call"); sub1.addComplement("Jeff"); sub1.setFeature(Feature.FORM, Form.PAST_PARTICIPLE); // this is an appositive modifier, which makes simplenlg put it between commas sub1.setFeature(Feature.APPOSITIVE, true); acct.addPostModifier(sub1); // second postmodifier of "an accountant" is "who lived in a forest" SPhraseSpec sub2 = phraseFactory.createClause(); VPPhraseSpec subvp = phraseFactory.createVerbPhrase("live"); subvp.setFeature(Feature.TENSE, Tense.PAST); subvp.Complement = phraseFactory.createPrepositionPhrase("in", phraseFactory.createNounPhrase("a", "forest")); sub2.VerbPhrase = subvp; // simplenlg can't yet handle wh-clauses in NPs, so we need to hack it // by setting the subject to "who" sub2.setSubject("who"); acct.addPostModifier(sub2); // main sentence SPhraseSpec s = phraseFactory.createClause("there", "be", acct); s.setFeature(Feature.TENSE, Tense.PAST); // add front modifier "once upon a time" s.addFrontModifier("once upon a time"); Assert.AreEqual("once upon a time there was an accountant, called Jeff, who lived in a forest", realiser.realise(s).Realisation); }
public virtual void tearDown() { realiser = null; phraseFactory = null; if (null != lexicon) { lexicon = null; } man = null; woman = null; dog = null; boy = null; np4 = null; np5 = null; np6 = null; proTest1 = null; proTest2 = null; beautiful = null; stunning = null; salacious = null; onTheRock = null; behindTheCurtain = null; inTheRoom = null; underTheTable = null; kick = null; kiss = null; walk = null; talk = null; getUp = null; fallDown = null; give = null; say = null; }
public Phrase(SightWords words, WordElement seed) { var factory = new NLGFactory(Lexicon); SentenceSpec = factory.createClause(); var category = (LexicalCategoryEnum)seed.getCategory().enumType; NPPhraseSpec subject = null; VPPhraseSpec verb = null; PPPhraseSpec complement = null; switch (category) { case LexicalCategoryEnum.PRONOUN: var v = words.Verb; Console.Out.WriteLine("PRONOUN: {0}, {1} VERB: {2}, {3}", seed.getBaseForm(), seed.id, v.getBaseForm(), v.id); subject = factory.createNounPhrase(seed); verb = factory.createVerbPhrase(v); break; case LexicalCategoryEnum.NOUN: subject = factory.createNounPhrase(words.Determiner, seed); //verb = words.Verb; break; case LexicalCategoryEnum.VERB: verb = factory.createVerbPhrase(seed); subject = factory.createNounPhrase(words.Pronoun); break; case LexicalCategoryEnum.ADJECTIVE: subject = factory.createNounPhrase(words.Determiner, words.Noun); //verb = words.Verb; ((NPPhraseSpec)subject).addModifier(seed); break; case LexicalCategoryEnum.DETERMINER: subject = factory.createNounPhrase(seed, words.Noun); //verb = words.Verb; break; case LexicalCategoryEnum.ADVERB: subject = factory.createNounPhrase(words.Pronoun); verb = factory.createVerbPhrase(words.Verb); ((VPPhraseSpec)verb).addPreModifier(seed); break; case LexicalCategoryEnum.PREPOSITION: complement = factory.createPrepositionPhrase(); complement.setComplement(factory.createNounPhrase(words.Determiner, words.Noun)); complement.setPreposition(seed); break; case LexicalCategoryEnum.CONJUNCTION: var subject1 = factory.createNounPhrase(words.Determiner, words.Noun); var subject2 = factory.createNounPhrase(words.Determiner, words.Noun); var coord = factory.createCoordinatedPhrase(subject1, subject2); coord.setFeature(Feature.CONJUNCTION.ToString(), seed); break; case LexicalCategoryEnum.MODAL: break; default: break; } if (subject != null) { SentenceSpec.setSubject(subject); } if (verb != null) { SentenceSpec.setVerb(verb); } //if (complement != null) // SentenceSpec.setComplement(complement); //SentenceSpec.setSubject("me"); //SentenceSpec.setVerb("ride"); // var tense = (Tense)Random.Next(0, 2); //SentenceSpec.setFeature(Feature.TENSE.ToString(), tense); }
/** * Unwrap a <code>simplenlg.xmlrealiser.wrapper.NLGElement</code> and map it * to a <code>simplenlg.framework.NLGElement</code> * * @param wps * The wrapper object * @return the NLGElement */ public virtual NLGElement UnwrapNLGElement(wrapper.XmlNLGElement wps) { if (wps == null) { return(null); } if (wps is wrapper.XmlDocumentElement) { return((NLGElement)UnwrapDocumentElement((wrapper.XmlDocumentElement)wps)); } // Handle coordinate phrase specs first, which will cause recursion. NLGElement cp = UnwrapCoordinatePhraseSpec(wps); if (cp != null) { return(cp); } // Literal text. if (wps is wrapper.XmlStringElement) { wrapper.XmlStringElement wp = (wrapper.XmlStringElement)wps; NLGElement p = factory.createStringElement(wp.Val); return(p); } // WordElements (delegate to UnwrapWordElement) -- useful to have // because it is called by unWrapPhraseComponents, and pre/post mods // might be WordElements if (wps is XmlWordElement) { return(UnwrapWordElement((XmlWordElement)wps)); } // Sentence else if (wps is wrapper.XmlSPhraseSpec) { wrapper.XmlSPhraseSpec wp = (wrapper.XmlSPhraseSpec)wps; SPhraseSpec sp = factory.createClause(); NLGElement vp = null; List <NLGElement> subjects = new List <NLGElement>(); foreach (wrapper.XmlNLGElement p in wp.Subj) { NLGElement p1 = UnwrapNLGElement(p); checkFunction(DiscourseFunction.SUBJECT, p1); subjects.Add(p1); } if (subjects.Any()) { sp.setFeature(InternalFeature.SUBJECTS, subjects); } if (wp.Vp != null) { vp = UnwrapNLGElement(wp.Vp); sp.VerbPhrase = vp; } if (wp.CuePhrase != null) { NLGElement cue = UnwrapNLGElement(wp.CuePhrase); cue.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.CUE_PHRASE); sp.setFeature(Feature.CUE_PHRASE, cue); } if (wp.COMPLEMENTISER != null) { sp.setFeature(Feature.COMPLEMENTISER, wp.COMPLEMENTISER); } setSFeatures(wp, sp, vp); // Common phrase components. UnwrapPhraseComponents(sp, wps); return(sp); } // Phrases else if (wps is wrapper.XmlPhraseElement) { wrapper.XmlPhraseElement we = (wrapper.XmlPhraseElement)wps; PhraseElement hp = null; XmlWordElement w = we.Head; NLGElement head = UnwrapWordElement(w); // NLGElement head; // simplenlg.xmlrealiser.wrapper.XmlNLGElement w = // we.getHeadstring(); // check whether we have a stringelement or wordelement as head // if(w == null) { // w = we.getHeadword(); // head = UnwrapWordElement((XmlWordElement) w); // // } else { // head = factory.createStringElement(((XmlStringElement) // w).getVal()); // } // Noun Phrase if (wps is wrapper.XmlNPPhraseSpec) { wrapper.XmlNPPhraseSpec wp = (wrapper.XmlNPPhraseSpec)wps; NPPhraseSpec p = factory.createNounPhrase(head); hp = p; if (wp.Spec != null) { // p.setSpecifier(UnwrapWordElement(wp.getSpec())); wrapper.XmlNLGElement spec = wp.Spec; if (spec is XmlWordElement) { WordElement specifier = (WordElement)UnwrapWordElement((XmlWordElement)spec); if (specifier != null) { p.setSpecifier(specifier); } } else { p.setSpecifier(UnwrapNLGElement(spec)); } } setNPFeatures(wp, p); } // Adjective Phrase else if (wps is wrapper.XmlAdjPhraseSpec) { wrapper.XmlAdjPhraseSpec wp = (wrapper.XmlAdjPhraseSpec)wps; AdjPhraseSpec p = factory.createAdjectivePhrase(head); hp = p; p.setFeature(Feature.IS_COMPARATIVE, wp.ISCOMPARATIVE); p.setFeature(Feature.IS_SUPERLATIVE, wp.ISSUPERLATIVE); } // Prepositional Phrase else if (wps is wrapper.XmlPPPhraseSpec) { PPPhraseSpec p = factory.createPrepositionPhrase(head); hp = p; } // Adverb Phrase else if (wps is wrapper.XmlAdvPhraseSpec) { wrapper.XmlAdvPhraseSpec wp = (wrapper.XmlAdvPhraseSpec)wps; AdvPhraseSpec p = factory.createAdverbPhrase(); p.setHead(head); hp = p; p.setFeature(Feature.IS_COMPARATIVE, wp.ISCOMPARATIVE); p.setFeature(Feature.IS_SUPERLATIVE, wp.ISSUPERLATIVE); } // Verb Phrase else if (wps is wrapper.XmlVPPhraseSpec) { wrapper.XmlVPPhraseSpec wp = (wrapper.XmlVPPhraseSpec)wps; VPPhraseSpec p = factory.createVerbPhrase(head); hp = p; setVPFeatures(wp, p); } // Common phrase components. UnwrapPhraseComponents(hp, wps); // set the discourse function, if defined if (we.DiscourseFunction != null) { DiscourseFunction func; Enum.TryParse(we.DiscourseFunction.ToString(), out func); hp.setFeature(InternalFeature.DISCOURSE_FUNCTION, func); } // check the appositive feature bool?appositive = we.Appositive; if (appositive != null) { hp.setFeature(Feature.APPOSITIVE, appositive); } return(hp); } return(null); }
protected virtual void setUp() { this.lexicon = Lexicon.getDefaultLexicon(); this.phraseFactory = new NLGFactory(this.lexicon); this.realiser = new Realiser(this.lexicon); this.man = this.phraseFactory.createNounPhrase("the", "man"); this.woman = this.phraseFactory.createNounPhrase("the", "woman"); this.dog = this.phraseFactory.createNounPhrase("the", "dog"); this.boy = this.phraseFactory.createNounPhrase("the", "boy"); this.beautiful = this.phraseFactory.createAdjectivePhrase("beautiful"); this.stunning = this.phraseFactory.createAdjectivePhrase("stunning"); this.salacious = this.phraseFactory.createAdjectivePhrase("salacious"); this.onTheRock = this.phraseFactory.createPrepositionPhrase("on"); this.np4 = this.phraseFactory.createNounPhrase("the", "rock"); this.onTheRock.addComplement(this.np4); this.behindTheCurtain = this.phraseFactory.createPrepositionPhrase("behind"); this.np5 = this.phraseFactory.createNounPhrase("the", "curtain"); this.behindTheCurtain.addComplement(this.np5); this.inTheRoom = this.phraseFactory.createPrepositionPhrase("in"); this.np6 = this.phraseFactory.createNounPhrase("the", "room"); this.inTheRoom.addComplement(this.np6); this.underTheTable = this.phraseFactory.createPrepositionPhrase("under"); this.underTheTable.addComplement(this.phraseFactory.createNounPhrase("the", "table")); this.proTest1 = this.phraseFactory.createNounPhrase("the", "singer"); this.proTest2 = this.phraseFactory.createNounPhrase("some", "person"); this.kick = this.phraseFactory.createVerbPhrase("kick"); this.kiss = this.phraseFactory.createVerbPhrase("kiss"); this.walk = this.phraseFactory.createVerbPhrase("walk"); this.talk = this.phraseFactory.createVerbPhrase("talk"); this.getUp = this.phraseFactory.createVerbPhrase("get up"); this.fallDown = this.phraseFactory.createVerbPhrase("fall down"); this.give = this.phraseFactory.createVerbPhrase("give"); this.say = this.phraseFactory.createVerbPhrase("say"); // the woman kisses the man s1 = this.phraseFactory.createClause(); s1.setSubject(this.woman); s1.setVerbPhrase(this.kiss); s1.setObject(this.man); // there is the dog on the rock s2 = this.phraseFactory.createClause(); s2.setSubject("there"); s2.setVerb("be"); s2.setObject(this.dog); s2.addPostModifier(this.onTheRock); // the man gives the woman John's flower s3 = this.phraseFactory.createClause(); s3.setSubject(this.man); s3.setVerbPhrase(this.give); var flower = this.phraseFactory.createNounPhrase("flower"); var john = this.phraseFactory.createNounPhrase("John"); john.setFeature(Feature.POSSESSIVE.ToString(), true); flower.setFeature(InternalFeature.SPECIFIER.ToString(), john); s3.setObject(flower); s3.setIndirectObject(this.woman); s4 = this.phraseFactory.createClause(); s4.setFeature(Feature.CUE_PHRASE.ToString(), "however"); s4.addFrontModifier("tomorrow"); var subject = this.phraseFactory .createCoordinatedPhrase(this.phraseFactory .createNounPhrase("Jane"), this.phraseFactory .createNounPhrase("Andrew")); s4.setSubject(subject); var pick = this.phraseFactory.createVerbPhrase("pick up"); s4.setVerbPhrase(pick); s4.setObject("the balls"); s4.addPostModifier("in the shop"); s4.setFeature(Feature.TENSE.ToString(), Tense.FUTURE); }