C# 多线程图像处理（源码）

【实例截图】

【核心代码】

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Reflection;
using System.IO;
using System.Threading;

// Threading example created by Harsha T, May 2010.
namespace ThreadingA
{
    //Delegate CallbackResult doesn't take any arguments and returns nothing. 
    //Object of this delegate is used for triggering the function ResultReturn 
    //once the thread completes its work. ResultReturn enables or disables the button 
    //which are created by UI thread. So passing accessing these controls from 
    //another thread is achieved through this.Invoke() function. And this.Invoke() takes a
    //delegate.
    public delegate void CallBackResult();

    public partial class Form1 : Form
    {
        //Bitmap Image which holds the contents read from the stream.
        private Bitmap LenaImage;
        //object of type CallBackResult and is passed to this.Invoke() function.
        private CallBackResult cbResult;
        //Graphics object for pictureBox.
        private Graphics g;
        //This is our thread. Created and started when user clicks on the Start button. 
        private Thread thread;

        public Form1()
        {
            InitializeComponent();
            //Loads the content of stream to bitmap.
            LoadImage();
            this.pictureBox.Image = this.LenaImage;
            //CallBackResult object is created.
            cbResult = new CallBackResult(ResultReturn);

            //Initially Stop and Pause buttons are dissabled.
            btnStop.Enabled = false;
            btnPause.Enabled = false;
        }

        //Following function, reads the Embedded Resource into Stream.
        private void LoadImage()
        {
            Assembly MyAssembly = Assembly.GetExecutingAssembly();
            Stream LenaImageStream = MyAssembly.GetManifestResourceStream("ThreadingA.Resources.lena.JPG");
            //Creates the LenaImage using the Stream.
            if (LenaImage == null)
                LenaImage = new Bitmap(LenaImageStream);
            //Close the stream which is no more required.
            LenaImageStream.Close();

        }

        //Function is triggered using CallBackResult delegate. This function enables/disables
        //UI components which are created by UI thread. It is not allowed to access these 
        //components from other threads. Winforms provides Invoke() function which takes
        //a delegate. So on any thread Invoke() function can be called.

        void ResultReturn()
        {
            this.btnStart.Enabled = true;
            this.btnStop.Enabled = false;
            this.btnPause.Enabled = false;
        }

        //This is triggered when user clicks on Start button. 
        private void btnStart_Click(object sender, EventArgs e)
        {
            //Create a new thread.
            thread = new Thread(StartConversion);
            //Set buttons before thread start.
            btnStart.Enabled = false;
            btnStop.Enabled = true;
            this.btnPause.Enabled = true;
            //Start the thread by calling thread.Start().
            thread.Start();
        }

        //Thread is created to work on this function which Draw on the picture box.
        // The purpose of this application is to demonstrate threading, and therefore
        // we have deliberately chosen a slow way of image access - through 
        // GetPixel().
        private void StartConversion()
        {
            for (int i = 0; i < LenaImage.Height; i  )
                for (int j = 0; j < LenaImage.Width; j  )
                {
                    //Get individual pixels.
                    Color c = LenaImage.GetPixel(j, i);
                    //This is standard formula for converting color image into grey scale 
                    //image.
                    double r = 0.3 * c.R;
                    double g = 0.59 * c.G;
                    double b = 0.11 * c.B;
                    if (r < 0) r = 0;
                    if (g < 0) g = 0;
                    if (b < 0) b = 0;

                    int average = (int)Math.Ceiling((r   g   b));
                    Color greyValue = Color.FromArgb(average, average, average);
                    UpdatePictureBox(j, i, greyValue);
                }
            //Calling Call back function when conversion completes             
            this.Invoke(cbResult);
        }

        private void UpdatePictureBox(int x, int y, Color c)
        {
            //Graphics object is created using pictureBox Graphics object.

            using (g = pictureBox.CreateGraphics())
            {
                Pen p = new Pen(c);
                //A small rectangle 1x1 is drawn at x,y with color c.
                g.DrawRectangle(p, x, y, 1, 1);
                p.Dispose();
            }
        }

        //This is triggered when user clicks on stop button.
        private void btnStop_Click(object sender, EventArgs e)
        {
            threadKill();
            //Setting button property.
            this.btnStart.Enabled = true;
            this.btnPause.Enabled = false;
            this.btnStop.Enabled = false;
        }

        private void btnPause_Click(object sender, EventArgs e)
        {
            //When you about to pause a thread, it is recommended  to check the 
            //thread state. If Thread state is not Suspended and is not SuspendRequested,
            //then suspend the thread.
            if (0 == (thread.ThreadState & (ThreadState.Suspended | ThreadState.SuspendRequested)))
            {
                thread.Suspend();
                btnStop.Enabled = false;
                btnPause.Text = "Resume";
            }
            else
            {
                btnPause.Text = "Pause";
                thread.Resume();
                btnStop.Enabled = true;
            }
        }

        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            //Dispose the bitmap and graphics object.
            LenaImage.Dispose();
            if (g != null)
                g.Dispose();
        }

        private void btnClose_Click(object sender, EventArgs e)
        {
            threadKill();
            this.Close();
        }

        private void threadKill()
        {
            //When killing a thread, it is recommended to check the thread state. 
            //Threads can be aborted when they are running. But when threads are suspended
            //or thread state is SuspendRequested, so in this case, thread.Resume is called
            //and threads are aborted.
            //Suspended threads cannot be aborted directly. CLR will not abort a suspected 
            //thread. It will take thread to a state where GC can reclaim the memory.
           if(thread !=null)
            switch (thread.ThreadState)
            {
                case ThreadState.Suspended:
                case ThreadState.SuspendRequested:
                    thread.Resume();
                    thread.Abort();
                    break;
                case ThreadState.Running:
                    thread.Abort();
                    break;
                case ThreadState.Unstarted:
                    break;                    
            }
        }
    }
}