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