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); }
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); }
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); }
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)); }
/** * Add a data point to the storage bin */ public void Add(AForge.Math.Complex d) { lock (data0) { data0.Add(d); } }
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; }
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; }
/// <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); }
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")); }
//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; }
/// <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); }
/// <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); }
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; }
/// <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); }
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(); }
/// <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); }
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; }
/// <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); }