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 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 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
