change.cs

编辑点属性,地理信息系统开发学习使用, 学习

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;



namespace photo
{

    public struct Complex
    {
        public double real;
        public double imaginary;

        public Complex(double real, double imaginary)  //constructor
        {
            this.real = real;
            this.imaginary = imaginary;
        }

        public static Complex operator +(Complex c1, Complex c2)
        {
            return new Complex(c1.real + c2.real, c1.imaginary + c2.imaginary);
        }
        public static Complex operator -(Complex c1, Complex c2)
        {
            return new Complex(c1.real - c2.real, c1.imaginary - c2.imaginary);
        }
        public static Complex operator *(Complex c1, Complex c2)
        {
            return new Complex(c1.real * c2.real - c1.imaginary * c2.imaginary, c1.real * c2.imaginary - c2.real * c1.imaginary);
        }
    }



    public partial class change : Form
    {
        Form1 form;
        public change()
        {
            InitializeComponent();
        }
        public change(Form1 pform)
        {

            form = pform;

            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            fuliyechange();
        }

        private void fuliyechange()
        {
            Bitmap bitmap = new Bitmap(form.PictureBox.Image);
            //原图像宽度和高度
            int lWidth = bitmap.Width;
            int lHeight = bitmap.Height;

            int w = 1;
            int h = 1;
            int wp = 0;
            int hp = 0;

            //计算进行傅立叶变换的高度和宽度（2的整数次方）
            while (w * 2 <= lWidth)
            {
                w *= 2;
                wp++;
            }
            while (h * 2 <= lHeight)
            {
                h *= 2;
                hp++;
            }
            Complex[,] TD = new Complex[w, h];
            Complex[,] FD = new Complex[w, h];

            for (int i = 0; i < h; i++)
            {
                for (int j = 0; j < w; j++)
                {
                    Color c = bitmap.GetPixel(i, j);
                    int grayscales = (c.R + c.G + c.B) / 3;
                    //给时域赋值
                    TD[i, j] = new Complex(grayscales, 0);
                }
            }


            for (int i = 0; i < h; i++)
            {//对y方向进行快速傅立叶变换,wp 为迭代次数
                FFT(&TD[i, 0], &FD[i, 0], wp);
            }



            //保存变换结果
            // for (int i = 0; i < h; i++)
            //{
            //    for (int j = 0; j < w; j++)
            //    {

            //        TD[i +h * j] =FD[j + w * i];
            //    }
            //}


            //  对x方向进行快速傅立叶变换,hp 为迭代次数

            // for (int i = 0; i < w; i++)
            //{
            //    FFT(&TD[i * h], &FD[i * h], hp);
            //}








            // throw new Exception("The method or operation is not implemented.");
        }



            private  void FFT(Complex* complex, Complex* complex_2, int wp)
            { //傅立叶变换点数
                int count = 1 << wp;
                int i, j, k;
                int bfsize, p;

                //角度
                double angle;

                Complex[] W = new Complex[count / 2];
                Complex[] X1 = new Complex[count];
                Complex[] X2 = new Complex[count];


                //计算W
                for (i = 0; i < count / 2; i++)
                {
                    angle = -i * Math.PI * 2 / count;
                    W[i] = new Complex(Math.Cos(angle), Math.Sin(angle));
                }
                //将时域点写入X1
                X1 = complex;
                  //采用蝶形算法进行快速傅立叶变换
                for (k = 0; k < wp; k++)
                {
                    for (j = 0; j < 1 << wp; j++)
                    {
                        bfsize = 1 << (wp - k);
                        for (i = 0; i < bfsize / 2; i++)
                        {
                            p = j * bfsize;
                            X2[i + p] = X1[i + p] + X1[i + p + bfsize / 2];
                            X2[i + p + bfsize / 2] = (X1[i + p] - X1[i + p + bfsize / 2]) * W[i * (1 << k)];
                        }
                    }
                    Complex[] X = new Complex[count];
                    X = X1;
                    X1 = X2;
                    X2 = X;
                }

                //重新排序

                for (j = 0; j < count; j++)
                {
                    p = 0;
                    for (i = 0; i < wp; i++)
                    {
                        if (j & (1 << i))
                        { p += 1 << (wp - i - 1); }

                    }
                    complex_2[j] = X1[p];
                }
            }
               // throw new Exception("The method or operation is not implemented.");
            }


















        ////    private void FFT(Complex[] complex, Complex[] complex_2, int wp)
        ////    {
        ////        //傅立叶变换点数
        ////        int count = 1 << wp;
        ////        int i, j, k;
        ////        int bfsize, p;

        ////        //角度
        ////        double angle;

        ////        Complex[] W = new Complex[count / 2];
        ////        Complex[] X1 = new Complex[count];
        ////        Complex[] X2 = new Complex[count];


        ////        //计算W
        ////        for (i = 0; i < count / 2; i++)
        ////        {
        ////            angle = -i * Math.PI * 2 / count;
        ////            W[i] = new Complex(Math.Cos(angle), Math.Sin(angle));
        ////        }
        ////        //将时域点写入X1
        ////        X1 = complex;
        ////        //采用蝶形算法进行快速傅立叶变换
        ////        for (k = 0; k < wp; k++)
        ////        {
        ////            for (j = 0; j < 1 << wp; j++)
        ////            {
        ////                bfsize = 1 << (wp - k);
        ////                for (i = 0; i < bfsize / 2; i++)
        ////                {
        ////                    p = j * bfsize;
        ////                    X2[i + p] = X1[i + p] + X1[i + p + bfsize / 2];
        ////                    X2[i + p + bfsize / 2] = (X1[i + p] - X1[i + p + bfsize / 2]) * W[i * (1 << k)];
        ////                }
        ////            }
        ////            Complex[] X = new Complex[count];
        ////            X = X1;
        ////            X1 = X2;
        ////            X2 = X;
        ////        }

        ////        //重新排序

        ////        for (j = 0; j < count; j++)
        ////        {
        ////            p = 0;
        ////            for (i = 0; i < wp; i++)
        ////            {
        ////                if (j & (1 << i))
        ////                { p += 1 << (wp - i - 1); }

        ////            }
        ////            complex_2[j] = X1[p];
        ////        }
        ////    }
        ////}












        //        //throw new Exception("The method or operation is not implemented.");
    }