Ejemplo n.º 1
0
        /// <summary>
        /// Tell whether one segment file is a valid one.
        /// </summary>
        /// <param name="filePath">Segment file to test.</param>
        /// <param name="setting">Setting.</param>
        /// <returns>True if valid, otherwise false.</returns>
        public static bool IsValid(string filePath, SegmentSetting setting)
        {
            if (string.IsNullOrEmpty(filePath))
            {
                throw new ArgumentNullException("filePath");
            }

            if (setting == null)
            {
                throw new ArgumentNullException("setting");
            }

            Collection<WaveSegment> segments = null;
            try
            {
                segments = ReadAllData(filePath, setting);
            }
            catch (InvalidDataException ide)
            {
                string message = string.Format(CultureInfo.InvariantCulture,
                    "Invalid data found for alignment file [{0}], for {1}",
                    filePath, ide.Message);
                System.Diagnostics.Trace.WriteLine(message);
                return false;
            }

            if (segments.Count < 3 && setting.HasHeadSilence && setting.HasTailSilence)
            {
                // should start/end with Phoneme.Silence tags, and at least one other segment
                return false;
            }

            if ((setting.HasHeadSilence && !segments[0].IsSilencePhone)
                || (setting.HasTailSilence && !segments[segments.Count - 1].IsSilencePhone))
            {
                // should start/end with Phoneme.Silence tags
                return false;
            }

            for (int i = 1; i < segments.Count; i++)
            {
                if (segments[i - 1].StartTime >= segments[i].StartTime)
                {
                    // timestamp of preview segment should less than following one.
                    return false;
                }
            }

            for (int i = 0; setting.HasEndTime && i < segments.Count; i++)
            {
                if (segments[i].StartTime > segments[i].EndTime)
                {
                    return false;
                }
            }

            return true;
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Save this segment data into TextWriter.
        /// </summary>
        /// <param name="tw">Text writer to write the segments.</param>
        /// <param name="setting">Setting.</param>
        public void Save(TextWriter tw, SegmentSetting setting)
        {
            if (tw == null)
            {
                throw new ArgumentNullException("tw");
            }

            foreach (WaveSegment ws in _waveSegments)
            {
                tw.WriteLine(ws.ToString(setting.HasEndTime));
            }
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Load segment data from text reader stream.
        /// </summary>
        /// <param name="tr">Text reader to read segment from.</param>
        /// <param name="setting">Setting.</param>
        /// <returns>Wave segment collection.</returns>
        public static Collection<WaveSegment> ReadAllData(TextReader tr, SegmentSetting setting)
        {
            if (tr == null)
            {
                throw new ArgumentNullException("tr");
            }

            if (setting == null)
            {
                throw new ArgumentNullException("setting");
            }

            Collection<WaveSegment> segs = new Collection<WaveSegment>();
            string line = null;
            while ((line = tr.ReadLine()) != null)
            {
                if (string.IsNullOrEmpty(line))
                {
                    continue;
                }

                if (line == ".")
                {
                    // end of section
                    break;
                }

                string[] items = line.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
                if (items.Length < 2 && !setting.HasEndTime)
                {
                    string message = string.Format(CultureInfo.InvariantCulture,
                        "The normal segment line of alignment file shoud be (timestamp) (label) [confidence score]. But '{0}' is found.",
                        line);
                    throw new InvalidDataException(message);
                }

                if (items.Length < 3 && setting.HasEndTime)
                {
                    string message = string.Format(CultureInfo.InvariantCulture,
                        "The normal segment line of alignment file should be (timestamp) (timestamp) (label) [confidence score]. But '{0}' is found.",
                        line);
                    throw new InvalidDataException(message);
                }

                WaveSegment seg = new WaveSegment();
                try
                {
                    seg.StartTime = float.Parse(items[0], CultureInfo.InvariantCulture);
                    if (!setting.HasEndTime)
                    {
                        if (items.Length == 3)
                        {
                            seg.Confidence = float.Parse(items[2], CultureInfo.InvariantCulture);
                        }
                    }
                    else
                    {
                        seg.EndTime = float.Parse(items[1], CultureInfo.InvariantCulture);
                    }
                }
                catch (FormatException)
                {
                    string message = string.Format(CultureInfo.InvariantCulture,
                        "Malformed line found as '{0}'",
                        line);
                    throw new InvalidDataException(message);
                }

                seg.Label = Phoneme.ToOffline(items[setting.HasEndTime ? 2 : 1]);
                segs.Add(seg);
            }

            RemoveDuplicatedSilence(segs);

            for (int i = 0; i < segs.Count - 1; i++)
            {
                if (!setting.HasEndTime)
                {
                    segs[i].EndTime = segs[i + 1].StartTime;
                }
                else
                {
                    if (segs[i].StartTime > segs[i].EndTime)
                    {
                        string message = string.Format(CultureInfo.InvariantCulture,
                            "The start time of the {0}(th) segment [{1}] must not be later the end time of it.",
                            i, segs[i].Label);
                        throw new InvalidDataException(message);
                    }
                }

                if (segs[i].StartTime > segs[i + 1].StartTime)
                {
                    string message = string.Format(CultureInfo.InvariantCulture,
                        "The start time of the {0}(th) segment [{1}] must not be later than the start time of the following segment [{2}].",
                        i, segs[i].Label, segs[i + 1].Label);
                    throw new InvalidDataException(message);
                }
            }

            return segs;
        }
Ejemplo n.º 4
0
 /// <summary>
 /// Save this segment data into file.
 /// </summary>
 /// <param name="filePath">Target file to save.</param>
 /// <param name="setting">Setting.</param>
 public void Save(string filePath, SegmentSetting setting)
 {
     Helper.EnsureFolderExistForFile(filePath);
     using (StreamWriter sw = new StreamWriter(filePath, false, Encoding.ASCII))
     {
         Save(sw, setting);
     }
 }
Ejemplo n.º 5
0
        /// <summary>
        /// Initialize from text stream.
        /// </summary>
        /// <param name="tr">Segment text stream.</param>
        /// <param name="setting">Setting.</param>
        public void Load(TextReader tr, SegmentSetting setting)
        {
            _waveSegments = SegmentFile.ReadAllData(tr, setting);

            UpdateNonSilenceWaveSegments();
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Initialize from a segment file.
        /// </summary>
        /// <param name="filePath">Segment file.</param>
        /// <param name="setting">Setting.</param>
        public void Load(string filePath, SegmentSetting setting)
        {
            if (string.IsNullOrEmpty(filePath))
            {
                throw new ArgumentNullException("filePath");
            }

            if (setting == null)
            {
                throw new ArgumentNullException("setting");
            }

            if (!File.Exists(filePath))
            {
                throw new FileNotFoundException(filePath);
            }

            _filePath = filePath;

            try
            {
                using (TextReader tr = new StreamReader(filePath))
                {
                    Load(tr, setting);
                }
            }
            catch (InvalidDataException ide)
            {
                string message = string.Format(CultureInfo.InvariantCulture,
                    "Failed to load alignment file [{0}].",
                    filePath);
                throw new InvalidDataException(message, ide);
            }

            if (WaveSegments.Count == 0)
            {
                string message = string.Format(CultureInfo.InvariantCulture,
                    "Empty alignment file found at [{0}].",
                    filePath);
                throw new InvalidDataException(message);
            }

            if (setting.HasTailSilence && !Phoneme.IsSilencePhone(WaveSegments[WaveSegments.Count - 1].Label))
            {
                string message = string.Format(CultureInfo.InvariantCulture,
                    "Last segment [{0}] in file [{1}] should be [{2}].",
                    WaveSegments[WaveSegments.Count - 1].Label, filePath, Phoneme.ToOffline(Phoneme.SilencePhone));
                throw new InvalidDataException(message);
            }
        }
Ejemplo n.º 7
0
        /// <summary>
        /// Initialize from a segment file.
        /// </summary>
        /// <param name="filePath">Segment file.</param>
        /// <param name="fHasEndTime">Whether to check the ending silence.</param>
        /// <param name="fHasHeadSilence">Whether to check the head silence.</param>
        /// <param name="fHasTailSilence">Whether to check the tail silence.</param>
        public void Load(string filePath, bool fHasEndTime, bool fHasHeadSilence, bool fHasTailSilence)
        {
            SegmentSetting setting = new SegmentSetting()
            {
                HasEndTime = fHasEndTime,
                HasHeadSilence = fHasHeadSilence,
                HasTailSilence = fHasTailSilence
            };

            Load(filePath, setting);
        }
Ejemplo n.º 8
0
        /// <summary>
        /// Load segment data from text file.
        /// </summary>
        /// <param name="filePath">Segment file path.</param>
        /// <param name="setting">Setting.</param>
        /// <returns>Wave segment collection.</returns>
        public static Collection<WaveSegment> ReadAllData(string filePath, SegmentSetting setting)
        {
            if (string.IsNullOrEmpty(filePath))
            {
                throw new ArgumentNullException("filePath");
            }

            if (setting == null)
            {
                throw new ArgumentNullException("setting");
            }

            try
            {
                using (StreamReader sr = new StreamReader(filePath))
                {
                    return SegmentFile.ReadAllData(sr, setting);
                }
            }
            catch (InvalidDataException ide)
            {
                string message = string.Format(CultureInfo.InvariantCulture,
                    "Failed to load alignment file [{0}].",
                    filePath);
                throw new InvalidDataException(message, ide);
            }
        }