예제 #1
0
        config = {
            'source':
            'HDF5',
            'path':
            r'\\193.136.222.220\cybh\data\CVP\hdf5',
            'experiments':
            ['T1-Sitting', 'T2-Sitting', 'T1-Recumbent', 'T2-Recumbent'],
            'mapper': {
                'raw': 'signals/ECG/hand/raw',
                'filtered': 'signals/ECG/hand/filtered/fir5to20',
                'segments': 'signals/ECG/hand/segments/engzee',
                'R': 'events/ECG/hand/R',
                'outlier': 'events/ECG/hand/outlier/dbscan'
            }
        }
        st = datamanager.Store(config)

        outlier_parameters = {
            'method': 'dbscan',
            'min_samples': 10,
            'eps': 0.95,
            'metric': 'euclidean'
        }
        outlier_results = {'info': outlier_parameters}
        for i in xrange(252):
            fd = gzip.open('falc_temp/outlier/dbscan/output-%d' % i, 'rb')
            outlier_results[i] = cPickle.load(fd)
            fd.close()
        outlier_method = 'DBSCAN'

        mdata = st.dbmetada()
예제 #2
0
def saveWaves(config, inputs):
    # save the wavelet coefficients

    # mother wavelets
    waves = [
        pywt.Wavelet('coif5'),
        pywt.Wavelet('rbio3.3'),
        pywt.Wavelet('rbio3.5'),
        pywt.Wavelet('rbio3.9'),
        pywt.Wavelet('rbio5.5'),
        pywt.Wavelet('db3'),
        pywt.Wavelet('db8')
    ]

    # decomposition level
    level = 10

    # update the config
    for wave in waves:
        waveName = wave.name
        for var in inputs:
            name = var + '+' + waveName
            ty = config['mapper'][var].split('/')
            ty[-1] = 'Wavelets'
            ty.append(waveName.replace('.', '-'))
            ty = '/'.join(ty)
            config['mapper'][name] = ty

    # cycle the subjects
    for subject in dm.Store(config):
        print subject

        # cycle the records
        for record in subject:
            print record

            # cycle the inputs
            for var in inputs:
                ty = config['mapper'][var]
                print var
                try:
                    data = record[var]
                except KeyError:
                    print "Skipped", var
                    continue

                # cycle the datasets
                for item in data:
                    print item.metadata['name']
                    weg = ty + '/' + item.metadata['name']

                    # cycle the wavelets
                    for wave in waves:
                        waveName = wave.name
                        print waveName

                        # compute the RDWT
                        coeffs = wavelets.RDWT(item.signal, wave, level)[0]

                        # save
                        name = var + '+' + waveName
                        print name
                        metadata = {
                            'units': item.metadata['units'],
                            'sampleRate': item.metadata['sampleRate'],
                            'wavelet': {
                                'name': waveName,
                                'level': level
                            },
                            'source': weg,
                            'labels': [waveName]
                        }
                        record[name] = dataContainer('signals',
                                                     signal=coeffs,
                                                     mdata=metadata)

    return config
예제 #3
0
def segWaves(config, inputs):
    # extract the wavelet segments

    # update the config
    for var in inputs:
        # to save the R positions
        name = var + '+R'
        ty = config['mapper'][var].replace('signals', 'events') + '/R'
        config['mapper'][name] = ty
        # to save the segments
        name = var + '+Segs'
        ty = config['mapper'][var] + '/Segments'
        config['mapper'][name] = ty

    # cycle the subjects
    for subject in dm.Store(config):
        print subject

        # cycle the records
        for record in subject:
            print record

            # cycle the inputs
            for var in inputs:
                print var

                try:
                    data = record[var]
                except KeyError:
                    print "Skipped", var
                    continue

                ty = config['mapper'][var]

                # cycle the datasets
                for item in data:
                    print item.metadata['name']

                    # convert wavelet coefficients to matrix
                    matrix = wavelets.coeffs2Matrix(item.signal)

                    # extract segments
                    R = wavelets.RPeaks(item.signal,
                                        item.metadata['sampleRate'])
                    segs = wavelets.extractSegments(
                        matrix, R, item.metadata['sampleRate'])

                    # store
                    weg = ty + '/' + item.metadata['name']

                    # store R locations
                    name = var + '+R'
                    print name

                    metadata = {
                        'source': weg,
                        'eventSync': 0,
                        'dictionary': {}
                    }
                    record[name] = dataContainer('events',
                                                 timeStamps=R,
                                                 values=[])

                    # store segments
                    name = var + '+Segs'
                    print name

                    metadata = {
                        'units': item.metadata['units'],
                        'sampleRate': item.metadata['sampleRate'],
                        'source': weg,
                        'labels': ['Segments']
                    }
                    record[name] = dataContainer('signals',
                                                 signal=segs,
                                                 mdata=metadata)

    return config
예제 #4
0
    FILTER = False
    SEGMENT = False
    OUTLIER = False
    PREPARE = False
    COMPUTE_DISTANCES = False

    RESULTS = True

    #    if RESULTS: LOAD, FILTER, SEGMENT, OUTLIER, PREPARE, COMPUTE_DISTANCES = False, False, False, False, False, False

    SAVE2DB = False

    # ----------------------------------------------------------------------------------------------------------
    # ECG BASED BIOMETRICS SCRIPT 1 - PREPARE DATA
    # Database
    st = datamanager.Store(mainConfig['database'])

    if LOAD:
        # Get Raw Files
        print "loading raw ...",
        res = st.db2data('raw')
        sampling_rate = float(res[0][0]['mdata']['sampleRate'])
        raw_data = {}
        for rid in res:
            raw_data[rid] = res[rid][0]['signal']
        print "done."

    if FILTER:
        # Filter
        filter_parameters = mainConfig['filter']
        ################ onde vou buscar a sampleRate???????????