public override void ProcessSentence(Sentence sentence) { _sentence = sentence; Debug.Assert(sentence.ElementList != null); Debug.Assert(sentence.ElementList.Count > 0); foreach (var word in sentence.ElementList.FindAll(x => (x.SyntacticRole.Value == SyntacticRole.DirectObject.Value && !(x.SurfaceSlot.Value == SurfaceSlot.ClauseInfinitiveForModalVerbs.Value) && !(x.SurfaceSlot.Value == SurfaceSlot.ClauseInfinitiveControl.Value) ) || x.SyntacticRole.Value == SyntacticRole.IndirectObject.Value || (x.SyntacticRole.Value == SyntacticRole.NonConcordantAttr.Value && ( x.SurfaceSlot.Value == SurfaceSlot.GenitivePostModifier.Value || x.SurfaceSlot.Value == SurfaceSlot.IdiomaticNominalGenitivePostmodifier.Value ) ) || ( (x.GrammarInfo.PartOfSpeech.Value == GrammarInfoPartOfSpeech.Noun.Value) && !(x.GrammarInfo.Case.Value == GrammarInfoCase.Nominative.Value) && (x.SurfaceSlot.Value == SurfaceSlot.RelativeGroup.Value) ) )) { Stage1ResultElement item = new Stage1ResultElement(); item.CopyFromSourceWord(word); Result.Items.Add(item); } }
public override void ProcessSentence(Sentence sentence) { _sentence = sentence; Debug.Assert(sentence.ElementList != null); Debug.Assert(sentence.ElementList.Count > 0); foreach (var word in sentence.ElementList.FindAll(x => x.ConjuctedWithId != "-1")) { Stage1ResultElement item = new Stage1ResultElement(); item.CopyFromSourceWord(word); item.ObjectType = ObjectType.MainWord; if (Result.Items.Find(x => x.Id == item.Id) == null) Result.Items.Add(item); foreach (var relatedWord in sentence.ElementList.FindAll(x => x.Id == item.ConjuctedWithId)) { Stage1ResultElement dItem = new Stage1ResultElement(); dItem.CopyFromSourceWord(relatedWord); dItem.ObjectType = ObjectType.RelatedWord; if (Result.Items.Find(x => x.Id == dItem.Id) == null) Result.Items.Add(dItem); } } }
public override void ProcessSentence(Sentence sentence) { _sentence = sentence; Debug.Assert(sentence.ElementList != null); Debug.Assert(sentence.ElementList.Count > 0); foreach (SentenceElement word in sentence.ElementList.FindAll(x => ( (x.SyntacticRole.Value == SyntacticRole.Subject.Value) || ( (x.GrammarInfo.PartOfSpeech.Value == GrammarInfoPartOfSpeech.Noun.Value) && (x.GrammarInfo.Case.Value == GrammarInfoCase.Nominative.Value) && (x.SurfaceSlot.Value == SurfaceSlot.RelativeGroup.Value) ) ) || ( (x.SyntacticRole.Value == SyntacticRole.Predicate.Value) && !(x.SurfaceSlot.Value == SurfaceSlot.InternalFiniteVerb.Value) ) )) { Stage1ResultElement item = new Stage1ResultElement(); item.CopyFromSourceWord(word); Result.Items.Add(item); } }
public override void ProcessSentence(Sentence sentence) { _sentence = sentence; Debug.Assert(sentence.WordList != null); Debug.Assert(sentence.WordList.Count > 0); foreach (var word in sentence.WordList.FindAll(x => x.Link.Value == LinkType.KomplNesobst1.Value || x.Link.Value == LinkType.KomplNesobst2.Value || x.Link.Value == LinkType.KomplNesobst3.Value || x.Link.Value == LinkType.NesobstAgent.Value || x.Link.Value == LinkType.KvaziAgent1.Value || x.Link.Value == LinkType.KvaziAgent.Value || x.Link.Value == LinkType.Agent1.Value || x.Link.Value == LinkType.Agent.Value || ( (x.Link.Value == LinkType.Kompl1.Value || x.Link.Value == LinkType.Kompl2.Value || x.Link.Value == LinkType.Kompl3.Value || x.Link.Value == LinkType.Kompl4.Value || x.Link.Value == LinkType.Kompl5.Value ) && x.Representation.Value != Representation.Infinitive.Value ) )) { Stage1ResultElement item = new Stage1ResultElement(); item.CopyFromSourceWord(word); item.ObjectKind = ObjectKind.Main; Result.Items.Add(item); } }
public override void ProcessSentence(Sentence sentence) { _sentence = sentence; Debug.Assert(sentence.WordList != null); Debug.Assert(sentence.WordList.Count > 0); // ищем слова с сочинительной связью, добавляем их, а также их потомков, проверяя итоговый список на уникальность findWordsWithSochLink(); // получили некое начальное множество слов. Начинаем процедуру поиска дополнительных слов bool allDone = false; int lastIterationUniformPartsCount, currentIterationUniformPartsCount; while (!allDone) { currentIterationUniformPartsCount = 0; lastIterationUniformPartsCount = getAllUniformPartsIds().Count; //ищем предлоги и вспомогательные глаголы в имеющейся выборке findPrepositionsAndAuxVerbsStraight(); findPrepositionsAndAuxVerbs(getAllUniformPartsIds()); currentIterationUniformPartsCount = getAllUniformPartsIds().Count; allDone = currentIterationUniformPartsCount == lastIterationUniformPartsCount; } }
private static void _checkDataPresence(Sentence sentence, List<string> result) { _checkCollection(sentence.Subjects, "подлежащие", result); _checkCollection(sentence.Predicates, "сказуемые", result); _checkCollection(sentence.Uniforms, "однородные члены", result); _checkCollection(sentence.ValuableAuxParts, "значимый объект", result); _checkCollection(sentence.LinkedChains, result); }
public static LinguisticObjectDetectionMetrics MetricsFor(LinguisticObjectMatch objectMatch, Sentence targetSentence, Sentence sampleSentence, LinguisticObjectType objectType) { if (objectMatch.TargetObjects == null) return _metricsForMissedObject(objectMatch, sampleSentence); if (objectMatch.SampleObjects == null) return _metricsForSurplusTargetObject(objectMatch, sampleSentence, targetSentence, objectType); var targetWords = objectMatch.TargetObjects.Words; var sampleWords = objectMatch.SampleObjects.Words; var detectedWords = _getDetectedWords(targetWords, sampleWords); var surplusWords = targetWords.Where(word => !detectedWords.Contains(word)).ToList(); var missedWords = sampleWords.Where(word => targetWords.All(targetWord => targetWord.Text != word.Text)).ToList(); var essentialSurpluses = surplusWords.Where(word => !word.IsAuxilary).ToList(); var essentialSurplusText = essentialSurpluses.Select(word => word.Text).ToList(); var essentialSurplusIndexes = essentialSurpluses.Select(targetSentence.WordIndex).ToList(); var nonEssentialSurpluses = surplusWords.Where(word => word.IsAuxilary).ToList(); var nonEssentialSurplusTexts = nonEssentialSurpluses.Select(word => word.Text).ToList(); var nonEssentialSurplusIndexes = nonEssentialSurpluses.Select(targetSentence.WordIndex).ToList(); var essentialMises = missedWords.Where(word => !word.IsAuxilary).ToList(); var essentialMissTexts = essentialMises.Select(word => word.Text).ToList(); var essentialMissIndexes = essentialMises.Select(sampleSentence.WordIndex).ToList(); var nonEssentialMises = missedWords.Where(word => word.IsAuxilary).ToList(); var nonEssentialMissTexts = nonEssentialMises.Select(word => word.Text).ToList(); var nonEssentialMissIndexes = nonEssentialMises.Select(sampleSentence.WordIndex).ToList(); return new LinguisticObjectDetectionMetrics { SampleWords = sampleWords.Select(word => word.Text).ToArray(), TargetWords = targetWords.Select(word => word.Text).ToArray(), SampleWordsCount = sampleWords.Count, SampleWordIndexes = sampleWords.Select(sampleSentence.WordIndex).ToArray(), TargetWordsCount = targetWords.Count, TargetWordIndexes = targetWords.Select(targetSentence.WordIndex).ToArray(), NonEssentialErrors = nonEssentialSurplusTexts.Concat(nonEssentialMissTexts).ToArray(), NonEssentialErrorIndexes = nonEssentialSurplusIndexes.Concat(nonEssentialMissIndexes).ToArray(), EssentialErrors = essentialSurplusText.Concat(essentialMissTexts).ToArray(), EssentialErrorIndexes = essentialSurplusIndexes.Concat(essentialMissIndexes).ToArray(), SurplusNonEssentialWords = nonEssentialSurplusTexts.ToArray(), SurplusNonEssentialWordIndexes = nonEssentialSurplusIndexes.ToArray(), MissedNonEssentialWords = nonEssentialMissTexts.ToArray(), MissedNonEssentialWordIndexes = nonEssentialMissIndexes.ToArray(), SurplusEssentialWords = essentialSurplusText.ToArray(), SurplusEssentialWordIndexes = essentialSurplusIndexes.ToArray(), MissedEssentialWords = essentialMissTexts.ToArray(), MissedEssentialWordIndexes = essentialMissIndexes.ToArray(), CorrectDetectionsCount = detectedWords.Count, Type = ErrorType.DetectionDefect, DetectionQuality = detectedWords.Any() ? _getQualityMeasure(detectedWords.Count, essentialSurpluses.Count, sampleWords.Count) : 0d }; }
public static ComparisonResult Compare(Sentence target, Sentence sample, LinguisticObjectsMap objectsMap) { return new ComparisonResult { SampleSantence = sample, TargetSentence = target, SimpleSentenceStats = (new SamplesProcessor(target, sample))._calculateStats(objectsMap), SimpleSentecesComparison = _getStatsFoSS(objectsMap, target, sample) }; }
private SamplesProcessor(Sentence target, Sentence sample) { _target = target; _sample = sample; _simpleSentencesStats = new List<SimpleSentenceStats>(); for (var i = 0; i < Math.Max(target.SimpleSentences.Count, sample.SimpleSentences.Count); ++i) { _simpleSentencesStats.Add(new SimpleSentenceStats()); } }
public static List<string> Validate(Sentence sentence, int index) { var result = new List<string>(); _checkDataPresence(sentence, result); _checkLinkedChainMasterExists(sentence, result); _checkLinkedChainMaster(sentence, result); //_checkLinkedChainMasterIsSingleWord(sentence, result); return result.Select(s => String.Format("Предложение {0}: {1}", index + 1, s)).ToList(); }
public override void ProcessSentence(Sentence sentence) { _sentence = sentence; Debug.Assert(sentence.WordList != null); Debug.Assert(sentence.WordList.Count > 0); GetDependantResultsForObjectType(ObjectType.MeaningPartDependOn); GetDependantResultsForObjectType(ObjectType.SubjectDependOn); GetDependantResultsForObjectType(ObjectType.PredicateDependOn); // сразу делаем второй этап foreach (var word in Result.Items) word.IsConfirmed = !(word.Link.Value == LinkType.Sochin.Value); }
public static Sentence Convert(JsonSentence jsonSentence) { var result = new Sentence(); result.Words.AddRange(jsonSentence.Words); result.SimpleSentences.AddRange(jsonSentence.SimpleSentences.Select(list => wordIndexesToSimpleSentence(list, jsonSentence.Words))); result.LinkedChains.AddRange(jsonSentence.LinkedChains.Select(chain => jsonLinkedChainToModelChain(chain, jsonSentence.Words))); result.Uniforms.AddRange(wordIndexesListsToWordChains(jsonSentence.Uniforms, jsonSentence.Words)); result.ValuableAuxParts.AddRange(wordIndexesListsToWordChains(jsonSentence.ValuableAuxParts, jsonSentence.Words)); result.Subjects.AddRange(wordIndexesListsToWordChains(jsonSentence.Subjects, jsonSentence.Words)); result.Predicates.AddRange(wordIndexesListsToWordChains(jsonSentence.Predicates, jsonSentence.Words)); return result; }
private static LinguisticObjectsGroup _getStatsFoSS(LinguisticObjectsMap objectsMap, Sentence target, Sentence sample) { var result = new LinguisticObjectsGroup { Objects = objectsMap.SimpleSentences.Select(match => _processSimpleSentence(match, target, sample)).ToList() }; _chargePenalties(result.Objects); result.Objects.ForEach(o => SimpleSentenceStats.CalculateAverage(result)); var falsey = result.Objects.Any(o => o.MappedObjects.SampleObjects == null); return result; }
public override void ProcessSentence(Sentence sentence) { _sentence = sentence; Debug.Assert(sentence.ElementList != null); Debug.Assert(sentence.ElementList.Count > 0); foreach (SentenceElement word in sentence.ElementList.FindAll(x => (x.SyntacticRole.Value == SyntacticRole.Predicate.Value) & !(x.SurfaceSlot.Value == SurfaceSlot.InternalFiniteVerb.Value))) { Stage1ResultElement item = new Stage1ResultElement(); item.CopyFromSourceWord(word); Result.Items.Add(item); } }
public static JsonSentence Convert(Sentence sentence) { var result = new JsonSentence { Words = sentence.Words.ToArray(), Text = String.Join(" ", sentence.Words.Select(word => word.Text)), SimpleSentences = wordsCahinsToIndexesLists(sentence.SimpleSentences, sentence.Words), Uniforms = wordsCahinsToIndexesLists(sentence.Uniforms, sentence.Words), ValuableAuxParts = wordsCahinsToIndexesLists(sentence.ValuableAuxParts, sentence.Words), Subjects = wordsCahinsToIndexesLists(sentence.Subjects, sentence.Words), Predicates = wordsCahinsToIndexesLists(sentence.Predicates, sentence.Words), LinkedChains = linkedChainsToJsonModel(sentence.LinkedChains, sentence.Words) }; return result; }
public override void ProcessSentence(Sentence sentence) { _sentence = sentence; Debug.Assert(sentence.ElementList != null); Debug.Assert(sentence.ElementList.Count > 0); Stage1Result algorithmResult = Result; GetDependantResultsForObjectType(sentence, ObjectType.MeaningPartDependOn, _meaningPartStage4Result.Items.Select(x => x.Id).ToList(), ref algorithmResult); GetDependantResultsForObjectType(sentence, ObjectType.SubjectDependOn, _mainPartsStage4Result.Items.Where(x => (x.SyntacticRole.Value != SyntacticRole.Predicate.Value) || (x.IsQuantativePart == true) || (x.IsSubstantivator == true)).Select(x => x.Id).ToList(), ref algorithmResult); GetDependantResultsForObjectType(sentence, ObjectType.PredicateDependOn, _mainPartsStage4Result.Items.Where(x => (x.SyntacticRole.Value == SyntacticRole.Predicate.Value) || (x.IsNamePart == true) || (x.IsInfinitivePart == true)).Select(x => x.Id).ToList(), ref algorithmResult); }
public override void ProcessSentence(Sentence sentence) { _sentence = sentence; Debug.Assert(sentence.WordList != null); Debug.Assert(sentence.WordList.Count > 0); foreach (SentenceWord word in sentence.WordList.FindAll(x => x.DOM == SentenceWord.DOMRoot || x.Link.Value == LinkType.SentSoch.Value || x.Link.Value == LinkType.PodchSouz.Value || x.Link.Value == LinkType.InfSouz.Value || x.Link.Value == LinkType.Eksplet.Value || x.Link.Value == LinkType.Relyat.Value )) { Stage1ResultElement item = new Stage1ResultElement(); item.CopyFromSourceWord(word); Result.Items.Add(item); } }
public static LinguisticObjectsMap MapLinguisticObjects(Sentence target, Sentence sample) { var simpleSentencesMap = _mapSimpleSentences(target.SimpleSentences, sample.SimpleSentences); return new LinguisticObjectsMap { Subjects = _mapSimpleParts(target.Subjects, sample.Subjects, (targetWords, sampleWords) => _measureLoQuality(targetWords, sampleWords, simpleSentencesMap)), Predicates = _mapSimpleParts(target.Predicates, sample.Predicates, (targetWords, sampleWords) => _measureLoQuality(targetWords, sampleWords, simpleSentencesMap)), Uniforms = _mapSimpleParts(target.Uniforms, sample.Uniforms, (targetWords, sampleWords) => _measureLoQuality(targetWords, sampleWords, simpleSentencesMap)), MeaningAuxParts = _mapSimpleParts(target.ValuableAuxParts, sample.ValuableAuxParts, (targetWords, sampleWords) => _measureLoQuality(targetWords, sampleWords, simpleSentencesMap)), LinkedChains = _mapLinkedChains(target.LinkedChains, sample.LinkedChains, (targetWords, sampleWords) => _measureLoQuality(targetWords, sampleWords, simpleSentencesMap)), SimpleSentences = simpleSentencesMap }; }
public override void ProcessSentence(Sentence sentence) { _sentence = sentence; Debug.Assert(sentence.WordList != null); Debug.Assert(sentence.WordList.Count > 0); // подлежащие. часть1 foreach (SentenceWord word in sentence.WordList.FindAll(x => (x.Link.Value == LinkType.Predic.Value || x.Link.Value == LinkType.DatSubject.Value ))) { Stage1ResultElement item = new Stage1ResultElement(); item.CopyFromSourceWord(word); item.ObjectType = ObjectType.Subject; item.ObjectKind = ObjectKind.Main; Result.Items.Add(item); } //сказуемые foreach (SentenceWord word in sentence.WordList.FindAll(x => (x.DOM == SentenceWord.DOMRoot /*&& (x.PartOfSpeech.Value == PartOfSpeech.Verb.Value || x.IsAuxVerb)*/) || x.Link.Value == LinkType.SentSoch.Value || (x.Link.Value == LinkType.PodchSouz.Value && (x.PartOfSpeech.Value == PartOfSpeech.Verb.Value || x.IsAuxVerb)) || x.Link.Value == LinkType.InfSouz.Value || x.Link.Value == LinkType.Eksplet.Value || x.Link.Value == LinkType.Relyat.Value )) { Stage1ResultElement item = new Stage1ResultElement(); item.CopyFromSourceWord(word); item.ObjectType = ObjectType.Predicate; item.ObjectKind = ObjectKind.Main; Result.Items.Add(item); } }
public override void ProcessSentence(Sentence sentence) { _sentence = sentence; Debug.Assert(sentence.ElementList != null); Debug.Assert(sentence.ElementList.Count > 0); List<SentenceElement> words = sentence.ElementList; // разворачиваем все, что добавили на 3-м этапе в список резльтатов 4-го и после этого плюсуем к ним СЧР foreach (var itemStage3 in _meaningPartStage3Result.Items) { Stage4ResultElement item = new Stage4ResultElement(); item.CopyFromSourceWord(itemStage3); item.AddedWordsCase1 = itemStage3.AddedWordsCase1; item.AddedWordsCase2 = itemStage3.AddedWordsCase2; Result.Items.Add(item); } foreach (var itemStage4 in Result.Items) { itemStage4.ServiceParts.AddRange(words.FindAll(x => (x.SyntacticParentWordId == itemStage4.Id) && (x.IsServicePart))); // TODO: провести поиск СЧР для составных частей Add1 и Add2 // добавляем второй проход по выявленным СЧР, чтобы выявить ситуации "не были удовлетворены" (частица + вспом.глагол + XXX) List<SentenceElement> servicePartsSecondLevel = new List<SentenceElement>(); foreach (var servicePart in itemStage4.ServiceParts) servicePartsSecondLevel.AddRange(words.FindAll(x => (x.SyntacticParentWordId == servicePart.Id) && (x.IsServicePart))); itemStage4.ServiceParts.AddRange(servicePartsSecondLevel); } }
public override void ProcessSentence(Sentence sentence) { _sentence = sentence; Debug.Assert(sentence.ElementList != null); Debug.Assert(sentence.ElementList.Count > 0); _stage3Result.Items.GroupBy(uniform => uniform.RowId) .Aggregate(_modelBuilder, (builder, uniforms) => builder.AddUniforms(uniforms.OrderBy(uniform => uniform.Order))); Result.Items.AddRange(_modelBuilder.Sentence.Uniforms.Select(uniforms => new StageComparisonResultElement(uniforms))); }
public override void ProcessSentence(Sentence sentence) { _sentence = sentence; Debug.Assert(sentence.ElementList != null); Debug.Assert(sentence.ElementList.Count > 0); // необходимо найти все атомарные ряды ОЧ во всех простых предложениях int restoredRowId = -1; int normalRowId = 1; foreach (var lastConjuctedItem in _uniformPartsStage2Result.FindAll(x => (x.IsConfirmed) && (x.ConjuctedWithId == "-1"))) { // выбрали все слова, которые находятся на самом низком уровне сочинительной свзяи для ОЧ // идем наверх, добавляя items в результаты с текущим rowId var currentItem = lastConjuctedItem; while (currentItem != null) { Stage3ResultElement item = new Stage3ResultElement(); item.CopyFromSourceWord(currentItem); item.ObjectType = currentItem.ObjectType; // отделяем восстановленные ОЧ if (item.IsRestored) item.RowId = restoredRowId; else item.RowId = normalRowId; currentItem = _uniformPartsStage2Result.Find(x => (x.IsConfirmed) && (x.ConjuctedWithId == currentItem.Id)); Result.Items.Add(item); } if (Result.Items.Last().IsRestored) restoredRowId--; else normalRowId++; } foreach (var itemStage3 in Result.Items) { itemStage3.SeviceParts.AddRange(sentence.ElementList.FindAll(x => (x.SyntacticParentWordId == itemStage3.Id) && (x.IsServicePart))); // добавляем второй проход по выявленным СЧР, чтобы выявить ситуации "не были удовлетворены" (частица + вспом.глагол + XXX) List<SentenceElement> servicePartsSecondLevel = new List<SentenceElement>(); foreach (var servicePart in itemStage3.SeviceParts) servicePartsSecondLevel.AddRange(sentence.ElementList.FindAll(x => (x.SyntacticParentWordId == servicePart.Id) && (x.IsServicePart))); itemStage3.SeviceParts.AddRange(servicePartsSecondLevel); } }
public override void ProcessSentence(Sentence sentence) { _sentence = sentence; Debug.Assert(sentence.ElementList != null); Debug.Assert(sentence.ElementList.Count > 0); foreach (var stage1Result in _uniformPartsStage1Result) { Stage2ResultElement item = new Stage2ResultElement(); item.CopyFromSourceWord(stage1Result); item.ObjectType = stage1Result.ObjectType; item.SubjectIdForCompare = "-1"; // Все пред. ОЧ, которые не имеют Predicate тэга, подтверждаем. if (item.SyntacticRole.Value == SyntacticRole.Predicate.Value) { // Если у некоторого сказуемого нет подлежащего, оно также удаляется из предварительного списка ОЧ. if (sentence.ElementList.Find(x => (x.SyntacticParentWordId == stage1Result.Id) && (x.SyntacticRole.Value == SyntacticRole.Subject.Value)) == null) { item.IsConfirmed = false; Result.Items.Add(item); continue; } else { // У сказуемого есть подлежащее, находим его ID SentenceElement subjectForPredicate = sentence.ElementList.Find(x => (x.SyntacticParentWordId == stage1Result.Id) && (x.SyntacticRole.Value == SyntacticRole.Subject.Value)); if (subjectForPredicate != null) item.SubjectIdForCompare = subjectForPredicate.Id; // надо проверять, если такая ситуация возникнет!!! else item.SubjectIdForCompare = "-1000"; // если подлежащее - субстантиватор, то в Id ставим Id которым он контролируется SentenceElement substanSubject = (sentence.ElementList.Find(x => (x.Id == item.SubjectIdForCompare) && (x.ControllerNodes.Find(y => y.ConnectionType.Value == ControllerConnectionType.Ellipsis.Value) != null))); if (substanSubject != null) item.SubjectIdForCompare = substanSubject.ControllerNodes.Find(y => y.ConnectionType.Value == ControllerConnectionType.Ellipsis.Value).OriginalWordId; //если подлежащее восстановлено, то надо взять первый дочерний его элемент if (item.IsRestored) { SentenceElement firstChildWord = sentence.ElementList.Find(x => x.SyntacticParentWordId == item.Id && x.SyntacticRole.Value != SyntacticRole.Subject.Value); if (firstChildWord != null) item.CopyFromSourceWord(firstChildWord); } Result.Items.Add(item); } } else { item.IsConfirmed = true; Result.Items.Add(item); continue; } } foreach (var stage2Result in Result.Items.FindAll(x => x.SubjectIdForCompare != "-1")) stage2Result.IsConfirmed = Result.Items.FindAll(x => x.SubjectIdForCompare == stage2Result.SubjectIdForCompare).Count > 1; }
public override void ProcessSentence(Sentence sentence) { _sentence = sentence; Debug.Assert(_meaningPartStage4Result != null); Debug.Assert(_mainPartsStage4Result != null); Debug.Assert(_stage1Result != null); List<SentenceWord> words = sentence.WordList; int[] excludeIds = _getMainIds().ToArray(); foreach (var stage1Item in _stage1Result.Items.FindAll(x => x.IsConfirmed)) CreateDependantChain(stage1Item.DOM, stage1Item, excludeIds, stage1Item.ObjectType, null); foreach (var item in Result.Items.FindAll(x => x.IsConjuction)) { if (item.ChainWordsIds.Count > 0) { int firstChildId = item.ChainWordsIds.All.Values.First(); int domId = item.DOM; ObjectType type = item.ObjectType; var itemChainWords = item.ChainWordsIds; item.CopyFromSourceWord(_sentence.WordList.Find(x => x.Id == firstChildId)); item.DOM = domId; item.ObjectType = type; item.ChainWordsIds = itemChainWords; item.ChainWordsIds.Remove(firstChildId); } else Result.Items.Remove(item); } foreach (var item in Result.Items) shrinkResultBySimpleSentence(item); }
public override void ProcessSentence(Sentence sentence) { _sentence = sentence; Debug.Assert(_stage3Result != null); _stage3Result.Items.Aggregate(_modelBuilder, (builder, element) => builder.AddLinkedChain(_sentence.WordList.Find(x => x.Id == element.DOM), dependantWords(element))); Result.Items.AddRange(_modelBuilder.Sentence.LinkedChains.Select(chain => new StageComparisonResultElement(chain))); }
public override void ProcessSentence(Sentence sentence) { _sentence = sentence; Debug.Assert(sentence.ElementList != null); Debug.Assert(sentence.ElementList.Count > 0); // Необходимо подтвердить, что родителем значимого объекта является главный член. Если это не так, то это не значимый член. foreach (var resultStage1 in _meaningPartStage1Result.Items) { Stage2ResultElement item = new Stage2ResultElement(); item.CopyFromSourceWord(resultStage1); item.IsWordConfirmed = false; item.IsWordConfirmed = _mainPartsStage4Result.Items.Find(x => x.Id == item.SyntacticParentWordId) != null; // также надо проверить все составные части сказуемых и подлежащих foreach (var mainResultStage4 in _mainPartsStage4Result.Items) { foreach (var addedWord in (mainResultStage4.AddedWordsCase1.Concat(mainResultStage4.AddedWordsCase2).Concat(mainResultStage4.ServiceParts))) item.IsWordConfirmed = item.IsWordConfirmed || addedWord.Id == item.SyntacticParentWordId; } Result.Items.Add(item); } }
public override void ProcessSentence(Sentence sentence) { _sentence = sentence; Debug.Assert(sentence.ElementList != null); Debug.Assert(sentence.ElementList.Count > 0); foreach (var resultStage2 in _meaningPartStage2Result.Items.FindAll(x => x.IsWordConfirmed)) { Stage3ResultElement item = new Stage3ResultElement(); item.CopyFromSourceWord(resultStage2); List<SentenceElement> words = sentence.ElementList; List<SentenceElement> AddedWords1 = item.AddedWordsCase1; List<SentenceElement> AddedWords2 = item.AddedWordsCase2; // количественная группа LWSUtils.FindQuantativeGroup(item.Id, ref AddedWords1, ref words); item.AddedWordsCase1 = AddedWords1; // субстантиватор LWSUtils.FindSubstantivatorInfo(item.Id, ref AddedWords2, ref words); item.AddedWordsCase2 = AddedWords2; Result.Items.Add(item); } }
public override void ProcessSentence(Sentence sentence) { _sentence = sentence; Debug.Assert(_stage4Result != null); _stage4Result.Items.FindAll(x => !x.IsRestored).Select(_compileMeaningPart). Aggregate(_modelBuilder, (builder, meaningPart) => builder.AddMeaningPart(meaningPart)); Result.Items.AddRange(_modelBuilder.Sentence.ValuableAuxParts.Select(chain => new StageComparisonResultElement(chain))); }
public override void ProcessSentence(Sentence sentence) { _sentence = sentence; Debug.Assert(_stage3Result != null); // ищем частицы List<SentenceWord> particles = sentence.WordList.Where(x => x.PartOfSpeech.Value == PartOfSpeech.Particle.Value).ToList(); foreach (var itemStage3 in _stage3Result.Items) { Stage4ResultElement item = new Stage4ResultElement(); item.CopyFromSourceWord(itemStage3); SentenceWord particle; particle = particles.Find(x => x.DOM == item.Id); if (particle != null) { SentenceWord word = new SentenceWord(); word.CopyFromSourceWord(particle); item.ServiceParts.Add(word); } particle = particles.Find(x => item.ServiceParts.Select(y => y.Id).ToList().Contains(x.DOM)); if (particle != null) { SentenceWord word = new SentenceWord(); word.CopyFromSourceWord(particle); item.ServiceParts.Add(word); } Result.Items.Add(item); } }
public override void ProcessSentence(Sentence sentence) { _sentence = sentence; Debug.Assert(_stage1Result != null); // формируем список элементов этапа №1, которые либо сами являются началом цепочки однородности (conjuctedwith == -1), либо имеют таковые СЧР List<Stage1ResultElement> firstElements = _stage1Result.Items.Where(x => (x.ConjuctedWithId == -1 || x.ServiceParts.Where(y => y.ConjuctedWithId == -1).Count() > 0) ).ToList(); int rowId = 1; foreach (var lastConjuctedItem in firstElements) { // выбрали все слова, которые находятся на самом низком уровне сочинительной связи для ОЧ // идем наверх, добавляя items в результаты с текущим rowId // при этом понимаем, что связи могут быть древовидными var currentItem = lastConjuctedItem; while (currentItem != null) currentItem = _searchForAnotherItemAndAddIt(currentItem, rowId); rowId++; // удаляем союзы Result.Items.RemoveAll(x => x.IsConjuction); foreach (var sp in Result.Items) sp.ServiceParts.RemoveAll(x => x.IsConjuction); } // найдем номера ПП для каждого из полученных ОЧ foreach (var item in Result.Items) { item.SimpleSentenceNr = -1; SimpleSentences.Algorithms.Stage3ResultElement ss = _simpleSentencesStage3Result.Items.Find(x => x.Id == item.Id || x.ChainWordsIds.All.Values.Contains(item.Id)); if (ss != null) item.SimpleSentenceNr = ss.SimpleSentenceNr; } }