o sit@s dZddlZddlZddlZddlmZddlZd@ddZdAdd ZdBd d Z dCd dZ dCddZ dDddZ dEddZ ddZ     dFddZdGddZd d!Zd"d#Zd$d%ZdHd'd(ZdCd)d*Zd+d,Zd-d.ZdId0d1Zd@d2d3Zd4d5Zd6d7Zd8d9Zd:d;Zdd?ZdS)Jzw Useful functionality required across the task submodules, such as preprocessing, validation, and common computations. N decoratorFcs^ii}|s dd|D}ttt|D] \}}||<|||<qfdd|D}||fS)aOConvert a list of string identifiers into numerical indices. Parameters ---------- labels : list of strings, shape=(n,) A list of annotations, e.g., segment or chord labels from an annotation file. case_sensitive : bool Set to True to enable case-sensitive label indexing (Default value = False) Returns ------- indices : list, shape=(n,) Numerical representation of ``labels`` index_to_label : dict Mapping to convert numerical indices back to labels. ``labels[i] == index_to_label[indices[i]]`` cSsg|]}t|qS)strlower.0srrA/home/ubuntu/.local/lib/python3.10/site-packages/mir_eval/util.py 'z index_labels..cg|]}|qSrrrlabel_to_indexrr r /) enumeratesortedset)labelscase_sensitiveindex_to_labelindexr indicesrrr index_labelss r__csfddtt|DS)aGiven an array of items (e.g. events, intervals), create a synthetic label for each event of the form '(label prefix)(item number)' Parameters ---------- items : list-like A list or array of events or intervals prefix : str This prefix will be prepended to all synthetically generated labels (Default value = '__') Returns ------- labels : list of str Synthetically generated labels csg|]}|qSrr)rnprefixrr r Gr z#generate_labels..)rangelen)itemsrrrr generate_labels5sr!皙?c CsLtt||}tj|tjd}|||}t||||}||fS)a;Convert an array of labeled time intervals to annotated samples. Parameters ---------- intervals : np.ndarray, shape=(n, d) An array of time intervals, as returned by :func:`mir_eval.io.load_intervals()` or :func:`mir_eval.io.load_labeled_intervals()`. The ``i`` th interval spans time ``intervals[i, 0]`` to ``intervals[i, 1]``. labels : list, shape=(n,) The annotation for each interval offset : float > 0 Phase offset of the sampled time grid (in seconds) (Default value = 0) sample_size : float > 0 duration of each sample to be generated (in seconds) (Default value = 0.1) fill_value : type(labels[0]) Object to use for the label with out-of-range time points. (Default value = None) Returns ------- sample_times : list list of sample times sample_labels : list array of labels for each generated sample Notes ----- Intervals will be rounded down to the nearest multiple of ``sample_size``. )dtype)intnpfloormaxarangefloat32tolistinterpolate_intervals) intervalsroffset sample_size fill_value num_samplessample_indices sample_timessampled_labelsrrr intervals_to_samplesJs $r4c Cst|}t|dd|ddkrtd|gt|}tj||dddfdd}tj||dddfdd}t|||D]\}}} | g|||||<qA|S) aAssign labels to a set of points in time given a set of intervals. Time points that do not lie within an interval are mapped to `fill_value`. Parameters ---------- intervals : np.ndarray, shape=(n, 2) An array of time intervals, as returned by :func:`mir_eval.io.load_intervals()`. The ``i`` th interval spans time ``intervals[i, 0]`` to ``intervals[i, 1]``. Intervals are assumed to be disjoint. labels : list, shape=(n,) The annotation for each interval time_points : array_like, shape=(m,) Points in time to assign labels. These must be in non-decreasing order. fill_value : type(labels[0]) Object to use for the label with out-of-range time points. (Default value = None) Returns ------- aligned_labels : list Labels corresponding to the given time points. Raises ------ ValueError If `time_points` is not in non-decreasing order. Nz+time_points must be in non-decreasing orderrleftsideright)r%asarrayany ValueErrorr searchsortedzip) r,r time_pointsr/aligned_labelsstartsendsstartendlabrrr r+vs %r+cs@t|dddf}||}dur|S|fdd|DfS)aSort intervals, and optionally, their corresponding labels according to start time. Parameters ---------- intervals : np.ndarray, shape=(n, 2) The input intervals labels : list, optional Labels for each interval Returns ------- intervals_sorted or (intervals_sorted, labels_sorted) Labels are only returned if provided as input Nrcr rr)r_rrr r rz*sort_labeled_intervals..)r%argsort)r,ridxintervals_sortedrrHr sort_labeled_intervalss rL?cCs8|dkr |dkr dSd|d|||d||S)aaCompute the f-measure from precision and recall scores. Parameters ---------- precision : float in (0, 1] Precision recall : float in (0, 1] Recall beta : float > 0 Weighting factor for f-measure (Default value = 1.0) Returns ------- f_measure : float The weighted f-measure rr5r) precisionrecallbetarrr f_measures$rScCstttj||dS)aoConvert interval times into boundaries. Parameters ---------- intervals : np.ndarray, shape=(n_events, 2) Array of interval start and end-times q : int Number of decimals to round to. (Default value = 5) Returns ------- boundaries : np.ndarray Interval boundary times, including the end of the final interval )decimals)r%uniqueravelround)r,qrrr intervals_to_boundariessrZcCsBt|t|s tdttt|dd|dd}|S)aOConvert an array of event times into intervals Parameters ---------- boundaries : list-like List-like of event times. These are assumed to be unique timestamps in ascending order. Returns ------- intervals : np.ndarray, shape=(n_intervals, 2) Start and end time for each interval z/Boundary times are not unique or not ascending.Nr6r5)r%allcloserVr=r;listr?) boundariesr,rrr boundaries_to_intervalss$r^rN__T_MIN__T_MAXcCs|dur|dur|jdkrt||gg|gfS|dus |dur)|jdkr)td|durut|dddf|k}t|dkrT|durL||dd}||dd}t||}||krut||g|f}|duru| d||durt|dddf|k}t|dkr|dur|d|d}|d|d}t ||}| |krt|| |gf}|dur| |||fS)afAdjust a list of time intervals to span the range ``[t_min, t_max]``. Any intervals lying completely outside the specified range will be removed. Any intervals lying partially outside the specified range will be cropped. If the specified range exceeds the span of the provided data in either direction, additional intervals will be appended. If an interval is appended at the beginning, it will be given the label ``start_label``; if an interval is appended at the end, it will be given the label ``end_label``. Parameters ---------- intervals : np.ndarray, shape=(n_events, 2) Array of interval start and end-times labels : list, len=n_events or None List of labels (Default value = None) t_min : float or None Minimum interval start time. (Default value = 0.0) t_max : float or None Maximum interval end time. (Default value = None) start_label : str or float or int Label to give any intervals appended at the beginning (Default value = '__T_MIN') end_label : str or float or int Label to give any intervals appended at the end (Default value = '__T_MAX') Returns ------- new_intervals : np.ndarray Intervals spanning ``[t_min, t_max]`` new_labels : list List of labels for ``new_labels`` Nrz8Supplied intervals are empty, can't append new intervalsr5rr) sizer%arrayr=argwherermaximumminvstackinsertminimumr'append)r,rt_mint_max start_label end_label first_idxlast_idxrrr adjust_intervalss61        rqcCs|dur?t||k}t|dkr%|dur||dd}||dd}|d|kr?t|g|f}|dur?|dd||dur}t||k}t|dkrd|dur\|d|d}|d|d}|d|kr}t||gf}|dur}|d|||fS)aBAdjust the given list of event times to span the range ``[t_min, t_max]``. Any event times outside of the specified range will be removed. If the times do not span ``[t_min, t_max]``, additional events will be added with the prefix ``label_prefix``. Parameters ---------- events : np.ndarray Array of event times (seconds) labels : list or None List of labels (Default value = None) t_min : float or None Minimum valid event time. (Default value = 0.0) t_max : float or None Maximum valid event time. (Default value = None) label_prefix : str Prefix string to use for synthetic labels (Default value = '__') Returns ------- new_times : np.ndarray Event times corrected to the given range. Nrraz%sT_MINr6z%sT_MAX)r%rdr concatenaterhrj)eventsrrkrl label_prefixrorprrr adjust_eventsgs*     rucsdddfdd|D}ttg}|D]}||vr/|d|||d|q|S)a'Return the intersection of two sets of filepaths, based on the file name (after the final '/') and ignoring the file extension. Examples -------- >>> flist1 = ['/a/b/abc.lab', '/c/d/123.lab', '/e/f/xyz.lab'] >>> flist2 = ['/g/h/xyz.npy', '/i/j/123.txt', '/k/l/456.lab'] >>> sublist1, sublist2 = mir_eval.util.intersect_files(flist1, flist2) >>> print sublist1 ['/e/f/xyz.lab', '/c/d/123.lab'] >>> print sublist2 ['/g/h/xyz.npy', '/i/j/123.txt'] Parameters ---------- flist1 : list first list of filepaths flist2 : list second list of filepaths Returns ------- sublist1 : list subset of filepaths with matching stems from ``flist1`` sublist2 : list corresponding filepaths from ``flist2`` cSstjtj|ddS)zReturn the filename given an absolute path. Parameters ---------- abs_path Returns ------- filename r6r)ospathsplitextsplit)abs_pathrrr fnames zintersect_files..fnamecsi|]}||qSrr)rfr{rr sz#intersect_files..rr5)r\rj)flist1flist2fmappairsr|rr}r intersect_filess  rcCs|d|dk|d|dkg}d|vrtdttj||gdd}t|dd|d dgj}gg}}tt|} tt|} |D].\} } | | |dddfk} ||| d| | |dddfk}|||dqI|||fS) a3Merge the time intervals of two sequences. Parameters ---------- x_intervals : np.ndarray Array of interval times (seconds) x_labels : list or None List of labels y_intervals : np.ndarray Array of interval times (seconds) y_labels : list or None List of labels Returns ------- new_intervals : np.ndarray New interval times of the merged sequences. new_x_labels : list New labels for the sequence ``x`` new_y_labels : list New labels for the sequence ``y`` ra)r6r5FzMTime intervals do not align; did you mean to call 'adjust_intervals()' first?raxisNr6r5) r=r%rVrrrcTr(rrj) x_intervalsx_labels y_intervalsy_labels align_checktime_boundariesoutput_intervals x_labels_out y_labels_out x_label_range y_label_ranget0rGx_idxy_idxrrr merge_labeled_intervalss$    rcsRi|D]}||D] }|vr||<nq q igfdd|DD]}|=q(t}|r{s{i}|D]}||D]}|vrQ||g|qBq list of right vertices The input bipartite graph. Each edge need only be specified once. Returns ------- matching : dictionary : right-vertex -> left vertex A maximal bipartite matching. Tcsi|]}|qSrr)ru) unmatchedrr r~8sz$_bipartite_match..NcsX|vr*|}|=|D]}|vr)|}|=|us"|r)||<dSq dS)zRecursively search backward through layers to find alternating paths. recursion returns true if found path, false otherwise TFr)vLrpumatchingpredpredsrecurserrr rVsz!_bipartite_match..recurse)r\ setdefaultrj)graphrrlayer new_layer unlayeredrrr _bipartite_matchsX       r cCs<t||}t||}ttj||}t|||S)aCompute the absolute outer distance modulo n. Using this distance, d(11, 0) = 1 (modulo 12) Parameters ---------- ref : np.ndarray, shape=(n,) Array of reference values. est : np.ndarray, shape=(m,) Array of estimated values. modulus : int The modulus. 12 by default for octave equivalence. Returns ------- outer_distance : np.ndarray, shape=(n, m) The outer circular distance modulo n. )r%modabssubtractouterri)refestmodulus ref_mod_n est_mod_nabs_diffrrr _outer_distance_mod_njs  rc Csr|durt||||k}nt|||}i}t|D]\}}||vr'g||<|||qtt|}|S)aCompute a maximum matching between reference and estimated event times, subject to a window constraint. Given two lists of event times ``ref`` and ``est``, we seek the largest set of correspondences ``(ref[i], est[j])`` such that ``distance(ref[i], est[j]) <= window``, and each ``ref[i]`` and ``est[j]`` is matched at most once. This is useful for computing precision/recall metrics in beat tracking, onset detection, and segmentation. Parameters ---------- ref : np.ndarray, shape=(n,) Array of reference values est : np.ndarray, shape=(m,) Array of estimated values window : float > 0 Size of the window. distance : function function that computes the outer distance of ref and est. By default uses ``|ref[i] - est[j]|`` Returns ------- matching : list of tuples A list of matched reference and event numbers. ``matching[i] == (i, j)`` where ``ref[i]`` matches ``est[j]``. N)r%where_fast_hit_windowsr?rjrrr ) rrwindowdistancehitsGref_iest_irrrr match_eventss rc Cst|}t|}t|}||}tj|||dd}tj|||dd}gg}}tt||D]\} \} } ||| | || g| | q3||fS)aFast calculation of windowed hits for time events. Given two lists of event times ``ref`` and ``est``, and a tolerance window, computes a list of pairings ``(i, j)`` where ``|ref[i] - est[j]| <= window``. This is equivalent to, but more efficient than the following: >>> hit_ref, hit_est = np.where(np.abs(np.subtract.outer(ref, est)) ... <= window) Parameters ---------- ref : np.ndarray, shape=(n,) Array of reference values est : np.ndarray, shape=(m,) Array of estimated values window : float >= 0 Size of the tolerance window Returns ------- hit_ref : np.ndarray hit_est : np.ndarray indices such that ``|hit_ref[i] - hit_est[i]| <= window`` r7r8r:)r%r;rIr>rr?extend) rrrref_idx ref_sortedleft_idx right_idxhit_refhit_estjrDrErrr rs    rcCsl|jdks |jddkrtd|j|dkrtd|dddf|dddfkr4tddS)zCheck that an (n, 2) interval ndarray is well-formed, and raises errors if not. Parameters ---------- intervals : np.ndarray, shape=(n, 2) Array of interval start/end locations. rOr5z6Intervals should be n-by-2 numpy ndarray, but shape={}rzNegative interval times foundNz0All interval durations must be strictly positive)ndimshaper=formatr<r,rrr validate_intervalss  $rL@cCsX||krtd|||jdkrtd|jt|dkr*tddS)a;Check that a 1-d event location ndarray is well-formed, and raises errors if not. Parameters ---------- events : np.ndarray, shape=(n,) Array of event times max_time : float If an event is found above this time, a ValueError will be raised. (Default value = 30000.) zAn event at time {} was found which is greater than the maximum allowable time of max_time = {} (did you supply event times in seconds?)r5z5Event times should be 1-d numpy ndarray, but shape={}rz%Events should be in increasing order.N)r<r=rr'rrr%diff)rsmax_timerrr validate_eventss   rcCsx|rt|}t||krtd||t||kr-td|||jdkr:td|jdS)aCheck that a 1-d frequency ndarray is well-formed, and raises errors if not. Parameters ---------- frequencies : np.ndarray, shape=(n,) Array of frequency values max_freq : float If a frequency is found above this pitch, a ValueError will be raised. (Default value = 5000.) min_freq : float If a frequency is found below this pitch, a ValueError will be raised. (Default value = 20.) allow_negatives : bool Whether or not to allow negative frequency values. zA frequency of {} was found which is greater than the maximum allowable value of max_freq = {} (did you supply frequency values in Hz?)zA frequency of {} was found which is less than the minimum allowable value of min_freq = {} (did you supply frequency values in Hz?)r5z5Frequencies should be 1-d numpy ndarray, but shape={}N) r%rr<r=rr'rfrr) frequenciesmax_freqmin_freqallow_negativesrrr validate_frequenciess$    rcCs4t|}t|jD] }|j|jkrdSq dS)zDetermine whether a function has \*\*kwargs. Parameters ---------- function : callable The function to test Returns ------- True if function accepts arbitrary keyword arguments. False otherwise. TF)inspect signaturer\ parametersvalueskind VAR_KEYWORD)functionsigparamrrr has_kwargsFs  rcOsdt|r ||i|S|j}|jd|j}i}t|D] \}}||vr*|||<q||i|S)a(Given a function and args and keyword args to pass to it, call the function but using only the keyword arguments which it accepts. This is equivalent to redefining the function with an additional \*\*kwargs to accept slop keyword args. If the target function already accepts \*\*kwargs parameters, no filtering is performed. Parameters ---------- _function : callable Function to call. Can take in any number of args or kwargs *args **kwargs Arguments and keyword arguments to _function. N)r__code__ co_varnames co_argcountr\r ) _functionargskwargs func_code function_argsfiltered_kwargskwargvaluerrr filter_kwargs\srcCs t|ttj|ddS)aConvert an array of n intervals to their n durations. Parameters ---------- intervals : np.ndarray, shape=(n, 2) An array of time intervals, as returned by :func:`mir_eval.io.load_intervals()`. The ``i`` th interval spans time ``intervals[i, 0]`` to ``intervals[i, 1]``. Returns ------- durations : np.ndarray, shape=(n,) Array of the duration of each interval. r6r)rr%rrflattenrrrr intervals_to_durations|srcCsdt|tddS)aConvert Hz to MIDI numbers Parameters ---------- freqs : number or ndarray Frequency/frequencies in Hz Returns ------- midi : number or ndarray MIDI note numbers corresponding to input frequencies. Note that these may be fractional. (@{@@Q@)r%log2)freqsrrr hz_to_midisrcCsdd|ddS)zConvert MIDI numbers to Hz Parameters ---------- midi : number or ndarray MIDI notes Returns ------- freqs : number or ndarray Frequency/frequencies in Hz corresponding to `midi` rg@rrr)midirrr midi_to_hzs rcsfdd}t|S)zeMark a function as deprecated. Using the decorated (old) function will result in a warning. c s:tj|jd|jdddtdd||i|S)z Warn the user, and then proceed..z$ Deprecated as of mir_eval version z*. It will be removed in mir_eval version )category stacklevel)warningswarn __module____name__ FutureWarning)funcrrversionversion_removedrr __wrapperszdeprecated..__wrapperr)rrrrrr deprecateds r)F)r)rr"N)N)rM)rT)NrNNr_r`)NrNNr)r)r) __doc__rvrrrnumpyr%rr!r4r+rLrSrZr^rqrurrrrrrrrrrrrrrrrrrr sH   '  , 5   bD6/ Z 2,  ,