def searchactive(datarray): samp_rate = source_var.sampling_rate() window_size = 2 * samp_rate finalarray=[] flag = False tempArray=[] tempcalcArray=[] ind=0 while flag == False: if (ind + window_size) <= len(datarray): endIndex = ind + window_size tempArray = datarray[ind:endIndex] tempcalcArray = activeFeat(tempArray) else: tempArray = datarray[ind : len(datarray)] tempcalcArray = activeFeat(tempArray) flag = True ind = ind + window_size for x in range(len(tempcalcArray)): finalarray.append(tempcalcArray[x]) tempArray = [] tempcalcArray=[] return finalarray
def main(): list_name = read_subject_name(source_var.source_var()) #cutting_index_list = read_cutting_index(source_var.source_index()) #print cutting_index_list for i in range(len(list_name)): name = list_name[i] #indexes = cutting_index_list[i] print "Processing data from :" print name source_raw_data = source_var.source_path_data(name) source_file_micro = source_var.source_path_scaled(name) freq_rate = source_var.sampling_rate() micro_path = source_var.source_path_micro(name) features_path = source_var.source_path_features(name) source_weka = source_var.source_path_wekafile(name) source_runtime = source_var.source_runtime(name) active_source = source_var.source_path_active(name) #scale_file.scale_file(source_raw_data, source_file_micro, indexes[0], indexes[1]) microannotate_right.micro_annotate( source_file_micro, micro_path) #re-annotate using micro-annotation activefeat.active_feat(name) non_cascade.run_feat_calc( name, freq_rate, active_source, features_path ) # damn you function! yes this is the cascade function for j in range(4): result = tt.train_test(j) write_result(result, j)
def threshold_function(array, dest, runtime_path): samp_rate = source_var.sampling_rate() pre_impact_win = samp_rate - 1 post_impact_win = samp_rate * 11 destFile = dest featureRes = [] runtime = [] outF = open(destFile, "w") csvWriter = csv.writer(outF, delimiter="\t") print("Calculate Features") # print(samp_rate) # print(len(array)) # i is the active state point in the window for i in range(pre_impact_win, len(array) - post_impact_win): data = array[i] # if data[9] == 1: act_state = data[9] microanno = data[8] dataFeatures = array[i - pre_impact_win : i + post_impact_win] x = timeit.default_timer() featureRes = featurescom.featurescom(dataFeatures, microanno, act_state) y = timeit.default_timer() run = y - x runtime.append(run) # print runtime csvWriter.writerow(featureRes) write_runtime(runtime, runtime_path) print("Finish Calculate Features")
def mytilt(acc_x,acc_y,acc_z,gyr_x,gyr_y,gyr_z): #============== Butterworth Filter ======================================================= # This function is to calculate Wn for butterworth function: cut_off_frequency/ (sampling-rate/2) samp_rate = source_var.sampling_rate() WN = 0.05/(samp_rate/2) a,b = signal.butter(2,WN,'high') # calculate Butterworth Filter coefficient #initial Kalman Filter values p1=0 #error covariance update p2=0 x_est_z=[0,0] x_est_y=[0,0] gyro_x=[0,0,0] gyro_filx=[0,0] gyro_y=[0,0,0] gyro_fily =[0,0] gyro_z=[0,0,0] gyro_filz=[0,0] gyrofilValx=0 gyrofilValy=0 gyrofilValz=0 gyro_savex=[0,0] gyro_savey=[0,0] gyro_savez=[0,0] error_cov1 = 0 error_cov2 = 0 angle_y_final=[] angle_z_final=[] for i in range(0,len(acc_x)): #compute tilt angle from accelerometer values angle_acc = acceltilt.acceltilt(acc_x[i],acc_y[i],acc_z[i]) #========== High Pass Filter for gyro data ============================================= # x axis gyro_x[2] = gyr_x[i] gyro_filx[1] = gyrofilValx gyrofilValx = butterfilt.butterfilt(gyro_x,gyro_filx,a,b) gyro_x[0]= gyro_x[1] gyro_x[1]= gyro_x[2] gyro_filx[0] = gyro_filx[1] gyro_savex[1] = gyrofilValx # y axis gyro_y[2] = gyr_y[i] gyro_fily[1] = gyrofilValy gyrofilValy = butterfilt.butterfilt(gyro_y,gyro_fily,a,b) gyro_y[0] = gyro_y[1] gyro_y[1] = gyro_y[2] gyro_fily[0] = gyro_fily[1] gyro_savey[1] = gyrofilValy # z axis gyro_z[2] = gyr_z[i] gyro_filz[1] = gyrofilValz gyrofilValz = butterfilt.butterfilt(gyro_z,gyro_filz,a,b) gyro_z[0] = gyro_z[1] gyro_z[1] = gyro_z[2] gyro_filz[0] = gyro_filz[1] gyro_savez[1] = gyrofilValz # angular velocity integration angles = angularinteg.angularinteg(gyro_savex,gyro_savey,gyro_savez) #update the value of integrated gyro for next iteration gyro_savex[0] = angles[0] gyro_savey[0] = angles[1] gyro_savez[0] = angles[2] #========== Kalman Filter ============================# # Kalman Filter for y axis x_est_y[0] = angle_acc[1] #tilt angle from accelerometer z axis meas_sens_y = angle_acc[0] k_val_y = kalman_filt.kalmanfilt(x_est_y, error_cov2,R2,meas_sens_y) x_est_y[1] = k_val_y[0] error_cov2 = k_val_y[1] angle_y = k_val_y[0] #====================================================== # Kalman Filter for Z axis # TODO this looks wrong. The x_est should only be updated by the kalman filter x_est_z[0] = angle_acc[2] # tilt angle from accelerometer z axis meas_sens_z= angles[1] # tilt angle from filtered gyro y axis k_val_z = kalman_filt.kalmanfilt(x_est_z, error_cov1, R1, meas_sens_z) #Kalman Implementation x_est_z[1] = k_val_z[0] #kalman value for next iteration error_cov1 = k_val_z[1] angle_z = k_val_z[0] #====================================================== # input value into array angle_z_final.append(angle_z) angle_y_final.append(angle_y) result = [angle_y_final, angle_z_final] return result
def featurescom (fullarray, micannot,act_state): samp_rate = source_var.sampling_rate() pre_win = [0, samp_rate] #pre-window imp_win = [(samp_rate/2)-1, int(6.5 * samp_rate)] # impact window post_win = [int((2.5 * samp_rate))-1, 12 * samp_rate] #post impact window max_win = [(samp_rate/2)-1, int(1.5 * samp_rate)] # window for search max value tilt_sample_impact = [(2*samp_rate)-1, 3*samp_rate] tilt_sample_post = [(3 * samp_rate) - 1, 12 * samp_rate] # window for tilt-angle datAr = [] #for vector magnitude datXa= [] #for X values datYa= [] #for Y values datZa= [] #for Z values datXg=[] datYg=[] datZg=[] for tempdata in fullarray: datAr.append(float(tempdata[6])) datXa.append(float(tempdata[0])) datYa.append(float(tempdata[1])) datZa.append(float(tempdata[2])) datXg.append(float(tempdata[3])) datYg.append(float(tempdata[4])) datZg.append(float(tempdata[5])) #****************************************************************************************************************************** #minimum value feature minVal = min(datAr[pre_win[0]:pre_win[1]]) #****************************************************************************************************************************** #maximum value feature maxVal = max(datAr[max_win[0]:max_win[1]]) #****************************************************************************************************************************** #mean for pre-impact event meanList1 = datAr[pre_win[0]:pre_win[1]] meanVal1 = numpy.mean(meanList1) #****************************************************************************************************************************** #mean for impact meanList2 = datAr[imp_win[0]:imp_win[1]] meanVal2 = numpy.mean(meanList2) #****************************************************************************************************************************** #mean for post-impact meanList3 = datAr[post_win[0]:post_win[1]] meanVal3 = numpy.mean(meanList3) #****************************************************************************************************************************** #Root mean square for pre-impact rmsList1 = datAr[pre_win[0]:pre_win[1]] rms1 = sqrt(mean(numpy.array(rmsList1)**2)) #Root mean square for impact rmsList2 = datAr[imp_win[0]:imp_win[1]] rms2 = sqrt(mean(numpy.array(rmsList2)**2)) #Root mean square for post-impact rmsList3 = datAr[post_win[0]:post_win[1]] rms3 = sqrt(mean(numpy.array(rmsList3)**2)) #****************************************************************************************************************************** #variance for pre-impact variance1 = numpy.var(datAr[pre_win[0]:pre_win[1]],ddof=1) #variance for impact variance2 = numpy.var(datAr[imp_win[0]:imp_win[1]],ddof=1) #variance for post-impact variance3 = numpy.var(datAr[post_win[0]:post_win[1]],ddof=1) #****************************************************************************************************************************** #velocity in pre-impact velo1 = integrator.integrate(datAr[pre_win[0]:pre_win[1]]) #velocity in impact velo2 = integrator.integrate(datAr[imp_win[0]:imp_win[1]]) #velocity in post-impact velo3 = integrator.integrate(datAr[post_win[0]:post_win[1]]) #****************************************************************************************************************************** #energy in pre-impact win1x = datXa[pre_win[0]:pre_win[1]] win1y = datYa[pre_win[0]:pre_win[1]] win1z = datZa[pre_win[0]:pre_win[1]] energy1 = energyFeat.energyCalc(win1x,win1y,win1z) #energy in impact win2x = datXa[imp_win[0]:imp_win[1]] win2y = datYa[imp_win[0]:imp_win[1]] win2z = datZa[imp_win[0]:imp_win[1]] energy2 = energyFeat.energyCalc(win2x,win2y,win2z) #energy in post-impact win3x = datXa[post_win[0]:post_win[1]] win3y = datYa[post_win[0]:post_win[1]] win3z = datZa[post_win[0]:post_win[1]] energy3 = energyFeat.energyCalc(win3x,win3y,win3z) #****************************************************************************************************************************** #signal magnitude are in pre-impact sma1 = smaFeat.smafeat(datXa[pre_win[0]:pre_win[1]],datYa[pre_win[0]:pre_win[1]],datZa[pre_win[0]:pre_win[1]]) #signal magnitude are in impact sma2 = smaFeat.smafeat(datXa[imp_win[0]:imp_win[1]],datYa[imp_win[0]:imp_win[1]],datZa[imp_win[0]:imp_win[1]]) #signal magnitude are in pre-impact sma3 = smaFeat.smafeat(datXa[post_win[0]:post_win[1]],datYa[post_win[0]:post_win[1]],datZa[post_win[0]:post_win[1]]) #****************************************************************************************************************************** #exponential moving average in pre-impact ewma1 = emafit.ema(datAr[pre_win[0]:pre_win[1]]) #exponential moving average in impact ewma2 = emafit.ema(datAr[imp_win[0]:imp_win[1]]) #exponential moving average in post-impact ewma3 = emafit.ema(datAr[post_win[0]:post_win[1]]) #****************************************************************************************************************************** #Tilt Angle in pre-impact all_angle_1 = mytilt.mytilt(datXa[pre_win[0]:pre_win[1]],datYa[pre_win[0]:pre_win[1]],datZa[pre_win[0]:pre_win[1]], datXg[pre_win[0]:pre_win[1]],datYg[pre_win[0]:pre_win[1]],datZg[pre_win[0]:pre_win[1]]) angle_y_1 = numpy.max(numpy.abs(numpy.array(all_angle_1[0]))) angle_z_1 = numpy.max(numpy.abs(numpy.array(all_angle_1[1]))) #Tilt Angle in impact all_angle_2 = mytilt.mytilt(datXa[tilt_sample_impact[0]:tilt_sample_impact[1]],datYa[tilt_sample_impact[0]:tilt_sample_impact[1]], datZa[tilt_sample_impact[0]:tilt_sample_impact[1]],datXg[tilt_sample_impact[0]:tilt_sample_impact[1]], datYg[tilt_sample_impact[0]:tilt_sample_impact[1]],datZg[tilt_sample_impact[0]:tilt_sample_impact[1]]) angle_y_2 = numpy.max(numpy.abs(numpy.array(all_angle_2[0]))) angle_z_2 = numpy.max(numpy.abs(numpy.array(all_angle_2[1]))) #Tilt Angle in post-impact all_angle_3 = mytilt.mytilt(datXa[tilt_sample_post[0]:tilt_sample_post[1]],datYa[tilt_sample_post[0]:tilt_sample_post[1]], datZa[tilt_sample_post[0]:tilt_sample_post[1]],datXg[tilt_sample_post[0]:tilt_sample_post[1]], datYg[tilt_sample_post[0]:tilt_sample_post[1]],datZg[tilt_sample_post[0]:tilt_sample_post[1]]) angle_y_3 = numpy.max(numpy.abs(numpy.array(all_angle_3[0]))) angle_z_3 = numpy.max(numpy.abs(numpy.array(all_angle_3[1]))) #****************************************************************************************************************************** annot = micannot #datfeat = [minVal, maxVal, meanVal1, meanVal2, meanVal3, rms1, rms2, rms3, variance1, variance2, variance3, velo1, # velo2, velo3, energy1, energy2, energy3, sma1, sma2, sma3, ewma1, ewma2, ewma3, act_state, annot] datfeat = [minVal, maxVal, meanVal1, meanVal2, meanVal3, rms1, rms2, rms3, variance1, variance2, variance3, velo1, velo2, velo3, energy1, energy2, energy3, sma1, sma2, sma3, ewma1, ewma2, ewma3, angle_y_1, angle_z_1, angle_y_2, angle_z_2,angle_y_3,angle_z_3,act_state, annot] return datfeat