test/classes/Gis/GisPolygonTest.php

   1 <?php
   2
   3 declare(strict_types=1);
   4
   5 namespace PhpMyAdmin\Tests\Gis;
   6
   7 use PhpMyAdmin\Gis\GisPolygon;
   8 use PhpMyAdmin\Image\ImageWrapper;
   9 use TCPDF;
  10
  11 /**
  12  * @covers \PhpMyAdmin\Gis\GisPolygon
  13  * @runTestsInSeparateProcesses
  14  * @preserveGlobalState disabled
  15  */
  16 class GisPolygonTest extends GisGeomTestCase
  17 {
  18     /** @var    GisPolygon */
  19     protected $object;
  20
  21     /**
  22      * Sets up the fixture, for example, opens a network connection.
  23      * This method is called before a test is executed.
  24      */
  25     protected function setUp(): void
  26     {
  27         parent::setUp();
  28         $this->object = GisPolygon::singleton();
  29     }
  30
  31     /**
  32      * Tears down the fixture, for example, closes a network connection.
  33      * This method is called after a test is executed.
  34      */
  35     protected function tearDown(): void
  36     {
  37         parent::tearDown();
  38         unset($this->object);
  39     }
  40
  41     /**
  42      * Provide some common data to data providers
  43      *
  44      * @return array common data for data providers
  45      */
  46     private function getData(): array
  47     {
  48         return [
  49             'POLYGON' => [
  50                 'no_of_lines' => 2,
  51                 0 => [
  52                     'no_of_points' => 5,
  53                     0 => [
  54                         'x' => 35,
  55                         'y' => 10,
  56                     ],
  57                     1 => [
  58                         'x' => 10,
  59                         'y' => 20,
  60                     ],
  61                     2 => [
  62                         'x' => 15,
  63                         'y' => 40,
  64                     ],
  65                     3 => [
  66                         'x' => 45,
  67                         'y' => 45,
  68                     ],
  69                     4 => [
  70                         'x' => 35,
  71                         'y' => 10,
  72                     ],
  73                 ],
  74                 1 => [
  75                     'no_of_points' => 4,
  76                     0 => [
  77                         'x' => 20,
  78                         'y' => 30,
  79                     ],
  80                     1 => [
  81                         'x' => 35,
  82                         'y' => 32,
  83                     ],
  84                     2 => [
  85                         'x' => 30,
  86                         'y' => 20,
  87                     ],
  88                     3 => [
  89                         'x' => 20,
  90                         'y' => 30,
  91                     ],
  92                 ],
  93             ],
  94         ];
  95     }
  96
  97     /**
  98      * data provider for testGenerateWkt
  99      *
 100      * @return array data for testGenerateWkt
 101      */
 102     public function providerForTestGenerateWkt(): array
 103     {
 104         $temp = [
 105             0 => $this->getData(),
 106         ];
 107
 108         $temp1 = $temp;
 109         unset($temp1[0]['POLYGON'][1][3]['y']);
 110
 111         $temp2 = $temp;
 112         $temp2[0]['POLYGON']['no_of_lines'] = 0;
 113
 114         $temp3 = $temp;
 115         $temp3[0]['POLYGON'][1]['no_of_points'] = 3;
 116
 117         return [
 118             [
 119                 $temp,
 120                 0,
 121                 null,
 122                 'POLYGON((35 10,10 20,15 40,45 45,35 10),(20 30,35 32,30 20,20 30))',
 123             ],
 124             // values at undefined index
 125             [
 126                 $temp,
 127                 1,
 128                 null,
 129                 'POLYGON(( , , , ))',
 130             ],
 131             // if a coordinate is missing, default is empty string
 132             [
 133                 $temp1,
 134                 0,
 135                 null,
 136                 'POLYGON((35 10,10 20,15 40,45 45,35 10),(20 30,35 32,30 20,20 ))',
 137             ],
 138             // missing coordinates are replaced with provided values (3rd parameter)
 139             [
 140                 $temp1,
 141                 0,
 142                 '0',
 143                 'POLYGON((35 10,10 20,15 40,45 45,35 10),(20 30,35 32,30 20,20 0))',
 144             ],
 145             // should have at least one ring
 146             [
 147                 $temp2,
 148                 0,
 149                 '0',
 150                 'POLYGON((35 10,10 20,15 40,45 45,35 10))',
 151             ],
 152             // a ring should have at least four points
 153             [
 154                 $temp3,
 155                 0,
 156                 '0',
 157                 'POLYGON((35 10,10 20,15 40,45 45,35 10),(20 30,35 32,30 20,20 30))',
 158             ],
 159         ];
 160     }
 161
 162     /**
 163      * data provider for testGenerateParams
 164      *
 165      * @return array data for testGenerateParams
 166      */
 167     public function providerForTestGenerateParams(): array
 168     {
 169         $temp = $this->getData();
 170
 171         $temp1 = $temp;
 172         $temp1['gis_type'] = 'POLYGON';
 173
 174         return [
 175             [
 176                 '\'POLYGON((35 10,10 20,15 40,45 45,35 10),(20 30,35 32,30 20,20 30))\',124',
 177                 null,
 178                 [
 179                     'srid' => 124,
 180                     0 => $temp,
 181                 ],
 182             ],
 183             [
 184                 'POLYGON((35 10,10 20,15 40,45 45,35 10),(20 30,35 32,30 20,20 30))',
 185                 2,
 186                 [2 => $temp1],
 187             ],
 188         ];
 189     }
 190
 191     /**
 192      * test for Area
 193      *
 194      * @param array $ring array of points forming the ring
 195      * @param float $area area of the ring
 196      *
 197      * @dataProvider providerForTestArea
 198      */
 199     public function testArea(array $ring, float $area): void
 200     {
 201         $this->assertEquals($area, $this->object->area($ring));
 202     }
 203
 204     /**
 205      * data provider for testArea
 206      *
 207      * @return array data for testArea
 208      */
 209     public function providerForTestArea(): array
 210     {
 211         return [
 212             [
 213                 [
 214                     0 => [
 215                         'x' => 35,
 216                         'y' => 10,
 217                     ],
 218                     1 => [
 219                         'x' => 10,
 220                         'y' => 10,
 221                     ],
 222                     2 => [
 223                         'x' => 15,
 224                         'y' => 40,
 225                     ],
 226                 ],
 227                 -375.00,
 228             ],
 229             // first point of the ring repeated as the last point
 230             [
 231                 [
 232                     0 => [
 233                         'x' => 35,
 234                         'y' => 10,
 235                     ],
 236                     1 => [
 237                         'x' => 10,
 238                         'y' => 10,
 239                     ],
 240                     2 => [
 241                         'x' => 15,
 242                         'y' => 40,
 243                     ],
 244                     3 => [
 245                         'x' => 35,
 246                         'y' => 10,
 247                     ],
 248                 ],
 249                 -375.00,
 250             ],
 251             // anticlockwise gives positive area
 252             [
 253                 [
 254                     0 => [
 255                         'x' => 15,
 256                         'y' => 40,
 257                     ],
 258                     1 => [
 259                         'x' => 10,
 260                         'y' => 10,
 261                     ],
 262                     2 => [
 263                         'x' => 35,
 264                         'y' => 10,
 265                     ],
 266                 ],
 267                 375.00,
 268             ],
 269         ];
 270     }
 271
 272     /**
 273      * test for isPointInsidePolygon
 274      *
 275      * @param array $point    x, y coordinates of the point
 276      * @param array $polygon  array of points forming the ring
 277      * @param bool  $isInside output
 278      *
 279      * @dataProvider providerForTestIsPointInsidePolygon
 280      */
 281     public function testIsPointInsidePolygon(array $point, array $polygon, bool $isInside): void
 282     {
 283         $this->assertEquals(
 284             $isInside,
 285             $this->object->isPointInsidePolygon($point, $polygon)
 286         );
 287     }
 288
 289     /**
 290      * data provider for testIsPointInsidePolygon
 291      *
 292      * @return array data for testIsPointInsidePolygon
 293      */
 294     public function providerForTestIsPointInsidePolygon(): array
 295     {
 296         $ring = [
 297             0 => [
 298                 'x' => 35,
 299                 'y' => 10,
 300             ],
 301             1 => [
 302                 'x' => 10,
 303                 'y' => 10,
 304             ],
 305             2 => [
 306                 'x' => 15,
 307                 'y' => 40,
 308             ],
 309             3 => [
 310                 'x' => 35,
 311                 'y' => 10,
 312             ],
 313         ];
 314
 315         return [
 316             // point inside the ring
 317             [
 318                 [
 319                     'x' => 20,
 320                     'y' => 15,
 321                 ],
 322                 $ring,
 323                 true,
 324             ],
 325             // point on an edge of the ring
 326             [
 327                 [
 328                     'x' => 20,
 329                     'y' => 10,
 330                 ],
 331                 $ring,
 332                 false,
 333             ],
 334             // point on a vertex of the ring
 335             [
 336                 [
 337                     'x' => 10,
 338                     'y' => 10,
 339                 ],
 340                 $ring,
 341                 false,
 342             ],
 343             // point outside the ring
 344             [
 345                 [
 346                     'x' => 5,
 347                     'y' => 10,
 348                 ],
 349                 $ring,
 350                 false,
 351             ],
 352         ];
 353     }
 354
 355     /**
 356      * test for getPointOnSurface
 357      *
 358      * @param array $ring array of points forming the ring
 359      *
 360      * @dataProvider providerForTestGetPointOnSurface
 361      */
 362     public function testGetPointOnSurface(array $ring): void
 363     {
 364         $point = $this->object->getPointOnSurface($ring);
 365         $this->assertIsArray($point);
 366         $this->assertTrue($this->object->isPointInsidePolygon($point, $ring));
 367     }
 368
 369     /**
 370      * data provider for testGetPointOnSurface
 371      *
 372      * @return array data for testGetPointOnSurface
 373      */
 374     public function providerForTestGetPointOnSurface(): array
 375     {
 376         $temp = $this->getData();
 377         unset($temp['POLYGON'][0]['no_of_points']);
 378         unset($temp['POLYGON'][1]['no_of_points']);
 379
 380         return [
 381             [
 382                 $temp['POLYGON'][0],
 383             ],
 384             [
 385                 $temp['POLYGON'][1],
 386             ],
 387         ];
 388     }
 389
 390     /**
 391      * data provider for testScaleRow
 392      *
 393      * @return array data for testScaleRow
 394      */
 395     public function providerForTestScaleRow(): array
 396     {
 397         return [
 398             [
 399                 'POLYGON((123 0,23 30,17 63,123 0))',
 400                 [
 401                     'minX' => 17,
 402                     'maxX' => 123,
 403                     'minY' => 0,
 404                     'maxY' => 63,
 405                 ],
 406             ],
 407             [
 408                 'POLYGON((35 10,10 20,15 40,45 45,35 10),(20 30,35 32,30 20,20 30)))',
 409                 [
 410                     'minX' => 10,
 411                     'maxX' => 45,
 412                     'minY' => 10,
 413                     'maxY' => 45,
 414                 ],
 415             ],
 416         ];
 417     }
 418
 419     /**
 420      * @requires extension gd
 421      */
 422     public function testPrepareRowAsPng(): void
 423     {
 424         $image = ImageWrapper::create(200, 124, ['red' => 229, 'green' => 229, 'blue' => 229]);
 425         $this->assertNotNull($image);
 426         $return = $this->object->prepareRowAsPng(
 427             'POLYGON((0 0,100 0,100 100,0 100,0 0),(10 10,10 40,40 40,40 10,10 10),(60 60,90 60,90 90,60 90,60 60))',
 428             'image',
 429             [176, 46, 224],
 430             ['x' => -56, 'y' => -16, 'scale' => 0.94, 'height' => 124],
 431             $image
 432         );
 433         $this->assertEquals(200, $return->width());
 434         $this->assertEquals(124, $return->height());
 435
 436         $fileExpected = $this->testDir . '/polygon-expected.png';
 437         $fileActual = $this->testDir . '/polygon-actual.png';
 438         $this->assertTrue($image->png($fileActual));
 439         $this->assertFileEquals($fileExpected, $fileActual);
 440     }
 441
 442     /**
 443      * test case for prepareRowAsPdf() method
 444      *
 445      * @param string $spatial    GIS POLYGON object
 446      * @param string $label      label for the GIS POLYGON object
 447      * @param int[]  $color      color for the GIS POLYGON object
 448      * @param array  $scale_data array containing data related to scaling
 449      * @param TCPDF  $pdf        TCPDF instance
 450      *
 451      * @dataProvider providerForPrepareRowAsPdf
 452      */
 453     public function testPrepareRowAsPdf(
 454         string $spatial,
 455         string $label,
 456         array $color,
 457         array $scale_data,
 458         TCPDF $pdf
 459     ): void {
 460         $return = $this->object->prepareRowAsPdf($spatial, $label, $color, $scale_data, $pdf);
 461
 462         $fileExpected = $this->testDir . '/polygon-expected.pdf';
 463         $fileActual = $this->testDir . '/polygon-actual.pdf';
 464         $return->Output($fileActual, 'F');
 465         $this->assertFileEquals($fileExpected, $fileActual);
 466     }
 467
 468     /**
 469      * data provider for testPrepareRowAsPdf() test case
 470      *
 471      * @return array test data for testPrepareRowAsPdf() test case
 472      */
 473     public function providerForPrepareRowAsPdf(): array
 474     {
 475         return [
 476             [
 477                 'POLYGON((0 0,100 0,100 100,0 100,0 0),(10 10,10 40,40 40,40 10,10 10),(60 60,90 60,90 90,60 90,60 6'
 478                 . '0))',
 479                 'pdf',
 480                 [176, 46, 224],
 481                 ['x' => -8, 'y' => -32, 'scale' => 1.80, 'height' => 297],
 482                 $this->createEmptyPdf('POLYGON'),
 483             ],
 484         ];
 485     }
 486
 487     /**
 488      * test case for prepareRowAsSvg() method
 489      *
 490      * @param string $spatial   GIS POLYGON object
 491      * @param string $label     label for the GIS POLYGON object
 492      * @param int[]  $color     color for the GIS POLYGON object
 493      * @param array  $scaleData array containing data related to scaling
 494      * @param string $output    expected output
 495      *
 496      * @dataProvider providerForPrepareRowAsSvg
 497      */
 498     public function testPrepareRowAsSvg(
 499         string $spatial,
 500         string $label,
 501         array $color,
 502         array $scaleData,
 503         string $output
 504     ): void {
 505         $svg = $this->object->prepareRowAsSvg($spatial, $label, $color, $scaleData);
 506         $this->assertEquals($output, $svg);
 507     }
 508
 509     /**
 510      * data provider for testPrepareRowAsSvg() test case
 511      *
 512      * @return array test data for testPrepareRowAsSvg() test case
 513      */
 514     public function providerForPrepareRowAsSvg(): array
 515     {
 516         return [
 517             [
 518                 'POLYGON((123 0,23 30,17 63,123 0),(99 12,30 35,25 55,99 12))',
 519                 'svg',
 520                 [176, 46, 224],
 521                 [
 522                     'x' => 12,
 523                     'y' => 69,
 524                     'scale' => 2,
 525                     'height' => 150,
 526                 ],
 527                 '<path d=" M 222, 288 L 22, 228 L 10, 162 Z  M 174, 264 L 36, 218 L 26, 178 Z " name="svg" id="svg12'
 528                 . '34567890" class="polygon vector" stroke="black" stroke-width="0.5" fill="#b02ee0" fill-rule="evenod'
 529                 . 'd" fill-opacity="0.8"/>',
 530             ],
 531         ];
 532     }
 533
 534     /**
 535      * test case for prepareRowAsOl() method
 536      *
 537      * @param string $spatial    GIS POLYGON object
 538      * @param int    $srid       spatial reference ID
 539      * @param string $label      label for the GIS POLYGON object
 540      * @param int[]  $color      color for the GIS POLYGON object
 541      * @param array  $scale_data array containing data related to scaling
 542      * @param string $output     expected output
 543      *
 544      * @dataProvider providerForPrepareRowAsOl
 545      */
 546     public function testPrepareRowAsOl(
 547         string $spatial,
 548         int $srid,
 549         string $label,
 550         array $color,
 551         array $scale_data,
 552         string $output
 553     ): void {
 554         $ol = $this->object->prepareRowAsOl($spatial, $srid, $label, $color, $scale_data);
 555         $this->assertEquals($output, $ol);
 556     }
 557
 558     /**
 559      * data provider for testPrepareRowAsOl() test case
 560      *
 561      * @return array test data for testPrepareRowAsOl() test case
 562      */
 563     public function providerForPrepareRowAsOl(): array
 564     {
 565         return [
 566             [
 567                 'POLYGON((123 0,23 30,17 63,123 0))',
 568                 4326,
 569                 'Ol',
 570                 [176, 46, 224],
 571                 [
 572                     'minX' => '0',
 573                     'minY' => '0',
 574                     'maxX' => '1',
 575                     'maxY' => '1',
 576                 ],
 577                 'var style = new ol.style.Style({fill: new ol.style.Fill({"color":[176,46,224,0.8]'
 578                 . '}),stroke: new ol.style.Stroke({"color":[0,0,0],"width":0.5}),text: new ol.styl'
 579                 . 'e.Text({"text":"Ol"})});var minLoc = [0, 0];var maxLoc = [1, 1];var ext = ol.ex'
 580                 . 'tent.boundingExtent([minLoc, maxLoc]);ext = ol.proj.transformExtent(ext, ol.pro'
 581                 . 'j.get("EPSG:4326"), ol.proj.get(\'EPSG:3857\'));map.getView().fit(ext, map.getS'
 582                 . 'ize());var arr = [];var lineArr = [];var line = new ol.geom.LinearRing(new Arra'
 583                 . 'y((new ol.geom.Point([123,0]).transform(ol.proj.get("EPSG:4326"), ol.proj.get('
 584                 . '\'EPSG:3857\'))).getCoordinates(), (new ol.geom.Point([23,30]).transform(ol.pro'
 585                 . 'j.get("EPSG:4326"), ol.proj.get(\'EPSG:3857\'))).getCoordinates(), (new ol.geom'
 586                 . '.Point([17,63]).transform(ol.proj.get("EPSG:4326"), ol.proj.get(\'EPSG:3857\'))'
 587                 . ').getCoordinates(), (new ol.geom.Point([123,0]).transform(ol.proj.get("EPSG:432'
 588                 . '6"), ol.proj.get(\'EPSG:3857\'))).getCoordinates()));var coord = line.getCoordi'
 589                 . 'nates();for (var i = 0; i < coord.length; i++) lineArr.push(coord[i]);arr.push(lineArr);'
 590                 . 'var polygon = new ol.geom.Polygon(arr);var feature = new ol.Feature({geometry: polygon});f'
 591                 . 'eature.setStyle(style);vectorLayer.addFeature(feature);',
 592             ],
 593         ];
 594     }
 595
 596     /**
 597      * test case for isOuterRing() method
 598      *
 599      * @param array $ring coordinates of the points in a ring
 600      *
 601      * @dataProvider providerForIsOuterRing
 602      */
 603     public function testIsOuterRing(array $ring): void
 604     {
 605         $this->assertTrue($this->object->isOuterRing($ring));
 606     }
 607
 608     /**
 609      * data provider for testIsOuterRing() test case
 610      *
 611      * @return array test data for testIsOuterRing() test case
 612      */
 613     public function providerForIsOuterRing(): array
 614     {
 615         return [
 616             [
 617                 [
 618                     [
 619                         'x' => 0,
 620                         'y' => 0,
 621                     ],
 622                     [
 623                         'x' => 0,
 624                         'y' => 1,
 625                     ],
 626                     [
 627                         'x' => 1,
 628                         'y' => 1,
 629                     ],
 630                     [
 631                         'x' => 1,
 632                         'y' => 0,
 633                     ],
 634                 ],
 635             ],
 636         ];
 637     }
 638 }