コード例 #1
0
ファイル: single_data.py プロジェクト: hankes-garden/emg_key
def preprocess(dfData, lsColumns2Inspect, nRawStart, nRawEnd,
               dSamplingFreq, dSMDuration, dRectDuration):
    # raw
    lsData_raw = []
    for col in lsColumns2Inspect:
        arrData = dfData[col].iloc[nRawStart: nRawEnd]
        lsData_raw.append(arrData)
        
    # fft 
    nSamples_fft = len(lsData_raw[0])
    dRes_fft = dSamplingFreq*1.0/nSamples_fft
    lsData_fft = []
    for arrData in lsData_raw:
        arrFFT = fftpack.fft(arrData)
        arrPSD = np.sqrt(abs(arrFFT)**2.0/(nSamples_fft*1.0))
        lsData_fft.append(arrPSD)
        
    # filtered
    nLowCut = 5
    dPowerInterference = 50.0
    nFilterOrder = 9
    nFilterShift = int(0.7 *dSamplingFreq)
    lsData_filtered = []
    for arrData in lsData_raw:
        # remove power line inteference
        arrNoise = sf.notch_filter(arrData, dPowerInterference-1., 
                                   dPowerInterference+1., 
                                   dSamplingFreq, order=nFilterOrder)
                                   
        arrFiltered = arrData - arrNoise 
        
        # remove movement artifact
        arrFiltered = sf.butter_highpass_filter(arrFiltered, cutoff=nLowCut, 
                                                fs=dSamplingFreq, 
                                                order=nFilterOrder)
        lsData_filtered.append(arrFiltered[nFilterShift:])
        
        
#    # ---- fft on filtered ----
#    nSamples_fft_filtered = len(lsData_filtered[0])
#    dRes_fft_filtered = dSamplingFreq*1.0/nSamples_fft_filtered
#    lsData_fft_filtered = []
#    for arrFiltered in lsData_filtered:
#        arrFFT = fftpack.fft(arrFiltered)
#        arrPSD = np.sqrt(abs(arrFFT)**2.0/(nSamples_fft_filtered*1.0))
#        lsData_fft_filtered.append(arrPSD)
        
    # rectified data
    nSmoothingWnd = int(dSMDuration* dSamplingFreq)
    lsData_rectified = []
    for arrData in lsData_filtered:
        arrRect = rectifyEMG(arrData, dSamplingFreq, 
                             dWndDuration=dRectDuration,
                             method=RECTIFY_RMS)
        arrRect_sm = pd.rolling_mean(arrRect, window=nSmoothingWnd,
                                     min_periods=1)
                                     
        lsData_rectified.append(arrRect_sm)
        
    return lsData_raw, lsData_fft, lsData_filtered, lsData_rectified
コード例 #2
0
def onDraw(frameNum, dataQueue, nChannels,
           dSamplingFreq, 
           lsAx_raw,
           lsAx_filtered,
           lsAx_fft_filtered,
           lsAx_rect,
           bt, dataLock, writtingEvent):

    # get a copy of data
    lsData_raw = []
    dataLock.acquire()
    for i in range(nChannels):
        arrData = np.array([d[i+1] for d in dataQueue], dtype=np.float64)
        lsData_raw.append(arrData)
    dataLock.release()
    
    # update time-domain plot
    for i, ax in enumerate(lsAx_raw):
        arrData = lsData_raw[i]
        ax.set_data(range(len(arrData) ), arrData)

    
    nSamples = len(lsData_raw[0])
    if (nSamples >= dSamplingFreq):

        # filter data
        dPowerInterference = 50.0
        nFilterOrder = 9
        for i, ax in enumerate(lsAx_filtered):
            arrData = lsData_raw[i]
            # remove power line inteference
            arrNoise = sf.notch_filter(arrData, dPowerInterference-2., 
                                       dPowerInterference+2., 
                                       dSamplingFreq, order=nFilterOrder)
                                       
            arrData_filtered = arrData - arrNoise
            
            # remove movement artifact
            arrData_filtered = sf.butter_highpass_filter(arrData_filtered, 
                                                     cutoff=FILTER_LOW_CUT, 
                                                         fs=dSamplingFreq, 
                                                         order=nFilterOrder)
    
            ax.set_data(range(len(arrData_filtered) ), arrData_filtered)        
        
        # fft on filtered data
        dResolution = dSamplingFreq*1.0/nSamples
        nDCEnd = 5
        arrFreqIndex = np.linspace(nDCEnd*dResolution,
                                   dSamplingFreq/2.0, 
                                   nSamples/2-nDCEnd)
        for i, ax in enumerate(lsAx_fft_filtered):
           arrData = lsData_raw[i]
           # remove power line inteference
           arrNoise = sf.notch_filter(arrData, dPowerInterference-2., 
                                       dPowerInterference+2., 
                                       dSamplingFreq, order=nFilterOrder)
                                       
           arrData_filtered = arrData - arrNoise
            
           # remove movement artifact
           arrData_filtered = sf.butter_highpass_filter(arrData_filtered, 
                                                     cutoff=FILTER_LOW_CUT, 
                                                         fs=dSamplingFreq, 
                                                         order=nFilterOrder)
                                                         
           arrFFT = fftpack.fft(arrData_filtered)
           arrPSD = np.sqrt(abs(arrFFT)**2.0 / (nSamples*1.0))
           ax.set_data(arrFreqIndex, arrPSD[nDCEnd:nSamples/2])
            
        # rectified data
        for i, ax in enumerate(lsAx_rect):
            arrData = lsData_raw[i]
            # remove power line inteference
            arrNoise = sf.notch_filter(arrData, dPowerInterference-2., 
                                       dPowerInterference+2., 
                                       dSamplingFreq, order=nFilterOrder)
                                       
            arrData_filtered = arrData - arrNoise
            
            # remove movement artifact
            arrData_filtered = sf.butter_highpass_filter(arrData_filtered, 
                                                         cutoff=FILTER_LOW_CUT, 
                                                         fs=dSamplingFreq, 
                                                         order=nFilterOrder)
            # rectify filtered data
            arrRect = sd.rectifyEMG(arrData_filtered, dSamplingFreq*0.3,
                                    method=sd.RECTIFY_RMS)
            ax.set_data(range(len(arrRect) ), arrRect)
        
    
    strLabel = "stop" if (writtingEvent.is_set()) else "record"
    bt.label.set_text(strLabel)