o piMl@sxdZddlZddlmZmZmZmZmZmZddl m Z ddl Z ddl mZedddGd d d ZGd d d ZdS) as ####### Segment ####### .. plot:: pyplots/segment.py :class:`pyannote.core.Segment` instances describe temporal fragments (*e.g.* of an audio file). The segment depicted above can be defined like that: .. code-block:: ipython In [1]: from pyannote.core import Segment In [2]: segment = Segment(start=5, end=15) In [3]: print(segment) It is nothing more than 2-tuples augmented with several useful methods and properties: .. code-block:: ipython In [4]: start, end = segment In [5]: start In [6]: segment.end In [7]: segment.duration # duration (read-only) In [8]: segment.middle # middle (read-only) In [9]: segment & Segment(3, 12) # intersection In [10]: segment | Segment(3, 12) # union In [11]: segment.overlaps(3) # does segment overlap time t=3? Use `Segment.set_precision(ndigits)` to automatically round start and end timestamps to `ndigits` precision after the decimal point. To ensure consistency between `Segment` instances, it is recommended to call this method only once, right after importing `pyannote.core.Segment`. .. code-block:: ipython In [12]: Segment(1/1000, 330/1000) == Segment(1/1000, 90/1000+240/1000) Out[12]: False In [13]: Segment.set_precision(ndigits=4) In [14]: Segment(1/1000, 330/1000) == Segment(1/1000, 90/1000+240/1000) Out[14]: True See :class:`pyannote.core.Segment` for the complete reference. N)UnionOptionalTupleListIteratorIterable) Alignment) dataclassT)frozenorderc@seZdZUdZdZeed<dZeed<ed-de e fddZ d d Z d d Z ed efddZed efddZd eefddZd.ddZd/ddZddZddd efddZded efddZd0d d!Zd0d"d#Zd$ed efd%d&Zd'd(Zd)d*Zd+d,ZdS)1Segmenta Time interval Parameters ---------- start : float interval start time, in seconds. end : float interval end time, in seconds. Segments can be compared and sorted using the standard operators: >>> Segment(0, 1) == Segment(0, 1.) True >>> Segment(0, 1) != Segment(3, 4) True >>> Segment(0, 1) < Segment(2, 3) True >>> Segment(0, 1) < Segment(0, 2) True >>> Segment(1, 2) < Segment(0, 3) False Note ---- A segment is smaller than another segment if one of these two conditions is verified: - `segment.start < other_segment.start` - `segment.start == other_segment.start` and `segment.end < other_segment.end` startendNndigitscCs&|dur dadadSdad| adS)aAutomatically round start and end timestamps to `ndigits` precision after the decimal point To ensure consistency between `Segment` instances, it is recommended to call this method only once, right after importing `pyannote.core.Segment`. Usage ----- >>> from pyannote.core import Segment >>> Segment.set_precision(2) >>> Segment(1/3, 2/3) NFgư>T )AUTO_ROUND_TIMESEGMENT_PRECISION)rrI/home/ubuntu/.local/lib/python3.10/site-packages/pyannote/core/segment.py set_precisions zSegment.set_precisioncCst|j|jtkS)u&Emptiness >>> if segment: ... # segment is not empty. ... else: ... # segment is empty. Note ---- A segment is considered empty if its end time is smaller than its start time, or its duration is smaller than 1μs. )boolrrrselfrrr__bool__ zSegment.__bool__cCsLtr$t|dt|jtdtt|dt|jtdtdSdS)zERound start and end up to SEGMENT_PRECISION precision (when required)r?rN)robject __setattr__intrrrrrrr __post_init__s $zSegment.__post_init__returncCs|r|j|jSdS)zSegment duration (read-only)r)rrrrrrdurationszSegment.durationcCsd|j|jS)zSegment mid-time (read-only)rrrrrrrmiddleszSegment.middleccs|jV|jVdS)zmUnpack segment boundaries >>> segment = Segment(start, end) >>> start, end = segment Nr$rrrr__iter__s zSegment.__iter__cCst|j|jdS)z{Get a copy of the segment Returns ------- copy : Segment Copy of the segment. r$)r rrrrrrcopysz Segment.copyothercCs|j|jko |j|jkS)zInclusion >>> segment = Segment(start=0, end=10) >>> Segment(start=3, end=10) in segment: True >>> Segment(start=5, end=15) in segment: False r$rr(rrr __contains__s zSegment.__contains__cCs(t|j|j}t|j|j}t||dS)aIntersection >>> segment = Segment(0, 10) >>> other_segment = Segment(5, 15) >>> segment & other_segment Note ---- When the intersection is empty, an empty segment is returned: >>> segment = Segment(0, 10) >>> other_segment = Segment(15, 20) >>> intersection = segment & other_segment >>> if not intersection: ... # intersection is empty. r$)maxrminrr rr(rrrrr__and__s zSegment.__and__cCsD|j|jkr|j|jtkp!|j|jko|j|jtkp!|j|jkS)aCheck whether two segments intersect each other Parameters ---------- other : Segment Other segment Returns ------- intersect : bool True if segments intersect, False otherwise )rrrr)rrr intersectss   zSegment.intersectstcCs|j|ko |j|kS)zCheck if segment overlaps a given time Parameters ---------- t : float Time, in seconds. Returns ------- overlap: bool True if segment overlaps time t, False otherwise. r$rr0rrroverlapsrzSegment.overlapscCs8|s|S|s|St|j|j}t|j|j}t||dS)aUnion >>> segment = Segment(0, 10) >>> other_segment = Segment(5, 15) >>> segment | other_segment Note ---- When a gap exists between the segment, their union covers the gap as well: >>> segment = Segment(0, 10) >>> other_segment = Segment(15, 20) >>> segment | other_segment >> segment = Segment(0, 10) >>> other_segment = Segment(15, 20) >>> segment ^ other_segment >> segment = Segment(0, 10) >>> empty_segment = Segment(11, 11) >>> segment ^ empty_segment ValueError: The gap between a segment and an empty segment is not defined. z>The gap between a segment and an empty segment is not defined.r$) ValueErrorr,rr+rr r-rrr__xor__3s zSegment.__xor__secondsc Csvddlm}|dk}t|}||d}|jd|j}|j}t|d\}}t|d\}}d|r1dnd ||||d fS) Nr) timedelta)r6iQi<z%s%02d:%02d:%02d.%03d- i)datetimer7absr6days microsecondsdivmod) rr6r7negativetdr>hours remainderminutesrrr _str_helperOs  zSegment._str_helpercCs$|rd||j||jfSdS)zHuman-readable representation >>> print(Segment(1337, 1337 + 0.42)) [ 00:22:17.000 --> 00:22:17.420] Note ---- Empty segments are printed as "[]" z [%s --> %s]z[])rErrrrrr__str__\s   zSegment.__str__cCsd|j|jfS)zrComputer-readable representation >>> Segment(1337, 1337 + 0.42) zr$rrrr__repr__kszSegment.__repr__cCslddlm}m}|st|j|jjddSddlm}z||WSt y5td|dYdSw)zjIPython notebook support See also -------- :mod:`pyannote.core.notebook` r)MATPLOTLIB_IS_AVAILABLEMATPLOTLIB_WARNING)klassN) repr_segmentzBCouldn't import matplotlib to render the vizualization for object zY. To enable, install the required dependencies with 'pip install pyannore.core[notebook]') notebookrHrIwarningswarnformat __class____name__rK ImportError)rrHrIrKrrr _repr_png_ss    zSegment._repr_png_N)r"r )r(r )r(r r"r ) rQ __module__ __qualname____doc__rfloat__annotations__r staticmethodrr rrr!propertyr#r%rr&r'r*r.rr/r2r3r5strrErFrGrSrrrrr ]s0         r c@seZdZdZdHddZedefd d Zedefd d Zedefd dZ edefddZ dede fddZ dIdede de fddZ   dJdeedfde deedeedeejeee ff dd Zd!edee e ffd"d#Zd!edee e ffd$d%Zd&e d'e defd(d)Zd&e d'e defd*d+Zd,e defd-d.Zd/e defd0d1Zd2ede fd3d4Zd2ede fd5d6Zd7e defd8d9Z defd:d;Z!defdd?Z#de fd@dAZ$dKdBdCZ% dLdDeedfdEede&efdFdGZ'dS)M SlidingWindowaSliding window Parameters ---------- duration : float > 0, optional Window duration, in seconds. Default is 30 ms. step : float > 0, optional Step between two consecutive position, in seconds. Default is 10 ms. start : float, optional First start position of window, in seconds. Default is 0. end : float > `start`, optional Default is infinity (ie. window keeps sliding forever) Examples -------- >>> sw = SlidingWindow(duration, step, start) >>> frame_range = (a, b) >>> frame_range == sw.toFrameRange(sw.toSegment(*frame_range)) ... True >>> segment = Segment(A, B) >>> new_segment = sw.toSegment(*sw.toFrameRange(segment)) >>> abs(segment) - abs(segment & new_segment) < .5 * sw.step >>> sw = SlidingWindow(end=0.1) >>> print(next(sw)) [ 00:00:00.000 --> 00:00:00.030] >>> print(next(sw)) [ 00:00:00.010 --> 00:00:00.040] Q?{Gz?rNcCsd|dkrtd||_|dkrtd||_||_|dur"tj|_n ||kr*td||_d|_dS)Nrz'duration' must be a float > 0.z'step' must be a float > 0.z#'end' must be greater than 'start'.)r4_SlidingWindow__duration_SlidingWindow__step_SlidingWindow__startnpinf_SlidingWindow__end_SlidingWindow__i)rr#steprrrrr__init__s  zSlidingWindow.__init__r"cC|jS)z%Sliding window start time in seconds.)rcrrrrrzSlidingWindow.startcCrj)z#Sliding window end time in seconds.)rfrrrrrrkzSlidingWindow.endcCrj)zSliding window step in seconds.)rbrrrrrhrkzSlidingWindow.stepcCrj)z#Sliding window duration in seconds.)rarrrrr#rkzSlidingWindow.durationr0cCs$tt||jd|j|jS)zClosest frame to timestamp. Parameters ---------- t : float Timestamp, in seconds. Returns ------- index : int Index of frame whose middle is the closest to `timestamp` r)r rdrintrcrarbr1rrr closest_frameszSlidingWindow.closest_framestrict from_durationmodecCsh|dkrtt||j|jdS|dkr$tt||j|jS|dkr2tt||jSdS)aNumber of frames Parameters ---------- from_duration : float Duration in seconds. mode : {'strict', 'loose', 'center'} In 'strict' mode, computes the maximum number of consecutive frames that can be fitted into a segment with duration `from_duration`. In 'loose' mode, computes the maximum number of consecutive frames intersecting a segment with duration `from_duration`. In 'center' mode, computes the average number of consecutive frames where the first one is centered on the start time and the last one is centered on the end time of a segment with duration `from_duration`. rnrloosecenterN)r rdfloorr#rhrl)rrorprrrsamplesszSlidingWindow.samplesrqFfocusTimelinefixed return_rangescsfddlm}t|t|fsd}t|t||rpdur"d}t||r[g}t|D],\}} j| dd} |dksI| dd|d dkrN|| 7}q,| dd|d d<q,|St fd d |D} t | Sd kr|j j j j} tt | }dur|jj j} tt | }||df} njd d }|||f} nqdkr|j j j} tt | }dur|jj j j} tt | }||df} n?jdd }|||f} n1dkr|j }dur |j}||df} njdd }|||f} nd}t||r)t| gSt jt| t jdS)aCrop sliding window Parameters ---------- focus : `Segment` or `Timeline` mode : {'strict', 'loose', 'center'}, optional In 'strict' mode, only indices of segments fully included in 'focus' support are returned. In 'loose' mode, indices of any intersecting segments are returned. In 'center' mode, first and last positions are chosen to be the positions whose centers are the closest to 'focus' start and end times. Defaults to 'loose'. fixed : float, optional Overrides `Segment` 'focus' duration and ensures that the number of returned frames is fixed (which might otherwise not be the case because of rounding erros). return_ranges : bool, optional Return as list of ranges. Defaults to indices numpy array. Returns ------- indices : np.array (or list of ranges) Array of unique indices of matching segments rrvz3"focus" must be a `Segment` or `Timeline` instance.Nz1'fixed' is not supported with `Timeline` 'focus'.Trprwrxrr`csg|] }j|ddqS)Frz)crop).0srwrprrr @sz&SlidingWindow.crop..rq)rprnrrz4'mode' must be one of {'loose', 'strict', 'center'}.)dtype)timelinerv isinstancer TypeErrorr4 enumeratesupportr{rdhstackuniquerr#rhr ceilrrsrtrmlistarrayrangeint64)rrurprwrxrvmsgrangesir}rngindicesi_j_jnrr~rr{sh           zSlidingWindow.cropsegmentcCtdt||S)Nz)Deprecated in favor of `segment_to_range`)rMrNDeprecationWarningsegment_to_range)rrrrrsegmentToRange zSlidingWindow.segmentToRangecCs(||j}t|j|jd}||fS)aConvert segment to 0-indexed frame range Parameters ---------- segment : Segment Returns ------- i0 : int Index of first frame n : int Number of frames Examples -------- >>> window = SlidingWindow() >>> print window.segment_to_range(Segment(10, 15)) i0, n r)rmrr r#rh)rri0rrrrrs zSlidingWindow.segment_to_rangerrcCstdt|||S)Nz1This is deprecated in favor of `range_to_segment`)rMrNrrange_to_segment)rrrrrrrangeToSegments zSlidingWindow.rangeToSegmentcCsH|j|d|jd|j}||j}||}|dkr|j}t||S)akConvert 0-indexed frame range to segment Each frame represents a unique segment of duration 'step', centered on the middle of the frame. The very first frame (i0 = 0) is the exception. It is extended to the sliding window start time. Parameters ---------- i0 : int Index of first frame n : int Number of frames Returns ------- segment : Segment Examples -------- >>> window = SlidingWindow() >>> print window.range_to_segment(3, 2) [ --> ] rr)rcrbrarr )rrrrr#rrrrrs #  zSlidingWindow.range_to_segmentnSamplescCr)Nz4This is deprecated in favor of `samples_to_duration`)rMrNrsamples_to_duration)rrrrrsamplesToDurationrzSlidingWindow.samplesToDuration n_samplescCs|d|jS)zReturns duration of samplesr)rr#)rrrrrrsz!SlidingWindow.samples_to_durationr#cCr)Nz4This is deprecated in favor of `duration_to_samples`)rMrNrduration_to_samplesrr#rrrdurationToSamplesrzSlidingWindow.durationToSamplescCs|td|dS)zReturns samples in durationrr)rr rrrrrsz!SlidingWindow.duration_to_samplesrcCs0|j||j}||jkrdSt|||jdS)z Parameters ---------- i : int Index of sliding window position Returns ------- segment : :class:`Segment` Sliding window at ith position Nr$)rcrbrfr ra)rrrrrr __getitem__s zSlidingWindow.__getitem__cCs|SrT)__next__rrrrnextszSlidingWindow.nextcCs&|jd7_||j}|r|St)Nr)rg StopIteration)rwindowrrrrs  zSlidingWindow.__next__cCs d|_|S)aSliding window iterator Use expression 'for segment in sliding_window' Examples -------- >>> window = SlidingWindow(end=0.1) >>> for segment in window: ... print(segment) [ 00:00:00.000 --> 00:00:00.030] [ 00:00:00.010 --> 00:00:00.040] [ 00:00:00.020 --> 00:00:00.050] [ 00:00:00.030 --> 00:00:00.060] [ 00:00:00.040 --> 00:00:00.070] [ 00:00:00.050 --> 00:00:00.080] [ 00:00:00.060 --> 00:00:00.090] [ 00:00:00.070 --> 00:00:00.100] [ 00:00:00.080 --> 00:00:00.110] [ 00:00:00.090 --> 00:00:00.120] r`)rgrrrrr&szSlidingWindow.__iter__cCs@t|jr td||j}||r|d7}||s|}|S)zNumber of positions Equivalent to len([segment for segment in window]) Returns ------- length : int Number of positions taken by the sliding window (from start times to end times) zinfinite sliding window.r)rdisinfrfr4rm)rrlengthrrr__len__*s  zSlidingWindow.__len__cCs.|j}|j}|j}|j}|j||||d}|S)zDuplicate sliding windowr#rhrr)r#rhrrrP)rr#rhrrsliding_windowrrrr'CszSlidingWindow.copyr align_lastc csddlm}t||r|}nt|tr||gd}n dt|d}t||D]7}|j|jkr2q)t|j|j|j |j d}|D] }||vrK|V|} q@|r`| j |j kr`t|j |j|j dVq)dS) aSlide window over support Parameter --------- support : Segment or Timeline Support on which to slide the window. align_last : bool, optional Yield a final segment so that it aligns exactly with end of support. Yields ------ chunk : Segment Example ------- >>> window = SlidingWindow(duration=2., step=1.) >>> for chunk in window(Segment(3, 7.5)): ... print(tuple(chunk)) (3.0, 5.0) (4.0, 6.0) (5.0, 7.0) >>> for chunk in window(Segment(3, 7.5), align_last=True): ... print(tuple(chunk)) (3.0, 5.0) (4.0, 6.0) (5.0, 7.0) (5.5, 7.5) rry)segmentsz>"support" must be either a Segment or a Timeline instance (is )rr$N) pyannote.corervrr typerr#r]rhrr) rrrrvrrrrr}lastrrr__call__Ns<    zSlidingWindow.__call__)r^r_rN)rn)rqNF)r"r])F)(rQrUrVrWrir[rXrrrhr#r rmr rtrr rrrdndarrayrr{rrrrrrrrrrrrr&rr'rrrrrrr]s^  -    r])rWrMtypingrrrrrr utils.typesr numpyrd dataclassesr r r]rrrrs6    ,