0053975c1b779ddeb72e76ef5e099eab8bde08b3,acoular/tbeamform.py,BeamformerCleantSq,result,#BeamformerCleantSq#,814

Before Change

        // initialize values
        numMics = self.steer.mics.num_mics
        m_index = arange(numMics, dtype=int)
        n_index = arange(0,num)[:,newaxis]
        c = self.steer.env.c/self.source.sample_freq
        delays = self.rm/c
        d_index = array(delays, dtype=int) // integer index
        d_interp2 = delays % 1 // 2nd coeff for lin interpolation between samples
        d_interp1 = 1-d_interp2 // 1st coeff for lin interpolation 
        w = self._get_weights()
        amp = (w/(self.rm*self.rm)).sum(1) * self.r0
        amp = 1.0/(amp[:, newaxis]*self.rm) // multiplication factor
        temp = empty((self.grid.size, self.source.numchannels), dtype=float)
        d_interp1 *= amp // premultiplication, to save later ops
        d_interp2 *= amp
        maxdelay = int((self.rm/c).max())+2 + num // +2 because interpolation
        initialNumberOfBlocks = int(ceil(maxdelay/num))
        bufferSize=initialNumberOfBlocks*num
        self.buffer = zeros((bufferSize,numMics), dtype=float)
        self.bufferIndex = bufferSize // indexing current time sample in buffer 
        fill_buffer_generator = self._fill_buffer(num)
        for _ in range(initialNumberOfBlocks):
            next(fill_buffer_generator)

        // start processing
        flag = True
        while flag:
            samplesleft = self.buffer.shape[0]-self.bufferIndex
            if samplesleft-maxdelay <= 0:
                num += samplesleft-maxdelay
                maxdelay += samplesleft-maxdelay
                n_index = arange(0,num)[:,newaxis]
                flag=False
            // init step
            p_res = array(
                self.buffer[self.bufferIndex:self.bufferIndex+maxdelay,:])
            Phi, autopow = self.delay_and_sum(
                num,p_res,d_interp1,d_interp2,d_index,m_index,temp)
            Gamma = zeros(Phi.shape)
            Gamma_autopow = zeros(Phi.shape)
            J = 0
            // deconvolution 
            while (J < self.n_iter):
                // print(f"start clean iteration {J+1} of max {self.n_iter}")
                if self.r_diag:
                    powPhi = clip((Phi[:num]**2-autopow).sum(0),1e-100,1e+100)
                else:
                    powPhi = (Phi[:num]**2).sum(0)
                imax = argmax(powPhi)
                t_float = delays[imax,m_index]+n_index
                t_ind = t_float.astype(int)
                for m in range(numMics): 
                    p_res[t_ind[:num,m],m] -= self.damp*interp(t_ind[:num,m],
                                                               t_float[:num,m],

After Change

        // initialize values
        numMics = self.steer.mics.num_mics
        m_index = arange(numMics, dtype=int)
        n_index = arange(0,num+1)[:,newaxis]
        c = self.steer.env.c/self.source.sample_freq
        delays = self.rm/c
        d_index = array(delays, dtype=int) // integer index
        d_interp2 = delays % 1 // 2nd coeff for lin interpolation between samples
        d_interp1 = 1-d_interp2 // 1st coeff for lin interpolation 
        w = self._get_weights()
        amp = (w/(self.rm*self.rm)).sum(1) * self.r0
        amp = 1.0/(amp[:, newaxis]*self.rm) // multiplication factor
        temp = empty((self.grid.size, self.source.numchannels), dtype=float)
        d_interp1 *= amp // premultiplication, to save later ops
        d_interp2 *= amp
        maxdelay = int((self.rm/c).max())+2 + num // +2 because interpolation
        initialNumberOfBlocks = int(ceil(maxdelay/num))
        bufferSize=initialNumberOfBlocks*num
        self.buffer = zeros((bufferSize,numMics), dtype=float)
        self.bufferIndex = bufferSize // indexing current time sample in buffer 
        fill_buffer_generator = self._fill_buffer(num)
        for _ in range(initialNumberOfBlocks):
            next(fill_buffer_generator)

        // start processing
        flag = True
        while flag:
            samplesleft = self.buffer.shape[0]-self.bufferIndex
            if samplesleft-maxdelay <= 0:
                num += samplesleft-maxdelay
                maxdelay += samplesleft-maxdelay
                n_index = arange(0,num+1)[:,newaxis]
                flag=False
            // init step
            p_res = array(
                self.buffer[self.bufferIndex:self.bufferIndex+maxdelay,:])
            Phi, autopow = self.delay_and_sum(
                num,p_res,d_interp1,d_interp2,d_index,m_index,temp)
            Gamma = zeros(Phi.shape)
            Gamma_autopow = zeros(Phi.shape)
            J = 0
            // deconvolution 
            while (J < self.n_iter):
                // print(f"start clean iteration {J+1} of max {self.n_iter}")
                if self.r_diag:
                    powPhi = clip((Phi[:num]**2-autopow).sum(0),1e-100,1e+100)
                else:
                    powPhi = (Phi[:num]**2).sum(0)
                imax = argmax(powPhi)
                t_float = delays[imax,m_index]+n_index
                t_ind = t_float.astype(int)
                for m in range(numMics): 
                    p_res[t_ind[:num+1,m],m] -= self.damp*interp(t_ind[:num+1,m],
                                                               t_float[:num,m],

Instances