def fbeamextraction(mg, rg, ts, be, firstframe, lastframe, csvdata, _name,
fbeamplot, fbeamplot_2ndSrc, algoplot, algoplot_2ndSrc):
##################### DeepLearning-Matrix (Framewise) #########################
################ Elevation Azimuth Frequenzbänder ###################
DL_Matrix = zeros((NPOINTS_ELE, NPOINTS_AZI, len(FREQBANDS)),
dtype="float32") ##
#################################################################################
for frame in range(firstframe, lastframe):
if frame in csvdata[:, 0]:
fr_index = where(csvdata[:, 0] == frame)[0][0]
if DETAILEDINFO_LVL >= 1:
print(' FRAME: ', frame - firstframe, ' (', frame, ')')
ts.start = frame * NUM
ts.stop = (frame + 1) * NUM
# Zur Berechnung des Mittelwerts der Richtungswinkel
if not (TRAINING):
azis = list(zeros(len(FREQBANDS)))
azic = list(zeros(len(FREQBANDS)))
eles = list(zeros(len(FREQBANDS)))
elec = list(zeros(len(FREQBANDS)))
azis_2nd = list(zeros(len(FREQBANDS)))
azic_2nd = list(zeros(len(FREQBANDS)))
eles_2nd = list(zeros(len(FREQBANDS)))
elec_2nd = list(zeros(len(FREQBANDS)))
#%% 1. Quelle ##############################
# Zur Angle-Prediction ohne händischem Algo
glob_maxval = 0
glob_maxidx = 0
for freq_index, freq in enumerate(FREQBANDS):
be.n = -1 #Eigenwerte sind der Größe nach sortiert! -> größter Eigenwert (default)
Lm = L_p(be.synthetic(freq, 3)).reshape(rg.shape).flatten()
DL_Matrix[:, :, freq_index] = Lm.reshape(rg.shape).T
if PLOTBEAMMAPS or DETAILEDINFO_LVL >= 3 or not (TRAINING):
max_idx = argmax(Lm.flatten(
)) # position in grid with max source strength
max_value = amax(Lm.flatten())
if glob_maxval < max_value: # TODO: 'and freq != 500:' !?!
glob_maxidx = max_idx
glob_maxval = max_value
# min_value = amin(Lm.flatten())
max_cartcoord = rg.gpos[:, max_idx]
temp_azi = arctan2(sin(rg.phi[max_idx]),
cos(rg.phi[max_idx]))
temp_ele = pi / 2 - rg.theta[max_idx]
max_polcoord = [rad2deg(temp_azi), rad2deg(temp_ele)]
azis[freq_index] = sin(temp_azi)
azic[freq_index] = cos(temp_azi)
eles[freq_index] = sin(temp_ele)
elec[freq_index] = cos(temp_ele)
if PLOTBEAMMAPS:
#### 3D-Plot ###
fig = plt.figure()
ax = fig.add_subplot(121, projection='3d')
ax.set_xlabel('x-Achse')
ax.set_ylabel('y-Achse')
ax.set_zlabel('z-Achse')
ax.set_xlim(-1, 1)
ax.set_ylim(-1, 1)
ax.set_zlim(-1, 1)
cmhot = plt.get_cmap("hot_r")
if frame == firstframe:
ax.scatter(rg.gpos[0],
rg.gpos[1],
-rg.gpos[2],
s=50,
c=Lm,
cmap=cmhot,
marker='.')
# Mikros
ax.scatter(mg.mpos[0], mg.mpos[1], mg.mpos[2], 'o')
ax.scatter(max_cartcoord[0],
max_cartcoord[1],
max_cartcoord[2],
s=60,
c='blue')
### 3D-Plot Ende ###
### 2D-Map ###
ax2 = fig.add_subplot(122)
ax2.set_xticks(arange(-180, 270, step=90))
ax2.set_yticks(arange(-90, 135, step=45))
cax2 = ax2.imshow(Lm.reshape(rg.shape).T,
cmap=cmhot,
vmin=Lm.max() - 6,
vmax=Lm.max(),
extent=[-180, 180, -90, 90])
ax2.plot(max_polcoord[0], max_polcoord[1], 'bo')
fig.set_figheight(4)
fig.set_figwidth(8)
fig.colorbar(cax2)
fig.tight_layout(pad=3.0)
fig.suptitle(_name + ' ' + str(frame) + ' ' + str(freq))
plt.show()
### 2D-Map Ende ###
if DETAILEDINFO_LVL >= 3:
print(' {:4d} [{:7.2f}, {:7.2f}] {}'.format(
freq, round(max_polcoord[0], 2),
round(max_polcoord[1], 2), round(max_value, 2)))
#print(' ',freq, max_cartcoord, max_value)
if DETAILEDINFO_LVL >= 2 and TRAINING:
print(" .csv-Values: Class Azi Ele")
print(" ", '{:4d}'.format(csvdata[fr_index, 1]),
'{:4d}'.format(csvdata[fr_index, 2]),
'{:4d}'.format(csvdata[fr_index, 3]))
if TRAINING:
feature_dict = {
'inputmap': _float_list_feature(DL_Matrix),
'class': _int64_feature(csvdata[fr_index, 1]),
'azi': _int64_feature(csvdata[fr_index, 2]),
'ele': _int64_feature(csvdata[fr_index, 3]),
}
if not (TRAINING):
# Prediction nur übers globale Maximum
azi_pred = arctan2(sin(rg.phi[glob_maxidx]),
cos(rg.phi[glob_maxidx]))
ele_pred = pi / 2 - rg.theta[glob_maxidx]
fbeamplot.append([frame, rad2deg(azi_pred), rad2deg(ele_pred)])
# Calculation per Algorithmus (basierend auf Ergebnissen des fbeamformings)
azi_algo, ele_algo = angle_calc_algo(azis, azic, eles, elec)
algoplot.append([frame, rad2deg(azi_algo), rad2deg(ele_algo)])
feature_dict = {'inputmap': _float_list_feature(DL_Matrix)}
yield feature_dict
#%% 2. Quelle ##############################
# Nur, wenn nicht bereits am Ende des Arrays (wenn bei letztem aktiven Frame nur 1 Quelle)
if not (fr_index + 1 == len(csvdata)):
if not (JUST_1SOURCE_FRAMES
or TRAINING) and (frame == csvdata[fr_index + 1, 0]):
glob_maxval = 0
glob_maxidx = 0
if DETAILEDINFO_LVL >= 1:
print(' FRAME: ', frame - firstframe, ' (', frame,
'), 2nd Src')
for freq_index, freq in enumerate(FREQBANDS):
be.n = -2 # zweitgrößter Eigenwert -> zweitstärkste Quelle
Lm = L_p(be.synthetic(freq,
3)).reshape(rg.shape).flatten()
DL_Matrix[:, :, freq_index] = Lm.reshape(rg.shape).T
max_idx = argmax(Lm.flatten(
)) # position in grid with max source strength
max_value = amax(Lm.flatten())
if glob_maxval < max_value: # TODO: 'and freq != 500:' !?!
glob_maxidx = max_idx
glob_maxval = max_value
max_cartcoord = rg.gpos[:, max_idx]
temp_azi = arctan2(sin(rg.phi[max_idx]),
cos(rg.phi[max_idx]))
temp_ele = pi / 2 - rg.theta[max_idx]
max_polcoord = [rad2deg(temp_azi), rad2deg(temp_ele)]
azis_2nd[freq_index] = sin(temp_azi)
azic_2nd[freq_index] = cos(temp_azi)
eles_2nd[freq_index] = sin(temp_ele)
elec_2nd[freq_index] = cos(temp_ele)
if PLOTBEAMMAPS:
#### 3D-Plot ###
fig = plt.figure()
ax = fig.add_subplot(121, projection='3d')
ax.set_xlabel('x-Achse')
ax.set_ylabel('y-Achse')
ax.set_zlabel('z-Achse')
ax.set_xlim(-1, 1)
ax.set_ylim(-1, 1)
ax.set_zlim(-1, 1)
cmhot = plt.get_cmap("hot_r")
if frame == firstframe:
ax.scatter(rg.gpos[0],
rg.gpos[1],
-rg.gpos[2],
s=50,
c=Lm,
cmap=cmhot,
marker='.')
# Mikros
ax.scatter(mg.mpos[0], mg.mpos[1], mg.mpos[2], 'o')
ax.scatter(max_cartcoord[0],
max_cartcoord[1],
max_cartcoord[2],
s=60,
c='blue')
### 3D-Plot Ende ###
### 2D-Map ###
ax2 = fig.add_subplot(122)
ax2.set_xticks(arange(-180, 270, step=90))
ax2.set_yticks(arange(-90, 135, step=45))
cax2 = ax2.imshow(Lm.reshape(rg.shape).T,
cmap=cmhot,
vmin=Lm.max() - 6,
vmax=Lm.max(),
extent=[-180, 180, -90, 90])
ax2.plot(max_polcoord[0], max_polcoord[1], 'bo')
fig.set_figheight(4)
fig.set_figwidth(8)
fig.colorbar(cax2)
fig.tight_layout(pad=3.0)
fig.suptitle(_name + ' (Frame:' + str(frame) +
', Freq:' + str(freq) +
') 2nd Source')
plt.show()
### 2D-Map Ende ###
if DETAILEDINFO_LVL >= 3:
print(' {:4d} [{:7.2f}, {:7.2f}] {} (2nd Src)'.
format(freq, round(max_polcoord[0], 2),
round(max_polcoord[1], 2),
round(max_value, 2)))
#print(' ',freq, max_cartcoord, max_value)
# Prediction nur übers globale Maximum
azi_pred_2nd = arctan2(sin(rg.phi[glob_maxidx]),
cos(rg.phi[glob_maxidx]))
ele_pred_2nd = pi / 2 - rg.theta[glob_maxidx]
fbeamplot_2ndSrc.append(
[frame,
rad2deg(azi_pred_2nd),
rad2deg(ele_pred_2nd)])
# Calculation per Algorithmus (basierend auf Ergebnissen des fbeamformings)
azi_algo_2nd, ele_algo_2nd = angle_calc_algo(
azis_2nd, azic_2nd, eles_2nd, elec_2nd)
algoplot_2ndSrc.append(
[frame,
rad2deg(azi_algo_2nd),
rad2deg(ele_algo_2nd)])
feature_dict = {'inputmap': _float_list_feature(DL_Matrix)}
yield feature_dict
# ax2 = fig.add_subplot(122)
# ax2.set_xticks(arange(-180, 270, step=90))
# ax2.set_yticks(arange(-90, 135, step=45))
# cax2 = ax2.imshow(Lm.reshape(rg.shape).T, cmap=cmhot,
# vmin=Lm.max()-6, vmax=Lm.max(),
# extent=[-180,180,-90,90])
# ax2.plot(max_polcoord[0],max_polcoord[1], 'bo')
# fig.set_figheight(4)
# fig.set_figwidth(8)
# fig.colorbar(cax2)
# fig.tight_layout(pad=3.0)
# show()
### 2D-Map Ende ###
DL_Matrix[:, :, freq_index, frame_index] = Lm.reshape(rg.shape).T
# DL_Matrix[:,:,freq_index] = Lm.reshape(rg.shape).T
summed_azi_x += cos(temp_azi)
summed_azi_y += sin(temp_azi)
summed_ele += max_polcoord[1]
summed_max_v += max_value
print(max_polcoord, max_value)
h5file = open_file('fold1_room2_mix002_ov1.h5', mode='w', title='Audio Data')
h5file.create_array('/',
'audio_features',
obj=DL_Matrix,
shape=DL_Matrix.shape)
h5file.close()
# with open('fold1_room2_mix002_ov1.npy', 'ab') as file:
maxval1 = zeros(len(FREQBANDS))
maxval2 = zeros(len(FREQBANDS))
# Opt 2
tot_maxval1 = 0
tot_maxval2 = 0
# Opt 3
tot_maxval = 0
# Befüllen von Src1_Matrix und Src2_Matrix
for freq_index, freq in enumerate(FREQBANDS):
be.n = -1 #Eigenwerte der Größe nach sortiert -> größter Eigenwert (default)
Lm = L_p(be.synthetic(freq, 3)).reshape(rg.shape).flatten()
Src1_Matrix[:,:,freq_index] = Lm.reshape(rg.shape).T
max_idx1 = argmax(Lm.flatten()) # position in grid with max source strength
max_value1 = amax(Lm.flatten())
be.n = -2 #Eigenwerte der Größe nach sortiert -> größter Eigenwert (default)
Lm = L_p(be.synthetic(freq, 3)).reshape(rg.shape).flatten()
Src2_Matrix[:,:,freq_index] = Lm.reshape(rg.shape).T
max_idx2 = argmax(Lm.flatten()) # position in grid with max source strength
max_value2 = amax(Lm.flatten())
# Opt 1
maxval1[freq_index] = max_value1
maxval2[freq_index] = max_value2
