praatio.data_classes.klattgrid

  1"""KlattGrid and related classes.
  2
  3KlattGrids can be used for synthesizing and manipulating speech
  4"""
  5
  6import io
  7
  8from typing import List, Optional, Dict, Callable, Union
  9
 10from praatio.data_classes import textgrid
 11from praatio.data_classes import textgrid_tier
 12from praatio.utilities import errors
 13from praatio.utilities import my_math
 14
 15
 16class _KlattBaseTier:
 17    def __init__(self, name: str):
 18        self.tierNameList: List[str] = []  # Preserves the order of the tiers
 19        self.tierDict: Dict[str, "_KlattBaseTier"] = {}
 20        self.name = name
 21        self.minTimestamp = None
 22        self.maxTimestamp = None
 23
 24    def __eq__(self, other):
 25        if not isinstance(other, _KlattBaseTier):
 26            return False
 27
 28        isEqual = True
 29        isEqual &= self.name == other.name
 30        isEqual &= self.minTimestamp == other.minTimestamp
 31        isEqual &= self.maxTimestamp == other.maxTimestamp
 32
 33        isEqual &= self.tierNameList == other.tierNameList
 34        if isEqual:
 35            for tierName in self.tierNameList:
 36                isEqual &= self.tierDict[tierName] == other.tierDict[tierName]
 37
 38        return isEqual
 39
 40    def addTier(self, tier, tierIndex=None) -> None:
 41
 42        if tierIndex is None:
 43            self.tierNameList.append(tier.name)
 44        else:
 45            self.tierNameList.insert(tierIndex, tier.name)
 46
 47        if tier.name in list(self.tierDict.keys()):
 48            raise errors.TierNameExistsError(
 49                f"Cannot add tier with name {tier.name} as it already exists in the Klattgrid"
 50            )
 51        self.tierDict[tier.name] = tier
 52
 53        minV = tier.minTimestamp
 54        if self.minTimestamp is None or (minV is not None and minV < self.minTimestamp):
 55            self.minTimestamp = minV
 56
 57        maxV = tier.maxTimestamp
 58        if self.maxTimestamp is None or (maxV is not None and maxV > self.maxTimestamp):
 59            self.maxTimestamp = maxV
 60
 61
 62class KlattContainerTier(_KlattBaseTier):
 63    """Contains a set of intermediate tiers"""
 64
 65    def getAsText(self):
 66        outputTxt = ""
 67        outputTxt += "%s? <exists>\n" % self.name
 68
 69        try:
 70            self.minTimestamp = toIntOrFloat(self.minTimestamp)
 71            outputTxt += "xmin = %s\nxmax = %s\n" % (
 72                my_math.numToStr(self.minTimestamp),
 73                my_math.numToStr(self.maxTimestamp),
 74            )
 75        except TypeError:
 76            pass
 77
 78        for name in self.tierNameList:
 79            outputTxt += self.tierDict[name].getAsText()
 80
 81        return outputTxt
 82
 83    def modifySubtiers(self, tierName: str, modFunc) -> None:
 84        """
 85        Modify values in every tier contained in the named intermediate tier
 86        """
 87        kit = self.tierDict[tierName]
 88        for name in kit.tierNameList:
 89            subpointTier = kit.tierDict[name]
 90            subpointTier.modifyValues(modFunc)
 91
 92
 93class KlattIntermediateTier(_KlattBaseTier):
 94    """
 95    Has many point tiers that are semantically related (e.g. formant tiers)
 96    """
 97
 98    def getAsText(self):
 99        outputTxt = ""
100        headerTxt = "%s: size=%d\n" % (self.name, len(self.tierNameList))
101
102        for name in self.tierNameList:
103            outputTxt += self.tierDict[name].getAsText()
104
105        outputTxt = headerTxt + outputTxt
106
107        return outputTxt
108
109
110class KlattPointTier(textgrid_tier.TextgridTier):
111    """
112    A Klatt tier not contained within another tier
113    """
114
115    def __init__(
116        self,
117        name: str,
118        entries: List,
119        minT: Optional[float] = None,
120        maxT: Optional[float] = None,
121    ):
122
123        entries = [(float(time), label) for time, label in entries]
124
125        # Determine the min and max timestamps
126        timeList = [time for time, label in entries]
127        if minT is not None:
128            timeList.append(float(minT))
129        if maxT is not None:
130            timeList.append(float(maxT))
131
132        try:
133            setMinT = min(timeList)
134            setMaxT = max(timeList)
135        except ValueError:
136            raise errors.TimelessTextgridTierException()
137
138        super(KlattPointTier, self).__init__(name, entries, setMinT, setMaxT)
139
140    def crop(self):
141        raise NotImplementedError
142
143    def dejitter(self):
144        raise NotImplementedError
145
146    def deleteEntry(self, entry):
147        raise NotImplementedError
148
149    def editTimestamps(self):
150        raise NotImplementedError
151
152    def eraseRegion(self):
153        raise NotImplementedError
154
155    def insertEntry(self):
156        raise NotImplementedError
157
158    def insertSpace(self):
159        raise NotImplementedError
160
161    @property
162    def timestamps(self):
163        raise NotImplementedError
164
165    def validate(self):
166        raise NotImplementedError
167
168    def modifyValues(self, modFunc: Callable[[float], bool]) -> None:
169        newEntries = [
170            (timestamp, modFunc(float(value))) for timestamp, value in self.entries
171        ]
172
173        self._entries = newEntries
174
175    def getAsText(self) -> str:
176        outputList = []
177        self.minTimestamp = toIntOrFloat(self.minTimestamp)
178        outputList.append("%s? <exists> " % self.name)
179        outputList.append("xmin = %s" % my_math.numToStr(self.minTimestamp))
180        outputList.append("xmax = %s" % my_math.numToStr(self.maxTimestamp))
181
182        if self.name not in ["phonation", "vocalTract", "coupling", "frication"]:
183            outputList.append("points: size= %d" % len(self.entries))
184
185        for i, entry in enumerate(self.entries):
186            outputList.append("points [%d]:" % (i + 1))
187            outputList.append("    number = %s" % my_math.numToStr(entry[0]))
188            outputList.append("    value = %s" % my_math.numToStr(entry[1]))
189
190        return "\n".join(outputList) + "\n"
191
192
193class KlattSubPointTier(KlattPointTier):
194    """
195    Tiers contained in a KlattIntermediateTier
196    """
197
198    def getAsText(self) -> str:
199        outputList = []
200        outputList.append("%s:" % self.name)
201        self.minTimestamp = toIntOrFloat(self.minTimestamp)
202        outputList.append("    xmin = %s" % my_math.numToStr(self.minTimestamp))
203        outputList.append("    xmax = %s" % my_math.numToStr(self.maxTimestamp))
204        outputList.append("    points: size = %d" % len(self.entries))
205
206        for i, entry in enumerate(self.entries):
207            outputList.append("    points [%d]:" % (i + 1))
208            outputList.append("        number = %s" % my_math.numToStr(entry[0]))
209            outputList.append("        value = %s" % my_math.numToStr(entry[1]))
210
211        return "\n".join(outputList) + "\n"
212
213
214class Klattgrid(textgrid.Textgrid):
215    def save(self, fn: str, minimumIntervalLength: Optional[float] = None):
216        """
217
218        minimumIntervalLength is used for compatibility with Textgrid.save()
219            but it has no impact on a Klattgrid
220        """
221
222        # Header
223        outputTxt = ""
224        outputTxt += 'File type = "ooTextFile"\n'
225        outputTxt += 'Object class = "KlattGrid"\n\n'
226        self.minTimestamp = toIntOrFloat(self.minTimestamp)
227        outputTxt += "xmin = %s\nxmax = %s\n" % (
228            my_math.numToStr(self.minTimestamp),
229            my_math.numToStr(self.maxTimestamp),
230        )
231
232        for tierName in self.tierNames:
233            outputTxt += self._tierDict[tierName].getAsText()
234
235        outputTxt = _cleanNumericValues(outputTxt)
236
237        with io.open(fn, "w", encoding="utf-8") as fd:
238            fd.write(outputTxt)
239
240
241def toIntOrFloat(val: Union[str, float]) -> float:
242    if float(val) - float(int(val)) == 0.0:
243        val = int(val)
244    else:
245        val = float(val)
246    return val
247
248
249def _cleanNumericValues(dataStr: str) -> str:
250    dataList = dataStr.split("\n")
251    newDataList = []
252    for row in dataList:
253        row = row.rstrip()
254        try:
255            if "min" in row or "max" in row:
256                raise errors.ParsingError(
257                    f"Found unexpected keyword 'min' or 'max' in row '{row}'"
258                )
259
260            head, tail = row.split("=")
261            head = head.rstrip()
262            tail = tail.strip()
263            try:
264                row = str(int(tail))
265            except ValueError:
266                tail = "%s" % tail
267                if float(tail) == 0:
268                    tail = "0"
269            row = "%s = %s" % (head, tail)
270        except (ValueError, errors.ParsingError):  # TODO: Is it really ok?
271            pass
272        finally:
273            newDataList.append(row.rstrip())
274
275    outputTxt = "\n".join(newDataList)
276
277    return outputTxt