public void Export(Stream stream, CogProject project, SyllablePosition syllablePosition)
        {
            FeatureSymbol domainSyllablePosition = null;

            switch (syllablePosition)
            {
            case SyllablePosition.Onset:
                domainSyllablePosition = CogFeatureSystem.Onset;
                break;

            case SyllablePosition.Nucleus:
                domainSyllablePosition = CogFeatureSystem.Nucleus;
                break;

            case SyllablePosition.Coda:
                domainSyllablePosition = CogFeatureSystem.Coda;
                break;
            }

            var comparer = new SegmentComparer();

            Segment[] segments = project.Varieties
                                 .SelectMany(v => v.SyllablePositionSegmentFrequencyDistributions[domainSyllablePosition].ObservedSamples)
                                 .Distinct().OrderBy(GetSortOrder).ThenBy(s => s, comparer).ToArray();

            using (var writer = new StreamWriter(new NonClosingStreamWrapper(stream)))
            {
                foreach (Segment seg in segments)
                {
                    writer.Write("\t");
                    writer.Write(seg.StrRep);
                }
                writer.WriteLine();

                foreach (Variety variety in project.Varieties)
                {
                    writer.Write(variety.Name);
                    foreach (Segment seg in segments)
                    {
                        writer.Write("\t");
                        writer.Write(variety.SyllablePositionSegmentFrequencyDistributions[domainSyllablePosition][seg]);
                    }
                    writer.WriteLine();
                }
            }
        }
        public void Export(Stream stream, CogProject project, SyllablePosition syllablePosition)
        {
            FeatureSymbol domainSyllablePosition = null;
            switch (syllablePosition)
            {
                case SyllablePosition.Onset:
                    domainSyllablePosition = CogFeatureSystem.Onset;
                    break;
                case SyllablePosition.Nucleus:
                    domainSyllablePosition = CogFeatureSystem.Nucleus;
                    break;
                case SyllablePosition.Coda:
                    domainSyllablePosition = CogFeatureSystem.Coda;
                    break;
            }

            var comparer = new SegmentComparer();
            Segment[] segments = project.Varieties
                .SelectMany(v => v.SyllablePositionSegmentFrequencyDistributions[domainSyllablePosition].ObservedSamples)
                .Distinct().OrderBy(GetSortOrder).ThenBy(s => s, comparer).ToArray();

            using (var writer = new StreamWriter(new NonClosingStreamWrapper(stream)))
            {
                foreach (Segment seg in segments)
                {
                    writer.Write("\t");
                    writer.Write(seg.StrRep);
                }
                writer.WriteLine();

                foreach (Variety variety in project.Varieties)
                {
                    writer.Write(variety.Name);
                    foreach (Segment seg in segments)
                    {
                        writer.Write("\t");
                        writer.Write(variety.SyllablePositionSegmentFrequencyDistributions[domainSyllablePosition][seg]);
                    }
                    writer.WriteLine();
                }
            }
        }
Esempio n. 3
0
        private void PopulateSegments()
        {
            var comparer = new SegmentComparer();

            _busyService.ShowBusyIndicatorUntilFinishDrawing();
            using (_domainSegments.BulkUpdate())
                using (_segments.BulkUpdate())
                {
                    _domainSegments.Clear();
                    _segments.Clear();
                    foreach (Segment segment in _projectService.Project.Varieties
                             .SelectMany(v => v.SyllablePositionSegmentFrequencyDistributions[DomainSyllablePosition].ObservedSamples)
                             .Distinct().OrderBy(s => CategorySortOrderLookup[GetCategory(s)]).ThenBy(s => s, comparer))
                    {
                        _domainSegments.Add(segment);
                        _segments.Add(new SegmentViewModel(segment));
                    }
                }

            _categories.ReplaceAll(_segments.GroupBy(s => GetCategory(s.DomainSegment)).OrderBy(g => CategorySortOrderLookup[g.Key]).Select(g => new SegmentCategoryViewModel(g.Key, g)));
            HasSegments = _segments.Count > 0;
        }
        public SegmentMappingsTableViewModel(IProjectService projectService, SegmentMappingsTableSegmentPairViewModel.Factory segmentPairFactory, SegmentMappingViewModel.Factory mappingFactory,
			IEnumerable<SegmentMappingViewModel> mappings, SoundType soundType, int threshold)
        {
            _threshold = threshold;

            _soundType = soundType;
            FeatureSymbol segmentType;
            switch (_soundType)
            {
                case SoundType.Consonant:
                    segmentType = CogFeatureSystem.ConsonantType;
                    break;
                case SoundType.Vowel:
                    segmentType = CogFeatureSystem.VowelType;
                    break;
                default:
                    throw new InvalidEnumArgumentException();
            }

            var segmentComparer = new SegmentComparer();
            var categoryComparer = new SegmentCategoryComparer();
            _segments = new ReadOnlyList<SegmentMappingsTableSegmentViewModel>(projectService.Project.Varieties.SelectMany(v => v.SegmentFrequencyDistribution.ObservedSamples)
                .Where(s => s.Type == segmentType).Distinct().OrderBy(s => s.Category(), categoryComparer).ThenBy(s => s, segmentComparer)
                .Select(s => new SegmentMappingsTableSegmentViewModel(s, _soundType)).Concat(new SegmentMappingsTableSegmentViewModel(null, _soundType)).ToArray());
            _categories = new ReadOnlyList<SegmentCategoryViewModel>(_segments.GroupBy(s => s.DomainSegment == null ? string.Empty : s.DomainSegment.Category())
                .OrderBy(g => g.Key, categoryComparer).Select(g => new SegmentCategoryViewModel(g.Key, g)).ToArray());

            var mappingLookup = new Dictionary<UnorderedTuple<string, string>, HashSet<UnorderedTuple<string, string>>>();
            foreach (SegmentMappingViewModel mapping in mappings)
            {
                string seg1, seg2;
                FeatureSymbol leftEnv1, rightEnv1, leftEnv2, rightEnv2;
                if (ListSegmentMappings.Normalize(projectService.Project.Segmenter, mapping.Segment1, out seg1, out leftEnv1, out rightEnv1)
                    && ListSegmentMappings.Normalize(projectService.Project.Segmenter, mapping.Segment2, out seg2, out leftEnv2, out rightEnv2))
                {
                    UnorderedTuple<string, string> key = UnorderedTuple.Create(seg1, seg2);
                    HashSet<UnorderedTuple<string, string>> m = mappingLookup.GetValue(key, () => new HashSet<UnorderedTuple<string, string>>());
                    m.Add(UnorderedTuple.Create(mapping.Segment1, mapping.Segment2));
                }
            }

            IWordAligner aligner = projectService.Project.WordAligners[ComponentIdentifiers.PrimaryWordAligner];
            foreach (SegmentMappingsTableSegmentViewModel segment1 in _segments)
            {
                bool isEnabled = true;
                foreach (SegmentMappingsTableSegmentViewModel segment2 in _segments)
                {
                    if (EqualityComparer<Segment>.Default.Equals(segment1.DomainSegment, segment2.DomainSegment))
                        isEnabled = false;

                    int delta = segment1.DomainSegment == null || segment2.DomainSegment == null ? -1
                        : aligner.Delta(segment1.DomainSegment.FeatureStruct, segment2.DomainSegment.FeatureStruct);
                    SegmentMappingsTableSegmentPairViewModel segmentPair = segmentPairFactory(segment1, segment2, delta, isEnabled);
                    segmentPair.MeetsThreshold = delta != -1 && delta <= _threshold;
                    HashSet<UnorderedTuple<string, string>> pairMappings;
                    if (mappingLookup.TryGetValue(UnorderedTuple.Create(segment1.StrRep, segment2.StrRep), out pairMappings))
                        segmentPair.Mappings.Mappings.AddRange(pairMappings.Select(m => mappingFactory(m.Item1, m.Item2)));
                    segment1.SegmentPairs.Add(segmentPair);
                }
            }
        }
Esempio n. 5
0
        public SegmentMappingsTableViewModel(IProjectService projectService, SegmentMappingsTableSegmentPairViewModel.Factory segmentPairFactory, SegmentMappingViewModel.Factory mappingFactory,
                                             IEnumerable <SegmentMappingViewModel> mappings, SoundType soundType, int threshold)
        {
            _threshold = threshold;

            _soundType = soundType;
            FeatureSymbol segmentType;

            switch (_soundType)
            {
            case SoundType.Consonant:
                segmentType = CogFeatureSystem.ConsonantType;
                break;

            case SoundType.Vowel:
                segmentType = CogFeatureSystem.VowelType;
                break;

            default:
                throw new InvalidEnumArgumentException();
            }

            var segmentComparer  = new SegmentComparer();
            var categoryComparer = new SegmentCategoryComparer();

            _segments = new ReadOnlyList <SegmentMappingsTableSegmentViewModel>(projectService.Project.Varieties.SelectMany(v => v.SegmentFrequencyDistribution.ObservedSamples)
                                                                                .Where(s => s.Type == segmentType).Distinct().OrderBy(s => s.Category(), categoryComparer).ThenBy(s => s, segmentComparer)
                                                                                .Select(s => new SegmentMappingsTableSegmentViewModel(s, _soundType)).Concat(new SegmentMappingsTableSegmentViewModel(null, _soundType)).ToArray());
            _categories = new ReadOnlyList <SegmentCategoryViewModel>(_segments.GroupBy(s => s.DomainSegment == null ? string.Empty : s.DomainSegment.Category())
                                                                      .OrderBy(g => g.Key, categoryComparer).Select(g => new SegmentCategoryViewModel(g.Key, g)).ToArray());

            var mappingLookup = new Dictionary <UnorderedTuple <string, string>, HashSet <UnorderedTuple <string, string> > >();

            foreach (SegmentMappingViewModel mapping in mappings)
            {
                string        seg1, seg2;
                FeatureSymbol leftEnv1, rightEnv1, leftEnv2, rightEnv2;
                if (ListSegmentMappings.Normalize(projectService.Project.Segmenter, mapping.Segment1, out seg1, out leftEnv1, out rightEnv1) &&
                    ListSegmentMappings.Normalize(projectService.Project.Segmenter, mapping.Segment2, out seg2, out leftEnv2, out rightEnv2))
                {
                    UnorderedTuple <string, string>            key = UnorderedTuple.Create(seg1, seg2);
                    HashSet <UnorderedTuple <string, string> > m   = mappingLookup.GetOrCreate(key, () => new HashSet <UnorderedTuple <string, string> >());
                    m.Add(UnorderedTuple.Create(mapping.Segment1, mapping.Segment2));
                }
            }

            IWordAligner aligner = projectService.Project.WordAligners[ComponentIdentifiers.PrimaryWordAligner];

            foreach (SegmentMappingsTableSegmentViewModel segment1 in _segments)
            {
                bool isEnabled = true;
                foreach (SegmentMappingsTableSegmentViewModel segment2 in _segments)
                {
                    if (EqualityComparer <Segment> .Default.Equals(segment1.DomainSegment, segment2.DomainSegment))
                    {
                        isEnabled = false;
                    }

                    int delta = segment1.DomainSegment == null || segment2.DomainSegment == null ? -1
                                                : aligner.Delta(segment1.DomainSegment.FeatureStruct, segment2.DomainSegment.FeatureStruct);
                    SegmentMappingsTableSegmentPairViewModel segmentPair = segmentPairFactory(segment1, segment2, delta, isEnabled);
                    segmentPair.MeetsThreshold = delta != -1 && delta <= _threshold;
                    HashSet <UnorderedTuple <string, string> > pairMappings;
                    if (mappingLookup.TryGetValue(UnorderedTuple.Create(segment1.StrRep, segment2.StrRep), out pairMappings))
                    {
                        segmentPair.Mappings.Mappings.AddRange(pairMappings.Select(m => mappingFactory(m.Item1, m.Item2)));
                    }
                    segment1.SegmentPairs.Add(segmentPair);
                }
            }
        }
Esempio n. 6
0
        private void PopulateSegments()
        {
            var segmentComparer = new SegmentComparer();
            var categoryComparer = new SegmentCategoryComparer();
            _busyService.ShowBusyIndicatorUntilFinishDrawing();
            using (_domainSegments.BulkUpdate())
            using (_segments.BulkUpdate())
            {
                _domainSegments.Clear();
                _segments.Clear();
                foreach (Segment segment in _projectService.Project.Varieties
                    .SelectMany(v => v.SyllablePositionSegmentFrequencyDistributions[DomainSyllablePosition].ObservedSamples)
                    .Distinct().OrderBy(s => s.Category(), categoryComparer).ThenBy(s => s, segmentComparer))
                {
                    _domainSegments.Add(segment);
                    _segments.Add(new SegmentViewModel(segment));
                }
            }

            _categories.ReplaceAll(_segments.GroupBy(s => s.DomainSegment.Category()).OrderBy(g => g.Key, categoryComparer).Select(g => new SegmentCategoryViewModel(g.Key, g)));
            HasSegments = _segments.Count > 0;
        }