Added separation with beamformers that use true source locations. Also did some checks on rank of STFT tensor with no luck - no low-rank tensors found

Author: podkiva

MatlabUtils.py

@@ -24,6 +24,7 @@ def find_engine():
 
     engine.addpath('amsbss/ILRMA')
     engine.addpath('amsbss/AuxIVA')
+    engine.addpath('amsbss/AuxIVA/STFT')
     return engine
 
 

Model.py

@@ -6,6 +6,7 @@
 from RecorderClass import Recorder
 import threading
 from Player import play
+import matplotlib.pyplot as plt
 
 
 def mix(s_input: np.ndarray, sim: dict, data_set: dict):
@@ -54,19 +55,8 @@ def mix_linear(S: np.ndarray, sim: dict) -> Tuple[np.ndarray, np.ndarray, dict]:
     return filtered, mixed, {'mixing_matrix': A}
 
 
-def hexagonal_points(d: float) -> np.ndarray:
-    return d * np.array([[-1, 0, 0],
-                         [-1 / 2, 3 ** 0.5 / 2, 0],
-                         [-1 / 2, -3 ** 0.5 / 2, 0],
-                         [0, 0, 0],
-                         [1 / 2, 3 ** 0.5 / 2, 0],
-                         [1 / 2, -3 ** 0.5 / 2, 0],
-                         [1, 0, 0]]).T
-
-
 def mix_convolutive(S: np.array, sim: dict, data_set: dict) -> Tuple[np.ndarray, np.ndarray, dict]:
     # Get parameters
-    import matplotlib.pyplot as plt
     opts = sim['env_options']
     N = S.shape[0]  # number of sources
     M = sim['microphones'] if 'microphones' in sim else N  # number of microphones
@@ -84,26 +74,19 @@ def mix_convolutive(S: np.array, sim: dict, data_set: dict) -> Tuple[np.ndarray,
                        max_order=max_order,
                        sigma2_awgn=opts['sigma2_awgn'])
     # Microphone locations for hexagonal array
-    array_loc = np.array([[3], [2], [0.5]])
-    micro_locs = hexagonal_points(sim['microphones_distance'])
-    micro_locs += array_loc
+    micro_locs = opts['micro_locations']
 
     # Check that required number of microphones has it's locations
-    if micro_locs.shape[0] < M:
+    if micro_locs.shape[1] < M:
         raise ValueError('{} microphones required, but only {} microphone locations specified'
                          .format(M, micro_locs.shape[0]))
 
     # Select as much microphones as needed
     R = micro_locs[:, :M]
 
     room.add_microphone_array(pra.MicrophoneArray(R, room.fs))
-    # room.add_microphone_array(pra.Beamformer(R, room.fs))
     # Place the sources inside the room
-    source_locs = np.array([
-        [3., 3, 0.85],   # source 1
-        [3., 1, 0.85],   # source 2
-        [5., 2, 0.85],  # source 3
-    ])
+    source_locs = opts['source_locations']
 
     # Check that required number of microphones has it's locations
     if source_locs.shape[0] < N:
@@ -116,10 +99,10 @@ def mix_convolutive(S: np.array, sim: dict, data_set: dict) -> Tuple[np.ndarray,
         room.add_source(loc, signal=np.zeros_like(sig))
     # Make separate recordings
 
-    #room.plot_rir()
-    #fig = plt.gcf()
-    #fig.set_size_inches(9, 6)
-    #plt.show()
+    # room.plot_rir()
+    # fig = plt.gcf()
+    # fig.set_size_inches(9, 6)
+    # plt.show()
 
     filtered = []
     for source, s in zip(room.sources, S):

Normalizer.py

@@ -5,10 +5,10 @@
 
 def form_source_matrix(S_input: list) -> np.ndarray:
     S = copy.deepcopy(S_input)
-    l_max = max(len(s) for s in S)
+    l_min = min(len(s) for s in S)
 
     for s in S:
-        s.resize((1, l_max), refcheck=False)
+        s.resize((1, l_min), refcheck=False)
 
     return np.vstack(S)
 
@@ -25,7 +25,8 @@ def normalize(s: np.ndarray) -> np.ndarray:
     # span = np.max(s) - np.min(s)
     # span = 1 if span == 0 else span  # safety check to avoid division by zero
     # s = ((s - np.min(s)) * 2) / span - 1
-    return s / np.max(np.abs(s))
+    max_v = np.max(np.abs(s))
+    return s / np.max(np.abs(s)) if max_v > 0 else s
 
 
 def normalize_old(S: np.ndarray) -> np.ndarray: