在.NET环境下绘制模糊数学中隶属函数分布图

最新推荐文章于 2024-08-08 21:21:17 发布
最新推荐文章于 2024-08-08 21:21:17 发布
阅读量1.4k 收藏 2
点赞数
分类专栏： 哲学与人生 文章标签： .net float object 图形 string button
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzhflyqh/article/details/1894800
版权
using  System;
 using  System.Collections.Generic;
 using  System.ComponentModel;
 using  System.Data;
 using  System.Drawing;
 using  System.Text;
 using  System.Collections;
 using  System.Windows.Forms;
 using  System.Drawing.Imaging;
 using  System.Drawing.Drawing2D;

 namespace  ImageFuzzy
 {
    public partial class Form1 : Form
    {
        private int type1;
        private int type2;
        private string item1;
        private string item2;
        private float a;
        private float b;
        private float c;
        private float d1;
        private float k;
        private float l;
        private float tempx;
        private float tempy;

        public void InitArray()
        {
           
            type1 = 0;
            type2 = 0;
            k = 2;
            item1 = this.comboBox1.Text.ToString();
            item2 = this.comboBox2.Text.ToString();
            this.groupBox1.Text = item1 + item2 + "图形";
            a = float.Parse(this.tbA.Text.Trim().ToString());
            b = float.Parse(this.tbB.Text.Trim().ToString());
            c = float.Parse(this.tbC.Text.Trim().ToString());
            d1 = float.Parse(this.tbD.Text.Trim().ToString());
            k = float.Parse(this.tbK.Text.Trim().ToString());
            l = float.Parse(this.tbL.Text.Trim().ToString());
            type1 = this.comboBox1.SelectedIndex+1;
            type2 = this.comboBox2.SelectedIndex+1;
        }

        private void delete()
        {
            a = 0;
            b = 0;
            c = 0;
            d1 = 0;
            k = 0;
            l = 0;
        }
        private void set1()
        {
            this.tbA.Text = "1";
            this.tbB.Text = "2";
            this.tbC.Text = "3";
            this.tbD.Text = "4";
            this.tbK.Text = "1";
            this.tbL.Text = "2";
        }
        private void set2()
        {
            this.tbA.Text = "1";
            this.tbB.Text = "1.5";
            this.tbC.Text = "2";
            this.tbD.Text = "2.5";
            this.tbK.Text = "1";
            this.tbL.Text = "2";
        }
        private void set3()
        {
            this.tbA.Text = "0.5";
            this.tbB.Text = "1.5";
            this.tbC.Text = "2";
            this.tbD.Text = "3";
            this.tbK.Text = "3";
            this.tbL.Text = "2";
        }
        private void set4()
        {
            this.tbA.Text = "1.5";
            this.tbB.Text = "1.5";
            this.tbC.Text = "2";
            this.tbD.Text = "2.5";
            this.tbK.Text = "0.5";
            this.tbL.Text = "2";
        }
        private void set5()
        {
            this.tbA.Text = "2";
            this.tbB.Text = "2.5";
            this.tbC.Text = "3";
            this.tbD.Text = "3.5";
            this.tbK.Text = "4";
            this.tbL.Text = "6";
        }
        private void set6()
        {
            this.tbA.Text = "0.5";
            this.tbB.Text = "1.5";
            this.tbC.Text = "2";
            this.tbD.Text = "2.5";
            this.tbK.Text = "2";
            this.tbL.Text = "4";
        }
        public Form1()
        {
            InitializeComponent();
            
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            //set1();
        }

        private void Form1_Paint(object sender, PaintEventArgs e)
        {

        }

        private void pictureBox1_Paint(object sender, PaintEventArgs e)
        {
            float d;
            float x1;
            float x2;
            float y1;
            float y2;
            PointF p1;
            PointF p2;

            int unit = 40;//放大倍数
            Font font = new Font("MS UI Gothic", 12);
            SolidBrush brush = new SolidBrush(Color.Black);
            float interval = 0.001F;   //步进刻度，值越小越精确(必须大小0)，但速度也越慢   
            PointF o = new PointF(this.pictureBox1.Width / 2, this.pictureBox1.Height / 2);
            e.Graphics.DrawLine(Pens.Red, 0, this.pictureBox1.Height / 2, this.pictureBox1.Width, this.pictureBox1.Height / 2);
            e.Graphics.DrawLine(Pens.Red, this.pictureBox1.Width / 2, 0, this.pictureBox1.Width / 2, this.pictureBox1.Height);
            e.Graphics.DrawString("O", font, brush, o);
            if (type1 == 0)
            {
                for (d = -6.28F; d < 6.28F; d += interval)
                {
                    x1 = o.X + d * unit;
                    x2 = o.X + (d + interval) * unit;
                    y1 = o.Y - (float)(unit * System.Math.Sin(d));
                    y2 = o.Y - (float)(unit * System.Math.Sin(d + interval));
                    p1 = new PointF(x1, y1);
                    p2 = new PointF(x2, y2);
                    e.Graphics.DrawLine(Pens.Black, p1, p2);
                    
                }
            }
            else if (type1 == 1)
            {
                //set1();
                PointF o1 = new PointF(this.pictureBox1.Width/2, this.pictureBox1.Height / 4);
                e.Graphics.DrawString("1", font, brush, o1);
                if (type2 == 1)
                {
                    for (d = 0; d < a; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(this.pictureBox1.Height / 4);
                        y2 = o.Y - (float)(this.pictureBox1.Height / 4);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Black, p1, p2);
                        tempx = x2;
                        tempy = this.pictureBox1.Height/2;
                    }
                    PointF o2 = new PointF(tempx, tempy);
                    e.Graphics.DrawString(a.ToString(), font, brush, o2);
                }
                else if (type2 == 2)
                {
                    
                    for (d = a; d < 2*a; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(this.pictureBox1.Height / 4);
                        y2 = o.Y - (float)(this.pictureBox1.Height / 4);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                    PointF o2 = new PointF(tempx, tempy);
                    e.Graphics.DrawString(a.ToString(), font, brush, o2);
                }
                else if (type2 == 3)
                {

                    for (d = a; d <b; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(this.pictureBox1.Height / 4);
                        y2 = o.Y - (float)(this.pictureBox1.Height / 4);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                    PointF o2 = new PointF(tempx, tempy);
                    e.Graphics.DrawString(a.ToString(), font, brush, o2);
                }
              
            }
            else if (type1 == 2)
            {
                //set2();
                PointF o1 = new PointF(this.pictureBox1.Width/2, this.pictureBox1.Height / 4);
                e.Graphics.DrawString("1", font, brush, o1);
                if (type2 == 1)
                {
                    for (d = 0; d <=a; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(1*unit);
                        y2 = o.Y - (float)(1*unit);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                    for (d = a; d < b; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1=o.Y-(float)(unit*((b-d)/(b-a)));
                        y2=o.Y-(float)(unit*((b-d-interval)/(b-a)));
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                }
                else if(type2==2)
                {
                    for (d = a; d < b; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1=o.Y-(float)(unit*((d-a)/(b-a)));
                        y2=o.Y-(float)(unit*((d-a-interval)/(b-a)));
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                    for (d = b; d <= (b+a); d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(1 * unit);
                        y2 = o.Y - (float)(1 * unit);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                }
                else if (type2 == 3)
                {
                    for (d = a; d < b; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(unit * ((d - a) / (b - a)));
                        y2 = o.Y - (float)(unit * ((d - a - interval) / (b - a)));
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                    for (d = b; d <= c; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(1 * unit);
                        y2 = o.Y - (float)(1 * unit);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                    for (d = c; d < d1; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(unit * ((d1 - d) / (d1 - c)));
                        y2 = o.Y - (float)(unit * ((d1 - d - interval) / (d1 - c)));
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                }
               
            }
            else if (type1 == 3)
            {
                //set3();
                PointF o1 = new PointF(this.pictureBox1.Width / 2, this.pictureBox1.Height / 4);
                e.Graphics.DrawString("1", font, brush, o1);
                if (type2 == 1)
                {
                    for (d = 0; d <= a; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(1 * unit);
                        y2 = o.Y - (float)(1 * unit);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                    for (d = a; d < b; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(unit * (System.Math.Pow((b-d)/(b-a),k)));
                        y2 = o.Y - (float)(unit * (System.Math.Pow((b - d - interval) / (b - a),k)));
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                }
                else if (type2 == 2)
                {
                    for (d = a; d < b; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(unit * (System.Math.Pow((d - a) / (b - a), k)));
                        y2 = o.Y - (float)(unit * (System.Math.Pow((d - a - interval) / (b - a), k)));
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                    for (d = b; d <= (a+b); d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(1 * unit);
                        y2 = o.Y - (float)(1 * unit);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                }
                else if (type2 == 3)
                {

                    for (d = a; d < b; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(unit * (System.Math.Pow((d - a) / (b - a), k)));
                        y2 = o.Y - (float)(unit * (System.Math.Pow((d - a - interval) / (b - a), k)));
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                    for (d = b; d <= c; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(1 * unit);
                        y2 = o.Y - (float)(1 * unit);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                    for (d = c; d < d1; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(unit * (System.Math.Pow((d1 - d) / (d1- c), k)));
                        y2 = o.Y - (float)(unit * (System.Math.Pow((d1 - d - interval) / (d1 - c), k)));
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                }
                
            }
            else if (type1 == 4)
            {
                //set4();
                PointF o1 = new PointF(this.pictureBox1.Width / 2, this.pictureBox1.Height / 4);
                e.Graphics.DrawString("1", font, brush, o1);
                if (type2 == 3)
                {
                    for (d = 0; d <= 2*a; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(System.Math.Exp(-((d-a)/k)*((d-a)/k)) * unit);
                        y2 = o.Y - (float)(System.Math.Exp(-((d-interval - a) / k) * ((d-interval - a) / k)) * unit );
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                }
                else if (type2 == 1)
                {
                    for (d = 0; d <= a; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(1 * unit);
                        y2 = o.Y - (float)(1 * unit);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                    for (d = a; d <= 2 * a; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(System.Math.Exp(-((d - a) / k) * ((d - a) / k)) * unit);
                        y2 = o.Y - (float)(System.Math.Exp(-((d - interval - a) / k) * ((d - interval - a) / k)) * unit);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                }
                else if (type2 == 2)
                {
                    for (d = a; d <= 2 * a; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(System.Math.Exp(-((d - a) / k) * ((d - a) / k)) * unit);
                        y2 = o.Y - (float)(1-System.Math.Exp(-((d - interval - a) / k) * ((d - interval - a) / k)) * unit);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                }
                
            }
            else if (type1 == 5)
            {
                //set5();
                PointF o1 = new PointF(this.pictureBox1.Width / 2, this.pictureBox1.Height / 4);
                e.Graphics.DrawString("1", font, brush, o1);
                if (type2 == 3)
                {
                    for (d = 0; d <= 2 * a; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)((1.0/(1+k*System.Math.Pow(d-a,l))) * unit);
                        y2 = o.Y - (float)((1.0 / (1 + k * System.Math.Pow(d-interval - a, l))) * unit);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                }
                else if (type2 == 1)
                {
                    for (d = 0; d <= a; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(1 * unit);
                        y2 = o.Y - (float)(1 * unit);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                    for (d = a; d <= 2 * a; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)((1.0 / (1 + k * System.Math.Pow(d - a, l))) * unit);
                        y2 = o.Y - (float)((1.0 / (1 + k * System.Math.Pow(d - interval - a, l))) * unit);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                }
                else if (type2 == 2)
                {

                    for (d = a; d <= 2 * a; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)((1.0 / (1 + k * System.Math.Pow(d - a, -l))) * unit);
                        y2 = o.Y - (float)((1.0 / (1 + k * System.Math.Pow(d - interval - a, -l))) * unit);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                    for (d = 2*a; d <= 3*a; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(1 * unit);
                        y2 = o.Y - (float)(1 * unit);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                }
              
            }
            else if (type1 == 6)
            {
                //set6();
                PointF o1 = new PointF(this.pictureBox1.Width / 2, this.pictureBox1.Height / 4);
                e.Graphics.DrawString("1", font, brush, o1);
                if (type2 == 3)
                {
                    for (d =-b; d < -a; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)((0.5 + 0.5 * System.Math.Sin((d-(a+b)/2)*(System.Math.PI/(b-a)))) * unit);
                        y2 = o.Y - (float)((0.5 + 0.5 * System.Math.Sin((d-interval - (a + b) / 2) * (System.Math.PI / (b - a)))) * unit);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                    for (d = -a; d < a; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(1* unit);
                        y2 = o.Y - (float)(1 * unit);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                    for (d = a; d < b; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)((0.5 - 0.5 * System.Math.Sin((d - (a + b) / 2) * (System.Math.PI / (b - a)))) * unit);
                        y2 = o.Y - (float)((0.5 - 0.5 * System.Math.Sin((d - interval - (a + b) / 2) * (System.Math.PI / (b - a)))) * unit);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                }
                else if (type2 == 1)
                {
                    for (d = 0; d < a; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(1 * unit);
                        y2 = o.Y - (float)(1 * unit);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                    for (d = a; d < b; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)((0.5 - 0.5 * System.Math.Sin((d - (a + b) / 2) * (System.Math.PI / (b - a)))) * unit);
                        y2 = o.Y - (float)((0.5 - 0.5 * System.Math.Sin((d - interval - (a + b) / 2) * (System.Math.PI / (b - a)))) * unit);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                }
                else if (type2 == 2)
                {
                    for (d = a; d < b; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)((0.5 + 0.5 * System.Math.Sin((d - (a + b) / 2) * (System.Math.PI / (b - a)))) * unit);
                        y2 = o.Y - (float)((0.5 + 0.5 * System.Math.Sin((d - interval - (a + b) / 2) * (System.Math.PI / (b - a)))) * unit);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                    for (d = b; d < c; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(1 * unit);
                        y2 = o.Y - (float)(1 * unit);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }
                }
                
            }
        }

        private void button1_Click(object sender, EventArgs e)
        {
            InitArray();
            Graphics g = Graphics.FromHwnd(this.pictureBox1.Handle);
            PaintEventArgs e1 = new PaintEventArgs(g, this.pictureBox1.ClientRectangle);
            this.pictureBox1_Paint(this.pictureBox1, e1);
            g.Dispose();   
        }
    }
}

 整个源代码如上。

首先：重载 pictureBox1_Paint 函数

进行画图时思想很简单，确定起始位置，结束位置，本程序中我用System.Drawing.PointF对象存储点坐标。

使用 e.Graphics.DrawLine(Pens.Black, 坐标1, 坐标2)进行线条的绘制。

下面我将拿绘制正态分布图形介绍下：

程序段如下：

for (d = a; d <= 2 * a; d += interval)
                    {
                        x1 = o.X + d * unit;
                        x2 = o.X + (d + interval) * unit;
                        y1 = o.Y - (float)(System.Math.Exp(-((d - a) / k) * ((d - a) / k)) * unit);
                        y2 = o.Y - (float)(1-System.Math.Exp(-((d - interval - a) / k) * ((d - interval - a) / k)) * unit);
                        p1 = new PointF(x1, y1);
                        p2 = new PointF(x2, y2);
                        e.Graphics.DrawLine(Pens.Blue, p1, p2);
                    }

其中：unit代表图形放大倍数，数值越大图形放大倍数越大。

interval 代表步进刻度，值越小越精确(必须大小0)，但速度也越慢 

先确定起始坐标（x1,y1），再结合正态分布在增加一个步进刻度的情况下确定(x2,y2)，接下来调用e.Graphics.DrawLine进行画图。

最后还有一点，由于每次重新画图的时候都要调用private void pictureBox1_Paint(object sender, PaintEventArgs e)，其不是用户定义方法，所以用户句柄重新获取PictureBox_Paint方法，重新绘制图形，代码段如下：

            Graphics g = Graphics.FromHwnd(this.pictureBox1.Handle);
            PaintEventArgs e1 = new PaintEventArgs(g, this.pictureBox1.ClientRectangle);
            this.pictureBox1_Paint(this.pictureBox1, e1);
            g.Dispose();

zzhflyqh
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
讲解.NET环境下绘制模糊数学中隶属函数分布图第1/5页
12-31
绘制模糊数学中隶属函数分布图　using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text; using System....
【老生谈算法】Matlab实现模糊数学模型.docx
11-05
文档中提到了三种基本的模糊隶属函数类型：偏小型梯形分布、偏小型Г分布和偏小型正态分布。通过Matlab可以方便地绘制这些函数的图形。例如，对于偏小型梯形分布，我们可以设定参数a和b，然后用Matlab的plot函数绘制...
模糊数学 1、模糊集、隶属度函数、如何确定隶属度函数
雾隐雾现的至渝博客
05-18 7万+
        集合的概念：一些具有相同特征的不同对象构成的全体，也称集或者经典集合。         经典集合的特征函数（和模糊集的隶属度函数一样）：                 &nb
模糊数学模型（一）： 隶属函数、模糊集合的表示方法、模糊关系、模糊矩阵
热门推荐
冷月无声的博客
05-06 8万+
模糊数学模型系列博文： 【1】基本概念： 隶属函数、模糊集合的表示方法、模糊关系、模糊矩阵 【2】模糊模式识别：海明贴近度 、欧几里得贴近度 、黎曼贴近度、 格贴近度、最大隶属原则、择近原则 【3】模糊聚类分析方法：模糊等价矩阵、模糊相似矩阵、传递闭包法、布尔矩阵法 【4】模糊决策分析方法 目录 1.1 模糊数学简介 1.2.1 模糊集和隶属函数 1.2.2 模糊集合的表示方法 ...
在.NET环境下绘制模糊数学中附属函数散布图
weixin_30690833的博客
05-01 57
有个在.NET环境下绘制模糊数学中隶属函数分布图的实例代码，并对其作了简单讲解，大家可以学习一下。 以下是援用片段：　　usingSystem; 　　usingSystem.Collections.Generic; 　　usingSystem.ComponentModel; 　　usingSystem.Data; 　　usingSystem.Drawing; 　...
Matlab 中绘制模糊隶属度函数
yzldream的专栏
03-07 4万+
6.2模糊推理结构FIS 6.2.1不使用数据聚类方法从数据生成FIS结构 函数 genfis1 格式 fismat=genfis1(data) fismat=genfis1(data,numMFs,inmftype,outmftype) 说明genfis1为anfis训练生成一个Sugeno型作为初始条件的FIS结构（初始隶属函数）。genfis1(data,numMFs,inmft
matlab常用隶属度函数,常用隶属函数.ppt
weixin_35867894的博客
03-17 5831
模糊集基本理论 典型隶属函数 如前所述, 构造恰当的隶属函数是模糊集理论应用的基础。一种基本的构造隶属函数的方法是“参考函数法”, 即参考一些典型的隶属函数, 通过选择适当的参数, 或通过拟合、整合、实验等手段得到需要的隶属函数。 下面介绍典型隶属函数(最早由法国学者A. Kaufmann收集整理)。 偏小型 降半矩形分布, 降半Γ形分布, 降半正态分布, 降半柯西分布, 降半梯形分布, 降岭形分...
matlab绘制正态分布曲线（高斯隶属度函数）
dq932073495的博客
01-08 8283
在matlab中提供了gaussmf函数,可以利用该函数进行正态分布曲线的绘制. 正态分布公式： gaussmf的语法: y = gaussmf(x,[sig c]) 其中 sig： 指代正态分布的标准偏差σ; c ：指代正态分布中的均值μ **x:**自变量 gaussmf帮助文档 x = 0:0.1:10; y = gaussmf(x,[2 5]); plot(x,y) xlabel('gaussmf, P=[2 5]') ...
绘制高斯隶属函数
云帝的博客
09-14 1万+
绘制高斯隶属函数模糊理论高斯型隶属函数实现 模糊理论 模糊理论以连续隶属函数理论为基础。它可以分为五个分支：模糊数学，模糊系统，不确定性和信息，模糊决策，模糊逻辑与人工智能。 隶属函数是用于表示模糊集的数学工具。 它表示元素属于模糊集的“真实度”。 隶属函数的值介于0和1之间。这似乎是概率，但它是一个不同的概念。 它代表了一个程度， 高斯隶属函数是其隶属函数之一。 高斯型隶属函数 高斯型隶属函数（...
模糊集合和隶属度函数--AForge.NET框架的使用（一）
weixin_34006965的博客
11-30 1429
原文:模糊集合和隶属度函数--AForge.NET框架的使用（一）什么是AForge.NET？ AForge.NET是一个为开发人员和研究人员开发的框架，它可以用于计算机视觉，遗传算法，图像处理，神经网络，机器人学习与控制，机器学习和模糊系统。 AForge.NET的官方文档比较丰富，网上也有一些相关文章，但是多是关于视觉和神经网络的，而我个人对模糊系统比较感兴趣，故写下自己的一些感受。 模...
数学建模——模糊综合评价模型学习笔记
m0_63240220的博客
07-31 1576
清风老师模糊综合评价模型学习笔记
matlab模糊算法：28 函数gaussmf建立高斯型隶属度函数.zip
05-26
高斯型隶属度函数是模糊逻辑中的一种常见类型，其形状类似于数学上的正态分布曲线，也称为钟形曲线。这种函数在模糊系统中常用来表示模糊集的成员度，因为它能很好地模拟现实世界中的连续和逐渐变化的特性。 `...
matlab模糊聚类程序 动态聚类图程序.zip_MATLAB 聚类_matlab 聚类程序_matlab谱系图_模糊动态聚类_
07-14
在模糊聚类中，数据点可以同时属于多个类别，具有一定的隶属度，这使得模型能够更好地处理边界数据和复杂的数据分布。 MATLAB中的`cmeans`函数是实现模糊C均值聚类的主要工具，其基本语法为`[idx,C] = cmeans(X,c)`...
matlab模糊算法：27 建立双边高斯型隶属度函数gauss2mf.zip
05-26
本文将深入探讨“建立双边高斯型隶属度函数gauss2mf”的概念，以及如何在MATLAB环境中实现这一算法。 双边高斯型隶属度函数，又称为双峰模糊函数，是模糊系统中一种常见的 membership function (MF) 形式。它是由两...
示例：在ML.NET中应用Model Builder模型生成器构建图片对象检测模型
HeBianGu的博客
08-05 875
以上步骤展示了如何使用 ML.NET 的 Model Builder 创建对象检测模型，并在项目中使用生成的模型进行对象检测。通过这种方式，你可以快速构建和部署对象检测模型。本文主要演示使用过程，采用更准、更多的数据源、应用更精确的标记方式可以提高准确率。
在Quartz.Net中使用Scoped Service
最新发布
Henry_Wu001的专栏
08-08 225
由于您必须匹配的接口API，它有点笨重，但可以说它更接近于您应该实现它的方式！就我个人而言，我认为我会坚持QuartzJobRunner的方法，但选择最适合你的方法。在Quartz.Net中无法使用scoped service比如DbContext，一般IJob只能是单例模式或Transient模式；不直接在IJob中实现，而是通过一个QuartzJobRunner的任务间接实现，在次任务中创建新的任务来实现；在很多场景下这个是可行的，此时IJob依然在DI中是单例模式。,所以可以在构造方法中使用。
C# .NET Framework的特殊委托
weixin_43284350的博客
08-08 121
用追马的时间种草吧
openai-dotnet：OpenAI官方提供的.NET SDK库！
成长的足迹
08-05 342
openai-dotnet是OpenAI 官方提供的 .NET库，用于方便.NET应用程序中访问 OpenAI REST API。该项目的关键特点和功能：1、快速开发：该库使得开发者在 .NET环境中快速调用 OpenAI 的各种功能，如聊天补全、文本嵌入、图像生成、音频转录等。2、OpenAPI 规范：库是根据 OpenAI 的 OpenAPI 规范生成的，并且与 Microsoft 合作开发。3、使用简单：通过NuGet包管理器可以很容易地将这个库添加到你的 .NET 项目中。
创建模糊逻辑中的隶属函数python
05-05
在Python中可以使用scipy库中的membership子模块来创建模糊逻辑中的隶属函数。下面是一个例子： ```python from scipy import linspace from scipy.stats import norm import matplotlib.pyplot as plt # 创建一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值