base

itzpr3d4t0r · itzpr3d4t0r · commit 41ecf29e8fe2 · 2023-02-07T20:03:55.000+01:00
diff --git a/docs/line.rst b/docs/line.rst
@@ -335,4 +335,39 @@ Line Methods
 
         Returns a new `Line` having the same position and radius as the original.
 
-      .. ## Line.copy ##
+      .. ## Line.copy ##
+
+    .. method:: as_segments
+
+        | :sl:`returns the line as a list of segments`
+        | :sg:`as_segments(n_segments) -> [(x, y), (x, y)]`
+
+        Segments the original line into N Lines of equal length and returns a list of
+        them. The number of segments is determined by the `n_segments` parameter.
+
+        .. note::
+            The original line is not modified. The returned list of lines will always
+            have the first line's `a` point at the same position as the original line's `a`
+            point and the last line's `b` point at the same position as the original line's
+            `b` point.
+
+
+      .. ## Line.as_segments ##
+
+    .. method:: as_points
+
+        | :sl:`returns the line as a list of points`
+        | :sg:`as_points(n_points) -> [(x, y), (x, y)]`
+
+        Returns a list of points that represent the line. The first point in the list
+        will be the line's `a` point and the last point will be the line's `b` point.
+        The number of points is determined by the `n_points` parameter.
+
+        .. note::
+            The n_points parameter refers to the number of points that will created in
+            between the line's `a` and `b` points. The number of points returned will
+            always be n_points + 2. Because of this the n_points parameter must be at
+            least 0.
+
+
+      .. ## Line.as_points ##
diff --git a/examples/line_as_points.py b/examples/line_as_points.py
@@ -0,0 +1,43 @@
+import pygame
+from geometry import *
+from pygame.draw import circle as draw_circle, line as draw_line
+
+WIDTH, HEIGHT = 800, 600
+WIDTH2, HEIGHT2 = WIDTH / 2, HEIGHT / 2
+pygame.init()
+screen = pygame.display.set_mode((WIDTH, HEIGHT))
+clock = pygame.time.Clock()
+keep = True
+N = 50
+# Create a line
+line = Line((WIDTH / 4, HEIGHT2), (3 * WIDTH / 4, HEIGHT2))
+
+while keep:
+    screen.fill((30, 30, 30))
+    # Draw the line
+    # draw_line(screen, (255, 255, 255), line.a, line.b, 2)
+    # Draw the points
+    for i, segment in enumerate(line.as_segments(N)):
+        draw_line(
+            screen,
+            ((100 + 45 * (i + 1)) % 255, 15 * (i + 1) % 255, (135 * (i + 1)) % 255),
+            segment.a,
+            segment.b,
+            3,
+        )
+    for point in line.as_points(N - 1):
+        draw_circle(screen, (255, 255, 255), point, 1)
+
+    line.b = pygame.mouse.get_pos()
+
+    pygame.display.flip()
+    clock.tick(165)
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            keep = False
+        if event.type == pygame.MOUSEWHEEL:
+            if event.y > 0:
+                N += 1
+            else:
+                if N > 2:
+                    N -= 1
diff --git a/geometry.pyi b/geometry.pyi
@@ -123,6 +123,8 @@ class Line(Sequence[float]):
     def flip_ip(self) -> None: ...
     def is_parallel(self, line: LineValue) -> bool: ...
     def is_perpendicular(self, line: LineValue) -> bool: ...
+    def as_points(self, n_points: int) -> List[Tuple[float, float]]: ...
+    def as_segments(self, n_segments: int) -> List[Tuple[Line]]: ...
 
 class Circle:
     x: float
diff --git a/src_c/line.c b/src_c/line.c
@@ -490,6 +490,129 @@ pg_line_flip_ip(pgLineObject *self, PyObject *_null)
     Py_RETURN_NONE;
 }
 
+static PyObject *
+pg_line_as_points(pgLineObject *self, PyObject *arg)
+{
+    int N = 0;
+    if (!pg_IntFromObj(arg, &N)) {
+        return RAISE(PyExc_TypeError, "as_points requires an integer");
+    }
+    if (N < 0) {
+        return RAISE(PyExc_ValueError, "as_points requires a positive integer");
+    }
+
+    PyObject *point = NULL;
+    PyObject *list = PyList_New(2 + N);
+    if (!list) {
+        return NULL;
+    }
+
+    pgLineBase *line = &self->line;
+
+    // Add the start and end points to the list
+    point = pg_TupleFromDoublePair(line->x1, line->y1);
+    if (!point) {
+        Py_DECREF(list);
+        return NULL;
+    }
+    PyList_SET_ITEM(list, 0, point);
+    point = pg_TupleFromDoublePair(line->x2, line->y2);
+    if (!point) {
+        Py_DECREF(list);
+        return NULL;
+    }
+    PyList_SET_ITEM(list, N + 1, point);
+
+    if (!N) {
+        return list;
+    }
+    else if (N == 1) {
+        point = pg_TupleFromDoublePair((line->x1 + line->x2) / 2,
+                                       (line->y1 + line->y2) / 2);
+        if (!point) {
+            Py_DECREF(list);
+            return NULL;
+        }
+        PyList_SET_ITEM(list, 1, point);
+        return list;
+    }
+
+    double step_x = (line->x2 - line->x1) / (N + 1);
+    double step_y = (line->y2 - line->y1) / (N + 1);
+    double x = line->x1 + step_x;
+    double y = line->y1 + step_y;
+
+    Py_ssize_t i;
+    for (i = 1; i < N + 1; i++) {
+        point = pg_TupleFromDoublePair(x, y);
+        if (!point) {
+            Py_DECREF(list);
+            return NULL;
+        }
+        PyList_SET_ITEM(list, i, point);
+        x += step_x;
+        y += step_y;
+    }
+
+    return list;
+}
+
+static PyObject *
+pg_line_as_segments(pgLineObject *self, PyObject *arg)
+{
+    /* Segments the line into N Lines of equal length and returns a list of
+     * them. */
+
+    int N = 1;
+    if (!pg_IntFromObj(arg, &N)) {
+        return RAISE(PyExc_TypeError,
+                     "as_segments requires an integer");
+    }
+    if (N < 1) {
+        return RAISE(PyExc_ValueError,
+                     "as_segments requires a positive integer");
+    }
+
+    PyObject *line_obj = NULL;
+    PyObject *list = PyList_New(N);
+    if (!list) {
+        return NULL;
+    }
+
+    if (N == 1) {
+        line_obj = pg_line_copy(self, NULL);
+        if (!line_obj) {
+            Py_DECREF(list);
+            return NULL;
+        }
+        PyList_SET_ITEM(list, 0, line_obj);
+        return list;
+    }
+
+    pgLineBase *line = &self->line;
+
+    double step_x = (line->x2 - line->x1) / N;
+    double step_y = (line->y2 - line->y1) / N;
+    double x1 = line->x1, y1 = line->y1;
+    double x2 = x1 + step_x, y2 = y1 + step_y;
+
+    Py_ssize_t i;
+    for (i = 0; i < N; i++) {
+        line_obj = _pg_line_subtype_new4(Py_TYPE(self), x1, y1, x2, y2);
+        if (!line_obj) {
+            Py_DECREF(list);
+            return NULL;
+        }
+        PyList_SET_ITEM(list, i, line_obj);
+        x1 = x2;
+        y1 = y2;
+        x2 += step_x;
+        y2 += step_y;
+    }
+
+    return list;
+}
+
 static struct PyMethodDef pg_line_methods[] = {
     {"__copy__", (PyCFunction)pg_line_copy, METH_NOARGS, NULL},
     {"copy", (PyCFunction)pg_line_copy, METH_NOARGS, NULL},
@@ -508,6 +631,8 @@ static struct PyMethodDef pg_line_methods[] = {
     {"at", (PyCFunction)pg_line_at, METH_O, NULL},
     {"flip", (PyCFunction)pg_line_flip, METH_NOARGS, NULL},
     {"flip_ip", (PyCFunction)pg_line_flip_ip, METH_NOARGS, NULL},
+    {"as_points", (PyCFunction)pg_line_as_points, METH_O, NULL},
+    {"as_segments", (PyCFunction)pg_line_as_segments, METH_O, NULL},
     {NULL, NULL, 0, NULL}};
 
 /* sequence functions */
diff --git a/test/test_line.py b/test/test_line.py
@@ -1,4 +1,5 @@
 import unittest
+from math import sqrt
 
 from pygame import Vector2, Vector3, Rect
 
@@ -8,6 +9,17 @@
 E_F = "Expected False, "
 
 
+def _distance(p1, p2):
+    return sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)
+
+
+def get_points_between(line, n_pts):
+    dx = (line.x2 - line.x1) / (n_pts + 1)
+    dy = (line.y2 - line.y1) / (n_pts + 1)
+
+    return [(line.x1 + i * dx, line.y1 + i * dy) for i in range(n_pts + 2)]
+
+
 class LineTypeTest(unittest.TestCase):
     class ClassWithLineAttrib:
         def __init__(self, line):
@@ -1004,6 +1016,112 @@ def test_meth_perpendicular_argtype(self):
             with self.assertRaises(TypeError):
                 l.is_perpendicular(value)
 
+    def test_meth_as_points(self):
+        """Test the as_points method."""
+        l = Line(0, 0, 1, 1)
+
+        for i in range(100):
+            pts = l.as_points(i)
+            self.assertEqual(2 + i, len(pts))
+            ex_pts = get_points_between(l, i)
+
+            for actual_pt, expected_pt in zip(pts, ex_pts):
+                self.assertIsInstance(actual_pt, tuple)
+                self.assertEqual(2, len(actual_pt))
+                self.assertAlmostEqual(expected_pt[0], actual_pt[0], places=14)
+                self.assertAlmostEqual(expected_pt[1], actual_pt[1], places=14)
+
+            self.assertAlmostEqual(
+                sum(_distance(p1, p2) for p1, p2 in zip(pts, pts[1:])), l.length
+            )
+
+    def test_meth_as_points_argtype(self):
+        l = Line(0, 0, 1, 1)
+        args = [
+            "string",
+            None,
+            [1, 2, 3],
+            [1, "s", 3, 4],
+            (1, 2, 3),
+            (1, "s", 3, 4),
+            ((1, "s"), (3, 4)),
+            ((1, 4), (3, "4")),
+            {1: 2, 3: 4},
+            object(),
+        ]
+        for value in args:
+            with self.assertRaises(TypeError):
+                l.as_points(value)
+
+    def test_meth_as_points_argnum(self):
+        l = Line(0, 0, 1, 1)
+        args = [
+            (1, 2),
+            (1, 2, 3),
+            (1, 2, 3, 4),
+            (1, 2, 3, 4, 5),
+        ]
+        for value in args:
+            with self.assertRaises(TypeError):
+                l.as_points(*value)
+
+    def test_meth_as_points_argvalue(self):
+        l = Line(0, 0, 1, 1)
+        args = [
+            -1,
+            -2,
+            -3,
+            -4,
+            -5,
+        ]
+        for value in args:
+            with self.assertRaises(ValueError):
+                l.as_points(value)
+
+    def test_meth_as_segments_argtype(self):
+        l = Line(0, 0, 1, 1)
+        args = [
+            "string",
+            None,
+            [1, 2, 3],
+            [1, "s", 3, 4],
+            (1, 2, 3),
+            (1, "s", 3, 4),
+            ((1, "s"), (3, 4)),
+            ((1, 4), (3, "4")),
+            {1: 2, 3: 4},
+            object(),
+        ]
+        for value in args:
+            with self.assertRaises(TypeError):
+                l.as_segments(value)
+
+    def test_meth_as_segments_argnum(self):
+        l = Line(0, 0, 1, 1)
+        args = [
+            (1, 2),
+            (1, 2, 3),
+            (1, 2, 3, 4),
+            (1, 2, 3, 4, 5),
+        ]
+        for value in args:
+            with self.assertRaises(TypeError):
+                l.as_segments(*value)
+
+    def test_meth_as_segments_argvalue(self):
+        l = Line(0, 0, 1, 1)
+        args = [
+            0,
+            -1,
+            -2,
+            -3,
+            -4,
+            -5,
+        ]
+        for value in args:
+            with self.assertRaises(ValueError):
+                l.as_segments(value)
+
 
 if __name__ == "__main__":
     unittest.main()
