示例#1
0
        static public BGRComplexImg Img2BGRComplexImg(Bitmap Source, bool Compress = false)
        {
            int           Width = Source.Width, Height = Source.Height;
            BitmapData    SourceData = Source.LockBits(new Rectangle(0, 0, Width, Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
            BGRComplexImg Result = new BGRComplexImg(Width, Height);
            byte *        SourcePointer = (byte *)SourceData.Scan0.ToPointer();
            int           X, Y, T;

            for (Y = 0; Y < Height; ++Y)
            {
                for (X = 0; X < Width; ++X)
                {
                    for (T = 0; T < 3; ++T)
                    {
                        Result[T][Y, X] = new AMComplex(SourcePointer[0], 0);
                        if (Compress)
                        {
                            Result[T][Y, X] /= 255;
                        }
                        ++SourcePointer;
                    }
                    ++SourcePointer;
                }
            }
            Source.UnlockBits(SourceData);
            return(Result);
        }
示例#2
0
        static public HSIComplexImg Img2HSIComplexImg(Bitmap Source)
        {
            int           Width = Source.Width, Height = Source.Height;
            BitmapData    SourceData = Source.LockBits(new Rectangle(0, 0, Width, Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
            HSIComplexImg Result     = new HSIComplexImg(Width, Height);
            BGR           BGRTmp     = new BGR();
            HSI           HSITmp;
            byte *        SourcePointer = (byte *)SourceData.Scan0.ToPointer();
            int           X, Y, T;

            for (Y = 0; Y < Height; ++Y)
            {
                for (X = 0; X < Width; ++X)
                {
                    for (T = 0; T < 3; ++T)
                    {
                        BGRTmp[T] = SourcePointer[0];
                        ++SourcePointer;
                    }
                    ++SourcePointer;
                    HSITmp          = BGRTmp.ToHSI();
                    Result[0][Y, X] = new AMComplex(HSITmp.H, 0);
                    Result[1][Y, X] = new AMComplex(HSITmp.S, 0);
                    Result[2][Y, X] = new AMComplex(HSITmp.I, 0);
                }
            }
            Source.UnlockBits(SourceData);
            return(Result);
        }
示例#3
0
        static public AMComplex[,] SimpleComplexKernel(int Width, int Height, float Length, bool Compress = false)
        {
            AMComplex[,] Result = new AMComplex[Height, Width];
            int X, Y;
            int CX = (int)((Width - Length) / 2), CY = Height / 2;

            for (Y = 0; Y < Height; ++Y)
            {
                for (X = 0; X < Width; ++X)
                {
                    if (Y == CY && CX <= X && X < CX + Length)
                    {
                        if (Compress)
                        {
                            Result[Y, X] = new AMComplex(1, 0);
                        }
                        else
                        {
                            Result[Y, X] = new AMComplex(255, 0);
                        }
                    }
                    else
                    {
                        Result[Y, X] = new AMComplex(0, 0);
                    }
                }
            }
            return(Result);
        }
示例#4
0
        static public Bitmap Deconvolution(Bitmap SourceA, Bitmap SourceB, double Lambda = 10, bool Zero = false)
        {
            int OWidth = SourceA.Width, OHeight = SourceA.Height;

            if (OWidth != SourceB.Width || OHeight != SourceB.Height)
            {
                throw new Exception("圖片大小不一");
            }
            SourceA = ImgExtend(SourceA, Zero);
            SourceB = ImgExtend(SourceB, Zero);
            int           Width = SourceA.Width, Height = SourceA.Height;
            int           X, Y, T;
            BGRComplexImg ComplexSourceA = Img2BGRComplexImg(SourceA);
            BGRComplexImg ComplexSourceB = Img2BGRComplexImg(SourceB);
            BGRComplexImg ComplexResult  = new BGRComplexImg(Width, Height);

            ComplexSourceA.FFT2();
            ComplexSourceB.FFT2();
            for (Y = 0; Y < Height; ++Y)
            {
                for (X = 0; X < Width; ++X)
                {
                    for (T = 0; T < 3; ++T)
                    {
                        ComplexResult[T][Y, X] = AMComplex.MaxDivide(ComplexSourceA[T][Y, X], ComplexSourceB[T][Y, X]) * (ComplexSourceA[T][Y, X].Magnitude / (ComplexSourceA[T][Y, X].Magnitude + Lambda));
                    }
                }
            }
            ComplexResult.BFFTShift();
            ComplexResult.IFFT2();
            Bitmap Result = BGRComplexImg2Img(ComplexResult);

            return(ImgUnExtend(Result, OWidth, OHeight));
        }
示例#5
0
 /**
  * Add a data point to the storage bin
  */
 public void Add(AForge.Math.Complex d)
 {
     lock (data0)
     {
         data0.Add(d);
     }
 }
示例#6
0
 public BGRComplexImg(int Width, int Height)
 {
     _R           = new AMComplex[Height, Width];
     _G           = new AMComplex[Height, Width];
     _B           = new AMComplex[Height, Width];
     this._Width  = Width;
     this._Height = Height;
 }
示例#7
0
 public HSIComplexImg(int Width, int Height)
 {
     _H           = new AMComplex[Height, Width];
     _S           = new AMComplex[Height, Width];
     _I           = new AMComplex[Height, Width];
     this._Width  = Width;
     this._Height = Height;
 }
示例#8
0
        /// <summary>
        /// 同態濾波(灰階)。
        /// </summary>
        /// <param name="Source">來源圖片</param>
        /// <param name="GammaHigh"></param>
        /// <param name="GammaLow"></param>
        /// <param name="C">坡度銳利度</param>
        /// <param name="D0">截止頻率</param>
        /// <returns>結果圖片</returns>
        static public Bitmap HomomorphicfilterGrayscale(Bitmap Source, double GammaHigh = 2, double GammaLow = 0.25, double C = 1, double D0 = 80)
        {
            int OWidth = Source.Width, OHeight = Source.Height;

            Source = ImageExtendZero(Grayscale(Source));
            int        Width = Source.Width, Height = Source.Height;
            BitmapData SourceData = Source.LockBits(new Rectangle(0, 0, Width, Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
            Bitmap     Result     = new Bitmap(Width, Height);
            BitmapData ResultData = Result.LockBits(new Rectangle(0, 0, Width, Height), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);

            AForge.Math.Complex[,] ComplexData = new AForge.Math.Complex[Height, Width];
            int    X, Y;
            double D = GammaHigh - GammaLow, P, T;
            byte * SourcePointer = (byte *)SourceData.Scan0.ToPointer();

            for (Y = 0; Y < Height; ++Y)
            {
                for (X = 0; X < Width; ++X)
                {
                    ComplexData[Y, X]    = new AForge.Math.Complex(SourcePointer[0], 0);
                    ComplexData[Y, X].Re = Math.Log(ComplexData[Y, X].Re + 1);
                    SourcePointer       += 4;
                }
            }
            AForge.Math.FourierTransform.FFT2(ComplexData, AForge.Math.FourierTransform.Direction.Forward);
            for (Y = 0; Y < Height; ++Y)
            {
                for (X = 0; X < Width; ++X)
                {
                    P = -C * ((Math.Pow(Y - (Height / 2), 2) + Math.Pow(X - (Width / 2), 2)) / (Math.Pow(D0, 2)));
                    T = (1 - Math.Exp(P));
                    ComplexData[Y, X] *= (D * T) + GammaLow;
                }
            }
            AForge.Math.FourierTransform.FFT2(ComplexData, AForge.Math.FourierTransform.Direction.Backward);
            byte *ResultPointer = (byte *)ResultData.Scan0.ToPointer();
            byte  Tmp;

            for (Y = 0; Y < Height; ++Y)
            {
                for (X = 0; X < Width; ++X)
                {
                    Tmp = DoubleToByte(Math.Exp(ComplexData[Y, X].Re));
                    ResultPointer[0] = Tmp;
                    ResultPointer[1] = Tmp;
                    ResultPointer[2] = Tmp;
                    ResultPointer[3] = 255;
                    ResultPointer   += 4;
                }
            }
            Source.UnlockBits(SourceData);
            Result.UnlockBits(ResultData);
            Result = ImageUnExtend(Result, OWidth, OHeight, ImagePosition.LeftTop);
            return(Result);
        }
示例#9
0
        private void Calc_And_Plot_DFT(List <byte> values)
        {
            if (InvokeRequired)
            {
                this.Invoke(new Action <List <byte> >(Calc_And_Plot_DFT), new object[] { values });
                return;
            }
            byte[]   values_Array     = values.ToArray();
            double[] Input            = new double[values.Count + 2];
            double[] FreqScale        = MathNet.Numerics.IntegralTransforms.Fourier.FrequencyScale(200, Globals.SamplingFreq);
            string[] FreqScale_labels = new string[FreqScale.Length];
            for (int i = 0; i < FreqScale.Length; i++)
            {
                FreqScale_labels[i] = FreqScale[i].ToString("0.0");
            }
            AForge.Math.Complex[] complex32 = new AForge.Math.Complex[200];
            for (int i = 0; i < 200; i++)
            {
                complex32[i] = new AForge.Math.Complex(Convert.ToSingle((values_Array[i])), 0);
            }

            AForge.Math.FourierTransform.DFT(complex32, AForge.Math.FourierTransform.Direction.Forward);

            for (int i = 0; i < 50; i++)
            {
                DFT_Values[i] = new ObservablePoint(i, 20 * Math.Log10(complex32[i].Magnitude / complex32[SecondLargestIndex(complex32)].Magnitude));
            }

            for (int i = 0; i < 200; i++)
            {
                Phase_Values[i] = new ObservablePoint(i, complex32[i].Phase);
            }
            cartesianChart_DFT.AxisX[0].Labels   = FreqScale_labels;
            cartesianChart_phase.AxisX[0].Labels = FreqScale_labels;

            label_Vpp.Text = string.Format("Vpp = {0}", (((values.Max() - values.Min()) / 255.0) * 3.2).ToString("0.00"));
            List <double> FreqScaleList = new List <double>(FreqScale);
            int           SLI           = SecondLargestIndex(complex32);

            label_Freq.Text  = string.Format("Frequency = {0}", Math.Abs(FreqScaleList[SLI]).ToString("0.00"));
            label_phase.Text = string.Format("Phase = {0}", complex32[SLI].Phase.ToString("0.00"));
        }
示例#10
0
        //STFT implementation. Uses FFT.
        public static Complex[][] STFT_fft(double[] x, int h, double[] window, int N, int minFreq, int maxFreq)
        {
            Complex[][] stft = new Complex[x.Length / h + 1][];
            if (x == null || x.Length == 0)
            {
                return(null);
            }
            int numOfCompletedThreads = 0;

            AForge.Math.Complex[] c_data = new AForge.Math.Complex[x.Length];
            for (int i = 0; i < x.Length; i++)
            {
                c_data[i] = new AForge.Math.Complex(x[i], 0);
            }

            for (int n = 0; n < (x.Length / h); n++)
            {
                if (n * h + N >= c_data.Length)
                {
                    continue;
                }
                AForge.Math.Complex[] partial_c_data = new AForge.Math.Complex[N];
                Array.Copy(c_data, n * h, partial_c_data, 0, N);
                ////Apply window
                //for (int i = 0; i < partial_c_data.Length; i++)
                //{
                //    partial_c_data[i] *= window[i];
                //}

                AForge.Math.FourierTransform.FFT(partial_c_data, AForge.Math.FourierTransform.Direction.Forward);
                stft[n] = new Complex[N];
                for (int i = 0; i < N; i++)
                {
                    stft[n][i] = new Complex(partial_c_data[i].Re, partial_c_data[i].Im);
                }
                Transcription.completedThreadsPercentage = (int)((((double)(++numOfCompletedThreads)) / ((x.Length / h) + 1)) * 100);
            }

            return(stft);
        }
        /////////////////////////////////////////////////////////////////////////////////////////////
        // Original Simple Fluid Solver Code is by Jos Stam
        // 	  http://www.dgp.utoronto.ca/people/stam/reality/Research/pub.html
        //
        //    Using AForge.Math.FourierTransform for FFT
        //
        void SolveSFSW(int n, float[] wu, float[] wv, float[] fu, float[] fv, int rsize, float visc, float dt)
        {
            for (int i = 0; i < n * n; i++)
            {
                wu [i] += dt * fu [i];
                wv [i] += dt * fv [i];
                m_work_u [i] = wu [i] / rsize;
                m_work_v [i] = wv [i] / rsize;
            }

            for (int j = 0; j < n; j++)
            {
                int jj = j * n;
                for (int i = 0; i < n; i++)
                {
                    float x = i - dt * m_work_u [i + jj] * n;
                    float y = j - dt * m_work_v [i + jj] * n;
                    //
                    int xi = (int)Math.Floor (x);
                    int yi = (int)Math.Floor (y);
                    float s = (x - xi);
                    float t = (y - yi);

                    int i0 = (n + (xi % n)) % n;
                    int i1 = (i0 + 1) % n;
                    int j0 = (n + (yi % n)) % n;
                    int j1 = (j0 + 1) % n;

                    wu [i + jj] = (1.0f - s) * ((1.0f - t) * m_work_u [i0 + n * j0] + t * m_work_u [i0 + n * j1])
                                    + s * ((1.0f - t) * m_work_u [i1 + n * j0] + t * m_work_u [i1 + n * j1]);
                    wv [i + jj] = (1.0f - s) * ((1.0f - t) * m_work_v [i0 + n * j0] + t * m_work_v [i0 + n * j1])
                                    + s * ((1.0f - t) * m_work_v [i1 + n * j0] + t * m_work_v [i1 + n * j1]);
                }
            }

            for (int j = 0; j < n; j++)
            {
                int jj = j * n;
                for (int i = 0; i < n; i++)
                {
                    m_comp_u [i, j] = new AForge.Math.Complex (wu [i + jj], 0.0);
                    m_comp_v [i, j] = new AForge.Math.Complex (wv [i + jj], 0.0);
                }
            }

            AForge.Math.FourierTransform.FFT2 (m_comp_u, AForge.Math.FourierTransform.Direction.Forward);
            AForge.Math.FourierTransform.FFT2 (m_comp_v, AForge.Math.FourierTransform.Direction.Forward);

            visc *= dt;
            for (int j = 0; j < n; j++)
            {
                float y = (float)(j <= n / 2 ? j : j - n);
                float yy = y * y;
                //
                for (int i = 0; i < n / 2 + 1; i++)
                {
                    float xx = i * i;
                    float r_sq = xx + yy;
                    if (r_sq != 0.0f)
                    {
                        float fac = (float)Math.Exp (-r_sq * visc);
                        float xy = i * y;

                        AForge.Math.Complex ux = m_comp_u [i, j];
                        AForge.Math.Complex vx = m_comp_v [i, j];
                        m_comp_u [i, j] = fac * ((1.0f - xx / r_sq) * ux - xy / r_sq * vx);
                        m_comp_v [i, j] = fac * (-xy / r_sq * ux + (1.0f - yy / r_sq) * vx);
                    }
                }
            }

            AForge.Math.FourierTransform.FFT2 (m_comp_u, AForge.Math.FourierTransform.Direction.Backward);
            AForge.Math.FourierTransform.FFT2 (m_comp_v, AForge.Math.FourierTransform.Direction.Backward);

            float nrml = 1.0f;//(n*n);
            for (int j = 0; j < n; j++)
            {
                int jj = j * n;
                for (int i = 0; i < n; i++)
                {
                    wu [i + jj] = (float)(nrml * m_comp_u [i, j].Re) * rsize;
                    wv [i + jj] = (float)(nrml * m_comp_v [i, j].Re) * rsize;
                }
            }

            return;
        }
示例#12
0
        /// <summary>
        /// 捲積(灰階)
        /// </summary>
        /// <param name="SourceA">圖片A</param>
        /// <param name="SourceB">圖片B</param>
        /// <returns>結果圖片</returns>
        static public Bitmap ConvolutionGrayscale(Bitmap SourceA, Bitmap SourceB)
        {
            int OWidth = SourceA.Width, OHeight = SourceA.Height;

            if (SourceB.Width != OWidth || SourceB.Height != OHeight)
            {
                throw new Exception("圖片大小不同");
            }
            SourceA = ImageExtendZero(Grayscale(SourceA));
            SourceB = ImageExtendZero(Grayscale(SourceB));
            int        Width = SourceA.Width, Height = SourceA.Height;
            BitmapData SourceAData = SourceA.LockBits(new Rectangle(0, 0, Width, Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
            BitmapData SourceBData = SourceB.LockBits(new Rectangle(0, 0, Width, Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
            Bitmap     Result      = new Bitmap(Width, Height);
            BitmapData ResultData  = Result.LockBits(new Rectangle(0, 0, Width, Height), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);

            AForge.Math.Complex[,] ComplexDataA      = new AForge.Math.Complex[Height, Width];
            AForge.Math.Complex[,] ComplexDataB      = new AForge.Math.Complex[Height, Width];
            AForge.Math.Complex[,] ComplexDataResult = new AForge.Math.Complex[Height, Width];
            double Scale = Math.Sqrt(Width * Height);
            int    X, Y;
            byte * SourceAPointer = (byte *)SourceAData.Scan0.ToPointer();
            byte * SourceBPointer = (byte *)SourceBData.Scan0.ToPointer();

            for (Y = 0; Y < Height; ++Y)
            {
                for (X = 0; X < Width; ++X)
                {
                    ComplexDataA[Y, X] = new AForge.Math.Complex(SourceAPointer[0], 0);
                    ComplexDataB[Y, X] = new AForge.Math.Complex(SourceBPointer[0], 0);
                    SourceAPointer    += 4;
                    SourceBPointer    += 4;
                }
            }
            AForge.Math.FourierTransform.FFT2(ComplexDataA, AForge.Math.FourierTransform.Direction.Forward);
            AForge.Math.FourierTransform.FFT2(ComplexDataB, AForge.Math.FourierTransform.Direction.Forward);
            for (Y = 0; Y < Height; ++Y)
            {
                for (X = 0; X < Width; ++X)
                {
                    ComplexDataResult[Y, X] = ComplexDataA[Y, X] * ComplexDataB[Y, X];
                }
            }
            AForge.Math.FourierTransform.FFT2(ComplexDataResult, AForge.Math.FourierTransform.Direction.Backward);
            byte *ResultPointer = (byte *)ResultData.Scan0.ToPointer();
            byte  T;

            for (Y = 0; Y < Height; ++Y)
            {
                for (X = 0; X < Width; ++X)
                {
                    T = DoubleToByte(ComplexDataResult[Y, X].Magnitude);
                    ResultPointer[0] = T;
                    ResultPointer[1] = T;
                    ResultPointer[2] = T;
                    ResultPointer[3] = 255;
                    ResultPointer   += 4;
                }
            }
            SourceA.UnlockBits(SourceAData);
            SourceB.UnlockBits(SourceBData);
            Result.UnlockBits(ResultData);
            return(Result);
        }
示例#13
0
        /// <summary>
        /// 上下左右反轉圖片。
        /// </summary>
        /// <param name="Source">來源圖片</param>
        /// <returns>結果圖片</returns>
        static public Bitmap Imagereverse(Bitmap Source)
        {
            int OWidth = Source.Width, OHeight = Source.Height;

            Source = ImageExtendZero(Source);
            int        Width = Source.Width, Height = Source.Height;
            BitmapData SourceData = Source.LockBits(new Rectangle(0, 0, Width, Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
            Bitmap     Result     = new Bitmap(Width, Height);
            BitmapData ResultData = Result.LockBits(new Rectangle(0, 0, Width, Height), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);

            AForge.Math.Complex[,] ComplexDataR = new AForge.Math.Complex[Height, Width];
            AForge.Math.Complex[,] ComplexDataG = new AForge.Math.Complex[Height, Width];
            AForge.Math.Complex[,] ComplexDataB = new AForge.Math.Complex[Height, Width];
            int   X, Y;
            byte *SourcePointer = (byte *)SourceData.Scan0.ToPointer();

            for (Y = 0; Y < Height; ++Y)
            {
                for (X = 0; X < Width; ++X)
                {
                    ComplexDataB[Y, X] = new AForge.Math.Complex(SourcePointer[0], 0);
                    ComplexDataG[Y, X] = new AForge.Math.Complex(SourcePointer[1], 0);
                    ComplexDataR[Y, X] = new AForge.Math.Complex(SourcePointer[2], 0);
                    SourcePointer     += 4;
                }
            }
            BFFTShift(ComplexDataR);
            BFFTShift(ComplexDataG);
            BFFTShift(ComplexDataB);
            AForge.Math.FourierTransform.FFT2(ComplexDataR, AForge.Math.FourierTransform.Direction.Forward);
            AForge.Math.FourierTransform.FFT2(ComplexDataG, AForge.Math.FourierTransform.Direction.Forward);
            AForge.Math.FourierTransform.FFT2(ComplexDataB, AForge.Math.FourierTransform.Direction.Forward);
            for (Y = 0; Y < Height; ++Y)
            {
                for (X = 0; X < Width; ++X)
                {
                    ComplexDataR[Y, X].Im *= -1;
                    ComplexDataG[Y, X].Im *= -1;
                    ComplexDataB[Y, X].Im *= -1;
                }
            }
            AForge.Math.FourierTransform.FFT2(ComplexDataR, AForge.Math.FourierTransform.Direction.Backward);
            AForge.Math.FourierTransform.FFT2(ComplexDataG, AForge.Math.FourierTransform.Direction.Backward);
            AForge.Math.FourierTransform.FFT2(ComplexDataB, AForge.Math.FourierTransform.Direction.Backward);
            BFFTShift(ComplexDataR);
            BFFTShift(ComplexDataG);
            BFFTShift(ComplexDataB);
            byte *ResultPointer = (byte *)ResultData.Scan0.ToPointer();

            for (Y = 0; Y < Height; ++Y)
            {
                for (X = 0; X < Width; ++X)
                {
                    ResultPointer[0] = DoubleToByte(ComplexDataB[Y, X].Magnitude);
                    ResultPointer[1] = DoubleToByte(ComplexDataG[Y, X].Magnitude);
                    ResultPointer[2] = DoubleToByte(ComplexDataR[Y, X].Magnitude);
                    ResultPointer[3] = 255;
                    ResultPointer   += 4;
                }
            }
            Source.UnlockBits(SourceData);
            Result.UnlockBits(ResultData);
            Result = ImageUnExtend(Result, OWidth, OHeight, ImagePosition.RightDown);
            return(Result);
        }
示例#14
0
        public static int Main(string[] args)
        {
            //IList<double> R = getRandomVector(500, 100);
            //Читаем файлик OHLCV
            //string path = "z:\\YandexDisk\\Data\\GAZP_test_1h.txt";
            //TS.DataSource.BarList BarList = new TS.DataSource.BarList(path);

            HsaClassLibrary.Helpers.HhtCreator emdcr = new HsaClassLibrary.Helpers.HhtCreator();
            //EmdClassLibrary.EmdAbstractClass emd = emdcr.FactoryMethod(EmdClassLibrary.InterpolationEnum.ЛинейнаяИнтерполяция, EmdClassLibrary.StopCriterionEnum.КоличествоИтераций, EmdClassLibrary.StopSiftCriterionEnum.КоличествоИтераций);
            //EmdClassLibrary.EmdAbstractClass emd = emdcr.FactoryMethod(EmdClassLibrary.InterpolationEnum.ЛинейнаяИнтерполяция, EmdClassLibrary.StopCriterionEnum.КоличествоИтераций, EmdClassLibrary.StopSiftCriterionEnum.ДостигнутаТочностьОтсеивания);
            HsaClassLibrary.Transform.HilbertSpectrum Hsa = emdcr.HsaFactoryMethod(HsaClassLibrary.Transform.EnumHilbertTransform.HilbertTransform);

            //Выбираем для анализа
            IList<double> R = HsaClassLibrary.Helpers.MathHelper.getCos(256, 1, 2.0 * Math.PI / 32.0);
            //IList<double> R = HsaClassLibrary.Helpers.MathHelper.getCosAM(256, 1, 2.0 * Math.PI / 32.0, 2.0 * Math.PI / 256.0);
            //Данные для вывода в файл
            IList<IList<double>> data = new List<IList<double>>();
            data.Add(R);
            Hsa.Source = R;

            //1 ft
            double[] FT1r = new double[R.Count];
            double[] FT1i = new double[R.Count];

            AForge.Math.Complex[] FT1f = new AForge.Math.Complex[R.Count];
            for (int i = 0; i < R.Count; i++)
            {
                FT1f[i].Re = R[i];
                FT1f[i].Im = 0;
            }
            AForge.Math.FourierTransform.DFT(FT1f, AForge.Math.FourierTransform.Direction.Forward);
            for (int i = 0; i < R.Count; i++)
            {
                FT1r[i] = FT1f[i].Re;
                FT1i[i] = FT1f[i].Im;
            }
            data.Add(FT1r);
            data.Add(FT1i);
            //2 ft
            double[] FT2r = new double[R.Count];
            double[] FT2i = new double[R.Count];

            AForge.Math.Complex[] FT2f = new AForge.Math.Complex[R.Count];
            for (int i = 0; i < R.Count; i++)
            {
                FT2f[i].Re = R[i];
                FT2f[i].Im = 0;
            }
            AForge.Math.FourierTransform.DFT(FT2f, AForge.Math.FourierTransform.Direction.Backward);
            for (int i = 0; i < R.Count; i++)
            {
                FT2r[i] = FT2f[i].Re;
                FT2i[i] = FT2f[i].Im;
            }
            data.Add(FT2r);
            data.Add(FT2i);

            //3 ft
            double[] FT3r = new double[R.Count];
            double[] FT3i = new double[R.Count];

            AForge.Math.Complex[] FT3f = new AForge.Math.Complex[R.Count];
            for (int i = 0; i < R.Count; i++)
            {
                FT3f[i].Re = R[i];
                FT3f[i].Im = 0;
            }
            AForge.Math.FourierTransform.FFT(FT3f, AForge.Math.FourierTransform.Direction.Forward);
            for (int i = 0; i < R.Count; i++)
            {
                FT3r[i] = FT3f[i].Re;
                FT3i[i] = FT3f[i].Im;
            }
            data.Add(FT1r);
            data.Add(FT1i);

            //4 ft
            double[] FT4r = new double[R.Count];
            double[] FT4i = new double[R.Count];

            AForge.Math.Complex[] FT4f = new AForge.Math.Complex[R.Count];
            for (int i = 0; i < R.Count; i++)
            {
                FT4f[i].Re = R[i];
                FT4f[i].Im = 0;
            }
            AForge.Math.FourierTransform.FFT(FT4f, AForge.Math.FourierTransform.Direction.Backward);
            for (int i = 0; i < R.Count; i++)
            {
                FT4r[i] = FT4f[i].Re;
                FT4i[i] = FT4f[i].Im;
            }
            data.Add(FT4r);
            data.Add(FT4i);

            //5
            double[] FT5r = new double[R.Count];
            double[] FT5i = new double[R.Count];

            double[] FT5 = new double[R.Count];
            R.CopyTo(FT5, 0);

            alglib.complex[] FT5f;
            alglib.fftr1d(FT5, out FT5f);
            for (int i = 0; i < R.Count; i++)
            {
                FT5r[i] = FT5f[i].x;
                FT5i[i] = FT5f[i].y;
            }
            data.Add(FT5r);
            data.Add(FT5i);

            //6
            double[] FT6f = new double[R.Count];

            alglib.complex[] FT6 = new alglib.complex[R.Count];
            for (int i = 0; i < R.Count; i++)
            {
                FT6[i].x = R[i];
                FT6[i].y = 0;
            }

            alglib.fftr1dinv(FT6, out FT6f);
            data.Add(FT6f);

            //7
            /*
            double[] FT7r = new double[R.Count];
            double[] FT7i = new double[R.Count];

            List<double> FT7 = new List<double>(R);
            List<Complex> FT7f;
            FT7f = HsaClassLibrary.Transform.FourierTransform.ft(FT7);
            for (int i = 0; i < R.Count; i++)
            {
                FT7r[i] = FT7f[i].Real;
                FT7i[i] = FT7f[i].Imaginary;
            }
            data.Add(FT7r);
            data.Add(FT7i);

            data.Add(R);
             */
            //8
            List<double> FT8 = new List<double>(R);
            List<Complex> FT8f;

            FT8f = HsaClassLibrary.Transform.FourierTransform.fft(FT8).ToList();

            IList<double> FT8r = new double[R.Count];
            IList<double> FT8i = new double[R.Count];
            HsaClassLibrary.Transform.TransformHelper.convert(FT8f, out FT8r, out FT8i);
            data.Add(FT8r);
            data.Add(FT8i);

            //9
            /*
            double[] FT9r = new double[R.Count];
            double[] FT9i = new double[R.Count];

            List<Complex> FT9 = new List<Complex>(R.Count);
            for (int i = 0; i < R.Count; i++)
            {
                FT9.Add(new Complex(R[i],0));
            }
            List<Complex> FT9f;

            FT9f = HsaClassLibrary.Transform.FourierTransform.ifft(FT9);
            for (int i = 0; i < R.Count; i++)
            {
                FT9r[i] = FT9f[i].Real;
                FT9i[i] = FT9f[i].Imaginary;
            }
            data.Add(FT9r);
            data.Add(FT9i);
            */
            //10
            List<Complex> FT10 = new List<Complex>(R.Count);
            for (int i = 0; i < R.Count; i++)
            {
                FT10.Add(new Complex(R[i], 0));
            }

            IList<Complex> FT10f;
            FT10f = HsaClassLibrary.Transform.FourierTransform.ifft(FT10);

            IList<double> FT10r = new double[R.Count];
            IList<double> FT10i = new double[R.Count];
            HsaClassLibrary.Transform.TransformHelper.convert(FT10f, out FT10r, out FT10i);
            data.Add(FT10r);
            data.Add(FT10i);

            //AForge.Math.FourierTransform.FFT

            //System.Console.WriteLine("FourierTransform.FFT выполнена.");
            //System.Console.WriteLine("Console.ReadKey();");
            //Console.ReadKey();
            HsaClassLibrary.Helpers.ReadWriteHelper emdWriter = new HsaClassLibrary.Helpers.ReadWriteHelper();
            emdWriter.WriteCSV(data, "D:\\hsa8.csv");
            System.Console.WriteLine("Файл csv создан.\nD:\\hsa8.csv");
            //System.Console.WriteLine("Console.ReadKey();");
            Console.ReadKey();
            return 0;
        }
示例#15
0
        /// <summary>
        /// Compute the FFT and raise an event containing the result.
        /// </summary>
        /// <param name="audioBuffer">Byte buffer containing the raw audio</param>
        /// <param name="readCount">Number of frames contained in the buffer.</param>
        /// <returns>Returns the intensity of each frequency in a float array</returns>
        public float[] getFFT(byte[] audioBuffer, int readCount)
        {
            const float Decay = 0.5f;

            for (int i = 0; i < readCount; i += 2)
            {
                short audioSample = BitConverter.ToInt16(audioBuffer, i);

                float audioSampleFloat = Invert * audioSample;

                try
                {
                    _AudioInputForFFT[this.accumulatedSampleCountfft++] = audioSampleFloat;
                }
                catch (Exception) { }

                if (this.accumulatedSampleCountfft < wBinsForFFT)
                {
                    continue;
                }

                //At this point we have enough samples to do our FFT
                for (int iSample = 0; iSample < wBinsForFFT; ++iSample)
                {
                    _BinsFFTReal[iSample] = _AudioInputForFFT[iSample] * _Window[iSample];
                }

                AForge.Math.Complex[] complexData = new AForge.Math.Complex[_AudioInputForFFT.Length];
                for (int j = 0; j < _BinsFFTReal.Length; ++j)
                {
                    complexData[j].Re = _BinsFFTReal[j];
                }
                for (int j = 0; j < _BinsFFTImaginary.Length; ++j)
                {
                    complexData[j].Im = _BinsFFTImaginary[j];
                }

                AForge.Math.FourierTransform.FFT(complexData, AForge.Math.FourierTransform.Direction.Forward);

                for (int iBin = 0; iBin < wBinsForFFT / 2; ++iBin)
                {
                    float imaginary = (float)complexData[iBin].Im;
                    float real      = (float)complexData[iBin].Re;

                    float magnitude = (float)Math.Sqrt(imaginary * imaginary + real * real);

                    //This next operation will smooth out the results a little and prevent the display from jumping around wildly.
                    //You can play with this by changing the "Decay" parameter above.
                    float decayedOldValue = _BinsFFTDisplay[iBin] * Decay;
                    _BinsFFTDisplay[iBin] = Math.Max(magnitude, decayedOldValue);
                    //If no smoothing required:
                    //_BinsFFTDisplay[iBin] = magnitude;
                }
                if (FFTEvent != null && !MainWindow.main.audioProvider.replayMode)
                {
                    FFTEvent(this, new FFTEventArgs(_BinsFFTDisplay));
                }
                // We're all done with our FFT so we'll clean up and get ready for next time.
                this.accumulatedSampleCountfft = 0;

                initBuff();
            }
            this.fftTime.Add((float[])_BinsFFTDisplay.Clone());
            if (fftTime.Count > Length)
            {
                fftTime.RemoveAt(0);
            }
            return(_BinsFFTDisplay);
        }
示例#16
0
        public void button1_Click(object sender, EventArgs e)
        {
            var header = new DataStruct.WavHeader();

            // Размер заголовка
            var headerSize = Marshal.SizeOf(header);
            var fileStream = new FileStream(WAVLink, FileMode.Open, FileAccess.Read);
            var buffer     = new byte[headerSize];


            fileStream.Read(buffer, 0, headerSize);
            var headerPtr = Marshal.AllocHGlobal(headerSize); // Чтобы не считывать каждое значение заголовка по отдельности, воспользуемся выделением unmanaged блока памяти

            Marshal.Copy(buffer, 0, headerPtr, headerSize);   // Копируем считанные байты из файла в выделенный блок памяти
            Marshal.PtrToStructure(headerPtr, header);        // Преобразовываем указатель на блок памяти к нашей структуре

            var dataRange = header.ChunkSize / header.BlockAlign;
            var koef      = 1; // костыль, по идее не нужен. используется чтобы сократить массив комплексных чисел на К, изменить масштабы и всю отрисовку

            AForge.Math.Complex[] complexData = new AForge.Math.Complex[dataRange / koef];

            int[,] data; // данные файла [номер канала, значение]

            data   = new int[header.NumChannels, dataRange];
            buffer = new byte[header.Subchunk2Size];
            fileStream.Read(buffer, 0, (int)header.Subchunk2Size);

            for (int i = 5; i < header.Subchunk2Size / header.BlockAlign; i++) // по количеству блоков - должно быть по семплам
            {
                switch (header.BlockAlign / header.NumChannels)                // определяем битность - длина блока на количество каналов
                {
                case 1:                                                        // 8 бит
                    for (int y = 0; y < header.NumChannels; y++)
                    {
                        data[y, i] = buffer[i];
                    }
                    break;

                case 2:     // 16 бит
                    for (int y = 0; y < header.NumChannels; y++)
                    {
                        data[y, i] = BitConverter.ToInt16(buffer, header.BlockAlign * i);
                    }
                    break;

                case 3:     // 24 бит
                    for (int y = 0; y < header.NumChannels; y++)
                    {
                        data[y, i] = BitConverter.ToInt32(buffer, header.BlockAlign * i);
                    }
                    break;

                case 4:     // 32 бит
                    for (int y = 0; y < header.NumChannels; y++)
                    {
                        data[y, i] = BitConverter.ToInt32(buffer, header.BlockAlign * i);
                    }
                    break;
                }
            }

            // чистим графики
            chart1.Series[0].Points.Clear();
            chart2.ChartAreas[0].AxisY.IsLogarithmic = true;
            chart2.Series[0].Points.Clear();

            // строим график
            for (int i = 0; i < 1000; i++)
            {
                chart1.Series[0].Points.AddXY(i, data[0, i]);
            }

            for (int i = 0; i < dataRange / 2 / koef; i++)
            {
                complexData[i] = (AForge.Math.Complex)data[0, i];
            }


            var nSize = 16384;

            var numArr = (header.ChunkSize / header.BlockAlign) / nSize;

            AForge.Math.Complex[,] newComplex = new AForge.Math.Complex[numArr, nSize];
            AForge.Math.Complex[] tempComplex = new AForge.Math.Complex[nSize];

            List <AForge.Math.Complex> finalComplex = new List <AForge.Math.Complex>();

            for (int i = 0; i < numArr; i++)
            {
                for (int j = 0; j < nSize; j++)
                {
                    newComplex[i, j] = complexData[j + i * nSize]; // тут записываем одномерный массив в двумерный
                }
            }

            for (int i = 0; i < numArr; i++)
            {
                switch (comboBox1.SelectedItem)
                {
                case "None":

                    for (int k = 0; k < nSize; k++)
                    {
                        tempComplex[k] = newComplex[i, k];     // тут по строкам забираем данные чтобы потом их в fft
                    }
                    ;
                    break;

                case "Hann":

                    for (int k = 0; k < nSize; k++)
                    {
                        tempComplex[k] = newComplex[i, k] * (0.5 - 0.5 * Math.Cos((2 * Math.PI * k) / (nSize - 1)));
                    }
                    ;
                    break;

                case "Rectangular":
                    for (int k = 0; k < nSize; k++)
                    {
                        tempComplex[k] = newComplex[i, k] * 1;     // тут по строкам забираем данные чтобы потом их в fft и попутно умножаем на окно
                    }
                    ;
                    break;

                case "Hamming":
                    for (int k = 0; k < nSize; k++)
                    {
                        tempComplex[k] = newComplex[i, k] * (0.54 - 0.46 * Math.Cos((2 * Math.PI * k) / (nSize - 1)));
                    }
                    ;
                    break;

                case "Blackmann":
                    for (int k = 0; k < nSize; k++)
                    {
                        tempComplex[k] = newComplex[i, k] * (0.42 - 0.5 * Math.Cos((2 * Math.PI * k) / (nSize - 1)) + 0.08 * Math.Cos((4 * Math.PI * k) / (nSize - 1)));
                    }
                    break;

                case "Barlett":
                    for (int k = 0; k < nSize; k++)
                    {
                        tempComplex[k] = newComplex[i, k] * (nSize - 2 * Math.Abs(k - (nSize / 2))) / nSize;
                    }
                    break;

                case "Blackmann-Harris":
                    for (int k = 0; k < nSize; k++)
                    {
                        tempComplex[k] = newComplex[i, k] * (0.35875 - 0.48829 * Math.Cos((2 * Math.PI * k) / (nSize - 1)) + 0.14128 * Math.Cos((4 * Math.PI * k) / (nSize - 1)) - 0.01168 * Math.Cos((6 * Math.PI * k) / (nSize - 1)));
                    }
                    break;

                case "Natall":
                    for (int k = 0; k < nSize; k++)
                    {
                        tempComplex[k] = newComplex[i, k] * (0.355768 - 0.487396 * Math.Cos((2 * Math.PI * k) / (nSize - 1)) + 0.144232 * Math.Cos((4 * Math.PI * k) / (nSize - 1)) - 0.012604 * Math.Cos((6 * Math.PI * k) / (nSize - 1)));
                    }
                    break;

                case "Gauss 0.1":
                    for (int k = 0; k < nSize; k++)
                    {
                        tempComplex[k] = newComplex[i, k] * Math.Exp(-(2 * Math.Pow(k - ((nSize - 1) / 2), 2)) / (Math.Pow(nSize * 0.1, 2)));
                    }
                    break;

                case "Flat peak":
                    for (int k = 0; k < nSize; k++)
                    {
                        tempComplex[k] = newComplex[i, k] * (1 - 1.93 * Math.Cos((2 * Math.PI * k) / (nSize - 1)) + 1.29 * Math.Cos((4 * Math.PI * k) / (nSize - 1)) - 0.388 * Math.Cos((6 * Math.PI * k) / (nSize - 1)) + 0.032 * Math.Cos((8 * Math.PI * k) / (nSize - 1)));
                    }
                    break;
                }

                AForge.Math.FourierTransform.FFT(tempComplex, AForge.Math.FourierTransform.Direction.Forward); // fft

                for (int j = 0; j < nSize; j++)
                {
                    finalComplex.Add(tempComplex[j]); // добавляем результат fft в одномерный финальный массив
                }
            }


            for (int i = 0; i < finalComplex.Count / (2 * numArr); i++)
            {
                chart2.Series[0].Points.AddXY(i * header.SampleRate / nSize, finalComplex[i].Magnitude);
            }

            label7.Text = Convert.ToString("SampleRate: " + header.SampleRate + " Elements: " + header.ChunkSize / header.BlockAlign + " numArr: " + numArr + " window: " + comboBox1.SelectedItem);

            fileStream.Close();
        }
示例#17
0
        /// <summary>
        /// 頻域相位圖片顯示。
        /// </summary>
        /// <param name="Source">來源圖片</param>
        /// <returns>結果圖片</returns>
        static public Bitmap Phasedisplay(Bitmap Source)
        {
            int OWidth = Source.Width, OHeight = Source.Height;

            Source = ImageExtendZero(Source);
            int        Width = Source.Width, Height = Source.Height;
            double     Scale      = Math.Sqrt(Width * Height);
            BitmapData SourceData = Source.LockBits(new Rectangle(0, 0, Width, Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
            Bitmap     Result     = new Bitmap(Width, Height);
            BitmapData ResultData = Result.LockBits(new Rectangle(0, 0, Width, Height), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);

            AForge.Math.Complex[,] ComplexDataR = new AForge.Math.Complex[Height, Width];
            AForge.Math.Complex[,] ComplexDataG = new AForge.Math.Complex[Height, Width];
            AForge.Math.Complex[,] ComplexDataB = new AForge.Math.Complex[Height, Width];
            int   X, Y;
            byte *SourcePointer = (byte *)SourceData.Scan0.ToPointer();

            for (Y = 0; Y < Height; ++Y)
            {
                for (X = 0; X < Width; ++X)
                {
                    ComplexDataB[Y, X] = new AForge.Math.Complex(SourcePointer[0], 0);
                    ComplexDataG[Y, X] = new AForge.Math.Complex(SourcePointer[1], 0);
                    ComplexDataR[Y, X] = new AForge.Math.Complex(SourcePointer[2], 0);
                    SourcePointer     += 4;
                }
            }
            BFFTShift(ComplexDataR);
            BFFTShift(ComplexDataG);
            BFFTShift(ComplexDataB);
            AForge.Math.FourierTransform.FFT2(ComplexDataR, AForge.Math.FourierTransform.Direction.Forward);
            AForge.Math.FourierTransform.FFT2(ComplexDataG, AForge.Math.FourierTransform.Direction.Forward);
            AForge.Math.FourierTransform.FFT2(ComplexDataB, AForge.Math.FourierTransform.Direction.Forward);

            /*
             * double MaxR = 0;
             * double MaxG = 0;
             * double MaxB = 0;
             * for( Y = 0 ; Y < Height ; ++Y ) {
             *  for( X = 0 ; X < Width ; ++X ) {
             *      MaxR = MaxR < ComplexDataR[ Y, X ].Phase ? ComplexDataR[ Y, X ].Phase : MaxR;
             *      MaxG = MaxG < ComplexDataG[ Y, X ].Phase ? ComplexDataG[ Y, X ].Phase : MaxG;
             *      MaxB = MaxB < ComplexDataB[ Y, X ].Phase ? ComplexDataB[ Y, X ].Phase : MaxB;
             *  }
             * }
             * MaxB = 255D / ( Math.Log10( MaxB + 1 ) );
             * MaxG = 255D / ( Math.Log10( MaxG + 1 ) );
             * MaxR = 255D / ( Math.Log10( MaxR + 1 ) );
             */
            byte *ResultPointer = (byte *)ResultData.Scan0.ToPointer();

            for (Y = 0; Y < Height; ++Y)
            {
                for (X = 0; X < Width; ++X)
                {
                    /*
                     * ResultPointer[ 0 ] = DoubleToByte( ( Math.Log10( ComplexDataB[ Y, X ].Phase + 1 ) ) * MaxB );
                     * ResultPointer[ 1 ] = DoubleToByte( ( Math.Log10( ComplexDataG[ Y, X ].Phase + 1 ) ) * MaxG );
                     * ResultPointer[ 2 ] = DoubleToByte( ( Math.Log10( ComplexDataR[ Y, X ].Phase + 1 ) ) * MaxR );
                     */
                    ResultPointer[0] = DoubleToByte(ComplexDataB[Y, X].Phase * Scale);
                    ResultPointer[1] = DoubleToByte(ComplexDataG[Y, X].Phase * Scale);
                    ResultPointer[2] = DoubleToByte(ComplexDataR[Y, X].Phase * Scale);
                    ResultPointer[3] = 255;
                    ResultPointer   += 4;
                }
            }
            Source.UnlockBits(SourceData);
            Result.UnlockBits(ResultData);
            return(Result);
        }
示例#18
0
        public static int Main(string[] args)
        {
            //IList<double> R = getRandomVector(500, 100);
            //Читаем файлик OHLCV
            //string path = "z:\\YandexDisk\\Data\\GAZP_test_1h.txt";
            //TS.DataSource.BarList BarList = new TS.DataSource.BarList(path);

            HsaClassLibrary.Helpers.HhtCreator emdcr = new HsaClassLibrary.Helpers.HhtCreator();
            //EmdClassLibrary.EmdAbstractClass emd = emdcr.FactoryMethod(EmdClassLibrary.InterpolationEnum.ЛинейнаяИнтерполяция, EmdClassLibrary.StopCriterionEnum.КоличествоИтераций, EmdClassLibrary.StopSiftCriterionEnum.КоличествоИтераций);
            //EmdClassLibrary.EmdAbstractClass emd = emdcr.FactoryMethod(EmdClassLibrary.InterpolationEnum.ЛинейнаяИнтерполяция, EmdClassLibrary.StopCriterionEnum.КоличествоИтераций, EmdClassLibrary.StopSiftCriterionEnum.ДостигнутаТочностьОтсеивания);
            HsaClassLibrary.Transform.HilbertSpectrum Hsa = emdcr.HsaFactoryMethod(HsaClassLibrary.Transform.EnumHilbertTransform.HilbertTransform);

            //Выбираем для анализа
            //IList<double> R = HsaClassLibrary.Helpers.MathHelper.getCosAM(256, 1, 2.0 * Math.PI / 32.0, 2.0 * Math.PI / 256.0);
            //y <- sin(2*pi*n*Tn/(T*N))
            IList<double> R = HsaClassLibrary.Helpers.MathHelper.getSin(256, 1, 2.0 * Math.PI / 256.0);

            //Данные для вывода в файл
            IList<IList<double>> data = new List<IList<double>>();
            data.Add(R);
            Hsa.Source = R;
            /*
            //заменяем коэффичиента преобразования
            //Hsa.HilbertTransform = new EmdClassLibrary.HilbertTransform1();
            Hsa.HS(true, false, false, false);
            //сохраняем для вывода
            data.Add(Hsa.Xi);
            //Hsa.Data = Hsa.Xi;
            //Hsa.HS(true, false, false, false);
            //data.Add(Hsa.Xi);

            //заменяем коэффичиента преобразования
            Hsa.HilbertTransform = new EmdClassLibrary.Transform.HilbertTransform1();
            Hsa.HS(true, false, false, false);
            //сохраняем для вывода
            data.Add(Hsa.Xi);

            //заменяем коэффичиента преобразования
            Hsa.HilbertTransform = new EmdClassLibrary.Transform.HilbertTransform2();
            Hsa.HS(true, false, false, false);
            //сохраняем для вывода
            data.Add(Hsa.Xi);

            //заменяем коэффичиента преобразования
            Hsa.HilbertTransform = new EmdClassLibrary.Transform.HilbertTransform3();
            Hsa.HS(true, false, false, false);
            //сохраняем для вывода
            data.Add(Hsa.Xi);

            //заменяем коэффичиента преобразования
            Hsa.HilbertTransform = new EmdClassLibrary.Transform.HilbertTransform4();
            Hsa.HS(true, false, false, false);
            //сохраняем для вывода
            data.Add(Hsa.Xi);

            //заменяем коэффичиента преобразования
            Hsa.HilbertTransform = new EmdClassLibrary.Transform.HilbertTransform5();
            Hsa.HS(true, false, false, false);
            //сохраняем для вывода
            data.Add(Hsa.Xi);
            /*
            //заменяем коэффичиента преобразования
            Hsa.HilbertTransform = new EmdClassLibrary.Transform.HilbertTransform6();
            Hsa.HS(true, false, false, false);
            //сохраняем для вывода
            data.Add(Hsa.Xi);

            //заменяем коэффичиента преобразования
            Hsa.HilbertTransform = new EmdClassLibrary.Transform.HilbertTransform7();
            Hsa.HS(true, false, false, false);
            //сохраняем для вывода
            data.Add(Hsa.Xi);
            */

            //0
            double[] HT0 = new double[R.Count];
            R.CopyTo(HT0, 0);

            Accord.Math.HilbertTransform.FHT(HT0, AForge.Math.FourierTransform.Direction.Forward);
            data.Add(HT0);

            //1
            //double[] dHT = new double[R.Count];
            double[] HT1 = new double[R.Count];
            R.CopyTo(HT1, 0);

            Accord.Math.HilbertTransform.FHT2(HT1, AForge.Math.FourierTransform.Direction.Forward);
            data.Add(HT1);

            // 2
            // Правильно но странно
            // инвертирован вызов преобразований фурье
            double[] HT2r = new double[R.Count];
            double[] HT2i = new double[R.Count];

            AForge.Math.Complex[] HT2 = new AForge.Math.Complex[R.Count];
            for (int i = 0; i < R.Count; i++)
            {
                HT2[i].Re = R[i];
                HT2[i].Im = 0;
            }
            Accord.Math.HilbertTransform.FHT(HT2, AForge.Math.FourierTransform.Direction.Forward);

            for (int i = 0; i < R.Count; i++)
            {
                HT2r[i] = HT2[i].Re;
                HT2i[i] = HT2[i].Im;
            }
            data.Add(HT2r);
            data.Add(HT2i);

            //3
            /*
            ///  QW модифицировал Accord.Math.HilbertTransform.FHT2
            ///  неправильно - инвертирован знак мнимой части
            double[] HT3r = new double[R.Count];
            double[] HT3i = new double[R.Count];

            //AForge.Math.Complex[] cHT = new AForge.Math.Complex[R.Count];
            AForge.Math.Complex[] HT3 = new AForge.Math.Complex[R.Count];
            for (int i = 0; i < R.Count; i++)
            {
                HT3[i].Re = R[i];
                HT3[i].Im = 0;
            }
            Accord.Math.HilbertTransform.FHT2(HT3, AForge.Math.FourierTransform.Direction.Forward);

            //double[] HTr = new double[R.Count];
            //double[] HTi = new double[R.Count];
            HT3r = new double[R.Count];
            HT3i = new double[R.Count];
            for (int i = 0; i < R.Count; i++)
            {
                HT3r[i] = HT3[i].Re;
                HT3i[i] = HT3[i].Im;
            }
            data.Add(HT3r);
            data.Add(HT3i);
            */
            //4 не совсем Правильно - постоянная
            double[] X4 = new double[R.Count];
            IList<double> HT4r = new double[R.Count];
            IList<double> HT4i = new double[R.Count];
            R.CopyTo(X4, 0);

            //HsaClassLibrary.Transform.HilbertTransformFFT FHT = new HsaClassLibrary.Transform.HilbertTransformFFT();
            //HT4i = FHT.(X4, out HT4r);
            HsaClassLibrary.Transform.HilbertTransform.HTFFT_alglib(X4, out HT4r, out HT4i);
            //сохраняем для вывода
            data.Add(HT4r);
            data.Add(HT4i);

            //--
            //4 Правильно
            double[] X5 = new double[R.Count];
            IList<double> HT5r = new double[R.Count];
            IList<double> HT5i = new double[R.Count];
            R.CopyTo(X5, 0);

            IList<Complex> HT5 = HsaClassLibrary.Transform.HilbertTransform.HTFFT(X5);
            HsaClassLibrary.Transform.TransformHelper.convert(HT5, out HT5r, out HT5i);
            //сохраняем для вывода
            data.Add(HT5r);
            data.Add(HT5i);
            //--

            //--
            //4 Правильно
            double[] X6 = new double[R.Count];
            IList<double> HT6r = new double[R.Count];
            IList<double> HT6i = new double[R.Count];
            R.CopyTo(X6, 0);

            IList<Complex> HT6 = HsaClassLibrary.Transform.HilbertTransform.HTFFT_alglib(X6);
            HsaClassLibrary.Transform.TransformHelper.convert(HT6, out HT6r, out HT6i);
            //сохраняем для вывода
            data.Add(HT6r);
            data.Add(HT6i);
            //--

            System.Console.WriteLine("HilbertTransform выполнена.");
            System.Console.WriteLine("Console.ReadKey();");
            Console.ReadKey();
            HsaClassLibrary.Helpers.ReadWriteHelper emdWriter = new HsaClassLibrary.Helpers.ReadWriteHelper();
            emdWriter.WriteCSV(data, "D:\\hsa7.csv");
            System.Console.WriteLine("Файл csv создан.\nD:\\hsa7.csv");
            System.Console.WriteLine("Console.ReadKey();");
            Console.ReadKey();
            return 0;
        }
示例#19
0
        /// <summary>
        /// 高斯高低通濾波。
        /// </summary>
        /// <param name="Source">來源圖片</param>
        /// <param name="D0">截止頻率</param>
        /// <param name="GP">選擇高通或是低通</param>
        /// <returns>結果圖片</returns>
        static public Bitmap Gaussianpass(Bitmap Source, double D0, GaussianPass GP, BinaryImage BI)
        {
            int OWidth = Source.Width, OHeight = Source.Height;

            Source = ImageExtendZero(Source);
            int        Width = Source.Width, Height = Source.Height;
            BitmapData SourceData = Source.LockBits(new Rectangle(0, 0, Width, Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
            Bitmap     Result     = new Bitmap(Width, Height);
            BitmapData ResultData = Result.LockBits(new Rectangle(0, 0, Width, Height), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);

            AForge.Math.Complex[,] ComplexDataR = new AForge.Math.Complex[Height, Width];
            AForge.Math.Complex[,] ComplexDataG = new AForge.Math.Complex[Height, Width];
            AForge.Math.Complex[,] ComplexDataB = new AForge.Math.Complex[Height, Width];
            int    X, Y;
            double D, F;

            unsafe
            {
                byte *SourcePointer = (byte *)SourceData.Scan0.ToPointer();
                for (Y = 0; Y < Height; ++Y)
                {
                    for (X = 0; X < Width; ++X)
                    {
                        ComplexDataB[Y, X] = new AForge.Math.Complex(SourcePointer[0], 0);
                        ComplexDataG[Y, X] = new AForge.Math.Complex(SourcePointer[1], 0);
                        ComplexDataR[Y, X] = new AForge.Math.Complex(SourcePointer[2], 0);
                        SourcePointer     += 4;
                    }
                }
                BFFTShift(ComplexDataR);
                BFFTShift(ComplexDataG);
                BFFTShift(ComplexDataB);
                AForge.Math.FourierTransform.FFT2(ComplexDataR, AForge.Math.FourierTransform.Direction.Forward);
                AForge.Math.FourierTransform.FFT2(ComplexDataG, AForge.Math.FourierTransform.Direction.Forward);
                AForge.Math.FourierTransform.FFT2(ComplexDataB, AForge.Math.FourierTransform.Direction.Forward);
                for (Y = 0; Y < Height; ++Y)
                {
                    for (X = 0; X < Width; ++X)
                    {
                        D = Math.Pow((Y - (Height / 2)), 2) + Math.Pow((X - (Width / 2)), 2);
                        F = Math.Exp(-1 * D / (D0 * D0));
                        if (GP == GaussianPass.High)
                        {
                            F = 1 - F;
                        }
                        ComplexDataR[Y, X] *= F;
                        ComplexDataG[Y, X] *= F;
                        ComplexDataB[Y, X] *= F;
                    }
                }
                AForge.Math.FourierTransform.FFT2(ComplexDataR, AForge.Math.FourierTransform.Direction.Backward);
                AForge.Math.FourierTransform.FFT2(ComplexDataG, AForge.Math.FourierTransform.Direction.Backward);
                AForge.Math.FourierTransform.FFT2(ComplexDataB, AForge.Math.FourierTransform.Direction.Backward);
                BFFTShift(ComplexDataR);
                BFFTShift(ComplexDataG);
                BFFTShift(ComplexDataB);
                byte *ResultPointer = (byte *)ResultData.Scan0.ToPointer();
                for (Y = 0; Y < Height; ++Y)
                {
                    for (X = 0; X < Width; ++X)
                    {
                        if (BI != BinaryImage.False)
                        {
                            int B = (int)BI;
                            ComplexDataB[Y, X].Re = ComplexDataB[Y, X].Re <= B ? 0 : 255;
                            ComplexDataG[Y, X].Re = ComplexDataG[Y, X].Re <= B ? 0 : 255;
                            ComplexDataR[Y, X].Re = ComplexDataR[Y, X].Re <= B ? 0 : 255;
                        }
                        ResultPointer[0] = DoubleToByte(ComplexDataB[Y, X].Magnitude);
                        ResultPointer[1] = DoubleToByte(ComplexDataG[Y, X].Magnitude);
                        ResultPointer[2] = DoubleToByte(ComplexDataR[Y, X].Magnitude);
                        ResultPointer[3] = 255;
                        ResultPointer   += 4;
                    }
                }
            }
            Source.UnlockBits(SourceData);
            Result.UnlockBits(ResultData);
            Result = ImageUnExtend(Result, OWidth, OHeight, ImagePosition.LeftTop);
            return(Result);
        }