30種類の画像アニメーション特効アルゴリズム(C#マルチスレッド版)(上)


オリジナル作品は、転載が許可されていますので、転載時には必ずハイパーリンク形式で文章を明記してください  元の出典 、作者情報と本声明.さもないと法律責任を追及する.http://mengliao.blog.51cto.com/876134/473169
    これは比較的複雑なプログラムで、30種類の画像アニメーションの特効プレゼンテーションが含まれており、C#を使用して作成され、ソースプログラムは約2000行以上あります.    このソフトウェアは実際には主に4つの方面の内容です.    ランダムワイヤ、交互ブロック、マルチスキャンなどを含む1、30種類のアニメーション特効アルゴリズム.これらのアルゴリズムの設計は比較的巧みで、つまり画像処理のいくつかの技術を大量に使用している.    2、.NETのGDI+技術機能は非常に強く、本ソフトウェアでは、シミュレーション変換マトリクス、色変換マトリクス、ブロック処理など、GDI+の各方面にほとんど関与しています.    3、マルチスレッド技術を採用し、ソフトウェアを秩序正しく見えるようにし、同時に信号量を採用して一時停止、継続、キャンセルなどの機能を実現する.    4、比较的に厳格なオブジェクト向けのプログラム设计技术を采用して、クラスの定义から方法の、事件の定义まですべて厳格にOOP理论によって完成して、比较的に完全で、精確にOOPの精髄を体現したと言える.    これはスクリーンショットのアニメーション効果です.      ソースプログラムが多すぎるので、3回に分けて出します. 

   
   
   
   
  1. using System;  
  2. using System.Drawing;  
  3. using System.Drawing.Drawing2D;  
  4. using System.Drawing.Imaging;  
  5. using System.Threading;  
  6. using System.Windows.Forms;  
  7.  
  8. namespace Mengliao.CSharp.A14  
  9. {  
  10.     #region    
  11.  
  12.     //  ,  
  13.     enum AnimateType  
  14.     {  
  15.         Animator01, Animator02, Animator03, Animator04, Animator05,  
  16.         Animator06, Animator07, Animator08, Animator09, Animator10,  
  17.         Animator11, Animator12, Animator13, Animator14, Animator15,  
  18.         Animator16, Animator17, Animator18, Animator19, Animator20,  
  19.         Animator21, Animator22, Animator23, Animator24, Animator25,  
  20.         Animator26, Animator27, Animator28, Animator29, Animator30  
  21.     }  
  22.  
  23.     #endregion  
  24.  
  25.     class AnimatorImage  
  26.     {  
  27.         #region   
  28.  
  29.         //   
  30.         private Bitmap bmp;  
  31.         //   
  32.         private bool drawStarted = false;  
  33.  
  34.         //  ,  
  35.         private AutoResetEvent cancelEvent = new AutoResetEvent(false);  
  36.  
  37.         //  ,  
  38.         private ManualResetEvent pauseEvent = new ManualResetEvent(false);  
  39.  
  40.         //  DC  
  41.         private Graphics dc;  
  42.  
  43.         #endregion  
  44.  
  45.         #region   
  46.  
  47.         private Bitmap outBmp;  
  48.         /// <summary>  
  49.         ///  。  
  50.         /// </summary>  
  51.         public Bitmap OutBmp  
  52.         {  
  53.             get { return outBmp; }  
  54.         }  
  55.  
  56.         private int delay;  
  57.         /// <summary>  
  58.         ///  。  
  59.         /// </summary>  
  60.         public int Delay  
  61.         {  
  62.             get { return delay; }  
  63.             set { delay = Math.Min(Math.Max(1, value), 100); } //  1 100  
  64.         }  
  65.  
  66.         /// <summary>  
  67.         ///  。  
  68.         /// </summary>  
  69.         public event PaintEventHandler Redraw;  
  70.         protected void OnRedraw(Rectangle clipRectangle)  
  71.         {  
  72.             if (Redraw != null)  
  73.             {  
  74.                 Redraw.Invoke(thisnew PaintEventArgs(dc, clipRectangle));  
  75.             }  
  76.         }  
  77.  
  78.         /// <summary>  
  79.         ///  。  
  80.         /// </summary>  
  81.         public event EventHandler DrawStarted;  
  82.         protected void OnDrawStarted(object sender, EventArgs e)  
  83.         {  
  84.             drawStarted = true;  
  85.             if (DrawStarted != null)  
  86.             {  
  87.                 DrawStarted.Invoke(sender, e);  
  88.             }  
  89.         }  
  90.  
  91.         /// <summary>  
  92.         ///  。  
  93.         /// </summary>  
  94.         public event EventHandler DrawCompleted;  
  95.         protected void OnDrawCompleted(object sender, EventArgs e)  
  96.         {  
  97.             drawStarted = false;  
  98.             cancelEvent.Reset();  
  99.             if (DrawCompleted != null)  
  100.             {  
  101.                 DrawCompleted.Invoke(sender, e);  
  102.             }  
  103.         }  
  104.  
  105.         #endregion  
  106.  
  107.         #region   
  108.  
  109.         //   
  110.         private void ShowError(string errMsg)  
  111.         {  
  112.             Font font = new Font(" ", 9);  
  113.             SizeF size = dc.MeasureString(errMsg, font);  
  114.             PointF point = new PointF((outBmp.Width - size.Width) / 2f, (outBmp.Height - size.Height) / 2f);  
  115.             //  , ,  
  116.             dc.DrawString(errMsg, font, Brushes.Red, point.X - 1f, point.Y);  
  117.             dc.DrawString(errMsg, font, Brushes.Red, point.X + 1f, point.Y);  
  118.             dc.DrawString(errMsg, font, Brushes.Red, point.X, point.Y - 1f);  
  119.             dc.DrawString(errMsg, font, Brushes.Red, point.X, point.Y + 1f);  
  120.             //   
  121.             dc.DrawString(errMsg, font, Brushes.White, point);  
  122.             ShowBmp(new Rectangle(Point.Round(point), Size.Round(size)));  
  123.         }  
  124.  
  125.         //  ,  
  126.         private void ShowBmp(Rectangle clipRectangle)  
  127.         {  
  128.             string cancelMsg = " !";  
  129.             OnRedraw(clipRectangle);  
  130.             if (cancelEvent.WaitOne(0)) //   
  131.             {  
  132.                 //  ,  
  133.                 throw new ApplicationException(cancelMsg);  
  134.             }  
  135.             while (pauseEvent.WaitOne(0)) //   
  136.             {  
  137.                 if (cancelEvent.WaitOne(10)) //   
  138.                 {  
  139.                     pauseEvent.Reset();  
  140.                     throw new ApplicationException(cancelMsg);  
  141.                 }  
  142.             }  
  143.         }  
  144.         private void ShowBmp(RectangleF clipRectangle) //   
  145.         {  
  146.             ShowBmp(Rectangle.Round(clipRectangle));  
  147.         }  
  148.         private void ShowBmp() //   
  149.         {  
  150.             ShowBmp(new Rectangle(0, 0, bmp.Width, bmp.Height));  
  151.         }  
  152.  
  153.         //   
  154.         private void ClearBackground()  
  155.         {  
  156.             dc.Clear(Color.FromKnownColor(KnownColor.ButtonFace)); //   
  157.             ShowBmp(); //   
  158.         }  
  159.  
  160.         #endregion  
  161.  
  162.         #region   
  163.  
  164.         /// <summary>  
  165.         ///  。  
  166.         /// </summary>  
  167.         public void CancelDraw()  
  168.         {  
  169.             if (drawStarted)  
  170.             {  
  171.                 cancelEvent.Set();  
  172.             }  
  173.         }  
  174.  
  175.         /// <summary>  
  176.         ///  。  
  177.         /// </summary>  
  178.         public void PauseDraw()  
  179.         {  
  180.             if (drawStarted)  
  181.             {  
  182.                 pauseEvent.Set();  
  183.             }  
  184.         }  
  185.  
  186.         /// <summary>  
  187.         ///  。  
  188.         /// </summary>  
  189.         public void ResumeDraw()  
  190.         {  
  191.             if (drawStarted)  
  192.             {  
  193.                 pauseEvent.Reset();  
  194.             }  
  195.         }  
  196.  
  197.         #endregion  
  198.  
  199.         #region   
  200.         /// <summary>  
  201.         ///  , , ; 1。  
  202.         /// </summary>  
  203.         /// <param name="inBmp"> </param>  
  204.         public AnimatorImage(Bitmap inBmp)  
  205.         {  
  206.             delay = 1;  
  207.             this.bmp = (Bitmap)inBmp.Clone();  
  208.             outBmp = new Bitmap(this.bmp.Width, this.bmp.Height);  
  209.             dc = Graphics.FromImage(outBmp);  
  210.         }  
  211.  
  212.         #endregion  
  213.  
  214.         #region   
  215.         /// <summary>  
  216.         ///  。  
  217.         /// </summary>  
  218.         /// <param name="animateType"> </param>  
  219.         public void DrawAnimator(AnimateType animateType)  
  220.         {  
  221.             if (drawStarted) //   
  222.             {  
  223.                 if (pauseEvent.WaitOne(0)) //  , ,  
  224.                     pauseEvent.Reset();  
  225.                 else 
  226.                     pauseEvent.Set();  
  227.                 return;  
  228.             }  
  229.             ThreadStart threadMethod;  
  230.             switch (animateType)  
  231.             {  
  232.                 case AnimateType.Animator01:  
  233.                     threadMethod = Animator01;  
  234.                     break;  
  235.                 case AnimateType.Animator02:  
  236.                     threadMethod = Animator02;  
  237.                     break;  
  238.                 case AnimateType.Animator03:  
  239.                     threadMethod = Animator03;  
  240.                     break;  
  241.                 case AnimateType.Animator04:  
  242.                     threadMethod = Animator04;  
  243.                     break;  
  244.                 case AnimateType.Animator05:  
  245.                     threadMethod = Animator05;  
  246.                     break;  
  247.                 case AnimateType.Animator06:  
  248.                     threadMethod = Animator06;  
  249.                     break;  
  250.                 case AnimateType.Animator07:  
  251.                     threadMethod = Animator07;  
  252.                     break;  
  253.                 case AnimateType.Animator08:  
  254.                     threadMethod = Animator08;  
  255.                     break;  
  256.                 case AnimateType.Animator09:  
  257.                     threadMethod = Animator09;  
  258.                     break;  
  259.                 case AnimateType.Animator10:  
  260.                     threadMethod = Animator10;  
  261.                     break;  
  262.                 case AnimateType.Animator11:  
  263.                     threadMethod = Animator11;  
  264.                     break;  
  265.                 case AnimateType.Animator12:  
  266.                     threadMethod = Animator12;  
  267.                     break;  
  268.                 case AnimateType.Animator13:  
  269.                     threadMethod = Animator13;  
  270.                     break;  
  271.                 case AnimateType.Animator14:  
  272.                     threadMethod = Animator14;  
  273.                     break;  
  274.                 case AnimateType.Animator15:  
  275.                     threadMethod = Animator15;  
  276.                     break;  
  277.                 case AnimateType.Animator16:  
  278.                     threadMethod = Animator16;  
  279.                     break;  
  280.                 case AnimateType.Animator17:  
  281.                     threadMethod = Animator17;  
  282.                     break;  
  283.                 case AnimateType.Animator18:  
  284.                     threadMethod = Animator18;  
  285.                     break;  
  286.                 case AnimateType.Animator19:  
  287.                     threadMethod = Animator19;  
  288.                     break;  
  289.                 case AnimateType.Animator20:  
  290.                     threadMethod = Animator20;  
  291.                     break;  
  292.                 case AnimateType.Animator21:  
  293.                     threadMethod = Animator21;  
  294.                     break;  
  295.                 case AnimateType.Animator22:  
  296.                     threadMethod = Animator22;  
  297.                     break;  
  298.                 case AnimateType.Animator23:  
  299.                     threadMethod = Animator23;  
  300.                     break;  
  301.                 case AnimateType.Animator24:  
  302.                     threadMethod = Animator24;  
  303.                     break;  
  304.                 case AnimateType.Animator25:  
  305.                     threadMethod = Animator25;  
  306.                     break;  
  307.                 case AnimateType.Animator26:  
  308.                     threadMethod = Animator26;  
  309.                     break;  
  310.                 case AnimateType.Animator27:  
  311.                     threadMethod = Animator27;  
  312.                     break;  
  313.                 case AnimateType.Animator28:  
  314.                     threadMethod = Animator28;  
  315.                     break;  
  316.                 case AnimateType.Animator29:  
  317.                     threadMethod = Animator29;  
  318.                     break;  
  319.                 default:  
  320.                     threadMethod = Animator30;  
  321.                     break;  
  322.             }  
  323.             Thread drawThread = new Thread(threadMethod);  
  324.             drawThread.IsBackground = true//  ,  
  325.             drawThread.Start();  
  326.         }  
  327.  
  328.         #endregion  
  329.  
  330.         // ==========  
  331.         //   
  332.         // ==========  
  333.  
  334.         #region  ( )  
  335.  
  336.         //  : ,  
  337.         private void Animator01()  
  338.         {  
  339.             const float blockSize = 8; //  ,  
  340.             try 
  341.             {  
  342.                 OnDrawStarted(this, EventArgs.Empty); //   
  343.                 //ClearBackground();  
  344.  
  345.                 Color bgColor = Color.FromKnownColor(KnownColor.ButtonFace);  
  346.                 RectangleF srcRect = new RectangleF(0, 0, bmp.Width, bmp.Height);  
  347.                 for (float i = (float)Math.Floor(-bmp.Height / blockSize); i <= Math.Ceiling(bmp.Height / blockSize); i++)  
  348.                 {  
  349.                     dc.Clear(bgColor); //  DC  
  350.                     float j = i * blockSize / 2;  
  351.                     float destTop = bmp.Height / 2 - j; //   
  352.                     //   
  353.                     RectangleF destRect = new RectangleF(0, destTop, bmp.Width, 2 * j);  
  354.                     //  ,  
  355.                     dc.DrawImage(bmp, destRect, srcRect, GraphicsUnit.Pixel);  
  356.  
  357.                     ShowBmp();  
  358.                     Thread.Sleep(10 * delay); //   
  359.                 }  
  360.             }  
  361.             catch (Exception ex)  
  362.             {  
  363.                 ShowError(ex.Message);  
  364.             }  
  365.             finally 
  366.             {  
  367.                 OnDrawCompleted(this, EventArgs.Empty); //   
  368.             }  
  369.         }  
  370.  
  371.         #endregion  
  372.  
  373.         #region  ( )  
  374.  
  375.         //  : ,  
  376.         private void Animator02()  
  377.         {  
  378.             const int stepCount = 4; //  ,  
  379.             try 
  380.             {  
  381.                 OnDrawStarted(this, EventArgs.Empty);  
  382.                 ClearBackground();  
  383.  
  384.                 Rectangle sourTopRect = new Rectangle(0, 0, bmp.Width, bmp.Height / 2); //   
  385.                 Rectangle sourBottRect = new Rectangle(0, bmp.Height / 2, bmp.Width, bmp.Height / 2); //   
  386.                 for (int i = 0; i <= bmp.Height / 2; i += stepCount)  
  387.                 {  
  388.                     Rectangle destTopRect = new Rectangle(0, i - bmp.Height / 2 + 1, bmp.Width, bmp.Height / 2); //   
  389.                     Rectangle destBottRect = new Rectangle(0, bmp.Height - i - 1, bmp.Width, bmp.Height / 2); //   
  390.                     dc.DrawImage(bmp, destTopRect, sourTopRect, GraphicsUnit.Pixel);  
  391.                     dc.DrawImage(bmp, destBottRect, sourBottRect, GraphicsUnit.Pixel);  
  392.  
  393.                     ShowBmp(Rectangle.Union(destTopRect, destBottRect));  
  394.                     Thread.Sleep(10 * delay);  
  395.                 }  
  396.             }  
  397.             catch (Exception ex)  
  398.             {  
  399.                 ShowError(ex.Message);  
  400.             }  
  401.             finally 
  402.             {  
  403.                 OnDrawCompleted(this, EventArgs.Empty);  
  404.             }  
  405.         }  
  406.  
  407.         #endregion  
  408.  
  409.         #region  ( )  
  410.  
  411.         //  : , ,  
  412.         private void Animator03()  
  413.         {  
  414.             const float stepCount = 4; //   
  415.             try 
  416.             {  
  417.                 OnDrawStarted(this, EventArgs.Empty);  
  418.                 ClearBackground();  
  419.  
  420.                 //  , Region ,  
  421.                 Region region = new Region(new GraphicsPath());  
  422.                 //   
  423.                 TextureBrush textureBrush = new TextureBrush(bmp);  
  424.                 for (float x = 0; x <= bmp.Width / 2f; x += stepCount)  
  425.                 {  
  426.                     //   
  427.                     region.Union(new Rectangle(0, 0, bmp.Width, bmp.Height));  
  428.                     //  ,  
  429.                     //  , , ,  
  430.                     float y = x * bmp.Height / bmp.Width;  
  431.                     RectangleF rect = new RectangleF(x, y, bmp.Width - 2f * x, bmp.Height - 2f * y);  
  432.                     //   
  433.                     region.Exclude(rect);  
  434.                     dc.FillRegion(textureBrush, region); //   
  435.  
  436.                     ShowBmp(region.GetBounds(dc));  
  437.                     Thread.Sleep(10 * delay);  
  438.                 }  
  439.                 //  stepCount , ,  
  440.                 dc.DrawImage(bmp, 0, 0);  
  441.  
  442.                 ShowBmp();  
  443.             }  
  444.             catch (Exception ex)  
  445.             {  
  446.                 ShowError(ex.Message);  
  447.             }  
  448.             finally 
  449.             {  
  450.                 OnDrawCompleted(this, EventArgs.Empty);  
  451.             }  
  452.         }  
  453.  
  454.         #endregion  
  455.  
  456.         #region  ( )  
  457.  
  458.         //  : ,  
  459.         private void Animator04()  
  460.         {  
  461.             const int stepCount = 4; //  ,  
  462.             try 
  463.             {  
  464.                 OnDrawStarted(this, EventArgs.Empty);  
  465.                 ClearBackground();  
  466.  
  467.                 Rectangle sourRect = new Rectangle(0, 0, bmp.Width, bmp.Height); //   
  468.                 for (int i = 0; i <= bmp.Width / 2; i += stepCount)  
  469.                 {  
  470.                     int j = i * bmp.Height / bmp.Width; //  , , ,  
  471.                     Rectangle destRect = new Rectangle(bmp.Width / 2 - i, bmp.Height / 2 - j, 2 * i, 2 * j);  
  472.                     dc.DrawImage(bmp, destRect, sourRect, GraphicsUnit.Pixel);  
  473.  
  474.                     ShowBmp(destRect);  
  475.                     Thread.Sleep(10 * delay);  
  476.                 }  
  477.             }  
  478.             catch (Exception ex)  
  479.             {  
  480.                 ShowError(ex.Message);  
  481.             }  
  482.             finally 
  483.             {  
  484.                 OnDrawCompleted(this, EventArgs.Empty);  
  485.             }  
  486.         }  
  487.  
  488.         #endregion  
  489.  
  490.         #region   
  491.  
  492.         //  : , ,  
  493.         private void Animator05()  
  494.         {  
  495.             const float blockSize = 50; //   
  496.             try 
  497.             {  
  498.                 OnDrawStarted(this, EventArgs.Empty);  
  499.                 ClearBackground();  
  500.  
  501.                 //  、 ,  
  502.                 for (int y = 0; y < Math.Ceiling(bmp.Height / blockSize); y++)  
  503.                 {  
  504.                     for (int x = 0; x < Math.Ceiling(bmp.Width / blockSize); x++)  
  505.                     {  
  506.                         RectangleF rect;  
  507.                         if (y % 2 == 0) //   
  508.                         {  
  509.                             rect = new RectangleF(x * blockSize, y * blockSize, blockSize, blockSize);  
  510.                         }  
  511.                         else //   
  512.                         {  
  513.                             rect = new RectangleF((bmp.Width / blockSize - x - 1) * blockSize, y * blockSize, blockSize, blockSize);  
  514.                         }  
  515.                         dc.DrawImage(bmp, rect, rect, GraphicsUnit.Pixel);  
  516.  
  517.                         ShowBmp(rect);  
  518.                         Thread.Sleep(10 * delay);  
  519.                     }  
  520.                 }  
  521.             }  
  522.             catch (Exception ex)  
  523.             {  
  524.                 ShowError(ex.Message);  
  525.             }  
  526.             finally 
  527.             {  
  528.                 OnDrawCompleted(this, EventArgs.Empty);  
  529.             }  
  530.         }  
  531.  
  532.         #endregion  
  533.  
  534.         #region  ( )  
  535.  
  536.         //  : , ,  
  537.         private void Animator06()  
  538.         {  
  539.             const float blockSize = 70; //   
  540.             const int showWidth = 1; //   
  541.             try 
  542.             {  
  543.                 OnDrawStarted(this, EventArgs.Empty);  
  544.                 ClearBackground();  
  545.  
  546.                 //  , Region ,  
  547.