PinkNoise.cs

Go to the documentation of this file.

using Microsoft.MixedReality.Toolkit.UI;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using UnityEngine;
 
public class PinkNoise : BaseNoiseClass
{
    #region Private Variables
    private float m_AlphaValue = 0.99f;
 
    private int m_SampleSize2X = 5000;
 
    private float m_SqrtOfTwo = 0.0f;
 
    private List<double> m_GKSqrt;
 
    #endregion
 
    protected override void Awake()
    {
        base.Awake();        
        m_GKSqrt = new List<double>();
        m_SqrtOfTwo = Mathf.Sqrt( 2.0f );        
        PopulateVariablesWithDataFromUI();
        m_DistributionButton.GetComponent<Interactable>().IsEnabled = true;
    }
 
    protected override void PopulateVariablesWithDataFromUI()
    {
        base.PopulateVariablesWithDataFromUI();
        m_SampleSize2X = m_SampleSize;
        m_SampleSize /= 2;
    }
 
    public override void GenerateNewDistribution()
    {
        base.GenerateNewDistribution();
        CalculateBaseNoise();
    }
 
    public override void ApplyPattern()
    {
        CalculateNoise();
        bool noiseAppliedState = ( m_NoiseValueList.Count >= ( m_SampleSize2X - 2 ) ) ? true : false;
        SetReadyMessage( noiseAppliedState, "Pink" );
    }
 
    protected override void CalculateNoise()
    {
        float value = 0.0f;
        ConvertToZScore( ref m_StandardNoiseDistribution );
 
        foreach( float unscaledSignal in m_StandardNoiseDistribution )
        {
            value = m_MeanPeriod + ( m_SDPeriod / m_NoiseSTD ) * unscaledSignal;
            m_NoiseValueList.Add( value );
        }
    }
 
    private void CalculateGKSQRT()
    {
 
        int basePinkNoiseArrLen = ( m_SampleSize2X - 2 );
        List<double> gammak = new List<double>();
 
        if( m_GKSqrt.Any() == true )
        {
            m_GKSqrt.Clear();
        }
 
        for( int i = 0; i < m_SampleSize; i++ )
        {
            double first = Math.Pow( ( Mathf.Abs( i - 1 ) ), ( 2 * m_AlphaValue ) );
 
            double second = 2 * ( Math.Pow( i, ( 2 * m_AlphaValue ) ) );
 
            double third = Math.Pow( ( i + 1 ), ( 2 * m_AlphaValue ) );
 
            double result = ( first - second + third ) / 2.0;
            gammak.Add( result * basePinkNoiseArrLen );
        }
 
        for( int i = ( m_SampleSize - 2 ); i > 0; i-- )
        {
            gammak.Add( gammak[i] );
        }
 
        Complex[] GammakComplex = new Complex[gammak.Count];
 
        for( int i = 0; i < gammak.Count; i++ )
        {
            Complex gamComp = new Complex( ( gammak[i] / gammak.Count ), 0.0 );
            GammakComplex[i] = gamComp;
        }
 
        gammak.Clear();
 
        IDFTReal( ref GammakComplex );
 
    }
 
    protected override void CalculateBaseNoise()
    {
        if( m_StandardNoiseDistribution.Count > 0 )
        {
            m_StandardNoiseDistribution.Clear();
        }
 
        List<float> basePinkNoise = new List<float>();
        List<float> leftHalf = new List<float>();
        List<float> rightHalf = new List<float>();
 
        Complex[] basePinkNoiseComplexArr = new Complex[m_SampleSize2X - 2];
 
        m_Multiplier = m_Mean + m_NoiseSTD;
 
        // Generate GaussianDistribution Random values and multiple each value with the multiplier ( mean + SD )
        for( int i = 0; i < m_SampleSize2X; i++ )
        {
            basePinkNoise.Add( m_Multiplier * (float)m_GaussianDistribution.RandomGauss( (double)m_Mean, (double)m_NoiseSTD ) );
 
            if( i < m_SampleSize )
            {
                leftHalf.Add( basePinkNoise[i] );
            }
            else
            {
                rightHalf.Add( basePinkNoise[i] );
            }
        }
 
        basePinkNoise.Clear();
 
        rightHalf[0] = 0;
        leftHalf[0] = leftHalf[0] * m_SqrtOfTwo;
 
        rightHalf[m_SampleSize - 1] = 0;
        leftHalf[m_SampleSize - 1] = leftHalf[m_SampleSize - 1] * m_SqrtOfTwo;
 
        for( int i = (m_SampleSize - 2); i > 0; i-- )
        {
            leftHalf.Add(leftHalf[i]);
            rightHalf.Add(-rightHalf[i]);
        }
 
        for( int i = 0; i < rightHalf.Count; i++ )
        {
            Complex myComplex = new Complex( leftHalf[i], rightHalf[i] );
            basePinkNoiseComplexArr[i] = myComplex;
        }
 
        leftHalf.Clear();
        rightHalf.Clear();
 
        bool noZeroFlag = true;
 
        CalculateGKSQRT();
 
        for( int i = 0; i < m_GKSqrt.Count; i++ )
        {
            if( Mathf.Approximately( (float)m_GKSqrt[i], 0.0f ) )
            {
                noZeroFlag = false;
                break;
            }
        }
 
        if( noZeroFlag == true )
        {
            int basePinkNoiseComplexArrLen = basePinkNoiseComplexArr.Length;
 
            for( int i = 0; i < basePinkNoiseComplexArrLen; i++ )
            {
                m_GKSqrt[i] = Math.Sqrt( m_GKSqrt[i] );
                basePinkNoiseComplexArr[i] = Complex.Multiply( basePinkNoiseComplexArr[i], m_GKSqrt[i] );
            }
 
            IDFT( ref basePinkNoiseComplexArr );
 
            for( int i = 0; i < basePinkNoiseComplexArrLen; i++ )
            {
                double power = Math.Pow( ( m_SampleSize - 1 ), ( -0.5 ) );
                Complex intermediateResult = Complex.Multiply( power, basePinkNoiseComplexArr[i] );
                Complex result = Complex.Multiply( intermediateResult, 0.5 );
                m_StandardNoiseDistribution.Add( (float)result.Real );
            }
 
            m_Title.text = "Distribution is Ready";
        }
        else
        {
            m_Title.text = "Distribution is NOT Ready";
        }
    }
 
    private void IDFT( ref Complex[] X )
    {
        // Number of spectrum elements
        int N = X.Length;
        Complex[] x = new Complex[N];
 
        for( int n = 0; n < N; n++ )
        {
            Complex sum = 0;
 
            for( int k = 0; k < N; k++ )
            {
                sum += X[k] * Complex.Exp( Complex.ImaginaryOne * 2 * Math.PI * (k * n) / Convert.ToDouble(N) );
            }
 
            // As a result we expect only real values (if our calculations are correct imaginary values should be equal or close to zero)
            x[n] = sum;
        }
 
        Array.Clear( X, 0, N );
 
        for( int i = 0; i < N; i++ )
        {
            X[i] = x[i];
        }
    }
 
    private void IDFTReal( ref Complex[] X )
    {
        int N = X.Length; // Number of spectrum elements        
 
        for( int n = 0; n < N; n++ )
        {
            Complex sum = 0;
 
            for( int k = 0; k < N; k++ )
            {
                sum += X[k] * Complex.Exp( Complex.ImaginaryOne * 2 * Math.PI * (k * n) / Convert.ToDouble(N) );
            }
 
            // As a result we expect only real values (if our calculations are correct imaginary values should be equal or close to zero)
            m_GKSqrt.Add( sum.Real );
        }
    }
}