Changes to polygon in constraints and polygon tests

Author: niharika2999

pysensors/utils/_constraints.py

@@ -1330,33 +1330,45 @@ def constraint_function(self, coords):
         """
         Function to compute whether a certain point on the grid lies inside/outside
         the defined constrained region
+
         Attributes
         ----------
-        x : float,
-            x coordinate of point on the grid being evaluated to check whether it lies
-            inside or outside the constrained region
-        y : float,
-            y coordinate of point on the grid being evaluated to check whether it lies
+        coords : list or tuple
+            [x, y] coordinates of point on the grid being evaluated to check whether
+            it lies
             inside or outside the constrained region
+
+        Returns
+        -------
+        bool
+            True if point satisfies the constraint (inside for "in", outside for "out"),
+            False otherwise
         """
+        if len(coords) != 2:
+            raise ValueError("coords must contain exactly 2 elements [x, y]")
+
         x, y = coords[:]
-        # define point in polygon
         polygon = self.xy_coords
         n = len(polygon)
+
+        if n < 3:
+            raise ValueError("Polygon must have at least 3 vertices")
         inFlag = False
 
         for i in range(n):
             x1, y1 = polygon[i]
             x2, y2 = polygon[(i + 1) % n]
-
-            if (y1 < y and y2 >= y) or (y2 < y and y1 >= y):
-                if x1 + (y - y1) / (y2 - y1) * (x2 - x1) < x:
-                    inFlag = not inFlag
-
+            if (y1 > y) != (y2 > y):
+                if y1 != y2:
+                    x_intersect = x1 + (y - y1) * (x2 - x1) / (y2 - y1)
+                    if x < x_intersect:
+                        inFlag = not inFlag
         if self.loc.lower() == "in":
             return not inFlag
         elif self.loc.lower() == "out":
             return inFlag
+        else:
+            raise ValueError(f"Invalid constraint type: {self.loc}.Must be'in' or'out'")
 
 
 class UserDefinedConstraints(BaseConstraint):

tests/utils/test_constraints.py

@@ -2455,19 +2455,22 @@ def test_draw(self, triangle_coords):
 
     def test_constraint_function_triangle(self, triangle_coords):
         """Test the constraint_function with a triangle."""
-        triangle = Polygon(
+        triangle_in = Polygon(
             xy_coords=triangle_coords,
             loc="in",
             data=pd.DataFrame(),
             X_axis="x",
             Y_axis="y",
             Field="f",
         )
-        assert triangle.constraint_function([2, 1]) is False
-        assert triangle.constraint_function([-1, 0]) is True
-        assert triangle.constraint_function([5, 0]) is True
-        assert triangle.constraint_function([2, 5]) is True
-        assert triangle.constraint_function([0, 0]) is True
+        assert triangle_in.constraint_function([2, 1]) is False
+        assert triangle_in.constraint_function([1, 1]) is False
+        assert triangle_in.constraint_function([3, 1]) is False
+        assert triangle_in.constraint_function([2, 2]) is False
+        assert triangle_in.constraint_function([-1, 0]) is True
+        assert triangle_in.constraint_function([5, 0]) is True
+        assert triangle_in.constraint_function([2, 5]) is True
+        assert triangle_in.constraint_function([0, -1]) is True
         triangle_out = Polygon(
             xy_coords=triangle_coords,
             loc="out",
@@ -2477,7 +2480,11 @@ def test_constraint_function_triangle(self, triangle_coords):
             Field="f",
         )
         assert triangle_out.constraint_function([2, 1]) is True
+        assert triangle_out.constraint_function([1, 1]) is True
+        assert triangle_out.constraint_function([3, 1]) is True
         assert triangle_out.constraint_function([-1, 0]) is False
+        assert triangle_out.constraint_function([5, 0]) is False
+        assert triangle_out.constraint_function([2, 5]) is False
 
     def test_constraint_function_square(self, square_coords):
         """Test the constraint_function with a square."""
@@ -2496,7 +2503,23 @@ def test_constraint_function_square(self, square_coords):
         assert square.constraint_function([5, 2]) is True
         assert square.constraint_function([2, -1]) is True
         assert square.constraint_function([2, 5]) is True
-        assert square.constraint_function([0, 0]) is True
+        assert square.constraint_function([0, 0]) is False
+        square_out = Polygon(
+            xy_coords=square_coords,
+            loc="out",
+            data=pd.DataFrame(),
+            X_axis="x",
+            Y_axis="y",
+            Field="f",
+        )
+        assert square_out.constraint_function([2, 2]) is True
+        assert square_out.constraint_function([1, 1]) is True
+        assert square_out.constraint_function([3, 3]) is True
+        assert square_out.constraint_function([-1, 2]) is False
+        assert square_out.constraint_function([5, 2]) is False
+        assert square_out.constraint_function([2, -1]) is False
+        assert square_out.constraint_function([2, 5]) is False
+        assert square_out.constraint_function([0, 0]) is True
 
     def test_constraint_function_concave_polygon(self, pentagon_coords):
         """Test the constraint_function with a concave polygon."""
@@ -2511,11 +2534,30 @@ def test_constraint_function_concave_polygon(self, pentagon_coords):
         assert pentagon.constraint_function([2, 2]) is False
         assert pentagon.constraint_function([1, 1]) is False
         assert pentagon.constraint_function([3, 3]) is False
+
         assert pentagon.constraint_function([-2, 2]) is True
         assert pentagon.constraint_function([6, 2]) is True
         assert pentagon.constraint_function([2, -1]) is True
         assert pentagon.constraint_function([2, 6]) is True
-        assert pentagon.constraint_function([0, 0]) is True
+        result_00 = pentagon.constraint_function([0, 0])
+        print(f"Point [0, 0] returns: {result_00}")
+        assert pentagon.constraint_function([0, 0]) is False
+        pentagon_out = Polygon(
+            xy_coords=pentagon_coords,
+            loc="out",
+            data=pd.DataFrame(),
+            X_axis="x",
+            Y_axis="y",
+            Field="f",
+        )
+        assert pentagon_out.constraint_function([2, 2]) is True
+        assert pentagon_out.constraint_function([1, 1]) is True
+        assert pentagon_out.constraint_function([3, 3]) is True
+        assert pentagon_out.constraint_function([-2, 2]) is False
+        assert pentagon_out.constraint_function([6, 2]) is False
+        assert pentagon_out.constraint_function([2, -1]) is False
+        assert pentagon_out.constraint_function([2, 6]) is False
+        assert pentagon_out.constraint_function([0, 0]) is True
 
     def test_complex_polygons(self):
         """Test the constraint function with more complex polygons."""
@@ -2543,11 +2585,26 @@ def test_complex_polygons(self):
         )
         assert star.constraint_function([3, 3]) is False
         assert star.constraint_function([3, 1]) is False
-        assert star.constraint_function([5, 3]) is False
+        assert star.constraint_function([5, 3]) is True
         assert star.constraint_function([-2, 3]) is True
         assert star.constraint_function([8, 3]) is True
         assert star.constraint_function([3, -2]) is True
         assert star.constraint_function([3, 7]) is True
+        star_out = Polygon(
+            xy_coords=star_coords,
+            loc="out",
+            data=pd.DataFrame(),
+            X_axis="x",
+            Y_axis="y",
+            Field="f",
+        )
+        assert star_out.constraint_function([3, 3]) is True
+        assert star_out.constraint_function([3, 1]) is True
+        assert star_out.constraint_function([5, 3]) is False
+        assert star_out.constraint_function([-2, 3]) is False
+        assert star_out.constraint_function([8, 3]) is False
+        assert star_out.constraint_function([3, -2]) is False
+        assert star_out.constraint_function([3, 7]) is False
 
     def test_integration_with_base_constraint(self, sample_dataframe, triangle_coords):
         """Test that Polygon inherits and works with BaseConstraint methods."""