public void Graph()
{
DispatcherHelper.Initialize();
var segmentPool = new SegmentPool();
var projectService = Substitute.For <IProjectService>();
var dialogService = Substitute.For <IDialogService>();
var busyService = Substitute.For <IBusyService>();
var graphService = new GraphService(projectService);
var imageExportService = Substitute.For <IImageExportService>();
var analysisService = new AnalysisService(_spanFactory, segmentPool, projectService, dialogService, busyService);
WordPairsViewModel.Factory wordPairsFactory = () => new WordPairsViewModel(busyService);
var globalCorrespondences = new GlobalCorrespondencesViewModel(projectService, busyService, dialogService, imageExportService, graphService, wordPairsFactory);
CogProject project = TestHelpers.GetTestProject(_spanFactory, segmentPool);
project.Meanings.AddRange(new[] { new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3") });
project.Varieties.AddRange(new[] { new Variety("variety1"), new Variety("variety2"), new Variety("variety3") });
project.Varieties[0].Words.AddRange(new[] { new Word("hɛ.loʊ", project.Meanings[0]), new Word("gʊd", project.Meanings[1]), new Word("bæd", project.Meanings[2]) });
project.Varieties[1].Words.AddRange(new[] { new Word("hɛlp", project.Meanings[0]), new Word("gu.gəl", project.Meanings[1]), new Word("gu.fi", project.Meanings[2]) });
project.Varieties[2].Words.AddRange(new[] { new Word("wɜrd", project.Meanings[0]), new Word("kɑr", project.Meanings[1]), new Word("fʊt.bɔl", project.Meanings[2]) });
projectService.Project.Returns(project);
analysisService.SegmentAll();
projectService.ProjectOpened += Raise.Event();
Assert.That(globalCorrespondences.Graph, Is.Null);
Messenger.Default.Send(new PerformingComparisonMessage());
var varietyPairGenerator = new VarietyPairGenerator();
varietyPairGenerator.Process(project);
var wordPairGenerator = new SimpleWordPairGenerator(segmentPool, project, 0.3, ComponentIdentifiers.PrimaryWordAligner);
var globalCorrIdentifier = new SoundCorrespondenceIdentifier(segmentPool, project, ComponentIdentifiers.PrimaryWordAligner);
foreach (VarietyPair vp in project.VarietyPairs)
{
wordPairGenerator.Process(vp);
foreach (WordPair wp in vp.WordPairs)
{
wp.AreCognatePredicted = true;
}
vp.SoundChangeFrequencyDistribution = new ConditionalFrequencyDistribution <SoundContext, Ngram <Segment> >();
vp.SoundChangeProbabilityDistribution = new ConditionalProbabilityDistribution <SoundContext, Ngram <Segment> >(vp.SoundChangeFrequencyDistribution, (sc, fd) => new MaxLikelihoodProbabilityDistribution <Ngram <Segment> >(fd));
globalCorrIdentifier.Process(vp);
}
Messenger.Default.Send(new ComparisonPerformedMessage());
Assert.That(globalCorrespondences.Graph, Is.Not.Null);
globalCorrespondences.SyllablePosition = SyllablePosition.Nucleus;
Assert.That(globalCorrespondences.Graph, Is.Not.Null);
Messenger.Default.Send(new DomainModelChangedMessage(true));
Assert.That(globalCorrespondences.Graph, Is.Null);
globalCorrespondences.SyllablePosition = SyllablePosition.Coda;
Assert.That(globalCorrespondences.Graph, Is.Null);
}
private static void AddComparisonData(TestEnvironment env)
{
var varietyPairGenerator = new VarietyPairGenerator();
varietyPairGenerator.Process(env.Project);
var wordPairGenerator = new SimpleWordPairGenerator(env.SegmentPool, env.Project, 0.3, ComponentIdentifiers.PrimaryWordAligner);
foreach (VarietyPair vp in env.Project.VarietyPairs)
{
wordPairGenerator.Process(vp);
vp.CognateSoundCorrespondenceFrequencyDistribution = new ConditionalFrequencyDistribution <SoundContext, Ngram <Segment> >();
vp.CognateSoundCorrespondenceProbabilityDistribution = new ConditionalProbabilityDistribution <SoundContext, Ngram <Segment> >(vp.CognateSoundCorrespondenceFrequencyDistribution, (sc, fd) => new MaxLikelihoodProbabilityDistribution <Ngram <Segment> >(fd));
}
int i = 0;
foreach (WordPair wp in env.Project.VarietyPairs[0].WordPairs)
{
wp.PhoneticSimilarityScore = (1.0 / env.Project.VarietyPairs[0].WordPairs.Count) * (env.Project.VarietyPairs[0].WordPairs.Count - i);
wp.PredictedCognacy = wp.Meaning.Gloss.IsOneOf("gloss1", "gloss3");
i++;
}
i = 0;
foreach (WordPair wp in env.Project.VarietyPairs[1].WordPairs)
{
wp.PhoneticSimilarityScore = (1.0 / env.Project.VarietyPairs[1].WordPairs.Count) * (env.Project.VarietyPairs[1].WordPairs.Count - i);
wp.PredictedCognacy = false;
i++;
}
}
public TestEnvironment(string word1, string word2, bool ignoreRegularInsertionDeletion = false, bool regularConsEqual = false, bool automaticRegularCorrThreshold = false)
{
_segmentPool = new SegmentPool();
_project = TestHelpers.GetTestProject(_segmentPool);
_project.Meanings.Add(new Meaning("gloss1", "cat1"));
_project.Varieties.AddRange(new[] { new Variety("variety1"), new Variety("variety2") });
_project.Varieties[0].Words.Add(new Word(word1, _project.Meanings[0]));
_project.Varieties[1].Words.Add(new Word(word2, _project.Meanings[0]));
var varSegementer = new VarietySegmenter(_project.Segmenter);
foreach (Variety variety in _project.Varieties)
{
varSegementer.Process(variety);
}
var vp = new VarietyPair(_project.Varieties[0], _project.Varieties[1]);
_project.VarietyPairs.Add(vp);
var wordPairGenerator = new SimpleWordPairGenerator(_segmentPool, _project, 0.3, "primary");
wordPairGenerator.Process(vp);
vp.CognateSoundCorrespondenceFrequencyDistribution = new ConditionalFrequencyDistribution <SoundContext, Ngram <Segment> >();
var ignoredMappings = Substitute.For <ISegmentMappings>();
var similarSegmentsMappings = Substitute.For <ISegmentMappings>();
_cognateIdentifier = new BlairCognateIdentifier(_segmentPool, ignoreRegularInsertionDeletion, regularConsEqual, automaticRegularCorrThreshold,
3, ignoredMappings, similarSegmentsMappings);
_aligner = new TestWordAligner(_segmentPool);
}
public void UpdateCognicity_RegularCorrespondences()
{
var segmentPool = new SegmentPool();
CogProject project = TestHelpers.GetTestProject(_spanFactory, segmentPool);
project.Meanings.AddRange(new[] { new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3") });
project.Varieties.AddRange(new[] { new Variety("variety1"), new Variety("variety2") });
project.Varieties[0].Words.AddRange(new[] { new Word("hɛ.lo", project.Meanings[0]), new Word("gʊd", project.Meanings[1]), new Word("bæ", project.Meanings[2]) });
project.Varieties[1].Words.AddRange(new[] { new Word("hɛ.ɬa", project.Meanings[0]), new Word("gud", project.Meanings[1]), new Word("pæ", project.Meanings[2]) });
var varSegementer = new VarietySegmenter(project.Segmenter);
foreach (Variety variety in project.Varieties)
{
varSegementer.Process(variety);
}
var vp = new VarietyPair(project.Varieties[0], project.Varieties[1]);
project.VarietyPairs.Add(vp);
var wordPairGenerator = new SimpleWordPairGenerator(segmentPool, project, 0.3, "primary");
wordPairGenerator.Process(vp);
vp.SoundChangeFrequencyDistribution[new SoundContext(segmentPool.GetExisting("l"))].Increment(segmentPool.GetExisting("ɬ"), 3);
vp.SoundChangeFrequencyDistribution[new SoundContext(segmentPool.GetExisting("b"))].Increment(segmentPool.GetExisting("p"), 3);
var aligner = new TestWordAligner(segmentPool);
var ignoredMappings = Substitute.For <ISegmentMappings>();
ignoredMappings.IsMapped(Arg.Any <ShapeNode>(), Arg.Any <Ngram <Segment> >(), Arg.Any <ShapeNode>(), Arg.Any <ShapeNode>(), Arg.Any <Ngram <Segment> >(), Arg.Any <ShapeNode>()).Returns(false);
var similarSegmentsMappings = Substitute.For <ISegmentMappings>();
similarSegmentsMappings.IsMapped(Arg.Any <ShapeNode>(), segmentPool.GetExisting("b"), Arg.Any <ShapeNode>(), Arg.Any <ShapeNode>(), segmentPool.GetExisting("p"), Arg.Any <ShapeNode>()).Returns(true);
var cognateIdentifier = new BlairCognateIdentifier(segmentPool, false, false, ignoredMappings, similarSegmentsMappings);
var wp = vp.WordPairs[0];
cognateIdentifier.UpdateCognicity(wp, aligner.Compute(wp));
Assert.That(wp.AreCognatePredicted, Is.True);
wp = vp.WordPairs[1];
cognateIdentifier.UpdateCognicity(wp, aligner.Compute(wp));
Assert.That(wp.AreCognatePredicted, Is.True);
wp = vp.WordPairs[2];
cognateIdentifier.UpdateCognicity(wp, aligner.Compute(wp));
Assert.That(wp.AreCognatePredicted, Is.True);
}
public void TaskAreas_ChangeSorting_WordPairOrderingUpdated()
{
using (var env = new TestEnvironment())
{
env.Project.Meanings.AddRange(new[] { new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3"), new Meaning("gloss4", "cat4") });
env.Project.Varieties.AddRange(new[] { new Variety("variety1"), new Variety("variety2"), new Variety("variety3") });
env.Project.Varieties[0].Words.AddRange(new[] { new Word("hɛ.loʊ", env.Project.Meanings[0]), new Word("gʊd", env.Project.Meanings[1]), new Word("bæd", env.Project.Meanings[2]), new Word("wɜrd", env.Project.Meanings[3]) });
env.Project.Varieties[1].Words.AddRange(new[] { new Word("hɛlp", env.Project.Meanings[0]), new Word("gu.gəl", env.Project.Meanings[1]), new Word("gu.fi", env.Project.Meanings[2]), new Word("kɑr", env.Project.Meanings[3]) });
env.AnalysisService.SegmentAll();
var varietyPairGenerator = new VarietyPairGenerator();
varietyPairGenerator.Process(env.Project);
var wordPairGenerator = new SimpleWordPairGenerator(env.SegmentPool, env.Project, 0.3, ComponentIdentifiers.PrimaryWordAligner);
foreach (VarietyPair vp in env.Project.VarietyPairs)
{
wordPairGenerator.Process(vp);
vp.CognateSoundCorrespondenceFrequencyDistribution = new ConditionalFrequencyDistribution <SoundContext, Ngram <Segment> >();
vp.CognateSoundCorrespondenceProbabilityDistribution = new ConditionalProbabilityDistribution <SoundContext, Ngram <Segment> >(vp.CognateSoundCorrespondenceFrequencyDistribution, (sc, fd) => new MaxLikelihoodProbabilityDistribution <Ngram <Segment> >(fd));
}
int i = 0;
foreach (WordPair wp in env.Project.VarietyPairs[0].WordPairs)
{
wp.PhoneticSimilarityScore = (1.0 / env.Project.VarietyPairs[0].WordPairs.Count) * (i + 1);
wp.PredictedCognacy = wp.Meaning.Gloss.IsOneOf("gloss1", "gloss3");
i++;
}
env.OpenProject();
env.SetupWordPairsViews();
WordPairViewModel[] cognatesArray = env.Cognates.WordPairsView.Cast <WordPairViewModel>().ToArray();
WordPairViewModel[] noncognatesArray = env.Noncognates.WordPairsView.Cast <WordPairViewModel>().ToArray();
Assert.That(cognatesArray.Select(wp => wp.Meaning.Gloss), Is.EqualTo(new[] { "gloss3", "gloss1" }));
Assert.That(noncognatesArray.Select(wp => wp.Meaning.Gloss), Is.EqualTo(new[] { "gloss4", "gloss2" }));
var commonTasks = (TaskAreaItemsViewModel)env.VarietyPairs.TaskAreas[0];
var sortWordsByItems = (TaskAreaItemsViewModel)commonTasks.Items[2];
var sortWordsByGroup = (TaskAreaCommandGroupViewModel)sortWordsByItems.Items[0];
// default sorting is by similarity, change to gloss
sortWordsByGroup.SelectedCommand = sortWordsByGroup.Commands[1];
sortWordsByGroup.SelectedCommand.Command.Execute(null);
cognatesArray = env.Cognates.WordPairsView.Cast <WordPairViewModel>().ToArray();
noncognatesArray = env.Noncognates.WordPairsView.Cast <WordPairViewModel>().ToArray();
Assert.That(cognatesArray.Select(wp => wp.Meaning.Gloss), Is.EqualTo(new[] { "gloss1", "gloss3" }));
Assert.That(noncognatesArray.Select(wp => wp.Meaning.Gloss), Is.EqualTo(new[] { "gloss2", "gloss4" }));
}
}
public void UpdateCognicity_NoSimilarSegments()
{
var segmentPool = new SegmentPool();
CogProject project = TestHelpers.GetTestProject(_spanFactory, segmentPool);
project.Meanings.AddRange(new[] { new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3") });
project.Varieties.AddRange(new[] { new Variety("variety1"), new Variety("variety2") });
project.Varieties[0].Words.AddRange(new[] { new Word("hɛ.loʊ", project.Meanings[0]), new Word("gʊd", project.Meanings[1]), new Word("bæ", project.Meanings[2]) });
project.Varieties[1].Words.AddRange(new[] { new Word("hɛ.ɬa", project.Meanings[0]), new Word("gud", project.Meanings[1]), new Word("pæ", project.Meanings[2]) });
var varSegementer = new VarietySegmenter(project.Segmenter);
foreach (Variety variety in project.Varieties)
{
varSegementer.Process(variety);
}
var vp = new VarietyPair(project.Varieties[0], project.Varieties[1]);
project.VarietyPairs.Add(vp);
var wordPairGenerator = new SimpleWordPairGenerator(segmentPool, project, 0.3, "primary");
wordPairGenerator.Process(vp);
var aligner = new TestWordAligner(segmentPool);
var ignoredMappings = Substitute.For <ISegmentMappings>();
var similarSegmentsMappings = Substitute.For <ISegmentMappings>();
var cognateIdentifier = new BlairCognateIdentifier(segmentPool, false, false, ignoredMappings, similarSegmentsMappings);
var wp = vp.WordPairs[0];
cognateIdentifier.UpdateCognicity(wp, aligner.Compute(wp));
Assert.That(wp.AreCognatePredicted, Is.False);
wp = vp.WordPairs[1];
cognateIdentifier.UpdateCognicity(wp, aligner.Compute(wp));
Assert.That(wp.AreCognatePredicted, Is.True);
wp = vp.WordPairs[2];
cognateIdentifier.UpdateCognicity(wp, aligner.Compute(wp));
Assert.That(wp.AreCognatePredicted, Is.False);
}
public void UpdateCognacy_RegularCorrespondences()
{
var segmentPool = new SegmentPool();
CogProject project = TestHelpers.GetTestProject(_spanFactory, segmentPool);
project.Meanings.AddRange(new[] {new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3")});
project.Varieties.AddRange(new[] {new Variety("variety1"), new Variety("variety2")});
project.Varieties[0].Words.AddRange(new[] {new Word("hɛ.lo", project.Meanings[0]), new Word("gʊd", project.Meanings[1]), new Word("bæ", project.Meanings[2])});
project.Varieties[1].Words.AddRange(new[] {new Word("hɛ.ɬa", project.Meanings[0]), new Word("gud", project.Meanings[1]), new Word("pæ", project.Meanings[2])});
var varSegementer = new VarietySegmenter(project.Segmenter);
foreach (Variety variety in project.Varieties)
varSegementer.Process(variety);
var vp = new VarietyPair(project.Varieties[0], project.Varieties[1]);
project.VarietyPairs.Add(vp);
var wordPairGenerator = new SimpleWordPairGenerator(segmentPool, project, 0.3, "primary");
wordPairGenerator.Process(vp);
vp.SoundChangeFrequencyDistribution[new SoundContext(segmentPool.GetExisting("l"))].Increment(segmentPool.GetExisting("ɬ"), 3);
vp.SoundChangeFrequencyDistribution[new SoundContext(segmentPool.GetExisting("b"))].Increment(segmentPool.GetExisting("p"), 3);
var aligner = new TestWordAligner(segmentPool);
var ignoredMappings = Substitute.For<ISegmentMappings>();
ignoredMappings.IsMapped(Arg.Any<ShapeNode>(), Arg.Any<Ngram<Segment>>(), Arg.Any<ShapeNode>(), Arg.Any<ShapeNode>(), Arg.Any<Ngram<Segment>>(), Arg.Any<ShapeNode>()).Returns(false);
var similarSegmentsMappings = Substitute.For<ISegmentMappings>();
similarSegmentsMappings.IsMapped(Arg.Any<ShapeNode>(), segmentPool.GetExisting("b"), Arg.Any<ShapeNode>(), Arg.Any<ShapeNode>(), segmentPool.GetExisting("p"), Arg.Any<ShapeNode>()).Returns(true);
var cognateIdentifier = new BlairCognateIdentifier(segmentPool, false, false, ignoredMappings, similarSegmentsMappings);
var wp = vp.WordPairs[0];
cognateIdentifier.UpdateCognacy(wp, aligner.Compute(wp));
Assert.That(wp.AreCognatePredicted, Is.True);
wp = vp.WordPairs[1];
cognateIdentifier.UpdateCognacy(wp, aligner.Compute(wp));
Assert.That(wp.AreCognatePredicted, Is.True);
wp = vp.WordPairs[2];
cognateIdentifier.UpdateCognacy(wp, aligner.Compute(wp));
Assert.That(wp.AreCognatePredicted, Is.True);
}
public void UpdateCognacy_NoSimilarSegments()
{
var segmentPool = new SegmentPool();
CogProject project = TestHelpers.GetTestProject(_spanFactory, segmentPool);
project.Meanings.AddRange(new[] {new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3")});
project.Varieties.AddRange(new[] {new Variety("variety1"), new Variety("variety2")});
project.Varieties[0].Words.AddRange(new[] {new Word("hɛ.loʊ", project.Meanings[0]), new Word("gʊd", project.Meanings[1]), new Word("bæ", project.Meanings[2])});
project.Varieties[1].Words.AddRange(new[] {new Word("hɛ.ɬa", project.Meanings[0]), new Word("gud", project.Meanings[1]), new Word("pæ", project.Meanings[2])});
var varSegementer = new VarietySegmenter(project.Segmenter);
foreach (Variety variety in project.Varieties)
varSegementer.Process(variety);
var vp = new VarietyPair(project.Varieties[0], project.Varieties[1]);
project.VarietyPairs.Add(vp);
var wordPairGenerator = new SimpleWordPairGenerator(segmentPool, project, 0.3, "primary");
wordPairGenerator.Process(vp);
var aligner = new TestWordAligner(segmentPool);
var ignoredMappings = Substitute.For<ISegmentMappings>();
var similarSegmentsMappings = Substitute.For<ISegmentMappings>();
var cognateIdentifier = new BlairCognateIdentifier(segmentPool, false, false, ignoredMappings, similarSegmentsMappings);
var wp = vp.WordPairs[0];
cognateIdentifier.UpdateCognacy(wp, aligner.Compute(wp));
Assert.That(wp.AreCognatePredicted, Is.False);
wp = vp.WordPairs[1];
cognateIdentifier.UpdateCognacy(wp, aligner.Compute(wp));
Assert.That(wp.AreCognatePredicted, Is.True);
wp = vp.WordPairs[2];
cognateIdentifier.UpdateCognacy(wp, aligner.Compute(wp));
Assert.That(wp.AreCognatePredicted, Is.False);
}
public void ObservedWordPairs()
{
DispatcherHelper.Initialize();
var segmentPool = new SegmentPool();
var projectService = Substitute.For <IProjectService>();
var dialogService = Substitute.For <IDialogService>();
var busyService = Substitute.For <IBusyService>();
var graphService = new GraphService(projectService);
var imageExportService = Substitute.For <IImageExportService>();
var analysisService = new AnalysisService(_spanFactory, segmentPool, projectService, dialogService, busyService);
WordPairsViewModel.Factory wordPairsFactory = () => new WordPairsViewModel(busyService);
WordPairViewModel.Factory wordPairFactory = (pair, order) => new WordPairViewModel(projectService, analysisService, pair, order);
var globalCorrespondences = new GlobalCorrespondencesViewModel(projectService, busyService, dialogService, imageExportService, graphService, wordPairsFactory, wordPairFactory);
CogProject project = TestHelpers.GetTestProject(_spanFactory, segmentPool);
project.Meanings.AddRange(new[] { new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3") });
project.Varieties.AddRange(new[] { new Variety("variety1"), new Variety("variety2"), new Variety("variety3") });
project.Varieties[0].Words.AddRange(new[] { new Word("hɛ.loʊ", project.Meanings[0]), new Word("gʊd", project.Meanings[1]), new Word("bæd", project.Meanings[2]) });
project.Varieties[1].Words.AddRange(new[] { new Word("hɛlp", project.Meanings[0]), new Word("gu.gəl", project.Meanings[1]), new Word("gu.fi", project.Meanings[2]) });
project.Varieties[2].Words.AddRange(new[] { new Word("wɜrd", project.Meanings[0]), new Word("kɑr", project.Meanings[1]), new Word("fʊt.bɔl", project.Meanings[2]) });
projectService.Project.Returns(project);
analysisService.SegmentAll();
var varietyPairGenerator = new VarietyPairGenerator();
varietyPairGenerator.Process(project);
var wordPairGenerator = new SimpleWordPairGenerator(segmentPool, project, 0.3, ComponentIdentifiers.PrimaryWordAligner);
var globalCorrIdentifier = new SoundCorrespondenceIdentifier(segmentPool, project, ComponentIdentifiers.PrimaryWordAligner);
foreach (VarietyPair vp in project.VarietyPairs)
{
wordPairGenerator.Process(vp);
foreach (WordPair wp in vp.WordPairs)
{
wp.PredictedCognacy = true;
}
vp.CognateSoundCorrespondenceFrequencyDistribution = new ConditionalFrequencyDistribution <SoundContext, Ngram <Segment> >();
vp.CognateSoundCorrespondenceProbabilityDistribution = new ConditionalProbabilityDistribution <SoundContext, Ngram <Segment> >(vp.CognateSoundCorrespondenceFrequencyDistribution, (sc, fd) => new MaxLikelihoodProbabilityDistribution <Ngram <Segment> >(fd));
globalCorrIdentifier.Process(vp);
}
projectService.AreAllVarietiesCompared.Returns(true);
projectService.ProjectOpened += Raise.Event();
var observedWordPairs = globalCorrespondences.ObservedWordPairs;
observedWordPairs.WordPairsView = new ListCollectionView(observedWordPairs.WordPairs);
Assert.That(observedWordPairs.WordPairsView, Is.Empty);
globalCorrespondences.SelectedCorrespondence = globalCorrespondences.Graph.Edges.First(e => e.Source.StrRep == "g" && e.Target.StrRep == "k");
WordPairViewModel[] wordPairsArray = observedWordPairs.WordPairsView.Cast <WordPairViewModel>().ToArray();
Assert.That(wordPairsArray.Length, Is.EqualTo(2));
Assert.That(wordPairsArray[0].Meaning.Gloss, Is.EqualTo("gloss2"));
Assert.That(wordPairsArray[0].AlignedNodes[2].IsSelected, Is.True);
Assert.That(wordPairsArray[1].Meaning.Gloss, Is.EqualTo("gloss2"));
Assert.That(wordPairsArray[1].AlignedNodes[0].IsSelected, Is.True);
globalCorrespondences.SyllablePosition = SyllablePosition.Nucleus;
globalCorrespondences.SelectedCorrespondence = globalCorrespondences.Graph.Edges.First(e => e.Source.StrRep == "ʊ" && e.Target.StrRep == "u");
wordPairsArray = observedWordPairs.WordPairsView.Cast <WordPairViewModel>().ToArray();
Assert.That(wordPairsArray.Length, Is.EqualTo(2));
Assert.That(wordPairsArray[0].Meaning.Gloss, Is.EqualTo("gloss2"));
Assert.That(wordPairsArray[0].AlignedNodes[1].IsSelected, Is.True);
Assert.That(wordPairsArray[1].Meaning.Gloss, Is.EqualTo("gloss3"));
Assert.That(wordPairsArray[1].AlignedNodes[1].IsSelected, Is.True);
globalCorrespondences.SelectedCorrespondence = null;
Assert.That(observedWordPairs.WordPairsView, Is.Empty);
}
public void TaskAreas()
{
DispatcherHelper.Initialize();
var segmentPool = new SegmentPool();
var projectService = Substitute.For <IProjectService>();
var dialogService = Substitute.For <IDialogService>();
var busyService = Substitute.For <IBusyService>();
var exportService = Substitute.For <IExportService>();
var analysisService = new AnalysisService(_spanFactory, segmentPool, projectService, dialogService, busyService);
WordPairsViewModel.Factory wordPairsFactory = () => new WordPairsViewModel(busyService);
VarietyPairViewModel.Factory varietyPairFactory = (vp, order) => new VarietyPairViewModel(segmentPool, projectService, wordPairsFactory, vp, order);
var varietyPairs = new VarietyPairsViewModel(projectService, busyService, dialogService, exportService, analysisService, varietyPairFactory);
CogProject project = TestHelpers.GetTestProject(_spanFactory, segmentPool);
project.Meanings.AddRange(new[] { new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3"), new Meaning("gloss4", "cat4") });
project.Varieties.AddRange(new[] { new Variety("variety1"), new Variety("variety2"), new Variety("variety3") });
project.Varieties[0].Words.AddRange(new[] { new Word("hɛ.loʊ", project.Meanings[0]), new Word("gʊd", project.Meanings[1]), new Word("bæd", project.Meanings[2]), new Word("wɜrd", project.Meanings[3]) });
project.Varieties[1].Words.AddRange(new[] { new Word("hɛlp", project.Meanings[0]), new Word("gu.gəl", project.Meanings[1]), new Word("gu.fi", project.Meanings[2]), new Word("kɑr", project.Meanings[3]) });
projectService.Project.Returns(project);
analysisService.SegmentAll();
var varietyPairGenerator = new VarietyPairGenerator();
varietyPairGenerator.Process(project);
var wordPairGenerator = new SimpleWordPairGenerator(segmentPool, project, 0.3, ComponentIdentifiers.PrimaryWordAligner);
foreach (VarietyPair vp in project.VarietyPairs)
{
wordPairGenerator.Process(vp);
vp.SoundChangeFrequencyDistribution = new ConditionalFrequencyDistribution <SoundContext, Ngram <Segment> >();
vp.SoundChangeProbabilityDistribution = new ConditionalProbabilityDistribution <SoundContext, Ngram <Segment> >(vp.SoundChangeFrequencyDistribution, (sc, fd) => new MaxLikelihoodProbabilityDistribution <Ngram <Segment> >(fd));
}
int i = 0;
foreach (WordPair wp in project.VarietyPairs[0].WordPairs)
{
wp.PhoneticSimilarityScore = (1.0 / project.VarietyPairs[0].WordPairs.Count) * (i + 1);
wp.AreCognatePredicted = wp.Meaning.Gloss.IsOneOf("gloss1", "gloss3");
i++;
}
projectService.ProjectOpened += Raise.Event();
varietyPairs.VarietiesView1 = new ListCollectionView(varietyPairs.Varieties);
varietyPairs.VarietiesView2 = new ListCollectionView(varietyPairs.Varieties);
WordPairsViewModel cognates = varietyPairs.SelectedVarietyPair.Cognates;
cognates.WordPairsView = new ListCollectionView(cognates.WordPairs);
WordPairViewModel[] cognatesArray = cognates.WordPairsView.Cast <WordPairViewModel>().ToArray();
WordPairsViewModel noncognates = varietyPairs.SelectedVarietyPair.Noncognates;
noncognates.WordPairsView = new ListCollectionView(noncognates.WordPairs);
WordPairViewModel[] noncognatesArray = noncognates.WordPairsView.Cast <WordPairViewModel>().ToArray();
Assert.That(cognatesArray.Select(wp => wp.Meaning.Gloss), Is.EqualTo(new[] { "gloss3", "gloss1" }));
Assert.That(noncognatesArray.Select(wp => wp.Meaning.Gloss), Is.EqualTo(new[] { "gloss4", "gloss2" }));
var commonTasks = (TaskAreaItemsViewModel)varietyPairs.TaskAreas[0];
var sortWordsByItems = (TaskAreaItemsViewModel)commonTasks.Items[2];
var sortWordsByGroup = (TaskAreaCommandGroupViewModel)sortWordsByItems.Items[0];
// default sorting is by similarity, change to gloss
sortWordsByGroup.SelectedCommand = sortWordsByGroup.Commands[1];
sortWordsByGroup.SelectedCommand.Command.Execute(null);
cognatesArray = cognates.WordPairsView.Cast <WordPairViewModel>().ToArray();
noncognatesArray = noncognates.WordPairsView.Cast <WordPairViewModel>().ToArray();
Assert.That(cognatesArray.Select(wp => wp.Meaning.Gloss), Is.EqualTo(new[] { "gloss1", "gloss3" }));
Assert.That(noncognatesArray.Select(wp => wp.Meaning.Gloss), Is.EqualTo(new[] { "gloss2", "gloss4" }));
}
public void FindCommand()
{
DispatcherHelper.Initialize();
var segmentPool = new SegmentPool();
var projectService = Substitute.For <IProjectService>();
var dialogService = Substitute.For <IDialogService>();
var busyService = Substitute.For <IBusyService>();
var exportService = Substitute.For <IExportService>();
var analysisService = new AnalysisService(_spanFactory, segmentPool, projectService, dialogService, busyService);
WordPairsViewModel.Factory wordPairsFactory = () => new WordPairsViewModel(busyService);
VarietyPairViewModel.Factory varietyPairFactory = (vp, order) => new VarietyPairViewModel(segmentPool, projectService, wordPairsFactory, vp, order);
var varietyPairs = new VarietyPairsViewModel(projectService, busyService, dialogService, exportService, analysisService, varietyPairFactory);
CogProject project = TestHelpers.GetTestProject(_spanFactory, segmentPool);
project.Meanings.AddRange(new[] { new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3") });
project.Varieties.AddRange(new[] { new Variety("variety1"), new Variety("variety2"), new Variety("variety3") });
project.Varieties[0].Words.AddRange(new[] { new Word("hɛ.loʊ", project.Meanings[0]), new Word("gʊd", project.Meanings[1]), new Word("bæd", project.Meanings[2]) });
project.Varieties[1].Words.AddRange(new[] { new Word("hɛlp", project.Meanings[0]), new Word("gu.gəl", project.Meanings[1]), new Word("gu.fi", project.Meanings[2]) });
project.Varieties[2].Words.AddRange(new[] { new Word("wɜrd", project.Meanings[0]), new Word("kɑr", project.Meanings[1]), new Word("fʊt.bɔl", project.Meanings[2]) });
projectService.Project.Returns(project);
analysisService.SegmentAll();
var varietyPairGenerator = new VarietyPairGenerator();
varietyPairGenerator.Process(project);
var wordPairGenerator = new SimpleWordPairGenerator(segmentPool, project, 0.3, ComponentIdentifiers.PrimaryWordAligner);
foreach (VarietyPair vp in project.VarietyPairs)
{
wordPairGenerator.Process(vp);
vp.SoundChangeFrequencyDistribution = new ConditionalFrequencyDistribution <SoundContext, Ngram <Segment> >();
vp.SoundChangeProbabilityDistribution = new ConditionalProbabilityDistribution <SoundContext, Ngram <Segment> >(vp.SoundChangeFrequencyDistribution, (sc, fd) => new MaxLikelihoodProbabilityDistribution <Ngram <Segment> >(fd));
}
int i = 0;
foreach (WordPair wp in project.VarietyPairs[0].WordPairs)
{
wp.PhoneticSimilarityScore = (1.0 / project.VarietyPairs[0].WordPairs.Count) * (project.VarietyPairs[0].WordPairs.Count - i);
wp.AreCognatePredicted = wp.Meaning.Gloss.IsOneOf("gloss1", "gloss3");
i++;
}
i = 0;
foreach (WordPair wp in project.VarietyPairs[1].WordPairs)
{
wp.PhoneticSimilarityScore = (1.0 / project.VarietyPairs[1].WordPairs.Count) * (project.VarietyPairs[1].WordPairs.Count - i);
i++;
}
projectService.ProjectOpened += Raise.Event();
varietyPairs.VarietiesView1 = new ListCollectionView(varietyPairs.Varieties);
varietyPairs.VarietiesView2 = new ListCollectionView(varietyPairs.Varieties);
WordPairsViewModel cognates = varietyPairs.SelectedVarietyPair.Cognates;
cognates.WordPairsView = new ListCollectionView(cognates.WordPairs);
WordPairViewModel[] cognatesArray = cognates.WordPairsView.Cast <WordPairViewModel>().ToArray();
WordPairsViewModel noncognates = varietyPairs.SelectedVarietyPair.Noncognates;
noncognates.WordPairsView = new ListCollectionView(noncognates.WordPairs);
WordPairViewModel[] noncognatesArray = noncognates.WordPairsView.Cast <WordPairViewModel>().ToArray();
FindViewModel findViewModel = null;
Action closeCallback = null;
dialogService.ShowModelessDialog(varietyPairs, Arg.Do <FindViewModel>(vm => findViewModel = vm), Arg.Do <Action>(callback => closeCallback = callback));
varietyPairs.FindCommand.Execute(null);
Assert.That(findViewModel, Is.Not.Null);
Assert.That(closeCallback, Is.Not.Null);
// already open, shouldn't get opened twice
dialogService.ClearReceivedCalls();
varietyPairs.FindCommand.Execute(null);
dialogService.DidNotReceive().ShowModelessDialog(varietyPairs, Arg.Any <FindViewModel>(), Arg.Any <Action>());
// form searches
findViewModel.Field = FindField.Form;
// nothing selected, no match
findViewModel.String = "nothing";
findViewModel.FindNextCommand.Execute(null);
Assert.That(cognates.SelectedWordPairs, Is.Empty);
Assert.That(noncognates.SelectedWordPairs, Is.Empty);
// nothing selected, matches
findViewModel.String = "g";
findViewModel.FindNextCommand.Execute(null);
Assert.That(cognates.SelectedWordPairs, Is.EquivalentTo(cognatesArray[1].ToEnumerable()));
Assert.That(noncognates.SelectedWordPairs, Is.Empty);
findViewModel.FindNextCommand.Execute(null);
Assert.That(cognates.SelectedWordPairs, Is.Empty);
Assert.That(noncognates.SelectedWordPairs, Is.EquivalentTo(noncognatesArray[0].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(cognates.SelectedWordPairs, Is.Empty);
Assert.That(noncognates.SelectedWordPairs, Is.EquivalentTo(noncognatesArray[0].ToEnumerable()));
// first word selected, matches
noncognates.SelectedWordPairs.Clear();
cognates.SelectedWordPairs.Add(cognatesArray[0]);
findViewModel.String = "ʊ";
findViewModel.FindNextCommand.Execute(null);
Assert.That(cognates.SelectedWordPairs, Is.Empty);
Assert.That(noncognates.SelectedWordPairs, Is.EquivalentTo(noncognatesArray[0].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(cognates.SelectedWordPairs, Is.EquivalentTo(cognatesArray[0].ToEnumerable()));
Assert.That(noncognates.SelectedWordPairs, Is.Empty);
findViewModel.FindNextCommand.Execute(null);
Assert.That(cognates.SelectedWordPairs, Is.EquivalentTo(cognatesArray[0].ToEnumerable()));
Assert.That(noncognates.SelectedWordPairs, Is.Empty);
// start over
findViewModel.FindNextCommand.Execute(null);
Assert.That(cognates.SelectedWordPairs, Is.Empty);
Assert.That(noncognates.SelectedWordPairs, Is.EquivalentTo(noncognatesArray[0].ToEnumerable()));
// last word selected, matches
cognates.SelectedWordPairs.Clear();
noncognates.SelectedWordPairs.Add(noncognatesArray[0]);
findViewModel.String = "h";
findViewModel.FindNextCommand.Execute(null);
Assert.That(cognates.SelectedWordPairs, Is.EquivalentTo(cognatesArray[0].ToEnumerable()));
Assert.That(noncognates.SelectedWordPairs, Is.Empty);
findViewModel.FindNextCommand.Execute(null);
Assert.That(cognates.SelectedWordPairs, Is.EquivalentTo(cognatesArray[0].ToEnumerable()));
Assert.That(noncognates.SelectedWordPairs, Is.Empty);
// switch variety pair, nothing selected, no cognates, matches, change selected word
varietyPairs.SelectedVariety2 = varietyPairs.Varieties[2];
cognates = varietyPairs.SelectedVarietyPair.Cognates;
cognates.WordPairsView = new ListCollectionView(cognates.WordPairs);
noncognates = varietyPairs.SelectedVarietyPair.Noncognates;
noncognates.WordPairsView = new ListCollectionView(noncognates.WordPairs);
noncognatesArray = noncognates.WordPairsView.Cast <WordPairViewModel>().ToArray();
findViewModel.String = "l";
findViewModel.FindNextCommand.Execute(null);
Assert.That(cognates.SelectedWordPairs, Is.Empty);
Assert.That(noncognates.SelectedWordPairs, Is.EquivalentTo(noncognatesArray[0].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(cognates.SelectedWordPairs, Is.Empty);
Assert.That(noncognates.SelectedWordPairs, Is.EquivalentTo(noncognatesArray[2].ToEnumerable()));
noncognates.SelectedWordPairs.Clear();
noncognates.SelectedWordPairs.Add(noncognatesArray[1]);
findViewModel.FindNextCommand.Execute(null);
Assert.That(cognates.SelectedWordPairs, Is.Empty);
Assert.That(noncognates.SelectedWordPairs, Is.EquivalentTo(noncognatesArray[2].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(cognates.SelectedWordPairs, Is.Empty);
Assert.That(noncognates.SelectedWordPairs, Is.EquivalentTo(noncognatesArray[0].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(cognates.SelectedWordPairs, Is.Empty);
Assert.That(noncognates.SelectedWordPairs, Is.EquivalentTo(noncognatesArray[0].ToEnumerable()));
// gloss searches
findViewModel.Field = FindField.Gloss;
findViewModel.String = "gloss2";
findViewModel.FindNextCommand.Execute(null);
Assert.That(cognates.SelectedWordPairs, Is.Empty);
Assert.That(noncognates.SelectedWordPairs, Is.EquivalentTo(noncognatesArray[1].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(cognates.SelectedWordPairs, Is.Empty);
Assert.That(noncognates.SelectedWordPairs, Is.EquivalentTo(noncognatesArray[1].ToEnumerable()));
}
public void ObservedWordPairs()
{
DispatcherHelper.Initialize();
var segmentPool = new SegmentPool();
var projectService = Substitute.For<IProjectService>();
var dialogService = Substitute.For<IDialogService>();
var busyService = Substitute.For<IBusyService>();
var graphService = new GraphService(projectService);
var imageExportService = Substitute.For<IImageExportService>();
var analysisService = new AnalysisService(_spanFactory, segmentPool, projectService, dialogService, busyService);
WordPairsViewModel.Factory wordPairsFactory = () => new WordPairsViewModel(busyService);
var globalCorrespondences = new GlobalCorrespondencesViewModel(projectService, busyService, dialogService, imageExportService, graphService, wordPairsFactory);
CogProject project = TestHelpers.GetTestProject(_spanFactory, segmentPool);
project.Meanings.AddRange(new[] {new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3")});
project.Varieties.AddRange(new[] {new Variety("variety1"), new Variety("variety2"), new Variety("variety3")});
project.Varieties[0].Words.AddRange(new[] {new Word("hɛ.loʊ", project.Meanings[0]), new Word("gʊd", project.Meanings[1]), new Word("bæd", project.Meanings[2])});
project.Varieties[1].Words.AddRange(new[] {new Word("hɛlp", project.Meanings[0]), new Word("gu.gəl", project.Meanings[1]), new Word("gu.fi", project.Meanings[2])});
project.Varieties[2].Words.AddRange(new[] {new Word("wɜrd", project.Meanings[0]), new Word("kɑr", project.Meanings[1]), new Word("fʊt.bɔl", project.Meanings[2])});
projectService.Project.Returns(project);
analysisService.SegmentAll();
var varietyPairGenerator = new VarietyPairGenerator();
varietyPairGenerator.Process(project);
var wordPairGenerator = new SimpleWordPairGenerator(segmentPool, project, 0.3, ComponentIdentifiers.PrimaryWordAligner);
var globalCorrIdentifier = new SoundCorrespondenceIdentifier(segmentPool, project, ComponentIdentifiers.PrimaryWordAligner);
foreach (VarietyPair vp in project.VarietyPairs)
{
wordPairGenerator.Process(vp);
foreach (WordPair wp in vp.WordPairs)
wp.AreCognatePredicted = true;
vp.SoundChangeFrequencyDistribution = new ConditionalFrequencyDistribution<SoundContext, Ngram<Segment>>();
vp.SoundChangeProbabilityDistribution = new ConditionalProbabilityDistribution<SoundContext, Ngram<Segment>>(vp.SoundChangeFrequencyDistribution, (sc, fd) => new MaxLikelihoodProbabilityDistribution<Ngram<Segment>>(fd));
globalCorrIdentifier.Process(vp);
}
projectService.AreAllVarietiesCompared.Returns(true);
projectService.ProjectOpened += Raise.Event();
var observedWordPairs = globalCorrespondences.ObservedWordPairs;
observedWordPairs.WordPairsView = new ListCollectionView(observedWordPairs.WordPairs);
Assert.That(observedWordPairs.WordPairsView, Is.Empty);
globalCorrespondences.SelectedCorrespondence = globalCorrespondences.Graph.Edges.First(e => e.Source.StrRep == "g" && e.Target.StrRep == "k");
WordPairViewModel[] wordPairsArray = observedWordPairs.WordPairsView.Cast<WordPairViewModel>().ToArray();
Assert.That(wordPairsArray.Length, Is.EqualTo(2));
Assert.That(wordPairsArray[0].Meaning.Gloss, Is.EqualTo("gloss2"));
Assert.That(wordPairsArray[0].AlignedNodes[2].IsSelected, Is.True);
Assert.That(wordPairsArray[1].Meaning.Gloss, Is.EqualTo("gloss2"));
Assert.That(wordPairsArray[1].AlignedNodes[0].IsSelected, Is.True);
globalCorrespondences.SyllablePosition = SyllablePosition.Nucleus;
globalCorrespondences.SelectedCorrespondence = globalCorrespondences.Graph.Edges.First(e => e.Source.StrRep == "ʊ" && e.Target.StrRep == "u");
wordPairsArray = observedWordPairs.WordPairsView.Cast<WordPairViewModel>().ToArray();
Assert.That(wordPairsArray.Length, Is.EqualTo(2));
Assert.That(wordPairsArray[0].Meaning.Gloss, Is.EqualTo("gloss2"));
Assert.That(wordPairsArray[0].AlignedNodes[1].IsSelected, Is.True);
Assert.That(wordPairsArray[1].Meaning.Gloss, Is.EqualTo("gloss3"));
Assert.That(wordPairsArray[1].AlignedNodes[1].IsSelected, Is.True);
globalCorrespondences.SelectedCorrespondence = null;
Assert.That(observedWordPairs.WordPairsView, Is.Empty);
}
public void Graph()
{
DispatcherHelper.Initialize();
var segmentPool = new SegmentPool();
var projectService = Substitute.For<IProjectService>();
var dialogService = Substitute.For<IDialogService>();
var busyService = Substitute.For<IBusyService>();
var graphService = new GraphService(projectService);
var imageExportService = Substitute.For<IImageExportService>();
var analysisService = new AnalysisService(_spanFactory, segmentPool, projectService, dialogService, busyService);
WordPairsViewModel.Factory wordPairsFactory = () => new WordPairsViewModel(busyService);
var globalCorrespondences = new GlobalCorrespondencesViewModel(projectService, busyService, dialogService, imageExportService, graphService, wordPairsFactory);
CogProject project = TestHelpers.GetTestProject(_spanFactory, segmentPool);
project.Meanings.AddRange(new[] {new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3")});
project.Varieties.AddRange(new[] {new Variety("variety1"), new Variety("variety2"), new Variety("variety3")});
project.Varieties[0].Words.AddRange(new[] {new Word("hɛ.loʊ", project.Meanings[0]), new Word("gʊd", project.Meanings[1]), new Word("bæd", project.Meanings[2])});
project.Varieties[1].Words.AddRange(new[] {new Word("hɛlp", project.Meanings[0]), new Word("gu.gəl", project.Meanings[1]), new Word("gu.fi", project.Meanings[2])});
project.Varieties[2].Words.AddRange(new[] {new Word("wɜrd", project.Meanings[0]), new Word("kɑr", project.Meanings[1]), new Word("fʊt.bɔl", project.Meanings[2])});
projectService.Project.Returns(project);
analysisService.SegmentAll();
projectService.ProjectOpened += Raise.Event();
Assert.That(globalCorrespondences.Graph, Is.Null);
Messenger.Default.Send(new PerformingComparisonMessage());
var varietyPairGenerator = new VarietyPairGenerator();
varietyPairGenerator.Process(project);
var wordPairGenerator = new SimpleWordPairGenerator(segmentPool, project, 0.3, ComponentIdentifiers.PrimaryWordAligner);
var globalCorrIdentifier = new SoundCorrespondenceIdentifier(segmentPool, project, ComponentIdentifiers.PrimaryWordAligner);
foreach (VarietyPair vp in project.VarietyPairs)
{
wordPairGenerator.Process(vp);
foreach (WordPair wp in vp.WordPairs)
wp.AreCognatePredicted = true;
vp.SoundChangeFrequencyDistribution = new ConditionalFrequencyDistribution<SoundContext, Ngram<Segment>>();
vp.SoundChangeProbabilityDistribution = new ConditionalProbabilityDistribution<SoundContext, Ngram<Segment>>(vp.SoundChangeFrequencyDistribution, (sc, fd) => new MaxLikelihoodProbabilityDistribution<Ngram<Segment>>(fd));
globalCorrIdentifier.Process(vp);
}
Messenger.Default.Send(new ComparisonPerformedMessage());
Assert.That(globalCorrespondences.Graph, Is.Not.Null);
globalCorrespondences.SyllablePosition = SyllablePosition.Nucleus;
Assert.That(globalCorrespondences.Graph, Is.Not.Null);
Messenger.Default.Send(new DomainModelChangedMessage(true));
Assert.That(globalCorrespondences.Graph, Is.Null);
globalCorrespondences.SyllablePosition = SyllablePosition.Coda;
Assert.That(globalCorrespondences.Graph, Is.Null);
}
public void Words()
{
DispatcherHelper.Initialize();
var segmentPool = new SegmentPool();
var projectService = Substitute.For<IProjectService>();
var busyService = Substitute.For<IBusyService>();
var exportService = Substitute.For<IExportService>();
var dialogService = Substitute.For<IDialogService>();
var analysisService = new AnalysisService(_spanFactory, segmentPool, projectService, dialogService, busyService);
var alignment = new MultipleWordAlignmentViewModel(projectService, busyService, exportService, analysisService);
var project = TestHelpers.GetTestProject(_spanFactory, segmentPool);
project.Meanings.AddRange(new[] {new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3")});
project.Varieties.AddRange(new[] {new Variety("variety1"), new Variety("variety2"), new Variety("variety3")});
project.Varieties[0].Words.AddRange(new[] {new Word("hɛ.loʊ", project.Meanings[0]), new Word("gʊd", project.Meanings[1]), new Word("bæd", project.Meanings[2])});
project.Varieties[1].Words.AddRange(new[] {new Word("hɛlp", project.Meanings[0]), new Word("gu.gəl", project.Meanings[1]), new Word("gu.fi", project.Meanings[2])});
project.Varieties[2].Words.AddRange(new[] {new Word("wɜrd", project.Meanings[0]), new Word("kɑr", project.Meanings[1]), new Word("fʊt.bɔl", project.Meanings[2])});
projectService.Project.Returns(project);
analysisService.SegmentAll();
var varietyPairGenerator = new VarietyPairGenerator();
varietyPairGenerator.Process(project);
var wordPairGenerator = new SimpleWordPairGenerator(segmentPool, project, 0.3, ComponentIdentifiers.PrimaryWordAligner);
foreach (VarietyPair vp in project.VarietyPairs)
{
wordPairGenerator.Process(vp);
foreach (WordPair wp in vp.WordPairs)
{
wp.PredictedCognacy = true;
wp.PredictedCognacyScore = 1.0;
}
vp.CognateSoundCorrespondenceFrequencyDistribution = new ConditionalFrequencyDistribution<SoundContext, Ngram<Segment>>();
vp.CognateSoundCorrespondenceProbabilityDistribution = new ConditionalProbabilityDistribution<SoundContext, Ngram<Segment>>(vp.CognateSoundCorrespondenceFrequencyDistribution, (sc, fd) => new MaxLikelihoodProbabilityDistribution<Ngram<Segment>>(fd));
}
projectService.AreAllVarietiesCompared.Returns(true);
projectService.ProjectOpened += Raise.Event();
Assert.That(alignment.SelectedMeaning, Is.Null);
Assert.That(alignment.Words, Is.Empty);
alignment.MeaningsView = new ListCollectionView(alignment.Meanings);
alignment.WordsView = new ListCollectionView(alignment.Words);
Assert.That(alignment.WordsView.Cast<MultipleWordAlignmentWordViewModel>().Select(w => w.StrRep), Is.EqualTo(new[] {"hɛ.loʊ", "hɛlp", "wɜrd"}));
Assert.That(alignment.ColumnCount, Is.EqualTo(4));
alignment.SelectedMeaning = alignment.Meanings[1];
Assert.That(alignment.WordsView.Cast<MultipleWordAlignmentWordViewModel>().Select(w => w.StrRep), Is.EqualTo(new[] {"gu.gəl", "gʊd", "kɑr"}));
Assert.That(alignment.ColumnCount, Is.EqualTo(5));
project.Varieties.RemoveAt(project.Varieties.Count - 1);
Messenger.Default.Send(new DomainModelChangedMessage(true));
Messenger.Default.Send(new PerformingComparisonMessage());
foreach (VarietyPair vp in project.VarietyPairs)
{
wordPairGenerator.Process(vp);
foreach (WordPair wp in vp.WordPairs)
{
wp.PredictedCognacy = true;
wp.PredictedCognacyScore = 1.0;
}
vp.CognateSoundCorrespondenceFrequencyDistribution = new ConditionalFrequencyDistribution<SoundContext, Ngram<Segment>>();
vp.CognateSoundCorrespondenceProbabilityDistribution = new ConditionalProbabilityDistribution<SoundContext, Ngram<Segment>>(vp.CognateSoundCorrespondenceFrequencyDistribution, (sc, fd) => new MaxLikelihoodProbabilityDistribution<Ngram<Segment>>(fd));
}
Messenger.Default.Send(new ComparisonPerformedMessage());
Assert.That(alignment.WordsView.Cast<MultipleWordAlignmentWordViewModel>().Select(w => w.StrRep), Is.EqualTo(new[] {"gu.gəl", "gʊd"}));
Assert.That(alignment.ColumnCount, Is.EqualTo(5));
project.Varieties.RemoveAt(project.Varieties.Count - 1);
Messenger.Default.Send(new PerformingComparisonMessage());
foreach (VarietyPair vp in project.VarietyPairs)
{
wordPairGenerator.Process(vp);
foreach (WordPair wp in vp.WordPairs)
wp.PredictedCognacy = true;
vp.CognateSoundCorrespondenceFrequencyDistribution = new ConditionalFrequencyDistribution<SoundContext, Ngram<Segment>>();
vp.CognateSoundCorrespondenceProbabilityDistribution = new ConditionalProbabilityDistribution<SoundContext, Ngram<Segment>>(vp.CognateSoundCorrespondenceFrequencyDistribution, (sc, fd) => new MaxLikelihoodProbabilityDistribution<Ngram<Segment>>(fd));
}
Messenger.Default.Send(new ComparisonPerformedMessage());
Assert.That(alignment.WordsView, Is.Empty);
}
public void TaskAreas_ChangeSorting_WordPairOrderingUpdated()
{
using (var env = new TestEnvironment())
{
env.Project.Meanings.AddRange(new[] {new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3"), new Meaning("gloss4", "cat4")});
env.Project.Varieties.AddRange(new[] {new Variety("variety1"), new Variety("variety2"), new Variety("variety3")});
env.Project.Varieties[0].Words.AddRange(new[] {new Word("hɛ.loʊ", env.Project.Meanings[0]), new Word("gʊd", env.Project.Meanings[1]), new Word("bæd", env.Project.Meanings[2]), new Word("wɜrd", env.Project.Meanings[3])});
env.Project.Varieties[1].Words.AddRange(new[] {new Word("hɛlp", env.Project.Meanings[0]), new Word("gu.gəl", env.Project.Meanings[1]), new Word("gu.fi", env.Project.Meanings[2]), new Word("kɑr", env.Project.Meanings[3])});
env.AnalysisService.SegmentAll();
var varietyPairGenerator = new VarietyPairGenerator();
varietyPairGenerator.Process(env.Project);
var wordPairGenerator = new SimpleWordPairGenerator(env.SegmentPool, env.Project, 0.3, ComponentIdentifiers.PrimaryWordAligner);
foreach (VarietyPair vp in env.Project.VarietyPairs)
{
wordPairGenerator.Process(vp);
vp.SoundChangeFrequencyDistribution = new ConditionalFrequencyDistribution<SoundContext, Ngram<Segment>>();
vp.SoundChangeProbabilityDistribution = new ConditionalProbabilityDistribution<SoundContext, Ngram<Segment>>(vp.SoundChangeFrequencyDistribution, (sc, fd) => new MaxLikelihoodProbabilityDistribution<Ngram<Segment>>(fd));
}
int i = 0;
foreach (WordPair wp in env.Project.VarietyPairs[0].WordPairs)
{
wp.PhoneticSimilarityScore = (1.0 / env.Project.VarietyPairs[0].WordPairs.Count) * (i + 1);
wp.AreCognatePredicted = wp.Meaning.Gloss.IsOneOf("gloss1", "gloss3");
i++;
}
env.OpenProject();
env.SetupWordPairsViews();
WordPairViewModel[] cognatesArray = env.Cognates.WordPairsView.Cast<WordPairViewModel>().ToArray();
WordPairViewModel[] noncognatesArray = env.Noncognates.WordPairsView.Cast<WordPairViewModel>().ToArray();
Assert.That(cognatesArray.Select(wp => wp.Meaning.Gloss), Is.EqualTo(new[] {"gloss3", "gloss1"}));
Assert.That(noncognatesArray.Select(wp => wp.Meaning.Gloss), Is.EqualTo(new[] {"gloss4", "gloss2"}));
var commonTasks = (TaskAreaItemsViewModel) env.VarietyPairs.TaskAreas[0];
var sortWordsByItems = (TaskAreaItemsViewModel) commonTasks.Items[2];
var sortWordsByGroup = (TaskAreaCommandGroupViewModel) sortWordsByItems.Items[0];
// default sorting is by similarity, change to gloss
sortWordsByGroup.SelectedCommand = sortWordsByGroup.Commands[1];
sortWordsByGroup.SelectedCommand.Command.Execute(null);
cognatesArray = env.Cognates.WordPairsView.Cast<WordPairViewModel>().ToArray();
noncognatesArray = env.Noncognates.WordPairsView.Cast<WordPairViewModel>().ToArray();
Assert.That(cognatesArray.Select(wp => wp.Meaning.Gloss), Is.EqualTo(new[] {"gloss1", "gloss3"}));
Assert.That(noncognatesArray.Select(wp => wp.Meaning.Gloss), Is.EqualTo(new[] {"gloss2", "gloss4"}));
}
}
private static void AddComparisonData(TestEnvironment env)
{
var varietyPairGenerator = new VarietyPairGenerator();
varietyPairGenerator.Process(env.Project);
var wordPairGenerator = new SimpleWordPairGenerator(env.SegmentPool, env.Project, 0.3, ComponentIdentifiers.PrimaryWordAligner);
foreach (VarietyPair vp in env.Project.VarietyPairs)
{
wordPairGenerator.Process(vp);
vp.SoundChangeFrequencyDistribution = new ConditionalFrequencyDistribution<SoundContext, Ngram<Segment>>();
vp.SoundChangeProbabilityDistribution = new ConditionalProbabilityDistribution<SoundContext, Ngram<Segment>>(vp.SoundChangeFrequencyDistribution, (sc, fd) => new MaxLikelihoodProbabilityDistribution<Ngram<Segment>>(fd));
}
int i = 0;
foreach (WordPair wp in env.Project.VarietyPairs[0].WordPairs)
{
wp.PhoneticSimilarityScore = (1.0 / env.Project.VarietyPairs[0].WordPairs.Count) * (env.Project.VarietyPairs[0].WordPairs.Count - i);
wp.AreCognatePredicted = wp.Meaning.Gloss.IsOneOf("gloss1", "gloss3");
i++;
}
i = 0;
foreach (WordPair wp in env.Project.VarietyPairs[1].WordPairs)
{
wp.PhoneticSimilarityScore = (1.0 / env.Project.VarietyPairs[1].WordPairs.Count) * (env.Project.VarietyPairs[1].WordPairs.Count - i);
i++;
}
}
public void FindCommand()
{
DispatcherHelper.Initialize();
var segmentPool = new SegmentPool();
var projectService = Substitute.For<IProjectService>();
var dialogService = Substitute.For<IDialogService>();
var busyService = Substitute.For<IBusyService>();
var graphService = new GraphService(projectService);
var imageExportService = Substitute.For<IImageExportService>();
var analysisService = new AnalysisService(_spanFactory, segmentPool, projectService, dialogService, busyService);
WordPairsViewModel.Factory wordPairsFactory = () => new WordPairsViewModel(busyService);
var globalCorrespondences = new GlobalCorrespondencesViewModel(projectService, busyService, dialogService, imageExportService, graphService, wordPairsFactory);
CogProject project = TestHelpers.GetTestProject(_spanFactory, segmentPool);
project.Meanings.AddRange(new[] {new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3")});
project.Varieties.AddRange(new[] {new Variety("variety1"), new Variety("variety2"), new Variety("variety3")});
project.Varieties[0].Words.AddRange(new[] {new Word("hɛ.loʊ", project.Meanings[0]), new Word("gʊd", project.Meanings[1]), new Word("kæd", project.Meanings[2])});
project.Varieties[1].Words.AddRange(new[] {new Word("hɛlp", project.Meanings[0]), new Word("gu.gəl", project.Meanings[1]), new Word("gu.fi", project.Meanings[2])});
project.Varieties[2].Words.AddRange(new[] {new Word("wɜrd", project.Meanings[0]), new Word("kɑr", project.Meanings[1]), new Word("fʊt.bɔl", project.Meanings[2])});
projectService.Project.Returns(project);
analysisService.SegmentAll();
var varietyPairGenerator = new VarietyPairGenerator();
varietyPairGenerator.Process(project);
var wordPairGenerator = new SimpleWordPairGenerator(segmentPool, project, 0.3, ComponentIdentifiers.PrimaryWordAligner);
var globalCorrIdentifier = new SoundCorrespondenceIdentifier(segmentPool, project, ComponentIdentifiers.PrimaryWordAligner);
foreach (VarietyPair vp in project.VarietyPairs)
{
wordPairGenerator.Process(vp);
foreach (WordPair wp in vp.WordPairs)
wp.AreCognatePredicted = true;
vp.SoundChangeFrequencyDistribution = new ConditionalFrequencyDistribution<SoundContext, Ngram<Segment>>();
vp.SoundChangeProbabilityDistribution = new ConditionalProbabilityDistribution<SoundContext, Ngram<Segment>>(vp.SoundChangeFrequencyDistribution, (sc, fd) => new MaxLikelihoodProbabilityDistribution<Ngram<Segment>>(fd));
globalCorrIdentifier.Process(vp);
}
projectService.AreAllVarietiesCompared.Returns(true);
projectService.ProjectOpened += Raise.Event();
WordPairsViewModel observedWordPairs = globalCorrespondences.ObservedWordPairs;
observedWordPairs.WordPairsView = new ListCollectionView(observedWordPairs.WordPairs);
FindViewModel findViewModel = null;
Action closeCallback = null;
dialogService.ShowModelessDialog(globalCorrespondences, Arg.Do<FindViewModel>(vm => findViewModel = vm), Arg.Do<Action>(callback => closeCallback = callback));
globalCorrespondences.FindCommand.Execute(null);
Assert.That(findViewModel, Is.Not.Null);
Assert.That(closeCallback, Is.Not.Null);
// already open, shouldn't get opened twice
dialogService.ClearReceivedCalls();
globalCorrespondences.FindCommand.Execute(null);
dialogService.DidNotReceive().ShowModelessDialog(globalCorrespondences, Arg.Any<FindViewModel>(), Arg.Any<Action>());
// form searches
findViewModel.Field = FindField.Form;
// no word pairs, no match
findViewModel.String = "nothing";
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.Empty);
globalCorrespondences.SelectedCorrespondence = globalCorrespondences.Graph.Edges.First(e => e.Source.StrRep == "k" && e.Target.StrRep == "g");
WordPairViewModel[] wordPairsArray = observedWordPairs.WordPairsView.Cast<WordPairViewModel>().ToArray();
// nothing selected, no match
findViewModel.String = "nothing";
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.Empty);
// nothing selected, matches
findViewModel.String = "d";
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[1].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[2].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[2].ToEnumerable()));
// first word selected, matches
observedWordPairs.SelectedWordPairs.Clear();
observedWordPairs.SelectedWordPairs.Add(wordPairsArray[0]);
findViewModel.String = "g";
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[1].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[2].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[0].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[0].ToEnumerable()));
// start search over
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[1].ToEnumerable()));
// last word selected, matches
observedWordPairs.SelectedWordPairs.Clear();
observedWordPairs.SelectedWordPairs.Add(wordPairsArray[2]);
findViewModel.String = "u";
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[0].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[2].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[2].ToEnumerable()));
// nothing selected, matches, change selected word
observedWordPairs.SelectedWordPairs.Clear();
findViewModel.String = ".";
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[0].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[2].ToEnumerable()));
observedWordPairs.SelectedWordPairs.Clear();
observedWordPairs.SelectedWordPairs.Add(wordPairsArray[1]);
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[2].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[0].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[0].ToEnumerable()));
// gloss searches
findViewModel.Field = FindField.Gloss;
findViewModel.String = "gloss2";
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[1].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[0].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[0].ToEnumerable()));
}
public void Varieties()
{
DispatcherHelper.Initialize();
var segmentPool = new SegmentPool();
var projectService = Substitute.For <IProjectService>();
var dialogService = Substitute.For <IDialogService>();
var busyService = Substitute.For <IBusyService>();
var exportService = Substitute.For <IExportService>();
var analysisService = new AnalysisService(_spanFactory, segmentPool, projectService, dialogService, busyService);
WordPairsViewModel.Factory wordPairsFactory = () => new WordPairsViewModel(busyService);
VarietyPairViewModel.Factory varietyPairFactory = (vp, order) => new VarietyPairViewModel(segmentPool, projectService, wordPairsFactory, vp, order);
var varietyPairs = new VarietyPairsViewModel(projectService, busyService, dialogService, exportService, analysisService, varietyPairFactory);
CogProject project = TestHelpers.GetTestProject(_spanFactory, segmentPool);
projectService.Project.Returns(project);
projectService.ProjectOpened += Raise.Event();
varietyPairs.VarietiesView1 = new ListCollectionView(varietyPairs.Varieties);
varietyPairs.VarietiesView2 = new ListCollectionView(varietyPairs.Varieties);
Assert.That(varietyPairs.Varieties, Is.Empty);
Assert.That(varietyPairs.VarietyPairState, Is.EqualTo(VarietyPairState.NotSelected));
Assert.That(varietyPairs.SelectedVariety1, Is.Null);
Assert.That(varietyPairs.SelectedVariety2, Is.Null);
Assert.That(varietyPairs.SelectedVarietyPair, Is.Null);
project.Meanings.AddRange(new[] { new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3") });
project.Varieties.AddRange(new[] { new Variety("variety1"), new Variety("variety2"), new Variety("variety3") });
project.Varieties[0].Words.AddRange(new[] { new Word("hɛ.loʊ", project.Meanings[0]), new Word("gʊd", project.Meanings[1]), new Word("bæd", project.Meanings[2]) });
project.Varieties[1].Words.AddRange(new[] { new Word("hɛlp", project.Meanings[0]), new Word("gu.gəl", project.Meanings[1]), new Word("gu.fi", project.Meanings[2]) });
project.Varieties[2].Words.AddRange(new[] { new Word("wɜrd", project.Meanings[0]), new Word("kɑr", project.Meanings[1]), new Word("fʊt.bɔl", project.Meanings[2]) });
analysisService.SegmentAll();
Messenger.Default.Send(new DomainModelChangedMessage(true));
Assert.That(varietyPairs.VarietyPairState, Is.EqualTo(VarietyPairState.SelectedAndNotCompared));
Assert.That(varietyPairs.SelectedVariety1, Is.EqualTo(varietyPairs.VarietiesView1.Cast <VarietyViewModel>().First()));
Assert.That(varietyPairs.SelectedVariety2, Is.EqualTo(varietyPairs.VarietiesView2.Cast <VarietyViewModel>().ElementAt(1)));
Assert.That(varietyPairs.SelectedVarietyPair, Is.Null);
Messenger.Default.Send(new PerformingComparisonMessage());
var varietyPairGenerator = new VarietyPairGenerator();
varietyPairGenerator.Process(project);
var wordPairGenerator = new SimpleWordPairGenerator(segmentPool, project, 0.3, ComponentIdentifiers.PrimaryWordAligner);
foreach (VarietyPair vp in project.VarietyPairs)
{
wordPairGenerator.Process(vp);
vp.SoundChangeFrequencyDistribution = new ConditionalFrequencyDistribution <SoundContext, Ngram <Segment> >();
vp.SoundChangeProbabilityDistribution = new ConditionalProbabilityDistribution <SoundContext, Ngram <Segment> >(vp.SoundChangeFrequencyDistribution, (sc, fd) => new MaxLikelihoodProbabilityDistribution <Ngram <Segment> >(fd));
}
Messenger.Default.Send(new ComparisonPerformedMessage());
Assert.That(varietyPairs.VarietyPairState, Is.EqualTo(VarietyPairState.SelectedAndCompared));
Assert.That(varietyPairs.SelectedVarietyPair, Is.Not.Null);
Assert.That(varietyPairs.SelectedVarietyPair.AreVarietiesInOrder, Is.True);
VarietyViewModel temp = varietyPairs.SelectedVariety2;
varietyPairs.SelectedVariety2 = varietyPairs.SelectedVariety1;
varietyPairs.SelectedVariety1 = temp;
Assert.That(varietyPairs.VarietyPairState, Is.EqualTo(VarietyPairState.SelectedAndCompared));
Assert.That(varietyPairs.SelectedVarietyPair, Is.Not.Null);
Assert.That(varietyPairs.SelectedVarietyPair.AreVarietiesInOrder, Is.False);
Messenger.Default.Send(new DomainModelChangedMessage(true));
Assert.That(varietyPairs.VarietyPairState, Is.EqualTo(VarietyPairState.SelectedAndNotCompared));
project.Varieties.RemoveRangeAt(0, 2);
Messenger.Default.Send(new DomainModelChangedMessage(true));
Assert.That(varietyPairs.VarietyPairState, Is.EqualTo(VarietyPairState.NotSelected));
Assert.That(varietyPairs.SelectedVariety1, Is.EqualTo(varietyPairs.VarietiesView1.Cast <VarietyViewModel>().First()));
Assert.That(varietyPairs.SelectedVariety2, Is.EqualTo(varietyPairs.VarietiesView2.Cast <VarietyViewModel>().First()));
}
public void FindCommand()
{
DispatcherHelper.Initialize();
var segmentPool = new SegmentPool();
var projectService = Substitute.For <IProjectService>();
var dialogService = Substitute.For <IDialogService>();
var busyService = Substitute.For <IBusyService>();
var graphService = new GraphService(projectService);
var imageExportService = Substitute.For <IImageExportService>();
var analysisService = new AnalysisService(_spanFactory, segmentPool, projectService, dialogService, busyService);
WordPairsViewModel.Factory wordPairsFactory = () => new WordPairsViewModel(busyService);
WordPairViewModel.Factory wordPairFactory = (pair, order) => new WordPairViewModel(projectService, analysisService, pair, order);
var globalCorrespondences = new GlobalCorrespondencesViewModel(projectService, busyService, dialogService, imageExportService, graphService, wordPairsFactory, wordPairFactory);
CogProject project = TestHelpers.GetTestProject(_spanFactory, segmentPool);
project.Meanings.AddRange(new[] { new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3") });
project.Varieties.AddRange(new[] { new Variety("variety1"), new Variety("variety2"), new Variety("variety3") });
project.Varieties[0].Words.AddRange(new[] { new Word("hɛ.loʊ", project.Meanings[0]), new Word("gʊd", project.Meanings[1]), new Word("kæd", project.Meanings[2]) });
project.Varieties[1].Words.AddRange(new[] { new Word("hɛlp", project.Meanings[0]), new Word("gu.gəl", project.Meanings[1]), new Word("gu.fi", project.Meanings[2]) });
project.Varieties[2].Words.AddRange(new[] { new Word("wɜrd", project.Meanings[0]), new Word("kɑr", project.Meanings[1]), new Word("fʊt.bɔl", project.Meanings[2]) });
projectService.Project.Returns(project);
analysisService.SegmentAll();
var varietyPairGenerator = new VarietyPairGenerator();
varietyPairGenerator.Process(project);
var wordPairGenerator = new SimpleWordPairGenerator(segmentPool, project, 0.3, ComponentIdentifiers.PrimaryWordAligner);
var globalCorrIdentifier = new SoundCorrespondenceIdentifier(segmentPool, project, ComponentIdentifiers.PrimaryWordAligner);
foreach (VarietyPair vp in project.VarietyPairs)
{
wordPairGenerator.Process(vp);
foreach (WordPair wp in vp.WordPairs)
{
wp.PredictedCognacy = true;
}
vp.CognateSoundCorrespondenceFrequencyDistribution = new ConditionalFrequencyDistribution <SoundContext, Ngram <Segment> >();
vp.CognateSoundCorrespondenceProbabilityDistribution = new ConditionalProbabilityDistribution <SoundContext, Ngram <Segment> >(vp.CognateSoundCorrespondenceFrequencyDistribution, (sc, fd) => new MaxLikelihoodProbabilityDistribution <Ngram <Segment> >(fd));
globalCorrIdentifier.Process(vp);
}
projectService.AreAllVarietiesCompared.Returns(true);
projectService.ProjectOpened += Raise.Event();
WordPairsViewModel observedWordPairs = globalCorrespondences.ObservedWordPairs;
observedWordPairs.WordPairsView = new ListCollectionView(observedWordPairs.WordPairs);
FindViewModel findViewModel = null;
Action closeCallback = null;
dialogService.ShowModelessDialog(globalCorrespondences, Arg.Do <FindViewModel>(vm => findViewModel = vm), Arg.Do <Action>(callback => closeCallback = callback));
globalCorrespondences.FindCommand.Execute(null);
Assert.That(findViewModel, Is.Not.Null);
Assert.That(closeCallback, Is.Not.Null);
// already open, shouldn't get opened twice
dialogService.ClearReceivedCalls();
globalCorrespondences.FindCommand.Execute(null);
dialogService.DidNotReceive().ShowModelessDialog(globalCorrespondences, Arg.Any <FindViewModel>(), Arg.Any <Action>());
// form searches
findViewModel.Field = FindField.Form;
// no word pairs, no match
findViewModel.String = "nothing";
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.Empty);
globalCorrespondences.SelectedCorrespondence = globalCorrespondences.Graph.Edges.First(e => e.Source.StrRep == "k" && e.Target.StrRep == "g");
WordPairViewModel[] wordPairsArray = observedWordPairs.WordPairsView.Cast <WordPairViewModel>().ToArray();
// nothing selected, no match
findViewModel.String = "nothing";
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.Empty);
// nothing selected, matches
findViewModel.String = "d";
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[1].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[2].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[2].ToEnumerable()));
// first word selected, matches
observedWordPairs.SelectedWordPairs.Clear();
observedWordPairs.SelectedWordPairs.Add(wordPairsArray[0]);
findViewModel.String = "g";
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[1].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[2].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[0].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[0].ToEnumerable()));
// start search over
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[1].ToEnumerable()));
// last word selected, matches
observedWordPairs.SelectedWordPairs.Clear();
observedWordPairs.SelectedWordPairs.Add(wordPairsArray[2]);
findViewModel.String = "u";
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[0].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[2].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[2].ToEnumerable()));
// nothing selected, matches, change selected word
observedWordPairs.SelectedWordPairs.Clear();
findViewModel.String = ".";
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[0].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[2].ToEnumerable()));
observedWordPairs.SelectedWordPairs.Clear();
observedWordPairs.SelectedWordPairs.Add(wordPairsArray[1]);
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[2].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[0].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[0].ToEnumerable()));
// gloss searches
findViewModel.Field = FindField.Gloss;
findViewModel.String = "gloss2";
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[1].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[0].ToEnumerable()));
findViewModel.FindNextCommand.Execute(null);
Assert.That(observedWordPairs.SelectedWordPairs, Is.EquivalentTo(wordPairsArray[0].ToEnumerable()));
}
public void Words()
{
DispatcherHelper.Initialize();
var segmentPool = new SegmentPool();
var projectService = Substitute.For <IProjectService>();
var busyService = Substitute.For <IBusyService>();
var exportService = Substitute.For <IExportService>();
var dialogService = Substitute.For <IDialogService>();
var analysisService = new AnalysisService(_spanFactory, segmentPool, projectService, dialogService, busyService);
var alignment = new MultipleWordAlignmentViewModel(projectService, busyService, exportService);
var project = TestHelpers.GetTestProject(_spanFactory, segmentPool);
project.Meanings.AddRange(new[] { new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3") });
project.Varieties.AddRange(new[] { new Variety("variety1"), new Variety("variety2"), new Variety("variety3") });
project.Varieties[0].Words.AddRange(new[] { new Word("hɛ.loʊ", project.Meanings[0]), new Word("gʊd", project.Meanings[1]), new Word("bæd", project.Meanings[2]) });
project.Varieties[1].Words.AddRange(new[] { new Word("hɛlp", project.Meanings[0]), new Word("gu.gəl", project.Meanings[1]), new Word("gu.fi", project.Meanings[2]) });
project.Varieties[2].Words.AddRange(new[] { new Word("wɜrd", project.Meanings[0]), new Word("kɑr", project.Meanings[1]), new Word("fʊt.bɔl", project.Meanings[2]) });
projectService.Project.Returns(project);
analysisService.SegmentAll();
var varietyPairGenerator = new VarietyPairGenerator();
varietyPairGenerator.Process(project);
var wordPairGenerator = new SimpleWordPairGenerator(segmentPool, project, 0.3, ComponentIdentifiers.PrimaryWordAligner);
foreach (VarietyPair vp in project.VarietyPairs)
{
wordPairGenerator.Process(vp);
foreach (WordPair wp in vp.WordPairs)
{
wp.AreCognatePredicted = true;
wp.CognicityScore = 1.0;
}
vp.SoundChangeFrequencyDistribution = new ConditionalFrequencyDistribution <SoundContext, Ngram <Segment> >();
vp.SoundChangeProbabilityDistribution = new ConditionalProbabilityDistribution <SoundContext, Ngram <Segment> >(vp.SoundChangeFrequencyDistribution, (sc, fd) => new MaxLikelihoodProbabilityDistribution <Ngram <Segment> >(fd));
}
projectService.AreAllVarietiesCompared.Returns(true);
projectService.ProjectOpened += Raise.Event();
Assert.That(alignment.SelectedMeaning, Is.Null);
Assert.That(alignment.Words, Is.Empty);
alignment.MeaningsView = new ListCollectionView(alignment.Meanings);
alignment.WordsView = new ListCollectionView(alignment.Words);
Assert.That(alignment.WordsView.Cast <MultipleWordAlignmentWordViewModel>().Select(w => w.StrRep), Is.EqualTo(new[] { "hɛ.loʊ", "hɛlp", "wɜrd" }));
Assert.That(alignment.ColumnCount, Is.EqualTo(4));
alignment.SelectedMeaning = alignment.Meanings[1];
Assert.That(alignment.WordsView.Cast <MultipleWordAlignmentWordViewModel>().Select(w => w.StrRep), Is.EqualTo(new[] { "gu.gəl", "gʊd", "kɑr" }));
Assert.That(alignment.ColumnCount, Is.EqualTo(5));
project.Varieties.RemoveAt(project.Varieties.Count - 1);
Messenger.Default.Send(new DomainModelChangedMessage(true));
Messenger.Default.Send(new PerformingComparisonMessage());
foreach (VarietyPair vp in project.VarietyPairs)
{
wordPairGenerator.Process(vp);
foreach (WordPair wp in vp.WordPairs)
{
wp.AreCognatePredicted = true;
wp.CognicityScore = 1.0;
}
vp.SoundChangeFrequencyDistribution = new ConditionalFrequencyDistribution <SoundContext, Ngram <Segment> >();
vp.SoundChangeProbabilityDistribution = new ConditionalProbabilityDistribution <SoundContext, Ngram <Segment> >(vp.SoundChangeFrequencyDistribution, (sc, fd) => new MaxLikelihoodProbabilityDistribution <Ngram <Segment> >(fd));
}
Messenger.Default.Send(new ComparisonPerformedMessage());
Assert.That(alignment.WordsView.Cast <MultipleWordAlignmentWordViewModel>().Select(w => w.StrRep), Is.EqualTo(new[] { "gu.gəl", "gʊd" }));
Assert.That(alignment.ColumnCount, Is.EqualTo(5));
project.Varieties.RemoveAt(project.Varieties.Count - 1);
Messenger.Default.Send(new PerformingComparisonMessage());
foreach (VarietyPair vp in project.VarietyPairs)
{
wordPairGenerator.Process(vp);
foreach (WordPair wp in vp.WordPairs)
{
wp.AreCognatePredicted = true;
}
vp.SoundChangeFrequencyDistribution = new ConditionalFrequencyDistribution <SoundContext, Ngram <Segment> >();
vp.SoundChangeProbabilityDistribution = new ConditionalProbabilityDistribution <SoundContext, Ngram <Segment> >(vp.SoundChangeFrequencyDistribution, (sc, fd) => new MaxLikelihoodProbabilityDistribution <Ngram <Segment> >(fd));
}
Messenger.Default.Send(new ComparisonPerformedMessage());
Assert.That(alignment.WordsView, Is.Empty);
}
public TestEnvironment(string word1, string word2, bool ignoreRegularInsertionDeletion = false, bool regularConsEqual = false, bool automaticRegularCorrThreshold = false)
{
_segmentPool = new SegmentPool();
_project = TestHelpers.GetTestProject(_spanFactory, _segmentPool);
_project.Meanings.Add(new Meaning("gloss1", "cat1"));
_project.Varieties.AddRange(new[] {new Variety("variety1"), new Variety("variety2")});
_project.Varieties[0].Words.Add(new Word(word1, _project.Meanings[0]));
_project.Varieties[1].Words.Add(new Word(word2, _project.Meanings[0]));
var varSegementer = new VarietySegmenter(_project.Segmenter);
foreach (Variety variety in _project.Varieties)
varSegementer.Process(variety);
var vp = new VarietyPair(_project.Varieties[0], _project.Varieties[1]);
_project.VarietyPairs.Add(vp);
var wordPairGenerator = new SimpleWordPairGenerator(_segmentPool, _project, 0.3, "primary");
wordPairGenerator.Process(vp);
vp.CognateSoundCorrespondenceFrequencyDistribution = new ConditionalFrequencyDistribution<SoundContext, Ngram<Segment>>();
var ignoredMappings = Substitute.For<ISegmentMappings>();
var similarSegmentsMappings = Substitute.For<ISegmentMappings>();
_cognateIdentifier = new BlairCognateIdentifier(_segmentPool, ignoreRegularInsertionDeletion, regularConsEqual, automaticRegularCorrThreshold,
3, ignoredMappings, similarSegmentsMappings);
_aligner = new TestWordAligner(_segmentPool);
}
