praatio.data_classes.data_point

  1"""An PointObject is used for storing non-annotation data in praat
  2
  3There are two variants: PointObject1D and PointObject2D
  4
  5PointObject1D only stores temporal data (it can track pulses/occurances in time).
  6PointObject2D stores temporal data and some other data (eg pitch).  It's not
  7so different from a PointTier, except that PointTiers specifically hold annotation
  8data.
  9"""
 10
 11import io
 12
 13from typing_extensions import Literal
 14from typing import List, Optional, Tuple, cast
 15
 16from praatio.utilities import constants
 17from praatio.utilities import errors
 18from praatio.utilities import my_math
 19
 20
 21class PointObject:
 22    def __init__(
 23        self,
 24        pointList: List[Tuple[float, ...]],  # Either (float) or (float, float)
 25        objectClass: str,
 26        minTime: float = 0,
 27        maxTime: float = None,
 28    ):
 29        self.pointList = [tuple(float(val) for val in row) for row in pointList]
 30        self.objectClass = objectClass
 31        self.minTime = minTime if minTime > 0 else 0
 32        self.maxTime = maxTime
 33
 34    def __eq__(self, other):
 35        if not isinstance(other, PointObject):
 36            return False
 37
 38        isEqual = True
 39        isEqual &= self.objectClass == other.objectClass
 40        isEqual &= self.minTime == other.minTime
 41        isEqual &= self.maxTime == other.maxTime
 42        isEqual &= len(self.pointList) == len(other.pointList)
 43
 44        if isEqual:
 45            for selfEntry, otherEntry in zip(self.pointList, other.pointList):
 46                isEqual &= selfEntry == otherEntry
 47
 48        return isEqual
 49
 50    def save(self, fn: str) -> None:
 51        header = 'File type = "ooTextFile"\n' 'Object class = "%s"\n' "\n%s\n%s\n%d"
 52        header %= (
 53            self.objectClass,
 54            my_math.numToStr(self.minTime),
 55            my_math.numToStr(self.maxTime),
 56            len(self.pointList),
 57        )
 58
 59        tmp = [my_math.numToStr(val) for entry in self.pointList for val in entry]
 60        strPoints = "\n".join(tmp)
 61
 62        outputStr = "%s\n%s\n" % (header, strPoints)
 63
 64        with io.open(fn, "w", encoding="utf-8") as fd:
 65            fd.write(outputStr)
 66
 67    def getPointsInInterval(
 68        self, start: float, end: float, startIndex: int = 0
 69    ) -> List[float]:
 70
 71        returnPointList = []
 72        for entry in self.pointList[startIndex:]:
 73            time = entry[0]
 74            if time >= start:
 75                if time <= end:
 76                    returnPointList.append(time)
 77                else:
 78                    break
 79
 80        return returnPointList
 81
 82
 83class PointObject1D(PointObject):
 84    """Points that only carry temporal information"""
 85
 86    def __init__(
 87        self,
 88        pointList: List[Tuple[float]],
 89        objectClass: Literal["point"],
 90        minTime: float = 0,
 91        maxTime: Optional[float] = None,
 92    ):
 93
 94        suitable1dPointTypes = [constants.DataPointTypes.POINT]
 95        if objectClass not in suitable1dPointTypes:
 96            raise errors.WrongOption("objectClass", objectClass, suitable1dPointTypes)
 97
 98        if maxTime is None:
 99            maxTime = max([row[0] for row in pointList])
100
101        castPointList = cast(List[Tuple[float, ...]], pointList)
102        super(PointObject1D, self).__init__(
103            castPointList, objectClass, minTime, maxTime
104        )
105
106
107class PointObject2D(PointObject):
108    """Points that carry a temporal value and some other value"""
109
110    def __init__(
111        self,
112        pointList: List[Tuple[float, float]],
113        objectClass: Literal["pitch", "duration"],
114        minTime: float = 0,
115        maxTime: float = None,
116    ):
117        suitable2dPointTypes = [
118            constants.DataPointTypes.PITCH,
119            constants.DataPointTypes.DURATION,
120        ]
121        if objectClass not in suitable2dPointTypes:
122            raise errors.WrongOption(
123                "objectClass",
124                objectClass,
125                suitable2dPointTypes,
126            )
127
128        if maxTime is None:
129            maxTime = max([timeV for timeV, _ in pointList])
130
131        castPointList = cast(List[Tuple[float, ...]], pointList)
132        super(PointObject2D, self).__init__(
133            castPointList, objectClass, minTime, maxTime
134        )