嗨，我是射手座的程序媛，期待和大家更多的交流与学习，欢迎添加3512724768。

《面向对象程序设计》-基于C# .NET 的数字图像处理系统开发

（一）实习的目的

根据《面向对象程序设计》理论课授课内容，是使学生掌握课程中讲述的有关面向对象程序设计的理论，同时熟悉C#编程进行Windows应用程序的开发。掌握C# 图形处理软件编程，根据要求完成一个应用程序的设计和开发。加强理论联系实际，提高学生综合面向对象的编程能力。
（二）实习的任务
使用C#作为开发语言，根据要求完成一个应用程序的开发。实现图像的加载保存以及图像处理的基本功能，如尺度变换（放大缩小）、图像取反、灰度化图像、图像加亮、图像平滑卷积、高斯模糊、图像边缘锐化等功能。

上传图片

图像取反

图像灰度化

图像加亮

图像锐化

图像边缘提取

图像颜色转换

图像平滑卷积

private void converToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (originalImage != null)
            {
                // 创建一个新的 Bitmap 用于存储平滑后的图像
                Bitmap smoothedImage = new Bitmap(originalImage.Width, originalImage.Height);

                // 定义平滑的卷积核（均值滤波器）
                int[,] kernel = {
            { 1, 1, 1 },
            { 1, 1, 1 },
            { 1, 1, 1 }
        };

                int kernelSize = 3;
                int radius = kernelSize / 2;
                int kernelSum = 9; // 3x3 kernel的总和

                // 复制原始图像数据到临时数组，以便在上面进行操作
                Color[,] pixels = new Color[originalImage.Width, originalImage.Height];
                for (int x = 0; x < originalImage.Width; x++)
                {
                    for (int y = 0; y < originalImage.Height; y++)
                    {
                        pixels[x, y] = originalImage.GetPixel(x, y);
                    }
                }

                // 应用卷积核进行平滑
                for (int x = radius; x < originalImage.Width - radius; x++)
                {
                    for (int y = radius; y < originalImage.Height - radius; y++)
                    {
                        int r = 0, g = 0, b = 0;

                        // 计算卷积
                        for (int i = -radius; i <= radius; i++)
                        {
                            for (int j = -radius; j <= radius; j++)
                            {
                                int px = x + i;
                                int py = y + j;
                                Color pixel = pixels[px, py];
                                int kernelValue = kernel[i + radius, j + radius];

                                r += pixel.R * kernelValue;
                                g += pixel.G * kernelValue;
                                b += pixel.B * kernelValue;
                            }
                        }

                        // 确保颜色值在有效范围内
                        r = Math.Max(0, Math.Min(255, r / kernelSum));
                        g = Math.Max(0, Math.Min(255, g / kernelSum));
                        b = Math.Max(0, Math.Min(255, b / kernelSum));

                        // 设置新像素值
                        smoothedImage.SetPixel(x, y, Color.FromArgb(r, g, b));
                    }
                }

                // 显示平滑后的图像
                pictureBox1.Image = smoothedImage;
            }
        }

高斯模糊

 private void gaussianBlurToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (originalImage != null)
            {
                // 应用高斯模糊
                Bitmap blurredImage = ApplyGaussianBlur(originalImage, 5); // 使用半径为 5 的高斯模糊

                // 显示处理后的图像
                pictureBox1.Image = blurredImage;
            }
        }

        private Bitmap ApplyGaussianBlur(Bitmap image, int radius)
        {
            Bitmap blurredImage = new Bitmap(image.Width, image.Height);

            // 根据半径计算高斯核
            double[,] kernel = CalculateGaussianKernel(radius);

            // 卷积操作
            for (int x = radius; x < image.Width - radius; x++)
            {
                for (int y = radius; y < image.Height - radius; y++)
                {
                    double r = 0, g = 0, b = 0;
                    for (int i = -radius; i <= radius; i++)
                    {
                        for (int j = -radius; j <= radius; j++)
                        {
                            Color pixel = image.GetPixel(x + i, y + j);
                            double weight = kernel[i + radius, j + radius];

                            r += pixel.R * weight;
                            g += pixel.G * weight;
                            b += pixel.B * weight;
                        }
                    }

                    // 将新像素值存入模糊图像
                    blurredImage.SetPixel(x, y, Color.FromArgb((int)r, (int)g, (int)b));
                }
            }

            return blurredImage;
        }

        private double[,] CalculateGaussianKernel(int radius)
        {
            int size = radius * 2 + 1;
            double[,] kernel = new double[size, size];
            double sigma = radius / 3.0; // 根据经验设定 sigma

            double twoSigmaSquare = 2 * sigma * sigma;
            double constant = 1.0 / (Math.PI * twoSigmaSquare);

            double sum = 0;

            for (int i = -radius; i <= radius; i++)
            {
                for (int j = -radius; j <= radius; j++)
                {
                    double distance = i * i + j * j;
                    kernel[i + radius, j + radius] = constant * Math.Exp(-distance / twoSigmaSquare);
                    sum += kernel[i + radius, j + radius];
                }
            }

            // 标准化
            for (int i = 0; i < size; i++)
            {
                for (int j = 0; j < size; j++)
                {
                    kernel[i, j] /= sum;
                }
            }

            return kernel;
        }

仅展示部分代码，详细代码如下

嗨，我是射手座的程序媛，期待和大家更多的交流与学习，欢迎添加3512724768。