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

   1 //
   2 // Region class testing unit
   3 //
   4 // Author:
   5 //   Jordi Mas, jordi@ximian.com
   6 //
   7
   8 //
   9 // Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
  10 //
  11 // Permission is hereby granted, free of charge, to any person obtaining
  12 // a copy of this software and associated documentation files (the
  13 // "Software"), to deal in the Software without restriction, including
  14 // without limitation the rights to use, copy, modify, merge, publish,
  15 // distribute, sublicense, and/or sell copies of the Software, and to
  16 // permit persons to whom the Software is furnished to do so, subject to
  17 // the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be
  20 // included in all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 //
  30
  31 using System;
  32 using System.Drawing.Imaging;
  33 using System.Drawing;
  34 using System.Drawing.Drawing2D;
  35 using System.Security.Permissions;
  36 using NUnit.Framework;
  37
  38 namespace MonoTests.System.Drawing
  39 {
  40
  41         [TestFixture]
  42         [SecurityPermission (SecurityAction.Deny, UnmanagedCode = true)]
  43         public class TestRegion
  44         {
  45                 [TearDown]
  46                 public void Clean() {}
  47
  48                 [SetUp]
  49                 public void GetReady()
  50                 {
  51
  52                 }
  53
  54                 /* For debugging */
  55                 public static void DumpRegion (Region rgn)
  56                 {
  57                         Matrix matrix = new Matrix ();
  58                         RectangleF [] rects = rgn.GetRegionScans (matrix);
  59
  60                         for (int i = 0; i < rects.Length; i++)
  61                                 Console.WriteLine ( rects[i]);
  62                 }
  63
  64                 [Test]
  65                 public void TestBounds()
  66                 {
  67                         Bitmap bmp = new Bitmap (600, 800);
  68                         Graphics dc = Graphics.FromImage (bmp);
  69                         Rectangle rect1, rect2;
  70                         Region rgn1, rgn2;
  71                         RectangleF bounds;
  72
  73                         rect1 = new Rectangle (500, 30, 60, 80);
  74                         rect2 = new Rectangle (520, 40, 60, 80);
  75                         rgn1 = new Region(rect1);
  76                         rgn2 = new Region(rect2);
  77                         rgn1.Union(rgn2);
  78
  79                         bounds = rgn1.GetBounds (dc);
  80
  81                         Assert.AreEqual (500, bounds.X);
  82                         Assert.AreEqual (30, bounds.Y);
  83                         Assert.AreEqual (80, bounds.Width);
  84                         Assert.AreEqual (90, bounds.Height);
  85                 }
  86
  87                 [Test]
  88                 public void TestCloneAndEquals()
  89                 {
  90                         Bitmap bmp = new Bitmap (600, 800);
  91                         Graphics dc = Graphics.FromImage (bmp);
  92                         Rectangle rect1, rect2;
  93                         Region rgn1, rgn2;
  94                         RectangleF [] rects;
  95                         RectangleF [] rects2;
  96                         Matrix matrix = new Matrix ();
  97
  98                         rect1 = new Rectangle (500, 30, 60, 80);
  99                         rect2 = new Rectangle (520, 40, 60, 80);
 100                         rgn1 = new Region (rect1);
 101                         rgn1.Union (rect2);
 102                         rgn2 = rgn1.Clone ();
 103
 104                         rects = rgn1.GetRegionScans (matrix);
 105                         rects2 = rgn2.GetRegionScans (matrix);
 106
 107                         Assert.AreEqual (rects.Length, rects2.Length);
 108
 109                         for (int i = 0; i < rects.Length; i++) {
 110
 111                                 Assert.AreEqual (rects[i].X, rects[i].X);
 112                                 Assert.AreEqual (rects[i].Y, rects[i].Y);
 113                                 Assert.AreEqual (rects[i].Width, rects[i].Width);
 114                                 Assert.AreEqual (rects[i].Height, rects[i].Height);
 115                         }
 116
 117                         Assert.AreEqual (true, rgn1.Equals (rgn2, dc));
 118                 }
 119
 120                  /*Tests infinite, empty, etc*/
 121                 [Test]
 122                 public void TestInfiniteAndEmpty()
 123                 {
 124                         Bitmap bmp = new Bitmap (600, 800);
 125                         Graphics dc = Graphics.FromImage (bmp);
 126                         Rectangle rect1, rect2;
 127                         Region rgn1;
 128                         RectangleF [] rects;
 129                         Matrix matrix = new Matrix ();
 130
 131                         rect1 = new Rectangle (500, 30, 60, 80);
 132                         rect2 = new Rectangle (520, 40, 60, 80);
 133                         rgn1 = new Region (rect1);
 134                         rgn1.Union (rect2);
 135
 136                         Assert.AreEqual (false, rgn1.IsEmpty (dc));
 137                         Assert.AreEqual (false, rgn1.IsInfinite (dc));
 138
 139                         rgn1.MakeEmpty();
 140                         Assert.AreEqual (true, rgn1.IsEmpty (dc));
 141
 142                         rgn1 = new Region (rect1);
 143                         rgn1.Union (rect2);
 144                         rgn1.MakeInfinite ();
 145                         rects = rgn1.GetRegionScans (matrix);
 146
 147                         Assert.AreEqual (1, rects.Length);
 148                         Assert.AreEqual (-4194304, rects[0].X);
 149                         Assert.AreEqual (-4194304, rects[0].Y);
 150                         Assert.AreEqual (8388608, rects[0].Width);
 151                         Assert.AreEqual (8388608, rects[0].Height);
 152                         Assert.AreEqual (true, rgn1.IsInfinite (dc));
 153                 }
 154
 155
 156                 [Test]
 157                 public void TestUnionGroup1 ()
 158                 {
 159                         Bitmap bmp = new Bitmap (600, 800);
 160                         Graphics dc = Graphics.FromImage (bmp);
 161                         Matrix matrix = new Matrix ();
 162                         Rectangle rect1, rect2, rect3, rect4;
 163                         Region rgn1, rgn2, rgn3, rgn4;
 164                         RectangleF [] rects;
 165
 166                         rect1 = new Rectangle (500, 30, 60, 80);
 167                         rect2 = new Rectangle (520, 40, 60, 80);
 168                         rgn1 = new Region(rect1);
 169                         rgn2 = new Region(rect2);
 170                         rgn1.Union(rgn2);
 171                         rects = rgn1.GetRegionScans (matrix);
 172
 173                         Assert.AreEqual (3, rects.Length);
 174                         Assert.AreEqual (500, rects[0].X);
 175                         Assert.AreEqual (30, rects[0].Y);
 176                         Assert.AreEqual (60, rects[0].Width);
 177                         Assert.AreEqual (10, rects[0].Height);
 178
 179                         Assert.AreEqual (500, rects[1].X);
 180                         Assert.AreEqual (40, rects[1].Y);
 181                         Assert.AreEqual (80, rects[1].Width);
 182                         Assert.AreEqual (70, rects[1].Height);
 183
 184                         Assert.AreEqual (520, rects[2].X);
 185                         Assert.AreEqual (110, rects[2].Y);
 186                         Assert.AreEqual (60, rects[2].Width);
 187                         Assert.AreEqual (10, rects[2].Height);
 188
 189                         rect1 = new Rectangle (20, 180, 40, 50);
 190                         rect2 = new Rectangle (50, 190, 40, 50);
 191                         rect3 = new Rectangle (70, 210, 30, 50);
 192                         rgn1 = new Region (rect1);
 193                         rgn2 = new Region (rect2);
 194                         rgn3 = new Region (rect3);
 195
 196                         rgn1.Union (rgn2);
 197                         rgn1.Union (rgn3);
 198                         rects = rgn1.GetRegionScans (matrix);
 199                         Assert.AreEqual (5, rects.Length);
 200
 201                         Assert.AreEqual (20, rects[0].X);
 202                         Assert.AreEqual (180, rects[0].Y);
 203                         Assert.AreEqual (40, rects[0].Width);
 204                         Assert.AreEqual (10, rects[0].Height);
 205
 206                         Assert.AreEqual (20, rects[1].X);
 207                         Assert.AreEqual (190, rects[1].Y);
 208                         Assert.AreEqual (70, rects[1].Width);
 209                         Assert.AreEqual (20, rects[1].Height);
 210
 211                         Assert.AreEqual (20, rects[2].X);
 212                         Assert.AreEqual (210, rects[2].Y);
 213                         Assert.AreEqual (80, rects[2].Width);
 214                         Assert.AreEqual (20, rects[2].Height);
 215
 216                         Assert.AreEqual (50, rects[3].X);
 217                         Assert.AreEqual (230, rects[3].Y);
 218                         Assert.AreEqual (50, rects[3].Width);
 219                         Assert.AreEqual (10, rects[3].Height);
 220
 221                         Assert.AreEqual (70, rects[4].X);
 222                         Assert.AreEqual (240, rects[4].Y);
 223                         Assert.AreEqual (30, rects[4].Width);
 224                         Assert.AreEqual (20, rects[4].Height);
 225
 226                         rect1 = new Rectangle (20, 330, 40, 50);
 227                         rect2 = new Rectangle (50, 340, 40, 50);
 228                         rect3 = new Rectangle (70, 360, 30, 50);
 229                         rect4 = new Rectangle (80, 400, 30, 10);
 230                         rgn1 = new Region (rect1);
 231                         rgn2 = new Region (rect2);
 232                         rgn3 = new Region (rect3);
 233                         rgn4 = new Region (rect4);
 234
 235                         rgn1.Union (rgn2);
 236                         rgn1.Union (rgn3);
 237                         rgn1.Union (rgn4);
 238
 239                         rects = rgn1.GetRegionScans (matrix);
 240
 241                         Assert.AreEqual (6, rects.Length);
 242
 243                         Assert.AreEqual (20, rects[0].X);
 244                         Assert.AreEqual (330, rects[0].Y);
 245                         Assert.AreEqual (40, rects[0].Width);
 246                         Assert.AreEqual (10, rects[0].Height);
 247
 248                         Assert.AreEqual (20, rects[1].X);
 249                         Assert.AreEqual (340, rects[1].Y);
 250                         Assert.AreEqual (70, rects[1].Width);
 251                         Assert.AreEqual (20, rects[1].Height);
 252
 253                         Assert.AreEqual (20, rects[2].X);
 254                         Assert.AreEqual (360, rects[2].Y);
 255                         Assert.AreEqual (80, rects[2].Width);
 256                         Assert.AreEqual (20, rects[2].Height);
 257
 258                         Assert.AreEqual (50, rects[3].X);
 259                         Assert.AreEqual (380, rects[3].Y);
 260                         Assert.AreEqual (50, rects[3].Width);
 261                         Assert.AreEqual (10, rects[3].Height);
 262
 263                         Assert.AreEqual (70, rects[4].X);
 264                         Assert.AreEqual (390, rects[4].Y);
 265                         Assert.AreEqual (30, rects[4].Width);
 266                         Assert.AreEqual (10, rects[4].Height);
 267
 268                         Assert.AreEqual (70, rects[5].X);
 269                         Assert.AreEqual (400, rects[5].Y);
 270                         Assert.AreEqual (40, rects[5].Width);
 271                         Assert.AreEqual (10, rects[5].Height);
 272
 273                         rect1 = new Rectangle (10, 20, 50, 50);
 274                         rect2 = new Rectangle (100, 100, 60, 60);
 275                         rect3 = new Rectangle (200, 200, 80, 80);
 276
 277                         rgn1 = new Region (rect1);
 278                         rgn1.Union (rect2);
 279                         rgn1.Union (rect3);
 280
 281                         rects = rgn1.GetRegionScans (matrix);
 282
 283                         Assert.AreEqual (3, rects.Length);
 284
 285                         Assert.AreEqual (10, rects[0].X);
 286                         Assert.AreEqual (20, rects[0].Y);
 287                         Assert.AreEqual (50, rects[0].Width);
 288                         Assert.AreEqual (50, rects[0].Height);
 289
 290                         Assert.AreEqual (100, rects[1].X);
 291                         Assert.AreEqual (100, rects[1].Y);
 292                         Assert.AreEqual (60, rects[1].Width);
 293                         Assert.AreEqual (60, rects[1].Height);
 294
 295                         Assert.AreEqual (200, rects[2].X);
 296                         Assert.AreEqual (200, rects[2].Y);
 297                         Assert.AreEqual (80, rects[2].Width);
 298                         Assert.AreEqual (80, rects[2].Height);
 299                 }
 300
 301                 void AssertEqualRectangles (RectangleF rect1, RectangleF rect2, string text)
 302                 {
 303                         Assert.AreEqual (rect1.X, rect2.X, text + ".X");
 304                         Assert.AreEqual (rect1.Y, rect2.Y, text + ".Y");
 305                         Assert.AreEqual (rect1.Width, rect2.Width, text + ".Width");
 306                         Assert.AreEqual (rect1.Height, rect2.Height, text + ".Height");
 307                 }
 308
 309                 [Test]
 310                 public void TestUnionGroup2 ()
 311                 {
 312                         RectangleF[] rects;
 313                         Region r1  = new Region ();
 314                         Rectangle rect2 = Rectangle.Empty;
 315                         Rectangle rect1 = Rectangle.Empty;
 316                         Rectangle rect3 = Rectangle.Empty;
 317                         Rectangle rect4 = Rectangle.Empty;
 318
 319                         { // TEST1: Not intersecting rects. Union just adds them
 320
 321                                 rect1 = new Rectangle (20, 20, 20, 20);
 322                                 rect2 = new Rectangle (20, 80, 20, 10);
 323                                 rect3 = new Rectangle (60, 60, 30, 10);
 324
 325                                 r1 = new Region (rect1);
 326                                 r1.Union (rect2);
 327                                 r1.Union (rect3);
 328
 329                                 rects = r1.GetRegionScans (new Matrix ());
 330                                 Assert.AreEqual (3, rects.Length, "TUG1Test1");
 331                                 AssertEqualRectangles (new RectangleF (20, 20, 20, 20), rects[0], "TUG1Test2");
 332                                 AssertEqualRectangles (new RectangleF (60, 60, 30, 10), rects[1], "TUG1Test3");
 333                                 AssertEqualRectangles (new RectangleF (20, 80, 20, 10), rects[2], "TUG1Test4");
 334                         }
 335
 336                         { // TEST2: Intersecting from the right
 337                                  /*
 338                                  *  -----------
 339                                  *  |         |
 340                                  *  |     |-------- |
 341                                  *  |     |         |
 342                                  *  |     |-------- |
 343                                  *  |         |
 344                                  *  ----------|
 345                                  *
 346                                  */
 347
 348                                 rect1 = new Rectangle (10, 10, 100, 100);
 349                                 rect2 = new Rectangle (40, 60, 100, 20);
 350                                 r1 = new Region (rect1);
 351                                 r1.Union (rect2);
 352
 353                                 rects = r1.GetRegionScans (new Matrix ());
 354                                 Assert.AreEqual  (3, rects.Length, "TUG2Test1");
 355                                 AssertEqualRectangles (new RectangleF (10, 10, 100, 50), rects[0], "TUG2Test2");
 356                                 AssertEqualRectangles (new RectangleF (10, 60, 130, 20), rects[1], "TUG2Test3");
 357                                 AssertEqualRectangles (new RectangleF (10, 80, 100, 30), rects[2], "TUG2Test4");
 358                         }
 359
 360                         { // TEST3: Intersecting from the right
 361                                  /*
 362                                  *      -----------
 363                                  *      |         |
 364                                  * |-------- |    |
 365                                  * |         |    |
 366                                  * |-------- |    |
 367                                  *      |         |
 368                                  *      ----------|
 369                                  *
 370                                  */
 371
 372                                 rect1 = new Rectangle (70, 10, 100, 100);
 373                                 rect2 = new Rectangle (40, 60, 100, 20);
 374
 375                                 r1 = new Region (rect1);
 376                                 r1.Union (rect2);
 377
 378                                 rects = r1.GetRegionScans (new Matrix ());
 379                                 Assert.AreEqual  (3, rects.Length, "TUG3Test1");
 380                                 AssertEqualRectangles (new RectangleF (70, 10, 100, 50), rects[0], "TUG3Test2");
 381                                 AssertEqualRectangles (new RectangleF (40, 60, 130, 20), rects[1], "TUG3Test3");
 382                                 AssertEqualRectangles (new RectangleF (70, 80, 100, 30), rects[2], "TUG3Test4");
 383                         }
 384
 385                         { // TEST4: Intersecting from the top
 386                                  /*
 387                                  *         -----
 388                                  *         |   |
 389                                  *      -----------
 390                                  *      |  |   |  |
 391                                  *      |  -----  |
 392                                  *      |         |
 393                                  *      |         |
 394                                  *      ----------|
 395                                  *
 396                                  */
 397
 398                                 rect1 = new Rectangle (40, 100, 100, 100);
 399                                 rect2 = new Rectangle (70, 80, 50, 40);
 400                                 r1 = new Region (rect1);
 401                                 r1.Union (rect2);
 402
 403                                 rects = r1.GetRegionScans (new Matrix ());
 404                                 Assert.AreEqual  (2, rects.Length, "TUG4Test1");
 405                                 AssertEqualRectangles (new RectangleF (70, 80, 50, 20), rects[0], "TUG4Test2");
 406                                 AssertEqualRectangles (new RectangleF (40, 100, 100, 100), rects[1], "TUG4Test3");
 407                         }
 408
 409                         { // TEST5: Intersecting from the bottom
 410                                  /*
 411
 412                                  *      -----------
 413                                  *      |         |
 414                                  *      |         |
 415                                  *      |         |
 416                                  *      |  |   |  |
 417                                  *      |--|   |--|
 418                                  *         |   |
 419                                  *         -----
 420                                  */
 421
 422                                 rect1 = new Rectangle (40, 10, 100, 100);
 423                                 rect2 = new Rectangle (70, 80, 50, 40);
 424
 425                                 r1 = new Region (rect1);
 426                                 r1.Union (rect2);
 427
 428                                 rects = r1.GetRegionScans (new Matrix ());
 429                                 Assert.AreEqual  (2, rects.Length, "TUG5Test1");
 430                                 AssertEqualRectangles (new RectangleF (40, 10, 100, 100), rects[0], "TUG5Test2");
 431                                 AssertEqualRectangles (new RectangleF (70, 110, 50, 10), rects[1], "TUG5Test3");
 432                         }
 433
 434                         { // TEST6: Multiple regions, two separted by zero pixels
 435
 436                                 rect1 = new Rectangle (30, 30, 80, 80);
 437                                 rect2 = new Rectangle (45, 45, 200, 200);
 438                                 rect3 = new Rectangle (160, 260, 10, 10);
 439                                 rect4 = new Rectangle (170, 260, 10, 10);
 440
 441                                 r1 = new Region (rect1);
 442                                 r1.Union (rect2);
 443                                 r1.Union (rect3);
 444                                 r1.Union (rect4);
 445
 446                                 rects = r1.GetRegionScans (new Matrix ());
 447                                 Assert.AreEqual  (4, rects.Length, "TUG6Test1");
 448                                 AssertEqualRectangles (new RectangleF (30, 30, 80, 15), rects[0], "TUG6Test2");
 449                                 AssertEqualRectangles (new RectangleF (30, 45, 215, 65), rects[1], "TUG6Test3");
 450                                 AssertEqualRectangles (new RectangleF (45, 110, 200, 135), rects[2], "TUG6Test4");
 451                                 AssertEqualRectangles (new RectangleF (160, 260, 20, 10), rects[3], "TUG6Test5");
 452                         }
 453                 }
 454
 455
 456                 [Test]
 457                 public void TestComplementGroup1 ()
 458                 {
 459                         RectangleF[] rects;
 460                         Region r1  = new Region ();
 461                         Region r2 = new Region ();
 462                         Rectangle rect1 = Rectangle.Empty;
 463                         Rectangle rect2 = Rectangle.Empty;
 464                         Rectangle rect3 = Rectangle.Empty;
 465                         Rectangle rect4 = Rectangle.Empty;
 466                         Rectangle rect5 = Rectangle.Empty;
 467                         Rectangle rect6 = Rectangle.Empty;
 468                         Rectangle rect7 = Rectangle.Empty;
 469
 470
 471                         { // TEST1
 472
 473                                 rect1 = new Rectangle (20, 20, 20, 20);
 474                                 rect2 = new Rectangle (20, 80, 20, 10);
 475                                 rect3 = new Rectangle (60, 60, 30, 10);
 476
 477                                 r1 = new Region (rect1);
 478                                 r2 = new Region (rect2);
 479                                 r2.Union (rect3);
 480                                 r1.Complement (r2);
 481
 482                                 rects = r1.GetRegionScans (new Matrix ());
 483                                 Assert.AreEqual  (2, rects.Length, "TCG1Test1");
 484                                 AssertEqualRectangles (new RectangleF (60, 60, 30, 10), rects[0], "TCG1Test2");
 485                                 AssertEqualRectangles (new RectangleF (20, 80, 20, 10), rects[1], "TCG1Test3");
 486                         }
 487
 488
 489                         { // TEST2
 490
 491                                 rect1 = new Rectangle (10, 10, 100, 100);
 492                                 rect2 = new Rectangle (40, 60, 100, 20);
 493
 494                                 r1 = new Region (rect1);
 495                                 r1.Complement (rect2);
 496
 497                                 rects = r1.GetRegionScans (new Matrix ());
 498                                 Assert.AreEqual  (1, rects.Length, "TCG2Test1");
 499                                 AssertEqualRectangles (new RectangleF (110, 60, 30, 20), rects[0], "TCG2Test2");
 500                         }
 501
 502                         { // TEST3
 503
 504                                 rect1 = new Rectangle (70, 10, 100, 100);
 505                                 rect2 = new Rectangle (40, 60, 100, 20);
 506
 507                                 r1 = new Region (rect1);
 508                                 r1.Complement (rect2);
 509
 510                                 rects = r1.GetRegionScans (new Matrix ());
 511                                 Assert.AreEqual  (1, rects.Length, "TCG3Test1");
 512                                 AssertEqualRectangles (new RectangleF (40, 60, 30, 20), rects[0], "TCG3Test2");
 513                         }
 514
 515                         { // TEST4
 516
 517                                 rect1 = new Rectangle (40, 100, 100, 100);
 518                                 rect2 = new Rectangle (70, 80, 50, 40);
 519
 520                                 r1 = new Region (rect1);
 521                                 r1.Complement (rect2);
 522
 523                                 rects = r1.GetRegionScans (new Matrix ());
 524                                 Assert.AreEqual  (1, rects.Length, "TCG4Test1");
 525                                 AssertEqualRectangles (new RectangleF (70, 80, 50, 20), rects[0], "TCG4Test2");
 526                         }
 527
 528                         { // TEST5
 529
 530                                 rect1 = new Rectangle (40, 10, 100, 100);
 531                                 rect2 = new Rectangle (70, 80, 50, 40);
 532
 533                                 r1 = new Region (rect1);
 534                                 r1.Complement (rect2);
 535
 536                                 rects = r1.GetRegionScans (new Matrix ());
 537                                 Assert.AreEqual  (1, rects.Length, "TCG5Test1");
 538                                 AssertEqualRectangles (new RectangleF (70, 110, 50, 10), rects[0], "TCG5Test2");
 539                         }
 540
 541                         { // TEST6: Multiple regions
 542
 543                                 rect1 = new Rectangle (30, 30, 80, 80);
 544                                 rect2 = new Rectangle (45, 45, 200, 200);
 545                                 rect3 = new Rectangle (160, 260, 10, 10);
 546                                 rect4 = new Rectangle (170, 260, 10, 10);
 547
 548                                 r1 = new Region (rect1);
 549                                 r1.Complement (rect2);
 550                                 r1.Complement (rect3);
 551                                 r1.Complement (rect4);
 552
 553                                 rects = r1.GetRegionScans (new Matrix ());
 554                                 Assert.AreEqual  (1, rects.Length, "TCG6Test1");
 555                                 AssertEqualRectangles (new RectangleF (170, 260, 10, 10), rects[0], "TCG6Test2");
 556                         }
 557
 558                 }
 559
 560                 [Test]
 561                 public void TestComplementGroup2 ()
 562                 {
 563
 564                         Bitmap bmp = new Bitmap (600, 800);
 565                         Graphics dc = Graphics.FromImage (bmp);
 566                         Matrix matrix = new Matrix ();
 567                         Rectangle rect1, rect2;
 568                         Region rgn1, rgn2;
 569                         RectangleF [] rects;
 570
 571                         rect1 = new Rectangle (20, 30, 60, 80);
 572                         rect2 = new Rectangle (50, 40, 60, 80);
 573                         rgn1 = new Region (rect1);
 574                         rgn2 = new Region (rect2);
 575                         dc.DrawRectangle (Pens.Green, rect1);
 576                         dc.DrawRectangle (Pens.Red, rect2);
 577                         rgn1.Complement (rgn2);
 578                         dc.FillRegion (Brushes.Blue, rgn1);
 579                         dc.DrawRectangles (Pens.Yellow, rgn1.GetRegionScans (matrix));
 580
 581                         rects = rgn1.GetRegionScans (matrix);
 582
 583                         Assert.AreEqual (2, rects.Length);
 584
 585                         Assert.AreEqual (80, rects[0].X);
 586                         Assert.AreEqual (40, rects[0].Y);
 587                         Assert.AreEqual (30, rects[0].Width);
 588                         Assert.AreEqual (70, rects[0].Height);
 589
 590                         Assert.AreEqual (50, rects[1].X);
 591                         Assert.AreEqual (110, rects[1].Y);
 592                         Assert.AreEqual (60, rects[1].Width);
 593                         Assert.AreEqual (10, rects[1].Height);
 594
 595                 }
 596
 597
 598                 [Test]
 599                 public void TestExcludeGroup1 ()
 600                 {
 601                         RectangleF[] rects;
 602                         Region r1  = new Region ();
 603                         Region r2 = new Region ();
 604                         Rectangle rect1 = Rectangle.Empty;
 605                         Rectangle rect2 = Rectangle.Empty;
 606                         Rectangle rect3 = Rectangle.Empty;
 607                         Rectangle rect4 = Rectangle.Empty;
 608                         Rectangle rect5 = Rectangle.Empty;
 609                         Rectangle rect6 = Rectangle.Empty;
 610                         Rectangle rect7 = Rectangle.Empty;
 611
 612
 613                         { // TEST1: Not intersecting rects. Exclude just adds them
 614
 615                                 rect1 = new Rectangle (20, 20, 20, 20);
 616                                 rect2 = new Rectangle (20, 80, 20, 10);
 617                                 rect3 = new Rectangle (60, 60, 30, 10);
 618
 619                                 r1 = new Region (rect1);
 620                                 r2 = new Region (rect2);
 621                                 r2.Union (rect3);
 622                                 r1.Exclude (r2);
 623
 624                                 rects = r1.GetRegionScans (new Matrix ());
 625                                 Assert.AreEqual  (1, rects.Length, "TEG1Test1");
 626                                 AssertEqualRectangles (new RectangleF (20, 20, 20, 20), rects[0], "TEG1Test2");
 627                         }
 628
 629                         { // TEST2: Excluding from the right
 630                                  /*
 631                                  *  -----------
 632                                  *  |         |
 633                                  *  |     |-------- |
 634                                  *  |     |         |
 635                                  *  |     |-------- |
 636                                  *  |         |
 637                                  *  ----------|
 638                                  *
 639                                  */
 640
 641                                 rect1 = new Rectangle (10, 10, 100, 100);
 642                                 rect2 = new Rectangle (40, 60, 100, 20);
 643                                 r1 = new Region (rect1);
 644                                 r1.Exclude (rect2);
 645
 646                                 rects = r1.GetRegionScans (new Matrix ());
 647                                 Assert.AreEqual  (3, rects.Length, "TEG2Test1");
 648                                 AssertEqualRectangles (new RectangleF (10, 10, 100, 50), rects[0], "TEG2Test2");
 649                                 AssertEqualRectangles (new RectangleF (10, 60, 30, 20), rects[1], "TEG2Test3");
 650                                 AssertEqualRectangles (new RectangleF (10, 80, 100, 30), rects[2], "TEG2Test4");
 651                         }
 652
 653
 654                         { // TEST3: Intersecting from the right
 655                                  /*
 656                                  *      -----------
 657                                  *      |         |
 658                                  * |-------- |    |
 659                                  * |         |    |
 660                                  * |-------- |    |
 661                                  *      |         |
 662                                  *      ----------|
 663                                  *
 664                                  */
 665
 666                                 rect1 = new Rectangle (70, 10, 100, 100);
 667                                 rect2 = new Rectangle (40, 60, 100, 20);
 668
 669                                 r1 = new Region (rect1);
 670                                 r1.Exclude (rect2);
 671
 672                                 rects = r1.GetRegionScans (new Matrix ());
 673                                 Assert.AreEqual  (3, rects.Length, "TEG3Test1");
 674                                 AssertEqualRectangles (new RectangleF (70, 10, 100, 50), rects[0], "TEG3Test2");
 675                                 AssertEqualRectangles (new RectangleF (140, 60, 30, 20), rects[1], "TEG3Test3");
 676                                 AssertEqualRectangles (new RectangleF (70, 80, 100, 30), rects[2], "TEG3Test4");
 677                         }
 678
 679
 680                         { // TEST4: Intersecting from the top
 681                                  /*
 682                                  *         -----
 683                                  *         |   |
 684                                  *      -----------
 685                                  *      |  |   |  |
 686                                  *      |  -----  |
 687                                  *      |         |
 688                                  *      |         |
 689                                  *      ----------|
 690                                  *
 691                                  */
 692
 693                                 rect1 = new Rectangle (40, 100, 100, 100);
 694                                 rect2 = new Rectangle (70, 80, 50, 40);
 695
 696                                 r1 = new Region (rect1);
 697                                 r1.Exclude (rect2);
 698
 699                                 rects = r1.GetRegionScans (new Matrix ());
 700                                 Assert.AreEqual  (3, rects.Length, "TEG4Test1");
 701                                 AssertEqualRectangles (new RectangleF (40, 100, 30, 20), rects[0], "TEG4Test2");
 702                                 AssertEqualRectangles (new RectangleF (120, 100, 20, 20), rects[1], "TEG4Test3");
 703                                 AssertEqualRectangles (new RectangleF (40, 120, 100, 80), rects[2], "TEG4Test4");
 704                         }
 705
 706
 707                         { // TEST5: Intersecting from the bottom
 708                                  /*
 709                                  *      -----------
 710                                  *      |         |
 711                                  *      |         |
 712                                  *      |         |
 713                                  *      |  |   |  |
 714                                  *      |--|   |--|
 715                                  *         |   |
 716                                  *         -----
 717                                  *
 718                                  */
 719
 720                                 rect1 = new Rectangle (40, 10, 100, 100);
 721                                 rect2 = new Rectangle (70, 80, 50, 40);
 722
 723                                 r1 = new Region (rect1);
 724                                 r1.Exclude (rect2);
 725
 726                                 rects = r1.GetRegionScans (new Matrix ());
 727                                 Assert.AreEqual (3, rects.Length, "TEG5Test1");
 728                                 AssertEqualRectangles (new RectangleF (40, 10, 100, 70), rects[0], "TEG5Test2");
 729                                 AssertEqualRectangles (new RectangleF (40, 80, 30, 30), rects[1], "TEG5Test3");
 730                                 AssertEqualRectangles (new RectangleF (120, 80, 20, 30), rects[2], "TEG5Test4");
 731                         }
 732
 733
 734                         { // TEST6: Multiple regions
 735
 736                                 rect1 = new Rectangle (30, 30, 80, 80);
 737                                 rect2 = new Rectangle (45, 45, 200, 200);
 738                                 rect3 = new Rectangle (160, 260, 10, 10);
 739                                 rect4 = new Rectangle (170, 260, 10, 10);
 740
 741                                 r1 = new Region (rect1);
 742                                 r1.Exclude (rect2);
 743                                 r1.Exclude (rect3);
 744                                 r1.Exclude (rect4);
 745
 746                                 rects = r1.GetRegionScans (new Matrix ());
 747                                 Assert.AreEqual (2, rects.Length, "TEG6Test1");
 748                                 AssertEqualRectangles (new RectangleF (30, 30, 80, 15), rects[0], "TEG6Test2");
 749                                 AssertEqualRectangles (new RectangleF (30, 45, 15, 65), rects[1], "TEG6Test3");
 750                         }
 751
 752
 753                         { // TEST7: Intersecting from the top with a larger rect
 754                                  /*
 755                                  *    -----------------
 756                                  *    |               |
 757                                  *    | -----------   |
 758                                  *      |  |   |  |
 759                                  *      |  -----  |
 760                                  *      |         |
 761                                  *      |         |
 762                                  *      ----------|
 763                                  *
 764                                  */
 765
 766                                 rect1 = new Rectangle (50, 100, 100, 100);
 767                                 rect2 = new Rectangle (30, 70, 150, 40);
 768
 769                                 r1 = new Region (rect1);
 770                                 r1.Exclude (rect2);
 771
 772                                 rects = r1.GetRegionScans (new Matrix ());
 773                                 Assert.AreEqual (1, rects.Length, "TEG7Test1");
 774                                 AssertEqualRectangles (new RectangleF (50, 110, 100, 90), rects[0], "TEG7Test2");
 775                         }
 776
 777                         { // TEST8: Intersecting from the right with a larger rect
 778                                  /*
 779                                  *
 780                                  * |--------|
 781                                  * |        |
 782                                  * |    -----------
 783                                  * |    |         |
 784                                  * |    |         |
 785                                  * |    |         |
 786                                  * |    |         |
 787                                  * |    |         |
 788                                  * |    ----------|
 789                                  * |-------|
 790                                  */
 791
 792                                 rect1 = new Rectangle (70, 60, 100, 70);
 793                                 rect2 = new Rectangle (40, 10, 100, 150);
 794
 795                                 r1 = new Region (rect1);
 796                                 r1.Exclude (rect2);
 797
 798                                 rects = r1.GetRegionScans (new Matrix ());
 799                                 Assert.AreEqual (1, rects.Length, "TEG8Test1");
 800                                 AssertEqualRectangles (new RectangleF (140, 60, 30, 70), rects[0], "TEG8Test2");
 801
 802                         }
 803
 804                         { // TEST9: Intersecting from the left with a larger rect
 805                                  /*
 806                                  *
 807                                  *              |--------|
 808                                  *              |        |
 809                                  *      -----------      |
 810                                  *      |         |      |
 811                                  *      |         |      |
 812                                  *      |         |      |
 813                                  *      |         |      |
 814                                  *      |         |      |
 815                                  *      ----------|      |
 816                                  *              |--------|
 817                                  *
 818                                  */
 819
 820
 821                                 rect1 = new Rectangle (70, 60, 100, 70);
 822                                 rect2 = new Rectangle (100, 10, 100, 150);
 823
 824                                 r1 = new Region (rect1);
 825                                 r1.Exclude (rect2);
 826
 827                                 rects = r1.GetRegionScans (new Matrix ());
 828                                 Assert.AreEqual (1, rects.Length, "TEG9Test1");
 829                                 AssertEqualRectangles (new RectangleF (70, 60, 30, 70), rects[0], "TEG9Test2");
 830                         }
 831
 832
 833                         { // TEST10: Intersecting from the bottom with a larger rect
 834                                  /*
 835                                  * *
 836                                  *              |--------|
 837                                  *              |        |
 838                                  *              |        |
 839                                  *              |        |
 840                                  *        --------------------
 841                                  *        |                  |
 842                                  *        |                  |
 843                                  *        |------------------|
 844                                  */
 845
 846
 847                                 rect1 = new Rectangle (20, 20, 100, 100);
 848                                 rect2 = new Rectangle (10, 80, 140, 150);
 849
 850                                 r1 = new Region (rect1);
 851                                 r1.Exclude (rect2);
 852
 853                                 rects = r1.GetRegionScans (new Matrix ());
 854                                 Assert.AreEqual (1, rects.Length, "TEG10Test1");
 855                                 AssertEqualRectangles (new RectangleF (20, 20, 100, 60), rects[0], "TEG10Test2");
 856                         }
 857
 858
 859                 }
 860
 861                 [Test]
 862                 public void TestExcludeGroup2 ()
 863                 {
 864                         Bitmap bmp = new Bitmap (600, 800);
 865                         Graphics dc = Graphics.FromImage (bmp);
 866                         Matrix matrix = new Matrix ();
 867                         Rectangle rect1, rect2;
 868                         Region rgn1;
 869                         RectangleF [] rects;
 870
 871                         rect1 = new Rectangle (130, 30, 60, 80);
 872                         rect2 = new Rectangle (170, 40, 60, 80);
 873                         rgn1 = new Region (rect1);
 874                         rgn1.Exclude (rect2);
 875                         rects = rgn1.GetRegionScans (matrix);
 876
 877                         Assert.AreEqual (2, rects.Length);
 878
 879                         Assert.AreEqual (130, rects[0].X);
 880                         Assert.AreEqual (30, rects[0].Y);
 881                         Assert.AreEqual (60, rects[0].Width);
 882                         Assert.AreEqual (10, rects[0].Height);
 883
 884                         Assert.AreEqual (130, rects[1].X);
 885                         Assert.AreEqual (40, rects[1].Y);
 886                         Assert.AreEqual (40, rects[1].Width);
 887                         Assert.AreEqual (70, rects[1].Height);
 888                 }
 889
 890                 [Test]
 891                 public void TestIntersect()
 892                 {
 893
 894
 895                         Bitmap bmp = new Bitmap (600, 800);
 896                         Graphics dc = Graphics.FromImage (bmp);
 897                         Matrix matrix = new Matrix ();
 898                         RectangleF [] rects;
 899                         RectangleF rect3, rect4;
 900                         Region rgn3, rgn4;
 901
 902                         /* Two simple areas */
 903                         Rectangle rect1 = new Rectangle (260, 30, 60, 80);
 904                         Rectangle rect2 = new Rectangle (290, 40, 60, 80);
 905                         Region rgn1 = new Region (rect1);
 906                         Region rgn2 = new Region (rect2);
 907                         rgn1.Intersect (rgn2);
 908
 909                         rects = rgn1.GetRegionScans (matrix);
 910                         Assert.AreEqual (1, rects.Length);
 911
 912                         Assert.AreEqual (290, rects[0].X);
 913                         Assert.AreEqual (40, rects[0].Y);
 914                         Assert.AreEqual (30, rects[0].Width);
 915                         Assert.AreEqual (70, rects[0].Height);
 916
 917                         /* No intersect */
 918                         rect1 = new Rectangle (20, 330, 40, 50);
 919                         rect2 = new Rectangle (50, 340, 40, 50);
 920                         rect3 = new Rectangle (70, 360, 30, 50);
 921                         rect4 = new Rectangle (80, 400, 30, 10);
 922                         rgn1 = new Region (rect1);
 923                         rgn2 = new Region (rect2);
 924                         rgn3 = new Region (rect3);
 925                         rgn4 = new Region (rect4);
 926
 927                         rgn1.Intersect (rgn2);
 928                         rgn1.Intersect (rgn3);
 929                         rgn1.Intersect (rgn4);
 930                         rects = rgn1.GetRegionScans (matrix);
 931                         Assert.AreEqual (0, rects.Length);
 932                 }
 933
 934                 [Test]
 935                 public void TestXor()
 936                 {
 937                         Bitmap bmp = new Bitmap (600, 800);
 938                         Graphics dc = Graphics.FromImage (bmp);
 939                         Matrix matrix = new Matrix ();
 940                         RectangleF [] rects;
 941
 942                         Rectangle rect1 = new Rectangle (380, 30, 60, 80);
 943                         Rectangle rect2 = new Rectangle (410, 40, 60, 80);
 944                         Region rgn1 = new Region (rect1);
 945                         Region rgn2 = new Region (rect2);
 946                         rgn1.Xor (rgn2);
 947
 948
 949                         rects = rgn1.GetRegionScans (matrix);
 950
 951                         Assert.AreEqual (4, rects.Length);
 952
 953                         Assert.AreEqual (380, rects[0].X);
 954                         Assert.AreEqual (30, rects[0].Y);
 955                         Assert.AreEqual (60, rects[0].Width);
 956                         Assert.AreEqual (10, rects[0].Height);
 957
 958                         Assert.AreEqual (380, rects[1].X);
 959                         Assert.AreEqual (40, rects[1].Y);
 960                         Assert.AreEqual (30, rects[1].Width);
 961                         Assert.AreEqual (70, rects[1].Height);
 962
 963                         Assert.AreEqual (440, rects[2].X);
 964                         Assert.AreEqual (40, rects[2].Y);
 965                         Assert.AreEqual (30, rects[2].Width);
 966                         Assert.AreEqual (70, rects[2].Height);
 967
 968                         Assert.AreEqual (410, rects[3].X);
 969                         Assert.AreEqual (110, rects[3].Y);
 970                         Assert.AreEqual (60, rects[3].Width);
 971                         Assert.AreEqual (10, rects[3].Height);
 972                 }
 973
 974
 975                 [Test]
 976                 public void TestIsVisible()
 977                 {
 978                         Bitmap bmp = new Bitmap (600, 800);
 979                         Graphics dc = Graphics.FromImage (bmp);
 980                         Rectangle rect1, rect2;
 981                         Region rgn1, rgn2;
 982                         Matrix matrix = new Matrix ();
 983
 984                         rect1 = new Rectangle (500, 30, 60, 80);
 985                         rect2 = new Rectangle (520, 40, 60, 80);
 986
 987                         rgn1 = new Region (new RectangleF (0, 0, 10,10));
 988                         Assert.AreEqual (false, rgn1.IsVisible (0,0,0,1));
 989
 990                         rgn1 = new Region (rect1);
 991                         Assert.AreEqual (false, rgn1.IsVisible (500,29));
 992                         Assert.AreEqual (true, rgn1.IsVisible (500,30));
 993                         Assert.AreEqual (true, rgn1.IsVisible (rect1));
 994                         Assert.AreEqual (true, rgn1.IsVisible (rect2));
 995                         Assert.AreEqual (false, rgn1.IsVisible (new Rectangle (50,50,2,5)));
 996
 997                         Rectangle r = new Rectangle (1,1, 2,1);
 998                         rgn2 = new Region (r);
 999                         Assert.AreEqual (true, rgn2.IsVisible (r));
1000                         Assert.AreEqual (true, rgn2.IsVisible (new Rectangle (1,1, 2,2)));
1001                         Assert.AreEqual (true, rgn2.IsVisible (new Rectangle (1,1, 10,10)));
1002                         Assert.AreEqual (true, rgn2.IsVisible (new Rectangle (1,1, 1,1)));
1003                         Assert.AreEqual (false, rgn2.IsVisible (new Rectangle (2,2, 1,1)));
1004                         Assert.AreEqual (false, rgn2.IsVisible (new Rectangle (0,0, 1,1)));
1005                         Assert.AreEqual (false, rgn2.IsVisible (new Rectangle (3,3, 1,1)));
1006
1007                         Assert.AreEqual (false, rgn2.IsVisible (0,0));
1008                         Assert.AreEqual (false, rgn2.IsVisible (1,0));
1009                         Assert.AreEqual (false, rgn2.IsVisible (2,0));
1010                         Assert.AreEqual (false, rgn2.IsVisible (3,0));
1011                         Assert.AreEqual (false, rgn2.IsVisible (0,1));
1012                         Assert.AreEqual (true, rgn2.IsVisible (1,1));
1013                         Assert.AreEqual (true, rgn2.IsVisible (2,1));
1014                         Assert.AreEqual (false, rgn2.IsVisible (3,1));
1015                         Assert.AreEqual (false, rgn2.IsVisible (0,2));
1016                         Assert.AreEqual (false, rgn2.IsVisible (1,2));
1017                         Assert.AreEqual (false, rgn2.IsVisible (2,2));
1018                         Assert.AreEqual (false, rgn2.IsVisible (3,2));
1019
1020
1021                 }
1022
1023                 [Test]
1024                 public void TestTranslate()
1025                 {
1026                         Region rgn1 = new Region (new RectangleF (10, 10, 120,120));
1027                         rgn1.Translate (30,20);
1028                         Matrix matrix = new Matrix ();
1029
1030                         RectangleF [] rects = rgn1.GetRegionScans (matrix);
1031
1032                         Assert.AreEqual (1, rects.Length);
1033
1034                         Assert.AreEqual (40, rects[0].X);
1035                         Assert.AreEqual (30, rects[0].Y);
1036                         Assert.AreEqual (120, rects[0].Width);
1037                         Assert.AreEqual (120, rects[0].Height);
1038                 }
1039
1040         }
1041 }
1042
1043