【Code Art / C#】圆形组合图像效果生成

最新推荐文章于 2024-07-17 08:56:54 发布
最新推荐文章于 2024-07-17 08:56:54 发布
阅读量996 收藏
点赞数
分类专栏： C# .NET Code Art
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ls9512/article/details/50926441
版权

原图



处理后效果



【思路】

取原图像某一位置一定范围内像素的平均颜色，绘制成一个圆点，循环全图即可实现。

为了实现更为复杂一些的上图效果，做成了鼠标经过后拆分圆形尺寸。


主窗口源代码如下：

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

namespace FragmentationDemo
{
    public partial class Fragmentation : Form
    {
        public Fragmentation()
        {
            InitializeComponent();
        }

        /// <summary>
        /// 最大碎片尺寸
        /// </summary>
        int max_Size = 160;
        /// <summary>
        /// 最小碎片尺寸
        /// </summary>
        int min_Size = 2;
        /// <summary>
        /// 文件名
        /// </summary>
        string bmpFile;
        /// <summary>
        /// 支持的格式
        /// </summary>
        static string[] File_Formart = { "jpg", "jpeg", "bmp","png","gif" };
        /// <summary>
        /// 图像
        /// </summary>
        Bitmap bmp;
        /// <summary>
        /// 碎片集合
        /// </summary>
        List<Pic> picture;
        /// <summary>
        /// 动画标志
        /// </summary>
        bool isAnima = false;

        /// <summary>
        /// 初始化窗口
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Fragmentation_Load(object sender, EventArgs e)
        {
            this.ClientSize = new Size(800, 480);
            this.FormBorderStyle = FormBorderStyle.FixedToolWindow;
            this.KeyPreview = true;
            this.CenterToScreen();
        }

        /// <summary>
        /// 重写重绘方法
        /// </summary>
        /// <param name="e"></param>
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);
            Graphics g = e.Graphics;
            g.FillRectangle(Brushes.White, this.ClientRectangle);
            if (bmp == null) 
            {
                using (SolidBrush sBrush = new SolidBrush(Color.Red))
                {
                    g.DrawString("请将需要处理的图像拖放至此", new Font("The New Roman", 22f, FontStyle.Bold), sBrush, 175, 225);
                    g.DrawString("操作提示按[A]自动演示,按[R]恢复图像初始状态.", new Font("The New Roman", 14f, FontStyle.Regular), sBrush, 175, 265);
                }
                return;
            }
            // 绘制图像
            foreach (Pic p in picture)
            {
                g.FillEllipse(new SolidBrush(p.c), new Rectangle(p.x, p.y, p.size, p.size));
            }
        }

        /// <summary>
        /// 鼠标移动处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Fragmentation_MouseMove(object sender, MouseEventArgs e)
        {
            if (isAnima) return;
            Create(e.X, e.Y);
        }

        /// <summary>
        /// 按键事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Fragmentation_KeyDown(object sender, KeyEventArgs e)
        {
            switch (e.KeyCode)
            {
                case Keys.A:
                    // 自动逐层展开
                    for (int num = max_Size; num > min_Size; num /= 2)
                    {
                        for (int j = 1; j < this.ClientSize.Height - num; j += num)
                        {
                            for (int i = 1; i < this.ClientSize.Width - num; i += num)
                            {
                                Application.DoEvents();
                                Create(i, j);
                            }
                        }
                    }
                    break;
                case Keys.R:
                    OpenFile(bmpFile);
                    break;
            }
        }

        /// <summary>
        /// 打开区域
        /// </summary>
        /// <param name="xx"></param>
        /// <param name="yy"></param>
        private void Create(int xx, int yy)
        {
            try
            {
                if (picture == null)
                {
                    return;
                }
                foreach (Pic p in picture)
                {
                    int x = p.x + p.size / 2;
                    int y = p.y + p.size / 2;
                    int size = p.size / 2;
                    int len = (int)Math.Sqrt(Math.Pow((x - xx), 2) + Math.Pow((y - yy), 2));
                    if (len < p.size / 2 && len >= min_Size)
                    {
                        // 动画放速度
                        double speed = 0.8;
                        Graphics g = Graphics.FromHwnd(this.Handle);
                        isAnima = true;
                        for (double r = p.size; r >= min_Size-1; r *= speed)
                        {
                            g.FillRectangle(Brushes.White, new Rectangle(p.x, p.y, p.size, p.size));
                            g.FillEllipse(new SolidBrush(p.c), p.x + (int)(p.size - r) / 2, p.y + (int)(p.size - r) / 2, (int)r, (int)r);
                            Thread.Sleep(5);
                            Application.DoEvents();
                        }
                        Pic p1 = new Pic();
                        p1.x = p.x;
                        p1.y = p.y;
                        p1.size = p.size / 2;
                        p1.c = GetColor(p.x, p.y, p.size / 2);
                        Pic p2 = new Pic();
                        p2.x = p.x + p.size / 2;
                        p2.y = p.y;
                        p2.size = p.size / 2;
                        p2.c = GetColor(p.x + p.size / 2, p.y, p.size / 2);
                        Pic p3 = new Pic();
                        p3.x = p.x;
                        p3.y = p.y + p.size / 2;
                        p3.size = p.size / 2;
                        p3.c = GetColor(p.x, p.y + p.size / 2, p.size / 2);
                        Pic p4 = new Pic();
                        p4.x = p.x + p.size / 2;
                        p4.y = p.y + p.size / 2;
                        p4.size = p.size / 2;
                        p4.c = GetColor(p.x + p.size / 2, p.y + p.size / 2, p.size / 2);
                        g.FillRectangle(Brushes.White, new Rectangle(p.x, p.y, p.size, p.size));
                        for (double r = min_Size; r <= p.size / 2 + 1; r /= speed)
                        {
                            //g.FillRectangle(Brushes.White, new Rectangle(p.x, p.y, p.size, p.size));
                            g.FillEllipse(new SolidBrush(p1.c), new Rectangle(p1.x + (int)(p.size / 2 - r)/2, p1.y + (int)(p.size / 2 - r)/2, (int)r, (int)r));
                            g.FillEllipse(new SolidBrush(p2.c), new Rectangle(p2.x + (int)(p.size / 2 - r)/2, p2.y + (int)(p.size / 2 - r)/2, (int)r, (int)r));
                            g.FillEllipse(new SolidBrush(p3.c), new Rectangle(p3.x + (int)(p.size / 2 - r)/2, p3.y + (int)(p.size / 2 - r)/2, (int)r, (int)r));
                            g.FillEllipse(new SolidBrush(p4.c), new Rectangle(p4.x + (int)(p.size / 2 - r)/2, p4.y + (int)(p.size / 2 - r)/2, (int)r, (int)r));
                            Thread.Sleep(5);
                            Application.DoEvents();
                        }
                        picture.Remove(p);
                        picture.Add(p1);
                        picture.Add(p2);
                        picture.Add(p3);
                        picture.Add(p4);
                        isAnima = false;
                        break;
                    }

                }
            }
            catch
            { 
            }
        }

        /// <summary>
        /// 加载文件
        /// </summary>
        /// <param name="FileName"></param>
        private void OpenFile(string FileName)
        {
            try
            {
                bmp = new Bitmap(Bitmap.FromFile(FileName), new Size(800, 480));
                picture = new List<Pic>();
                // 初始化数组
                for (int i = 0; i < 800; i += max_Size)
                {
                    for (int j = 0; j < 480; j += max_Size)
                    {
                        Pic p = new Pic();
                        p.x = i;
                        p.y = j;
                        p.size = max_Size;
                        p.c = GetColor(i, j, max_Size);
                        picture.Add(p);
                    }
                }
                this.Invalidate(this.ClientRectangle, true);
            }
            catch
            { 
            }
        }

        #region 图像处理函数
        /// <summary>
        ///  获取某一点某一尺寸的颜色
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="size"></param>
        /// <returns></returns>
        private Color GetColor(int x, int y, int size)
        {
            Color c;
            Bitmap b = BitmapCut(bmp, x, y, size, size);
            Bitmap bb = new Bitmap(b, new Size(1, 1));
            return bb.GetPixel(0, 0);
        }

        /// <summary>
        /// 图像切割函数
        /// </summary>
        /// <param name="b">图像源</param>
        /// <param name="StartX">起点x</param>
        /// <param name="StartY">起点y</param>
        /// <param name="iWidth">宽度</param>
        /// <param name="iHeight">高度</param>
        /// <returns></returns>
        private Bitmap BitmapCut(Bitmap b, int StartX, int StartY, int iWidth, int iHeight)
        {
            if (b == null)
            {
                return null;
            }
            int w = b.Width;
            int h = b.Height;
            if (StartX >= w || StartY >= h)
            {
                return null;
            }
            if (StartX + iWidth > w)
            {
                iWidth = w - StartX;
            }
            if (StartY + iHeight > h)
            {
                iHeight = h - StartY;
            }
            try
            {
                Bitmap bmpOut = new Bitmap(iWidth, iHeight, PixelFormat.Format32bppArgb);//ARGB取色以实现透明度
                Graphics g = Graphics.FromImage(bmpOut);
                g.DrawImage(b, new Rectangle(0, 0, iWidth, iHeight), new Rectangle(StartX, StartY, iWidth, iHeight), GraphicsUnit.Pixel);
                //元件边框
                //g.DrawRectangle(Pens.Black, new Rectangle(new Point(0, 0), new Size(iWidth - 3, iHeight - 3)));
                g.Dispose();
                return bmpOut;
            }
            catch
            {
                return null;
            }
        }  
        #endregion

        #region 拖放打开文件
        /// <summary>
        /// 拖放打开文件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Fragmentation_DragDrop(object sender, DragEventArgs e)
        {
            string fileName = ((System.Array)e.Data.GetData(DataFormats.FileDrop)).GetValue(0).ToString();
            string[] fileFormart = fileName.Split('.');
            if (FindFormartStr(fileFormart[fileFormart.Length - 1].ToLower()) > -1)
            {
                bmpFile = fileName;
                OpenFile(bmpFile);
            }
            else
            {
                MessageBox.Show("该文件格式不支持！", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        /// <summary>
        /// 拖放文件进入
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Fragmentation_DragEnter(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(DataFormats.FileDrop))
                e.Effect = DragDropEffects.Link;
            else e.Effect = DragDropEffects.None;
        }

        /// <summary>
        /// 查找指定格式
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        private int FindFormartStr(string str)
        {
            for (int i = 0; i < File_Formart.Length; i++)
            {
                if (File_Formart[i] == str)
                {
                    return i;
                }
            }
            return -1;
        } 
        #endregion

    }

    /// <summary>
    /// 碎片类
    /// </summary>
    public class Pic
    {
        public int x;
        public int y;
        public int size;
        public Color c;
    }
}


ls9512
关注
专栏目录
C#实战：使用ZXing.NET库轻松生成二维码与条形码
java专栏
04-20 2000
下面我将详细介绍C#中用于生成二维码和条形码的库——ZXing.NET，并附带一份详细的代码示例，其中每行代码均配有注释以解释其功能。ZXing.NET是基于开源项目ZXing（Zebra Crossing）的.NET移植版，它提供了生成和解析多种一维条形码和二维二维码的功能。以上两个示例展示了如何使用ZXing.NET库生成二维码和条形码，并将其保存为PNG图像文件。同样，对于二维码，除了默认的QR_CODE外，ZXing.NET还支持其他类型的二维条码编码。
C#中处理图片的拼接
lwd4210的专栏
04-17 2306
在动手前，先了解下两个概念： 位图：用像素点（块）来描述图形，效果逼真，画面有层次感，但放大后会失真，并且体积较大。 失量图：通过直线和曲线来描述图形，图形的元素包括点、线，矩形、圆、弧和椭圆等等，图形的展示可以通过公式来计算，线条的颜色和圈内外的着色。其放大不会失真且体积相对位图来说较小。 try {
.NET实现圆形头像效果
10-23
.net代码实现QQ的圆形头像效果，.net代码实现QQ的圆形头像效果
c#：画圆（整理）
however的博客
08-19 2830
c#：画圆（整理）
如何使用GDI+制作圆形图片(类似QQ圆形头像)（MFC，VC）
07-29
Bitmap b(image.GetWidth(),image.GetHeight());如何使用GDI+制作圆形图片(类似QQ圆形头像)（MFC，VC）
IOS 图片剪切（封装数据）
weixin_30487317的博客
03-21 113
封装 ：生成头像（UIImage (NJ).h / .m @interface UIImage (NJ) /** * 生成头像 * * @param icon 头像图片名称 * @param border 头像边框大小 * @param color 头像边框的颜色 * * @return 生成好的头像 */ + (instancetyp...
开源C#代码生成器
01-18
开源C#代码生成器是一款强大的开发工具，专为C#程序员设计，旨在提高开发效率，减少重复编写基础代码的工作量。这款工具的核心是利用winform作为用户界面，结合DevExpress控件库来提供友好的交互体验，并采用...
C#生成条形码 可设置高度、宽度等
09-27
以`BarcodeLib`为例，这是一个功能强大的C#条形码生成库，支持多种类型的条形码，包括Code 128，它是最常用的一种条形码类型，能编码所有128个ASCII字符。 1. **安装库**：首先，通过NuGet包管理器或者在`.csproj`...
通过vs2019用C#简单了实现二维码的生成与保存的2种方式
m0_68458051的博客
05-17 2650
方式二：直接利用ZXing中自带的类，直接调用；相对来说直接使用时，没有方式1（已二次封装）更加简洁。主要是记录一下，可能以后自己能再次通过自己写的这篇东西温故而知新；方式1.通过创建类的方式，将系统提供的ZXing类的数据进行封装。再通过调用ZXingLibs类的方式进行生成二维码，如下图所示。项目中右键找到管理NuGet程序包（N）其中参考了几篇其他大神写的实现。要想实现二维码的相关操作需要。先创建类ZXingLibs。
C#二维码的生成及打印
Cui856243的博客
09-28 4414
二维码的生成及打印，运用C#，winfrom窗体书写
圆形头像显示
01-30
不知何时开始,大多数软件的头像采用了圆形头像,使用WPF进行圆形头像显示比较简单,并不是将图像裁剪成圆形头像后显示. 思路是裁剪出一个正方形的头像,然后在显示的时候,只显示正方形中的内切圆部分即可.WPF中的Image类中有一个Clip属性,只需要设置好该属性即可.
c#视觉应用开发中如何在C#中实现图像拼接？
最新发布
zhangzhechun的专栏
07-17 190
以上介绍了如何使用、AForge.NET 和 OpenCVSharp 进行图像拼接的方法。适用于简单的图像拼接任务。AForge.NET提供更多图像处理功能，适合中等复杂度的任务。是功能最强大的选择，适合复杂的图像处理和计算机视觉任务。根据具体需求和熟悉的库，选择最适合的工具进行图像拼接操作。好的，我们继续探讨更复杂的图像拼接和处理示例，尤其是使用 OpenCVSharp 进行更高级的操作。这将包括图像对齐（例如，通过特征匹配）和垂直拼接。
C# Graphics.FillEllipse 方法
Godsight的博客
02-19 8556
Graphics.FillEllipse 方法 (Brush, Int32, Int32, Int32, Int32) .NET Framework (current version) 其他版本   填充边框所定义的椭圆的内部，该边框由一对坐标、一个宽度和一个高度指定。 命名空间:   System.Drawing 程序集:  Syste
从零开始使用CodeArt实践最佳领域驱动开发（一）
weixin_30902251的博客
06-30 227
前言： 　　目前绝大多数公司依然采用的是传统的项目实施方式——围绕数据库设计做应用程序开发。在这种方式下，程序员的主要工作就是不断的增删改查各种数据表，以数据为核心驱动系统的运行。随着项目进度的推进，系统暴露的问题却越来越多，程序员每天陷入无止境的修复状态中，增加或修改一个功能的代价也越来越大。项目进展看似在推进却好像永远都不会有完成的那一天。 　　我于2005年的时候就隐约感觉这种方式是错误...
053.maximum-subarray
m0_67403240的博客
03-14 1084
Find the contiguous subarray within an array (containing at least one number) which has the largest sum. For example, given the array [-2,1,-3,4,-1,2,1,-5,4], the contiguous subarray [4,-1,2,1] has the largest sum = 6. click to show more practice. More pra
C# 在窗口绘制图形（打点、画圆、画线）
weixin_30583563的博客
11-17 4556
需要包含命名空间 using System.Drawing; 画图前需要先创建画板 void Display() { Graphics g = this.CreateGraphics(); //创建画板 g.FillEllipse(Brushes.Silver, (x * (Z_data...
C# 图片切割成圆形图片的两种方式
weixin_45446038的博客
11-09 1562
private void Form1_Load(object sender, EventArgs e) { string file =System.IO.Path.Combine(Environment.CurrentDirectory, @"11.jpg"); try { ...
winform实现pictureBox显示成圆形形状，并实现pictureBox透明
_BigMao的博客
11-25 4820
winform实现picturebox透明，并展示圆形图片
C# 将方形图片剪切为圆形（winForm）
Mr_Left的博客
02-18 4693
先上图片看效果，（圆形图片大小可调） 示例图片：   后台代码： using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using S...
C#实现Code128条形码生成教程
在C#编程中，生成Code128条形码是一种常见的需求，尤其是在物流管理和库存管理等场景中。本文将详细介绍如何通过C#实现Code128条形码的生成，这是一项实用的编码技巧。Code128条形码有三种类型：Code128A、Code128B...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ls9512

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值