mcs/class/System.Drawing/Test/System.Drawing/TestBitmap.cs

   1 //
   2 // Bitmap class testing unit
   3 //
   4 // Author:
   5 //
   6 //       Jordi Mas i Hernàndez (jmas@softcatala.org>
   7 //
   8 // (C) 2004 Ximian, Inc.  http://www.ximian.com
   9 //
  10 using System;
  11 using System.Drawing;
  12 using System.Drawing.Imaging;
  13 using NUnit.Framework;
  14 using System.IO;
  15 using System.Security.Cryptography;
  16 using System.Text;
  17 using System.Runtime.InteropServices;
  18
  19 namespace MonoTests.System.Drawing{
  20
  21         [TestFixture]
  22         public class TestBitmap : Assertion {
  23
  24                 [TearDown]
  25                 public void Clean() {}
  26
  27                 [SetUp]
  28                 public void GetReady()
  29                 {
  30
  31                 }
  32
  33                 [Test]
  34                 public void TestPixels()
  35                 {
  36                         // Tests GetSetPixel/SetPixel
  37                         Bitmap bmp= new Bitmap(100,100, PixelFormat.Format32bppRgb);
  38                         bmp.SetPixel(0,0,Color.FromArgb(255,128,128,128));
  39                         Color color = bmp.GetPixel(0,0);
  40
  41                         AssertEquals (Color.FromArgb(255,128,128,128), color);
  42
  43                         bmp.SetPixel(99,99,Color.FromArgb(255,255,0,155));
  44                         Color color2 = bmp.GetPixel(99,99);
  45                         AssertEquals (Color.FromArgb(255,255,0,155), color2);
  46                 }
  47
  48                 /* Get the output directory depending on the runtime and location*/
  49                 internal string getOutSubDir()
  50                 {
  51                         string sSub, sRslt;
  52
  53                         if (Environment.GetEnvironmentVariable("MSNet")==null)
  54                                 sSub = "mono/";
  55                         else
  56                                 sSub = "MSNet/";
  57
  58                         sRslt = Path.GetFullPath (sSub);
  59
  60                         if (Directory.Exists(sRslt) ==  false)
  61                                 sRslt = "Test/System.Drawing/" + sSub;
  62
  63                         if (sRslt.Length > 0)
  64                                 if (sRslt[sRslt.Length-1] != '\\' && sRslt[sRslt.Length-1] != '/')
  65                                         sRslt += "/";
  66
  67                         return sRslt;
  68                 }
  69
  70                 /* Get the input directory depending on the runtime*/
  71                 internal string getInFile(string file)
  72                 {
  73                         string sRslt;
  74
  75                         sRslt = Path.GetFullPath (file);
  76
  77                         if (File.Exists(file)==false)
  78                                 sRslt = "Test/System.Drawing/" + file;
  79
  80                         return sRslt;
  81                 }
  82
  83
  84
  85                 //[Test]
  86                 public void MakeTransparent()
  87                 {
  88                         string sInFile =   getInFile("bitmaps/maketransparent.bmp");
  89                         string sOutFile =  getOutSubDir() + "transparent.bmp";
  90
  91                         Bitmap  bmp = new Bitmap(sInFile);
  92                         Console.WriteLine("Bitmap loaded OK", bmp != null);
  93
  94                         bmp.MakeTransparent();
  95                         bmp.Save(sOutFile);
  96
  97                         Color color = bmp.GetPixel(1,1);
  98                         AssertEquals (Color.Black.R, color.R);
  99                         AssertEquals (Color.Black.G, color.G);
 100                         AssertEquals (Color.Black.B, color.B);
 101                 }
 102
 103                 [Test]
 104                 public void Clone()
 105                 {
 106                         string sInFile = getInFile ("bitmaps/almogaver24bits.bmp");
 107                         string sOutFile =  getOutSubDir() + "clone24.bmp";
 108
 109                         Rectangle rect = new Rectangle(0,0,50,50);
 110                         Bitmap  bmp = new Bitmap(sInFile);
 111
 112                         Bitmap bmpNew = bmp.Clone (rect, PixelFormat.Format32bppArgb);
 113
 114                         Color colororg0 = bmp.GetPixel(0,0);
 115                         Color colororg50 = bmp.GetPixel(49,49);
 116                         Color colornew0 = bmpNew.GetPixel(0,0);
 117                         Color colornew50 = bmpNew.GetPixel(49,49);
 118
 119                         AssertEquals (colororg0, colornew0);
 120                         AssertEquals (colororg50, colornew50);
 121                 }
 122
 123                 [Test]
 124                 public void CloneImage()
 125                 {
 126                         string sInFile = getInFile ("bitmaps/almogaver24bits.bmp");
 127                         Bitmap  bmp = new Bitmap(sInFile);
 128
 129                         Bitmap bmpNew = (Bitmap) bmp.Clone ();
 130
 131                         AssertEquals (bmp.Width, bmpNew.Width);
 132                         AssertEquals (bmp.Height, bmpNew.Height);
 133                         AssertEquals (bmp.PixelFormat, bmpNew.PixelFormat);
 134
 135                 }
 136
 137                 //[Test]
 138                 public void Frames()
 139                 {
 140                         string sInFile = getInFile ("bitmaps/almogaver24bits.bmp");
 141                         Bitmap  bmp = new Bitmap(sInFile);
 142                         int cnt = bmp.GetFrameCount(FrameDimension.Page);
 143                         int active = bmp.SelectActiveFrame (FrameDimension.Page, 0);
 144
 145                         AssertEquals (1, cnt);
 146                         AssertEquals (0, active);
 147                 }
 148
 149                 static string ByteArrayToString(byte[] arrInput)
 150                 {
 151                         int i;
 152                         StringBuilder sOutput = new StringBuilder(arrInput.Length);
 153                         for (i=0;i < arrInput.Length -1; i++)
 154                         {
 155                                 sOutput.Append(arrInput[i].ToString("X2"));
 156                         }
 157                         return sOutput.ToString();
 158                 }
 159
 160
 161                 public string RotateBmp (Bitmap src, RotateFlipType rotate)
 162                 {
 163                         int witdh = 150, height = 150, index = 0;
 164                         byte[] pixels = new byte [witdh * height * 3];
 165                         Bitmap bmp_rotate;
 166                         byte[] hash;
 167                         Color clr;
 168
 169
 170                         bmp_rotate = src.Clone (new RectangleF (0,0, witdh, height), PixelFormat.Format32bppArgb);
 171                         bmp_rotate.RotateFlip (rotate);
 172
 173                         for (int y = 0; y < height; y++) {
 174                                 for (int x = 0; x < witdh; x++) {
 175                                         clr = bmp_rotate.GetPixel (x,y);
 176                                         pixels[index++] = clr.R; pixels[index++] = clr.G; pixels[index++]  = clr.B;
 177                                 }
 178                         }
 179
 180                         hash = new MD5CryptoServiceProvider().ComputeHash (pixels);
 181                         return ByteArrayToString (hash);
 182                 }
 183
 184
 185                 /*
 186                         Rotate bitmap in diffent ways, and check the result
 187                         pixels using MD5
 188                 */
 189                 [Test]
 190                 public void Rotate()
 191                 {
 192                         string sInFile = getInFile ("bitmaps/almogaver24bits.bmp");
 193                         Bitmap  bmp = new Bitmap(sInFile);
 194
 195                         AssertEquals ("312958A3C67402E1299413794988A3", RotateBmp (bmp, RotateFlipType.Rotate90FlipNone));
 196                         AssertEquals ("BF70D8DA4F1545AEDD77D0296B47AE", RotateBmp (bmp, RotateFlipType.Rotate180FlipNone));
 197                         AssertEquals ("15AD2ADBDC7090C0EC744D0F7ACE2F", RotateBmp (bmp, RotateFlipType.Rotate270FlipNone));
 198                         AssertEquals ("2E10FEC1F4FD64ECC51D7CE68AEB18", RotateBmp (bmp, RotateFlipType.RotateNoneFlipX));
 199                         AssertEquals ("E63204779B566ED01162B90B49BD9E", RotateBmp (bmp, RotateFlipType.Rotate90FlipX));
 200                         AssertEquals ("B1ECB17B5093E13D04FF55CFCF7763", RotateBmp (bmp, RotateFlipType.Rotate180FlipX));
 201                         AssertEquals ("71A173882C16755D86F4BC26532374", RotateBmp (bmp, RotateFlipType.Rotate270FlipX));
 202
 203                 }
 204
 205                 public void LockBmp (PixelFormat fmt, PixelFormat fmtlock, string output,
 206                         int lwidth , int lheight, ref string hash1, ref string hash2)
 207                 {
 208                         int width = 100, height = 100, bbps, cur, pos;
 209                         Bitmap  bmp = new Bitmap (width, height, fmt);
 210                         Graphics gr = Graphics.FromImage (bmp);
 211                         byte[] hash;
 212                         Color clr;
 213                         byte[] btv = new byte[1];
 214                         int y, x, len = width * height * 4, index = 0;
 215                         byte[] pixels = new byte [len];
 216                         hash1 = hash2 ="";
 217
 218                         bbps = Image.GetPixelFormatSize (fmt);
 219
 220                         Pen p = new Pen (Color.FromArgb (255, 100, 200, 250), 2);
 221                         gr.DrawRectangle(p, 1.0F, 1.0F, 80.0F, 80.0F);
 222
 223                         BitmapData bd = bmp.LockBits (new Rectangle (0, 0, lwidth, lheight), ImageLockMode.ReadOnly,  fmtlock);
 224
 225                         pos = bd.Scan0.ToInt32();
 226                         for (y = 0; y < bd.Height; y++) {
 227                                 for (x = 0; x < bd.Width; x++) {
 228
 229                                         /* Read the pixels*/
 230                                         for (int bt =0; bt < bbps/8; bt++, index++) {
 231                                                 cur = pos;
 232                                                 cur+= y * bd.Stride;
 233                                                 cur+= x * bbps/8;
 234                                                 cur+= bt;
 235                                                 Marshal.Copy ((IntPtr)cur, btv, 0, 1);
 236                                                 pixels[index] = btv[0];
 237
 238                                                 /* Make change of all the colours = 250 to 10*/
 239                                                 if (btv[0] == 250) {
 240                                                         btv[0] = 10;
 241                                                         Marshal.Copy (btv, 0, (IntPtr)cur, 1);
 242                                                 }
 243                                         }
 244                                 }
 245                         }
 246
 247                         for (int i = index; i < len; i++)
 248                                 pixels[index] = 0;
 249
 250                         hash = new MD5CryptoServiceProvider().ComputeHash (pixels);
 251                         bmp.UnlockBits (bd);
 252
 253                         hash1 = ByteArrayToString (hash);
 254
 255                         /* MD5 of the changed bitmap*/
 256                         for (y = 0, index = 0; y < height; y++) {
 257                                 for (x = 0; x < width; x++) {
 258                                         clr = bmp.GetPixel (x,y);
 259                                         pixels[index++] = clr.R; pixels[index++] = clr.G; pixels[index++]  = clr.B;
 260                                 }
 261                         }
 262
 263                         hash = new MD5CryptoServiceProvider().ComputeHash (pixels);
 264                         hash2 = ByteArrayToString (hash);
 265
 266                         /*bmp.Save (output, ImageFormat.Bmp);*/
 267                 }
 268                 /*
 269                         Tests the LockBitmap functions. Makes a hash of the block of pixels that it returns
 270                         firsts, changes them, and then using GetPixel does another check of the changes.
 271                         The results match the .Net framework
 272                 */
 273                 [Test]
 274                 public void LockBitmap ()
 275                 {
 276                         string hash = "";
 277                         string hashchg = "";
 278
 279                         /* Locks the whole bitmap*/
 280                         LockBmp (PixelFormat.Format32bppArgb, PixelFormat.Format32bppArgb, "output32bppArgb.bmp", 100, 100, ref hash, ref hashchg);
 281                         AssertEquals ("AF5BFD4E98D6708FF4C9982CC9C68F", hash);
 282                         AssertEquals ("BBEE27DC85563CB58EE11E8951230F", hashchg);
 283
 284                         LockBmp (PixelFormat.Format32bppPArgb, PixelFormat.Format32bppPArgb, "output32bppPArgb.bmp", 100, 100, ref hash, ref hashchg);
 285                         AssertEquals ("AF5BFD4E98D6708FF4C9982CC9C68F", hash);
 286                         AssertEquals ("BBEE27DC85563CB58EE11E8951230F", hashchg);
 287
 288                         LockBmp (PixelFormat.Format32bppRgb, PixelFormat.Format32bppRgb, "output32bppRgb.bmp", 100, 100, ref hash, ref hashchg);
 289                         AssertEquals ("AF5BFD4E98D6708FF4C9982CC9C68F", hash);
 290                         AssertEquals ("BBEE27DC85563CB58EE11E8951230F", hashchg);
 291
 292                         LockBmp (PixelFormat.Format24bppRgb, PixelFormat.Format24bppRgb, "output24bppRgb.bmp", 100, 100, ref hash, ref hashchg);
 293                         AssertEquals ("A8A071D0B3A3743905B4E193A62769", hash);
 294                         AssertEquals ("EEE846FA8F892339C64082DFF775CF", hashchg);
 295
 296                         /* Locks a portion of the bitmap*/
 297                         LockBmp (PixelFormat.Format32bppArgb, PixelFormat.Format32bppArgb, "output32bppArgb.bmp", 50, 50, ref hash, ref hashchg);
 298                         AssertEquals ("C361FBFD82A4F3C278605AE9EC5385", hash);
 299                         AssertEquals ("8C2C04B361E1D5875EE8ACF5073F4E", hashchg);
 300
 301                         LockBmp (PixelFormat.Format32bppPArgb, PixelFormat.Format32bppPArgb, "output32bppPArgb.bmp", 50, 50, ref hash, ref hashchg);
 302                         AssertEquals ("C361FBFD82A4F3C278605AE9EC5385", hash);
 303                         AssertEquals ("8C2C04B361E1D5875EE8ACF5073F4E", hashchg);
 304
 305                         LockBmp (PixelFormat.Format32bppRgb, PixelFormat.Format32bppRgb, "output32bppRgb.bmp", 50, 50, ref hash, ref hashchg);
 306                         AssertEquals ("C361FBFD82A4F3C278605AE9EC5385", hash);
 307                         AssertEquals ("8C2C04B361E1D5875EE8ACF5073F4E", hashchg);
 308
 309                         LockBmp (PixelFormat.Format24bppRgb, PixelFormat.Format24bppRgb, "output24bppRgb.bmp", 50, 50, ref hash, ref hashchg);
 310                         AssertEquals ("FFE86628478591D1A1EB30E894C34F", hash);
 311                         AssertEquals ("8C2C04B361E1D5875EE8ACF5073F4E", hashchg);
 312
 313                 }
 314
 315         }
 316 }