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