# -*- coding: utf-8 -*-

import numpy as np


class MS (object):
    """A modulation spectrum (MS) statistics class
    Estimate statistics and perform postfilter based on
    the MS statistics

    """

    def __init__(self):
        pass

    def estimate(self, datalist):
        """Estimate MS statistics from list of data

        Parameters
        ----------
        datalist : list, shape ('num_data')
            List of several data ([T, dim]) sequence

        Returns
        -------
        msstats : array, shape (`dim * 2`, `fftsize // 2 + 1`)
            Mean and variance of MS
        """

        # get max length in all data and define fft length
        maxlen = np.max(list(map(lambda x: x.shape[0], datalist)))
        n_bit = len(bin(maxlen)) - 2
        self.fftsize = 2 ** (n_bit + 1)

        mss = []
        for data in datalist:
            logpowerspec = self.logpowerspec(data)
            mss.append(logpowerspec)

        # calculate mean and variance in each freq. bin
        msm = np.mean(np.array(mss), axis=0)
        msv = np.var(np.array(mss), axis=0)
        return np.hstack([msm, msv])

    def postfilter(self, data, msstats, cvmsstats, alpha=1.0, k=0.85, startdim=1):
        """Perform postfilter based on MS statistics to data

        Parameters
        ----------
        data : array, shape (`T`, `dim`)
            Array of data sequence
        msstats : array, shape (`dim * 2`, `fftsize // 2 + 1`)
            Array of mean and variance for target MS
        cvmsstats : array, shape (`dim * 2`, `fftsize // 2 + 1`)
            Array of mean and variance for converted MS
            This option replaces the mean variance of the given data
            into the mean variance estimated from training data.
        alpha : float, optional
            Morphing coefficient between MS transformed data and data.
            .. math::
               alpha * mspf(data) + (1 - alpha) * data
            Default set to 1.0
        k : float, optional
            Postfilter emphasis coefficient [0 <= k <= 1]
            Default set to 1.0
        startdim : int, optional
            Start dimension to perform MS postfilter [1 < startdim < dim]

        Returns
        -------
        filtered_data : array, shape (`T`, `data`)
            Array of MS postfiltered data sequence
        """

        # get length and dimension
        T, dim = data.shape
        self.fftsize = msstats.shape[0]
        assert dim == msstats.shape[1] // 2

        # create zero padded data
        logpowerspec, phasespec = self.logpowerspec(data, phase=True)
        msed_logpowerspec = (1 - k) * logpowerspec + \
            k * (np.sqrt((msstats / cvmsstats)[:, dim:]) *
                 (logpowerspec - cvmsstats[:, :dim]) + msstats[:, :dim])

        # reconstruct
        reconst_complexspec = np.exp(msed_logpowerspec / 2) * (np.cos(phasespec) +
                                                               np.sin(phasespec) * 1j)
        filtered_data = np.fft.ifftn(reconst_complexspec)[:T].real

        if startdim == 1:
            filtered_data[:, 0] = data[:, 0]

        # apply morphing
        filtered_data = alpha * filtered_data + (1 - alpha) * data

        return filtered_data

    def logpowerspec(self, data, phase=False):
        """Calculate log power spectrum in each dimension

        Parameters
        ----------
        data : array, shape (`T`, `dim`)
            Array of data sequence

        Returns
        -------
        logpowerspec : array, shape (`dim`, `fftsize // 2 + 1`)
            Log power spectrum of sequence
        phasespec : array, shape (`dim`, `fftsize // 2 + 1`), optional
            Phase spectrum of sequences
        """

        # create zero padded data
        T, dim = data.shape
        padded_data = np.zeros((self.fftsize, dim))
        padded_data[:T] += data

        # calculate log power spectum of data
        complex_spec = np.fft.fftn(padded_data, axes=(0, 1))
        logpowerspec = 2 * np.log(np.absolute(complex_spec))

        if phase:
            phasespec = np.angle(complex_spec)
            return logpowerspec, phasespec
        else:
            return logpowerspec

# -*- coding: utf-8 -*-

import numpy as np


class MS (object):
    """A modulation spectrum (MS) statistics class
    Estimate statistics and perform postfilter based on
    the MS statistics

    """

    def __init__(self):
        pass

    def estimate(self, datalist):
        """Estimate MS statistics from list of data

        Parameters
        ----------
        datalist : list, shape ('num_data')
            List of several data ([T, dim]) sequence

        Returns
        -------
        msstats : array, shape (`dim * 2`, `fftsize // 2 + 1`)
            Mean and variance of MS
        """

        # get max length in all data and define fft length
        maxlen = np.max(list(map(lambda x: x.shape[0], datalist)))
        n_bit = len(bin(maxlen)) - 2
        self.fftsize = 2 ** (n_bit + 1)

        mss = []
        for data in datalist:
            logpowerspec = self.logpowerspec(data)
            mss.append(logpowerspec)

        # calculate mean and variance in each freq. bin
        msm = np.mean(np.array(mss), axis=0)
        msv = np.var(np.array(mss), axis=0)
        return np.hstack([msm, msv])

    def postfilter(self, data, msstats, cvmsstats, alpha=1.0, k=0.85, startdim=1):
        """Perform postfilter based on MS statistics to data

        Parameters
        ----------
        data : array, shape (`T`, `dim`)
            Array of data sequence
        msstats : array, shape (`dim * 2`, `fftsize // 2 + 1`)
            Array of mean and variance for target MS
        cvmsstats : array, shape (`dim * 2`, `fftsize // 2 + 1`)
            Array of mean and variance for converted MS
            This option replaces the mean variance of the given data
            into the mean variance estimated from training data.
        alpha : float, optional
            Morphing coefficient between MS transformed data and data.
            .. math::
               alpha * mspf(data) + (1 - alpha) * data
            Default set to 1.0
        k : float, optional
            Postfilter emphasis coefficient [0 <= k <= 1]
            Default set to 1.0
        startdim : int, optional
            Start dimension to perform MS postfilter [1 < startdim < dim]

        Returns
        -------
        filtered_data : array, shape (`T`, `data`)
            Array of MS postfiltered data sequence
        """

        # get length and dimension
        T, dim = data.shape
        self.fftsize = msstats.shape[0]
        assert dim == msstats.shape[1] // 2

        # create zero padded data
        logpowerspec, phasespec = self.logpowerspec(data, phase=True)
        msed_logpowerspec = (1 - k) * logpowerspec + \
            k * (np.sqrt((msstats / cvmsstats)[:, dim:]) *
                 (logpowerspec - cvmsstats[:, :dim]) + msstats[:, :dim])

        # reconstruct
        reconst_complexspec = np.exp(msed_logpowerspec / 2) * (np.cos(phasespec) +
                                                               np.sin(phasespec) * 1j)
        filtered_data = np.fft.ifftn(reconst_complexspec)[:T].real

        if startdim == 1:
            filtered_data[:, 0] = data[:, 0]

        # apply morphing
        filtered_data = alpha * filtered_data + (1 - alpha) * data

        return filtered_data

    def logpowerspec(self, data, phase=False):
        """Calculate log power spectrum in each dimension

        Parameters
        ----------
        data : array, shape (`T`, `dim`)
            Array of data sequence

        Returns
        -------
        logpowerspec : array, shape (`dim`, `fftsize // 2 + 1`)
            Log power spectrum of sequence
        phasespec : array, shape (`dim`, `fftsize // 2 + 1`), optional
            Phase spectrum of sequences
        """

        # create zero padded data
        T, dim = data.shape
        padded_data = np.zeros((self.fftsize, dim))
        padded_data[:T] += data

        # calculate log power spectum of data
        complex_spec = np.fft.fftn(padded_data, axes=(0, 1))
        logpowerspec = 2 * np.log(np.absolute(complex_spec))

        if phase:
            phasespec = np.angle(complex_spec)
            return logpowerspec, phasespec
        else:
            return logpowerspec

# -*- coding: utf-8 -*- A modulation spectrum (MS) statistics class     Estimate statistics and perform postfilter based on     the MS statistics Estimate MS statistics from list of data          Parameters         ----------         datalist : list, shape ('num_data')             List of several data ([T, dim]) sequence          Returns         -------         msstats : array, shape (`dim * 2`, `fftsize // 2 + 1`)             Mean and variance of MS # get max length in all data and define fft length # calculate mean and variance in each freq. bin Perform postfilter based on MS statistics to data          Parameters         ----------         data : array, shape (`T`, `dim`)             Array of data sequence         msstats : array, shape (`dim * 2`, `fftsize // 2 + 1`)             Array of mean and variance for target MS         cvmsstats : array, shape (`dim * 2`, `fftsize // 2 + 1`)             Array of mean and variance for converted MS             This option replaces the mean variance of the given data             into the mean variance estimated from training data.         alpha : float, optional             Morphing coefficient between MS transformed data and data.             .. math::                alpha * mspf(data) + (1 - alpha) * data             Default set to 1.0         k : float, optional             Postfilter emphasis coefficient [0 <= k <= 1]             Default set to 1.0         startdim : int, optional             Start dimension to perform MS postfilter [1 < startdim < dim]          Returns         -------         filtered_data : array, shape (`T`, `data`)             Array of MS postfiltered data sequence # get length and dimension # create zero padded data # reconstruct # apply morphing Calculate log power spectrum in each dimension          Parameters         ----------         data : array, shape (`T`, `dim`)             Array of data sequence          Returns         -------         logpowerspec : array, shape (`dim`, `fftsize // 2 + 1`)             Log power spectrum of sequence         phasespec : array, shape (`dim`, `fftsize // 2 + 1`), optional             Phase spectrum of sequences # create zero padded data # calculate log power spectum of data