Merge pull request #11 from MatanYadaev/more-spatial-functions

MatanYadaev · web-flow · commit d39caa83fd24 · 2021-02-08T23:20:32.000+02:00
More spatial functions
diff --git a/composer.json b/composer.json
@@ -43,7 +43,7 @@
         }
     },
     "scripts": {
-        "style-fix": "./vendor/bin/php-cs-fixer fix --allow-risky=yes",
+        "php-cs-fixer": "./vendor/bin/php-cs-fixer fix --allow-risky=yes",
         "phpstan": "vendor/bin/phpstan analyse --memory-limit=2G",
         "test": "vendor/bin/phpunit --colors=always",
         "test-coverage": "vendor/bin/phpunit --coverage-html coverage"
diff --git a/src/Builders/SpatialBuilder.php b/src/Builders/SpatialBuilder.php
@@ -85,6 +85,41 @@ public function whereTouches(string $column, Geometry | string $geometryOrColumn
         return $this->whereRaw("ST_TOUCHES(`{$column}`, {$geometryOrColumn})");
     }
 
+    public function whereIntersects(string $column, Geometry | string $geometryOrColumn): self
+    {
+        $geometryOrColumn = $this->toExpression($geometryOrColumn);
+
+        return $this->whereRaw("ST_INTERSECTS(`{$column}`, {$geometryOrColumn})");
+    }
+
+    public function whereCrosses(string $column, Geometry | string $geometryOrColumn): self
+    {
+        $geometryOrColumn = $this->toExpression($geometryOrColumn);
+
+        return $this->whereRaw("ST_CROSSES(`{$column}`, {$geometryOrColumn})");
+    }
+
+    public function whereDisjoint(string $column, Geometry | string $geometryOrColumn): self
+    {
+        $geometryOrColumn = $this->toExpression($geometryOrColumn);
+
+        return $this->whereRaw("ST_DISJOINT(`{$column}`, {$geometryOrColumn})");
+    }
+
+    public function whereOverlaps(string $column, Geometry | string $geometryOrColumn): self
+    {
+        $geometryOrColumn = $this->toExpression($geometryOrColumn);
+
+        return $this->whereRaw("ST_OVERLAPS(`{$column}`, {$geometryOrColumn})");
+    }
+
+    public function whereEquals(string $column, Geometry | string $geometryOrColumn): self
+    {
+        $geometryOrColumn = $this->toExpression($geometryOrColumn);
+
+        return $this->whereRaw("ST_EQUALS(`{$column}`, {$geometryOrColumn})");
+    }
+
     protected function toExpression(Geometry | string $geometryOrColumn): Expression
     {
         return $geometryOrColumn instanceof Geometry
diff --git a/tests/Builders/SpatialBuilderTest.php b/tests/Builders/SpatialBuilderTest.php
@@ -3,8 +3,9 @@
 namespace MatanYadaev\EloquentSpatial\Tests\Builders;
 
 use Illuminate\Foundation\Testing\DatabaseMigrations;
-use MatanYadaev\EloquentSpatial\Objects\MultiPolygon;
+use MatanYadaev\EloquentSpatial\Objects\LineString;
 use MatanYadaev\EloquentSpatial\Objects\Point;
+use MatanYadaev\EloquentSpatial\Objects\Polygon;
 use MatanYadaev\EloquentSpatial\Tests\TestCase;
 use MatanYadaev\EloquentSpatial\Tests\TestModels\TestPlace;
 
@@ -16,7 +17,7 @@ class SpatialBuilderTest extends TestCase
     public function it_calculates_distance_between_column_and_column(): void
     {
         TestPlace::factory()->create([
-            'point' => new Point(23.1, 55.5),
+            'point' => new Point(0, 0),
         ]);
 
         /** @var TestPlace $testPlaceWithDistance */
@@ -31,56 +32,55 @@ public function it_calculates_distance_between_column_and_column(): void
     public function it_calculates_distance_between_column_and_geometry(): void
     {
         TestPlace::factory()->create([
-            'point' => new Point(23.1, 55.5),
+            'point' => new Point(0, 0),
         ]);
 
         /** @var TestPlace $testPlaceWithDistance */
         $testPlaceWithDistance = TestPlace::query()
-            ->withDistance('point', new Point(23.1, 55.6))
+            ->withDistance('point', new Point(1, 1))
             ->firstOrFail();
 
-        $this->assertEquals(0.1, $testPlaceWithDistance->distance);
+        $this->assertEquals(1.4142135623731, $testPlaceWithDistance->distance);
     }
 
     /** @test */
     public function it_calculates_distance_with_defined_name(): void
     {
         TestPlace::factory()->create([
-            'point' => new Point(23.1, 55.5),
+            'point' => new Point(0, 0),
         ]);
 
         /** @var TestPlace $testPlaceWithDistance */
         $testPlaceWithDistance = TestPlace::query()
-            ->withDistance('point', new Point(23.1, 55.6), 'distance_in_meters')
+            ->withDistance('point', new Point(1, 1), 'distance_in_meters')
             ->firstOrFail();
 
-        $this->assertEquals(0.1, $testPlaceWithDistance->distance_in_meters);
+        $this->assertEquals(1.4142135623731, $testPlaceWithDistance->distance_in_meters);
     }
 
     /** @test */
     public function it_filters_by_distance(): void
     {
         TestPlace::factory()->create([
-            'point' => new Point(23.1, 55.5),
+            'point' => new Point(0, 0),
         ]);
 
-        /** @var TestPlace $testPlaceWithinDistance */
         $testPlaceWithinDistance = TestPlace::query()
-            ->whereDistance('point', new Point(23.1, 55.6), '<', 1)
-            ->firstOrFail();
+            ->whereDistance('point', new Point(1, 1), '<', 10)
+            ->first();
 
         $this->assertNotNull($testPlaceWithinDistance);
     }
 
     /** @test */
     public function it_orders_by_distance(): void
     {
-        $point = new Point(23.1, 55.51);
+        $point = new Point(0, 0);
         $testPlace1 = TestPlace::factory()->create([
-            'point' => new Point(23.1, 55.5),
+            'point' => new Point(1, 1),
         ]);
         $testPlace2 = TestPlace::factory()->create([
-            'point' => new Point(0, 0),
+            'point' => new Point(2, 2),
         ]);
 
         /** @var TestPlace $closestTestPlace */
@@ -100,7 +100,9 @@ public function it_orders_by_distance(): void
     /** @test */
     public function it_calculates_distance_sphere_column_and_column(): void
     {
-        TestPlace::factory()->create();
+        TestPlace::factory()->create([
+            'point' => new Point(0, 0),
+        ]);
 
         /** @var TestPlace $testPlaceWithDistance */
         $testPlaceWithDistance = TestPlace::query()
@@ -114,56 +116,55 @@ public function it_calculates_distance_sphere_column_and_column(): void
     public function it_calculates_distance_sphere_column_and_geometry(): void
     {
         TestPlace::factory()->create([
-            'point' => new Point(23.1, 55.5),
+            'point' => new Point(0, 0),
         ]);
 
         /** @var TestPlace $testPlaceWithDistance */
         $testPlaceWithDistance = TestPlace::query()
-            ->withDistanceSphere('point', new Point(23.1, 55.51))
+            ->withDistanceSphere('point', new Point(1, 1))
             ->firstOrFail();
 
-        $this->assertEquals(1022.7925914593363, $testPlaceWithDistance->distance);
+        $this->assertEquals(157249.0357231545, $testPlaceWithDistance->distance);
     }
 
     /** @test */
     public function it_calculates_distance_sphere_with_defined_name(): void
     {
         TestPlace::factory()->create([
-            'point' => new Point(23.1, 55.5),
+            'point' => new Point(0, 0),
         ]);
 
         /** @var TestPlace $testPlaceWithDistance */
         $testPlaceWithDistance = TestPlace::query()
-            ->withDistanceSphere('point', new Point(23.1, 55.51), 'distance_in_meters')
+            ->withDistanceSphere('point', new Point(1, 1), 'distance_in_meters')
             ->firstOrFail();
 
-        $this->assertEquals(1022.7925914593363, $testPlaceWithDistance->distance_in_meters);
+        $this->assertEquals(157249.0357231545, $testPlaceWithDistance->distance_in_meters);
     }
 
     /** @test */
     public function it_filters_distance_sphere(): void
     {
         TestPlace::factory()->create([
-            'point' => new Point(23.1, 55.5),
+            'point' => new Point(0, 0),
         ]);
 
-        /** @var TestPlace $testPlaceWithinDistanceSphere */
         $testPlaceWithinDistanceSphere = TestPlace::query()
-            ->whereDistanceSphere('point', new Point(23.1, 55.51), '<', 2000)
-            ->firstOrFail();
+            ->whereDistanceSphere('point', new Point(1, 1), '<', 200000)
+            ->first();
 
         $this->assertNotNull($testPlaceWithinDistanceSphere);
     }
 
     /** @test */
     public function it_orders_by_distance_sphere(): void
     {
-        $point = new Point(23.1, 55.51);
+        $point = new Point(0, 0);
         $testPlace1 = TestPlace::factory()->create([
-            'point' => new Point(23.1, 55.5),
+            'point' => new Point(1, 1),
         ]);
         $testPlace2 = TestPlace::factory()->create([
-            'point' => new Point(0, 0),
+            'point' => new Point(2, 2),
         ]);
 
         /** @var TestPlace $closestTestPlace */
@@ -184,13 +185,12 @@ public function it_orders_by_distance_sphere(): void
     public function it_filters_by_within(): void
     {
         TestPlace::factory()->create([
-            'point' => new Point(23.1, 55.5),
+            'point' => new Point(0, 0),
         ]);
 
-        /** @var TestPlace $testPlace */
         $testPlace = TestPlace::query()
-            ->whereWithin('point', MultiPolygon::fromJson('{"type":"MultiPolygon","coordinates":[[[[55.5,23.0],[55.4,23.2],[55.8,23.3],[55.5,23.0]]]]}'))
-            ->firstOrFail();
+            ->whereWithin('point', Polygon::fromJson('{"type":"Polygon","coordinates":[[[-1,-1],[1,-1],[1,1],[-1,1],[-1,-1]]]}'))
+            ->first();
 
         $this->assertNotNull($testPlace);
     }
@@ -199,13 +199,12 @@ public function it_filters_by_within(): void
     public function it_filters_by_contains(): void
     {
         TestPlace::factory()->create([
-            'multi_polygon' => MultiPolygon::fromJson('{"type":"MultiPolygon","coordinates":[[[[55.5,23.0],[55.4,23.2],[55.8,23.3],[55.5,23.0]]]]}'),
+            'polygon' => Polygon::fromJson('{"type":"Polygon","coordinates":[[[-1,-1],[1,-1],[1,1],[-1,1],[-1,-1]]]}'),
         ]);
 
-        /** @var TestPlace $testPlace */
         $testPlace = TestPlace::query()
-            ->whereContains('multi_polygon', new Point(23.1, 55.5))
-            ->firstOrFail();
+            ->whereContains('polygon', new Point(0, 0))
+            ->first();
 
         $this->assertNotNull($testPlace);
     }
@@ -214,13 +213,82 @@ public function it_filters_by_contains(): void
     public function it_filters_by_touches(): void
     {
         TestPlace::factory()->create([
-            'point' => new Point(23.1, 55.5),
+            'point' => new Point(0, 0),
+        ]);
+
+        $testPlace = TestPlace::query()
+            ->whereTouches('point', Polygon::fromJson('{"type":"Polygon","coordinates":[[[-1,-1],[0,-1],[0,0],[-1,0],[-1,-1]]]}'))
+            ->first();
+
+        $this->assertNotNull($testPlace);
+    }
+
+    /** @test */
+    public function it_filters_by_intersects(): void
+    {
+        TestPlace::factory()->create([
+            'point' => new Point(0, 0),
         ]);
 
-        /** @var TestPlace $testPlace */
         $testPlace = TestPlace::query()
-            ->whereTouches('point', MultiPolygon::fromJson('{"type":"MultiPolygon","coordinates":[[[[55.5,23.1],[55.6,23.2],[55.7,23.3],[55.5,23.1]]]]}'))
-            ->firstOrFail();
+            ->whereIntersects('point', Polygon::fromJson('{"type":"Polygon","coordinates":[[[-1,-1],[1,-1],[1,1],[-1,1],[-1,-1]]]}'))
+            ->first();
+
+        $this->assertNotNull($testPlace);
+    }
+
+    /** @test */
+    public function it_filters_by_crosses(): void
+    {
+        TestPlace::factory()->create([
+            'line_string' => LineString::fromJson('{"type":"LineString","coordinates":[[0,0],[2,0]]}'),
+        ]);
+
+        $testPlace = TestPlace::query()
+            ->whereCrosses('line_string', Polygon::fromJson('{"type":"Polygon","coordinates":[[[-1,-1],[1,-1],[1,1],[-1,1],[-1,-1]]]}'))
+            ->first();
+
+        $this->assertNotNull($testPlace);
+    }
+
+    /** @test */
+    public function it_filters_by_disjoint(): void
+    {
+        TestPlace::factory()->create([
+            'point' => new Point(0, 0),
+        ]);
+
+        $testPlace = TestPlace::query()
+            ->whereDisjoint('point', Polygon::fromJson('{"type":"Polygon","coordinates":[[[-1,-1],[-0.5,-1],[-0.5,-0.5],[-1,-0.5],[-1,-1]]]}'))
+            ->first();
+
+        $this->assertNotNull($testPlace);
+    }
+
+    /** @test */
+    public function it_filters_by_overlaps(): void
+    {
+        TestPlace::factory()->create([
+            'polygon' => Polygon::fromJson('{"type":"Polygon","coordinates":[[[-1,-1],[-0.5,-1],[-0.5,-0.5],[-1,-0.5],[-1,-1]]]}'),
+        ]);
+
+        $testPlace = TestPlace::query()
+            ->whereOverlaps('polygon', Polygon::fromJson('{"type":"Polygon","coordinates":[[[-0.75,-0.75],[1,-1],[1,1],[-1,1],[-0.75,-0.75]]]}'))
+            ->first();
+
+        $this->assertNotNull($testPlace);
+    }
+
+    /** @test */
+    public function it_filters_by_equals(): void
+    {
+        TestPlace::factory()->create([
+            'point' => new Point(0, 0),
+        ]);
+
+        $testPlace = TestPlace::query()
+            ->whereEquals('point', new Point(0, 0))
+            ->first();
 
         $this->assertNotNull($testPlace);
     }

Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@`
`43`	`43`	`}`
`44`	`44`	`},`
`45`	`45`	`"scripts": {`
`46`		`- "style-fix": "./vendor/bin/php-cs-fixer fix --allow-risky=yes",`
	`46`	`+ "php-cs-fixer": "./vendor/bin/php-cs-fixer fix --allow-risky=yes",`
`47`	`47`	`"phpstan": "vendor/bin/phpstan analyse --memory-limit=2G",`
`48`	`48`	`"test": "vendor/bin/phpunit --colors=always",`
`49`	`49`	`"test-coverage": "vendor/bin/phpunit --coverage-html coverage"`