U f{jk@s0ddlmZddlmZmZmZddlmZddlZddl m Z ddl m Z ddl Z ddlmZddlmZddlZddlmZddlZd d lmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)d d l*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1d d l2m3Z3d d l4m5Z5d dl6m7Z7d dl8m9Z9eZ:ddZ;ddZGdddZ?ddZ@ddZAdJddZBdKd d!ZCdLd#d$ZDd%d&ZEd'd(ZFd)d*ZGdMd,d-ZHd.d/ZIdNd0d1ZJd2d3ZKd4d5ZLd6d7ZMd8d9ZNd:d;ZOdd?ZQd@dAZRedOdDdEZSedPdFdGZTdHdIZUdS)Q) OrderedDict)datetime timedeltatimezoneNdeepcopy) takewhile)Counter)Iterable)shorten)_pl check_fname_validate_typeverbosewarnlogger_check_pandas_installed_mask_to_onsets_offsets_DefaultEventParser _check_dt _stamp_to_dt _dt_to_stamp _check_fnameint_like _check_optionfill_doc _on_missing _is_numeric_check_dict_keys) start_block end_block write_floatwrite_name_list write_double start_file write_string)FIFF) fiff_open) dir_tree_find)read_tagc Csttj|td}|jdkr2td|j|jftj|td}|jdksT|jdkrdt|t|}|jdkr~td|jftj|t d}|jdks|jdkrt|t|}|jdkrtd|jft |dd t |dt t tjfd |dkrd gt|}t |}t|D]d\}}t |t t tjfd |d t |||<t||D]$\}}t |t d |d|d qPqt|}t|t|krt|krt|ksntdt|dt|dt|dt|d ||||fS)Ndtyper z9Onset must be a one dimensional array, got %s (shape %s).r)r z1Duration must be a one dimensional array, got %d.z4Description must be a one dimensional array, got %d.check descriptionch_namesz ch_names[]z][zGOnset, duration, description, and ch_names must be equal in sizes, got , z, and .)np atleast_1darrayfloatndim ValueErrorshaperepeatlenstr_prep_name_listrtuplelistZndarray enumerate_ndarray_ch_names)onsetdurationr.r/Zaichcinamer0r0N/var/www/html/bwave/python/venv/lib/python3.8/site-packages/mne/annotations.py_check_o_d_s_c%sF       "6,rIcCs"tjt|td}||dd<|S)Nr+)r4emptyr<object)r/outr0r0rHrBNs rBc@seZdZdZd.ddZeddZddZd d Zd d Z d dZ ddZ ddZ ddZ ed/ddZddZddZddZddZdd Zed!dd"d#d$Zd%d&Zed0d(d)Zed1d*d+Zed2d,d-ZdS)3 AnnotationsaAnnotation object for annotating segments of raw data. .. note:: To convert events to `~mne.Annotations`, use `~mne.annotations_from_events`. To convert existing `~mne.Annotations` to events, use `~mne.events_from_annotations`. Parameters ---------- onset : array of float, shape (n_annotations,) The starting time of annotations in seconds after ``orig_time``. duration : array of float, shape (n_annotations,) | float Durations of the annotations in seconds. If a float, all the annotations are given the same duration. description : array of str, shape (n_annotations,) | str Array of strings containing description for each annotation. If a string, all the annotations are given the same description. To reject epochs, use description starting with keyword 'bad'. See example above. orig_time : float | str | datetime | tuple of int | None A POSIX Timestamp, datetime or a tuple containing the timestamp as the first element and microseconds as the second element. Determines the starting time of annotation acquisition. If None (default), starting time is determined from beginning of raw data acquisition. In general, ``raw.info['meas_date']`` (or None) can be used for syncing the annotations with raw data if their acquisition is started at the same time. If it is a string, it should conform to the ISO8601 format. More precisely to this '%%Y-%%m-%%d %%H:%%M:%%S.%%f' particular case of the ISO8601 format where the delimiter between date and time is ' '. %(ch_names_annot)s .. versionadded:: 0.23 See Also -------- mne.annotations_from_events mne.events_from_annotations Notes ----- Annotations are added to instance of :class:`mne.io.Raw` as the attribute :attr:`raw.annotations `. To reject bad epochs using annotations, use annotation description starting with 'bad' keyword. The epochs with overlapping bad segments are then rejected automatically by default. To remove epochs with blinks you can do: >>> eog_events = mne.preprocessing.find_eog_events(raw) # doctest: +SKIP >>> n_blinks = len(eog_events) # doctest: +SKIP >>> onset = eog_events[:, 0] / raw.info['sfreq'] - 0.25 # doctest: +SKIP >>> duration = np.repeat(0.5, n_blinks) # doctest: +SKIP >>> description = ['bad blink'] * n_blinks # doctest: +SKIP >>> annotations = mne.Annotations(onset, duration, description) # doctest: +SKIP >>> raw.set_annotations(annotations) # doctest: +SKIP >>> epochs = mne.Epochs(raw, events, event_id, tmin, tmax) # doctest: +SKIP **ch_names** Specifying channel names allows the creation of channel-specific annotations. Once the annotations are assigned to a raw instance with :meth:`mne.io.Raw.set_annotations`, if channels are renamed by the raw instance, the annotation channels also get renamed. If channels are dropped from the raw instance, any channel-specific annotation that has no channels left in the raw instance will also be removed. **orig_time** If ``orig_time`` is None, the annotations are synced to the start of the data (0 seconds). Otherwise the annotations are synced to sample 0 and ``raw.first_samp`` is taken into account the same way as with events. When setting annotations, the following alignments between ``raw.info['meas_date']`` and ``annotation.orig_time`` take place: :: ----------- meas_date=XX, orig_time=YY ----------------------------- | +------------------+ |______________| RAW | | | | | +------------------+ meas_date first_samp . . | +------+ . |_________| ANOT | . | | | . | +------+ . orig_time onset[0] . | +------+ |___________________| | | | | | +------+ orig_time onset[0]' ----------- meas_date=XX, orig_time=None --------------------------- | +------------------+ |______________| RAW | | | | | +------------------+ . N +------+ . o_________| ANOT | . n | | . e +------+ . | +------+ |________________________| | | | | | +------+ orig_time onset[0]' ----------- meas_date=None, orig_time=YY --------------------------- N +------------------+ o______________| RAW | n | | e +------------------+ | +------+ |_________| ANOT | | | | | +------+ [[[ CRASH ]]] ----------- meas_date=None, orig_time=None ------------------------- N +------------------+ o______________| RAW | n | | e +------------------+ . N +------+ . o_________| ANOT | . n | | . e +------+ . N +------+ o________________________| | n | | e +------+ orig_time onset[0]' .. warning:: This means that when ``raw.info['meas_date'] is None``, doing ``raw.set_annotations(raw.annotations)`` will not alter ``raw`` if and only if ``raw.first_samp == 0``. When it's non-zero, ``raw.set_annotations`` will assume that the "new" annotations refer to the original data (with ``first_samp==0``), and will be re-referenced to the new time offset! **Specific annotation** ``BAD_ACQ_SKIP`` annotation leads to specific reading/writing file behaviours. See :meth:`mne.io.read_raw_fif` and :meth:`Raw.save() ` notes for details. NcCs4t||_t||||\|_|_|_|_|dSN)_handle_meas_date _orig_timerIrCrDr.r/_sort)selfrCrDr. orig_timer/r0r0rH__init__s  zAnnotations.__init__cCs|jS)z!The time base of the Annotations.)rPrRr0r0rHrSszAnnotations.orig_timecCsZt|tsdSt|j|joXt|j|joXt|j|joXt|j|joX|j|jkS)z(Compare to another Annotations instance.F) isinstancerMr4Z array_equalrCrDr.r/rSrRotherr0r0rH__eq__s  zAnnotations.__eq__cCst|j}dddt|D}t|dkr6dnd|}|rJdnd}dt|jtt|j||f}d t |d d d d S)zShow the representation.r2cSsg|] }d|qS)z%s (%s)r0).0kr0r0rH sz(Annotations.__repr__..r: z, channel-specificzAnnotations | %s segment%s%s%s) r r.joinsorteditemsr< _any_ch_namesrCr r )rRcounterkindsZ ch_specificsr0r0rH__repr__s zAnnotations.__repr__cCs t|jS)zReturn the number of annotations. Returns ------- n_annot : int The number of annotations. )r<rDrUr0r0rH__len__szAnnotations.__len__cCs|}||7}|S)z*Add (concatencate) two Annotation objects.)copy)rRrXrLr0r0rH__add__#szAnnotations.__add__cCsLt|dkr|j|_|j|jkr4td|j|jf||j|j|j|jS)zsAdd (concatencate) two Annotation objects in-place. Both annotations must have the same orig_time rzLorig_time should be the same to add/concatenate 2 annotations (got %s != %s)) r<rSrPr9appendrCrDr.r/rWr0r0rH__iadd__)s  zAnnotations.__iadd__ccs$tt|jD]}||VqdS)zIterate over the annotations.N)ranger<rC __getitem__rRidxr0r0rH__iter__8szAnnotations.__iter__cCst|tr\d}|j||j||j||jf}|rN|d7}||j|f7}tt ||St|t rnt |n|}t |j||j||j||j|j|dSdS)zAPropagate indexing and slicing to the underlying numpy structure.rCrDr.rSr/rCrDr.rSr/N) rVrrCrDr.rSrgr/rzipr?r@rM)rRkeyZout_keysZout_valsr0r0rHrr=s"  zAnnotations.__getitem__cCsbt||||\}}}}t|j||_t|j||_t|j||_t|j||_||S)azAdd an annotated segment. Operates inplace. Parameters ---------- onset : float | array-like Annotation time onset from the beginning of the recording in seconds. duration : float | array-like Duration of the annotation in seconds. description : str | array-like Description for the annotation. To reject epochs, use description starting with keyword 'bad'. %(ch_names_annot)s .. versionadded:: 0.23 Returns ------- self : mne.Annotations The modified Annotations object. Notes ----- The array-like support for arguments allows this to be used similarly to not only ``list.append``, but also `list.extend `__. )rIr4rorCrDr.r/rQ)rRrCrDr.r/r0r0rHroOs zAnnotations.appendcCst|S)zReturn a copy of the Annotations. Returns ------- inst : instance of Annotations A copy of the object. rrUr0r0rHrmuszAnnotations.copycCsDt|j||_t|j||_t|j||_t|j||_dS)zRemove an annotation. Operates inplace. Parameters ---------- idx : int | array-like of int Index of the annotation to remove. Can be array-like to remove multiple indices. N)r4deleterCrDr.r/rsr0r0rHr{s zAnnotations.deletecsztdd}t|jdkr$tdjddfdd|jD}t||j|jd}|rl|j |j d | |}|S) aBExport annotations in tabular structure as a pandas DataFrame. Returns ------- result : pandas.DataFrame Returns a pandas DataFrame with onset, duration, and description columns. A column named ch_names is added if any annotations are channel-specific. TstrictNrtzinfocsg|]}t|dqS)seconds)rrZodtr0rHr\sz-Annotations.to_data_frame..)rCrDr.rw) rrOrSreplacerCdictrDr.rgupdater/ DataFrame)rRpdZ onsets_dtdfr0rrH to_data_frames    zAnnotations.to_data_framecCstdd|jDS)Ncss|]}t|VqdSrN)r<rZrEr0r0rH sz,Annotations._any_ch_names..)anyr/rUr0r0rHrgszAnnotations._any_ch_namesc Cst|d}|j}d}t}t|D]n\}}t|r$t} |D]0} | |krd|snt|d| d}q>| | q>t| ||<t||s$||q$t|r|||S)Nr/Fz zCropping complete (kept r+z6Omitted %s annotation(s) that were outside data range.zDLimited %s annotation(s) that were expanding outside the data range.)r<rSrOrrCminrDmaxr _datetimer9rdebugrAryr.r/r4isnanro total_secondsr6r7allAssertionErrorr=rBsumr)rRrrZ emit_warningZ use_orig_timeroffsetrzvalZ absolute_tminZ absolute_tmaxonsets durations descriptionsr/Z out_of_boundsZclip_left_elemZclip_right_elemrtrCrDr.rEZabsolute_onsetZabsolute_offsetZomittedZlimitedr0r0rHcrops             &    zAnnotations.cropcst|tttft|trZt||jddd|D]&fdd|jD}||j|<q0n2t|rxt |jj ||_nt dt |d|S)aVSet annotation duration(s). Operates inplace. Parameters ---------- mapping : dict | float A dictionary mapping the annotation description to a duration in seconds e.g. ``{'ShortStimulus' : 3, 'LongStimulus' : 12}``. Alternatively, if a number is provided, then all annotations durations are set to the single provided value. %(verbose)s Returns ------- self : mne.Annotations The modified Annotations object. Notes ----- .. versionadded:: 0.24.0 dataAnnotation description(s)Zvalid_key_sourceZkey_descriptioncsg|] }|kqSr0r0)rZdescZstimr0rHr\|sz-Annotations.set_durations..zbSetting durations requires the mapping of descriptions to times to be provided as a dict. Instead z was provided.)rintr7rrVrr.rDrr4Zonesr:r9type)rRmappingrZmap_idxr0rrH set_durations_s zAnnotations.set_durationscsXt|tt||jddd|D] \fdd|jD|_q$t|j|_|S)aRename annotation description(s). Operates inplace. Parameters ---------- mapping : dict A dictionary mapping the old description to a new description, e.g. {'1.0' : 'Control', '2.0' : 'Stimulus'}. %(verbose)s Returns ------- self : mne.Annotations The modified Annotations object. Notes ----- .. versionadded:: 0.24.0 rrrcsg|]}|qSr0rrZdnewoldr0rHr\sz&Annotations.rename..)rrrr.rfr4r6)rRrrr0rrHrenames  zAnnotations.rename)NN)N)NNFTN)N)N)__name__ __module__ __qualname____doc__rTpropertyrSrYrkrlrnrprurrrrormr{rrgrrrrQrrrr0r0r0rHrMXsB!      % %  l )rMc@sBeZdZdZeddZedddddZd d Zdd d Z dS)EpochAnnotationsMixinz&Mixin class for Annotations in Epochs.cCs|jSrN) _annotationsrUr0r0rHrsz!EpochAnnotationsMixin.annotationsraiseN)rcCsTt|tdfd|dkr d|_n0t|ddr4td|}||j|||_|S)a8Setter for Epoch annotations from Raw. This method does not handle offsetting the times based on first_samp or measurement dates, since that is expected to occur in Raw.set_annotations(). Parameters ---------- annotations : instance of mne.Annotations | None Annotations to set. %(on_missing_ch_names)s %(verbose)s Returns ------- self : instance of Epochs The epochs object with annotations. Notes ----- Annotation onsets and offsets are stored as time in seconds (not as sample numbers). If you have an ``-epo.fif`` file saved to disk created before 1.0, annotations can be added correctly only if no decimation or resampling was performed. We thus suggest to regenerate your :class:`mne.Epochs` from raw and re-save to disk with 1.0+ if you want to safely work with :class:`~mne.Annotations` in epochs. Since this method does not handle offsetting the times based on first_samp or measurement dates, the recommended way to add Annotations is:: raw.set_annotations(annotations) annotations = raw.annotations epochs.set_annotations(annotations) .. versionadded:: 1.0 NrZ_unsafe_annot_addFzAdding annotations to Epochs created (and saved to disk) before 1.0 will yield incorrect results if decimation or resampling was performed on the instance, we recommend regenerating the Epochs and re-saving them to disk)rrMrgetattrrrmrr)rRrrrZnew_annotationsr0r0rHset_annotationss* z%EpochAnnotationsMixin.set_annotationscCsjddtt|jD}|jdkr&|S|jdddf|j}t|t|jddgj\}}|j j }||j j }t t|t|jkt|t|jk}t t|t|jkt|t|jk}t t|t|jkt|t|jk} ||| } t t| D]D\} } |j | } || }| d|| d| df}|| |q |S) a<Get a list of annotations that occur during each epoch. Returns ------- epoch_annots : list A list of lists (with length equal to number of epochs) where each inner list contains any annotations that overlap the corresponding epoch. Annotations are stored as a :class:`tuple` of onset, duration, description (not as a :class:`~mne.Annotations` object), where the onset is now relative to time=0 of the epoch, rather than time=0 of the original continuous (raw) data. cSsg|]}gqSr0r0)rZ_r0r0rHr\szCEpochAnnotationsMixin.get_annotations_per_epoch..NrrrCrDr.)rqr<eventsrZ _raw_sfreqr4Z atleast_2dtimesTrrCrD logical_andryZnonzeroro)rRepoch_annot_listZ epoch_tzerosZ epoch_startsZ epoch_stopsZ annot_startsZ annot_stopsZannot_straddles_epoch_startZannot_straddles_epoch_endZannot_fully_within_epochZ all_casesZannot_ixZepo_ixZ this_annotZ this_tzeroannotr0r0rHget_annotations_per_epochsJ    z/EpochAnnotationsMixin.get_annotations_per_epochFc st}|jdkr$td|d|S|jdk r6|jn tt|jdf}|j|dt fdddDrx|sxt d | }ggg}}}|D]R}t |||fD]>\} fd d |D} d krtj | d d} | | qq||d<||d<||d<|_|S)aJAdd raw annotations into the Epochs metadata data frame. Adds three columns to the ``metadata`` consisting of a list in each row: - ``annot_onset``: the onset of each Annotation within the Epoch relative to the start time of the Epoch (in seconds). - ``annot_duration``: the duration of each Annotation within the Epoch in seconds. - ``annot_description``: the free-form text description of each Annotation. Parameters ---------- overwrite : bool Whether to overwrite existing columns in metadata or not. Default is False. Returns ------- self : instance of Epochs The modified instance (instance is also modified inplace). Notes ----- .. versionadded:: 1.0 Nz$There were no Annotations stored in z, so metadata was not modified.r)rc3s|]}|jkVqdSrN)columns)rZrG)metadatar0rHrUszDEpochAnnotationsMixin.add_annotations_to_metadata..) annot_onsetannot_durationannot_descriptionzeMetadata for Epochs already contains columns "annot_onset", "annot_duration", or "annot_description".csg|] }|qSr0r0)rZr)ixr0rHr\bszEEpochAnnotationsMixin.add_annotations_to_metadata.. )Zdecimalsrrr)rrr _metadatar4rJr<rrr RuntimeErrorrrAroundtolistroZSeriesr) rRrrrrrCrDr.Z epoch_annotZ annot_propentryr0)rrrHadd_annotations_to_metadata+s:    z1EpochAnnotationsMixin.add_annotations_to_metadata)r)F) rrrrrrrrrrr0r0r0rHrs 8Crc Cs|dk s t|dk st||}|||7}|||8}t|j|j|g}t|j|jg}t|j|jg} t|j|jg} t||| |j| S)zCombine a tuple of annotations.N) rr4 concatenaterCrDr.r/rMrS) onetwoZ one_n_samplesZone_first_sampZtwo_first_sampsfreqshiftrCrDr.r/r0r0rH_combine_annotationsus    rcCst|trHd}zt||}Wntk r6d}YqZX|jtjd}nt|trZt |}|dk rt |rt t |ddd}|ddg9}t t |}t||S)aXConvert meas_date to datetime or None. If `meas_date` is a string, it should conform to the ISO8601 format. More precisely to this '%Y-%m-%d %H:%M:%S.%f' particular case of the ISO8601 format where the delimiter between date and time is ' '. Note that ISO8601 allows for ' ' or 'T' as delimiters between date and time. z%Y-%m-%d %H:%M:%S.%fNr~rr g.A)rVr=rstrptimer9rrutcr?rr4Zisscalarr6modfrr) meas_dateZACCEPTED_ISO8601r0r0rHrOs     rOFcCs4|rdnd|j}|jd|jjks(t||}|S)z&Adjust onsets in relation to raw data.rr r)Z _first_timerrrSr)rawrCZinverserZ annot_startr0r0rH _sync_onsetsrskip_by_annotationcsxttttf|ttr$gnD]}t|ddq(t|jdkrdtgt tgt }}n\fddt |jj D}|jj |}t ||}||jj|}|j|dd}|j|dd}||kst|rptt|jt}t||D]\} } d|| | <q|}||k} || || } } t|\}}~ tt|| g}tt|| g}||kspt||fS)zOGet starts and stops from given kinds. onsets and ends are inclusive. r=z All entriesrcs*g|]"\}tfddDr|qS)c3s |]}|VqdSrN)upper startswith)rZkindrr0rHrsz7_annotations_starts_stops...)r)rZrtrirrHr\s  z-_annotations_starts_stops..T) use_rounding)rr=r@r?rVr<rr4r6rrAr.rCrrD time_as_indexrrzerosrboolryrsortr)rrirGinvertrrZendsZidxsmaskrCendextrasZ extra_onsetsZ extra_endsr0rrH_annotations_starts_stopss6    rr.cCs|dkr,tdd|Drtd|dnV|dkrHddd |DS|d ksTtt|tsbtt|sngSd d|dDSdS) Nr-cSsg|] }d|kqS){COLON}r0rZrr0r0rHr\sz#_prep_name_list..zThe substring "{COLON}" in z not supported.write:css|]}|ddVqdS)rrNrrr0r0rHrsz"_prep_name_list..readcSsg|]}|ddqS)rrrrr0r0rHr\s)rr9rdrrVr=r<split)lstZ operationrGr0r0rHr>s  r>cCst|tjt|tj|jt|tj|j|jt|tj t |j d d|j dk rlt|tjt|j |rt|tjtt|jt|tjdS)zWrite annotations.rrN)r r'FIFFB_MNE_ANNOTATIONSr"FIFF_MNE_BASELINE_MINrCFIFF_MNE_BASELINE_MAXrDr# FIFF_COMMENTr>r.rrSr$FIFF_MEAS_DATErrgr&FIFF_MNE_EPOCHS_DROP_LOGjsondumpsr?r/r!)rrr0r0rHrs(    rcCs8|}d|kr&dd|dD|d<|j|dddS)Nr/cSsg|]}t|dqSrr>rr0r0rHr\sz*_write_annotations_csv..F)index)rZto_csv)rrr0r0rHrs  rc Csd}|jdk r(|d|jjddd7}|d7}|j|j|jg}|rf|d7}|dd|jD|d7}tj |t d j }|j d kst |jd t|jkst |jd d kst t|d&}||tj||dddW5QRXdS)Nz# MNE-Annotations z# orig_time : r~ z# onset, duration, descriptionz , ch_namescSsg|]}t|dqSrrrr0r0rHr\sz*_write_annotations_txt..r+rrr wb,z%s) delimiterfmt)rSrrCrDr.rgror/r4r6r=rr8rr:r<openrencodeZsavetxt)rrcontentrrr0r0rHrs   rautoc Cs ddlm}ddlm}ddlm}ddlm}ddlm }ddl m }t |dd t |d d t|d d d }t|} | drt|dd\} } } | } t| | }W5QRXn>| drt|}t|\}}}}t|||||d}n| dr|||d}n| drt|}n| dr2||}n| drH||}n| drb|||d}n| dr||||d}nv| dr||\}}}tj|td}tj|td}t|||dd}n.| dr|d rt|}n td!||dkrtd"||S)#aRead annotations from a file. This function reads a .fif, .fif.gz, .vmrk, .amrk, .edf, .txt, .csv, .cnt, .cef, or .set file and makes an :class:`mne.Annotations` object. Parameters ---------- fname : str The filename. sfreq : float | 'auto' The sampling frequency in the file. This parameter is necessary for \*.vmrk, \*.amrk, and \*.cef files as Annotations are expressed in seconds and \*.vmrk/\*.amrk/\*.cef files are in samples. For any other file format, ``sfreq`` is omitted. If set to 'auto' then the ``sfreq`` is taken from the respective info file of the same name with according file extension (\*.vhdr/\*.ahdr for brainvision; \*.dap for Curry 7; \*.cdt.dpa for Curry 8). So data.vmrk/amrk looks for sfreq in data.vhdr/ahdr, data.cef looks in data.dap and data.cdt.cef looks in data.cdt.dpa. uint16_codec : str | None This parameter is only used in EEGLAB (\*.set) and omitted otherwise. If your \*.set file contains non-ascii characters, sometimes reading it may fail and give rise to error message stating that "buffer is too small". ``uint16_codec`` allows to specify what codec (for example: 'latin1' or 'utf-8') should be used when reading character arrays and can therefore help you solve this problem. Returns ------- annot : instance of Annotations | None The annotations. Notes ----- The annotations stored in a .csv require the onset columns to be timestamps. If you have onsets as floats (in seconds), you should use the .txt extension. r )_read_annotations_brainvision)_read_annotations_eeglab)_read_annotations_edf)_read_annotations_cnt)_read_annotations_curry)_read_annotations_ctfz path-likerrTz.ds)rZ must_existneed_dirrG)fifzfif.gzF)Zpreloadtxtrx)ZvmrkZamrk)rcsvZcntZdsZcefr) uint16_codec)ZedfZbdfZgdfr+NrvZevents_Zmatz#Unknown annotation file format "%s"z%No annotation data found in file "%s")io.brainvision.brainvisionr Zio.eeglab.eeglabr!Z io.edf.edfr"Z io.cnt.cntr#Zio.curry.curryr$Zio.ctf.markersr%rrr=ropbasenamer(_read_annotations_fif"_read_annotations_txt_parse_header_read_annotations_txtrM_read_annotations_csvr4r6r7r_read_brainstorm_annotationsIOError)rrr*r r!r"r#r$r%rGfftreerrrrSrCrDr.r/r0r0rHread_annotationssn'                          r6c Cstdd}|j|dd}|djd}zt|tdWntk rNYnX||d}||dj}|dj t}|d j}d }d |j krd d |d jD}t |||||S)zRead annotations from csv. Parameters ---------- fname : str The filename. Returns ------- annot : instance of Annotations The annotations. Tr|F)Zkeep_default_narCrzIt looks like you have provided annotation onsets as floats. These will be interpreted as MILLISECONDS. If that is not what you want, save your CSV as a TXT file; the TXT reader accepts onsets in seconds.rDr.Nr/cSsg|]}t|dqSrrrr0r0rHr\sz)_read_annotations_csv..) rZread_csvvaluesr7rr9 to_datetimerrastyperrM) rrrrSZonset_dtrCrDr.r/r0r0rHr1s$    r1c Csddlm}dd}||}ttt}}}|ddD]P\}} } } } } } || d||| t| d} |t|dg| 7}q@tt |t |||dS)aRead annotations from a Brainstorm events_ file. Parameters ---------- fname : str The filename orig_time : float | int | instance of datetime | array of int | None A POSIX Timestamp, datetime or an array containing the timestamp as the first element and microseconds as the second element. Determines the starting time of annotation acquisition. If None (default), starting time is determined from beginning of raw data acquisition. In general, ``raw.info['meas_date']`` (or None) can be used for syncing the annotations with raw data if their acquisition is started at the same time. Returns ------- annot : instance of Annotations | None The annotations. r)iocSs0|jddkr|d|dStt|dS)Nrrr )r:r4rr<)tr0r0rHget_duration_from_timessz=_read_brainstorm_annotations..get_duration_from_timesrrv) Zscipyr;Zloadmatr@ror<r=rMr4r) rrSr;r= annot_datarrrlabelrrZn_annotr0r0rHr2s    r2cCsd}t||dk S)Nz/^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}\.\d{6}$)recompilematch)Z candidate_strZISO8601r0r0rH _is_iso8601srCc s^ddt|}ttdd|}W5QRXfdd|D}dd|D}|sVdS|dS) NcSs |dS)Nz # orig_time :rxr0r0rH is_orig_timesz8_read_annotations_txt_parse_header..is_orig_timecSs |dS)N#rDrEr0r0rHz4_read_annotations_txt_parse_header..cs$g|]}|r|ddqS) N)strip)rZhrGr0rHr\sz6_read_annotations_txt_parse_header..cSsg|]}t|rt|qSr0)rCrO)rZorigr0r0rHr\sr)rr@r)rrheaderZ orig_valuesr0rNrHr/s  r/c Cstjdd$tdtj|dtjdd}W5QRXd}t|dkrXggg}}}n4tdt|dt|d kr|\}}}n |\}}}}d d t|D}d d t|D}d d t|D}|dk rdd |D}||||fS)NT)recordignorer)rr,unpackrz text headerrrcSsg|]}t|qSr0r7decoderr0r0rHr\sz)_read_annotations_txt..cSsg|]}t|qSr0rTrr0r0rHr\scSsg|]}t|qSr0)r=rUrLrr0r0rHr\scSsg|]}t|dqSr7)r>rUrLrr0r0rHr\s) warningscatch_warnings simplefilterr4Zloadtxtbytes_r<rr5)rrLr/rCrDrr0r0rHr0s*     r0c Cspt|tj}t|dkr d}nL|d}d}}ttt}}}|dD]} | j} | j} t|| } | tjkr| j }|dkrtn|}qN| tj kr| j }|dkrtn||}qN| tj krt | j d}qN| tj kr | j }z t|}Wntk rt|}YnXqN| tjkrNtddt| j D}qNt|t|krVt|ks\ntt|||||}|S)zRead annotations.rN directoryrcss|]}t|VqdSrN)r?)rZrFr0r0rHrsz(_read_annotations_fif..)r)r'r r<r@rposr*r rr r r>r r7 TypeErrorr?rrloadsrrM) rr5r>rrSr/rCrDr.Zentrr[tagr0r0rHr.s@          *r.cst|dkrdn|}tg}t|D]f}|kr6q(||dkrFq(t|trj||kr(|||<qq(q(||}|dk r||<q(||q(fddt|D}t|dkr|dk rt d|fS)z?Get a collection of descriptions and returns index of selected.Nz.*csg|]\}}|kr|qSr0r0)rZiikkZ event_id_r0rHr\3sz<_select_annotations_based_on_description..r/Could not find any of the events you specified.) r@rArrerBrVrorAr<r9)revent_idregexpZ regexp_compZdroppedrtrigger event_selr0rarH(_select_annotations_based_on_descriptions(    rgcstt|tr|jn|}|tj|dddfddddf}|D]}||}|dk rD||<qDfddt|D}t|dkrtd |fS) z9Get a collection of events and returns index of selected.NrT)Z return_indexr cs g|]\}}|dkr|qSrr0)rZr_eZ event_desc_r0rHr\Fs z._select_events_based_on_id..rrb)rrVgetr4uniquerAr<r9)r event_descfuncZ event_idsrirerfr0rjrH_select_events_based_on_id<s&  rocCsddlm}ddlm}ddlm}ddlm}m}|dkrBtS|dkrt||rZ|St|||fr||j j rt d|StSn(t |st|tr|Stdt|dS) Nr )_BVEventParser)_check_bv_annot)RawBrainVision)RawFIFRawArrayrz/Non-RawBrainVision raw using branvision markerszIInvalid type for event_id (should be None, str, dict or callable). Got {})r+rprqrrr;rsrtrrVrr.rrcallablerr9formatr)rcrrprqrrrsrtr0r0rH_check_event_idNs(      rwcCs|dkr"tt|dddf}t|trL|D]}t|tdfdq4n`t|trt |}|j dkrzt d |j tt|tt|}nt|rnt d t||S)z-Check event_id and convert to default format.Nrz Event namesr z#event_desc must be 1D, got shape {}zUInvalid type for event_desc (should be None, list, 1darray, dict or callable). Got {})r@r4rlrVrr8rr=r Zasarrayr8r9rvr:rymaprur)rmrrr0r0rH_check_event_descriptionfs$     ry%^(?![Bb][Aa][Dd]|[Ee][Dd][Gg][Ee]).*$Tcst|jdkr4t|tstn|}tjdtd|fS|j}t||}t|j ||d\}|dkr|j |j ||j d}|j dk r||j 7}fdd|j |D} ||}ntgt}} ||D]} | d | d } tj| d | |d } | | |k} | r| | } |j | ||j d}||j 7}t||}tjt|| d td }t| |} qtj|tt|| ft}tdtf|fS)a' Get :term:`events` and ``event_id`` from an Annotations object. Parameters ---------- raw : instance of Raw The raw data for which Annotations are defined. event_id : dict | callable | None | 'auto' Can be: - **dict**: map descriptions (keys) to integer event codes (values). Only the descriptions present will be mapped, others will be ignored. - **callable**: must take a string input and return an integer event code, or return ``None`` to ignore the event. - **None**: Map descriptions to unique integer values based on their ``sorted`` order. - **'auto' (default)**: prefer a raw-format-specific parser: - Brainvision: map stimulus events to their integer part; response events to integer part + 1000; optic events to integer part + 2000; 'SyncStatus/Sync On' to 99998; 'New Segment/' to 99999; all others like ``None`` with an offset of 10000. - Other raw formats: Behaves like None. .. versionadded:: 0.18 regexp : str | None Regular expression used to filter the annotations whose descriptions is a match. The default ignores descriptions beginning ``'bad'`` or ``'edge'`` (case-insensitive). .. versionchanged:: 0.18 Default ignores bad and edge descriptions. use_rounding : bool If True, use rounding (instead of truncation) when converting times to indices. This can help avoid non-unique indices. chunk_duration : float | None Chunk duration in seconds. If ``chunk_duration`` is set to None (default), generated events correspond to the annotation onsets. If not, :func:`mne.events_from_annotations` returns as many events as they fit within the annotation duration spaced according to ``chunk_duration``. As a consequence annotations with duration shorter than ``chunk_duration`` will not contribute events. %(verbose)s Returns ------- %(events)s event_id : dict The event_id variable that can be passed to :class:`~mne.Epochs`. See Also -------- mne.annotations_from_events Notes ----- For data formats that store integer events as strings (e.g., NeuroScan ``.cnt`` files), passing the Python built-in function :class:`int` as the ``event_id`` parameter will do what most users probably want in those circumstances: return an ``event_id`` dictionary that maps event ``'1'`` to integer event code ``1``, ``'2'`` to ``2``, etc. r)rrr+)rcrdN)rorigincsg|] }|qSr0r0)rZr`rar0rHr\sz+events_from_annotations..rCrD)startstopstepr.)r:Z fill_valuer,z!Used Annotations descriptions: %s)r<rrVrr4rJrrwrgr.rrCrS first_sampr6r:ZarangerrofullZc_rrrr@keys)rrcrdrZchunk_durationrrrfZindsr8rZ annot_offsetZ_onsetsZ good_eventsZ_indsZ_valuesrr0rarHevents_from_annotations~sVB               rc slt||}t||\}||}|dddf||}fdd|D} tt|} t|| | |d} | S)uwConvert an event array to an Annotations object. Parameters ---------- events : ndarray, shape (n_events, 3) The events. sfreq : float Sampling frequency. event_desc : dict | array-like | callable | None Events description. Can be: - **dict**: map integer event codes (keys) to descriptions (values). Only the descriptions present will be mapped, others will be ignored. - **array-like**: list, or 1d array of integers event codes to include. Only the event codes present will be mapped, others will be ignored. Event codes will be passed as string descriptions. - **callable**: must take a integer event code as input and return a string description or None to ignore it. - **None**: Use integer event codes as descriptions. first_samp : int The first data sample (default=0). See :attr:`mne.io.Raw.first_samp` docstring. orig_time : float | str | datetime | tuple of int | None Determines the starting time of annotation acquisition. If None (default), starting time is determined from beginning of raw data acquisition. For details, see :meth:`mne.Annotations` docstring. %(verbose)s Returns ------- annot : instance of Annotations The annotations. See Also -------- mne.events_from_annotations Notes ----- Annotations returned by this function will all have zero (null) duration. Creating events from annotations via the function `mne.events_from_annotations` takes in event mappings with key→value pairs as description→ID, whereas `mne.annotations_from_events` takes in event mappings with key→value pairs as ID→description. If you need to use these together, you can invert the mapping by doing:: event_desc = {v: k for k, v in event_id.items()} Nrcsg|]}|dqSrhr0)rZrirjr0rHr\%sz+annotations_from_events..rv)ryror4rr<rM) rrrmrrSrrfZ events_selrrrZannotsr0rjrHannotations_from_eventss4 rcCs"|jddk r|j|j7_dS)z4Adjust the annotation onsets based on raw meas_date.rN)rrCZ first_time)rrr0r0rH_adjust_onset_meas_date1sr)F)rF)r.)rN)N)rrzTNN)NrNN)V collectionsrrrros.pathpathr,r@rmr itertoolsrrr collections.abcr rVtextwrapr numpyr4utilsr rrrrrrrrrrrrrrrrrrZio.writer r!r"r#r$r%r&Z io.constantsr'Zio.openr(Zio.treer)Zio.tagr*rrIrBrKrMrrrOrrr>rrrr6r1r2rCr/r0r.rgrorwryrrrr0r0r0rHs|       T$    ) SN#  .  d# (#$ n C