Merge pull request #774 from mattiskoh/polyline_functions

Polyline functions

Author: beverlylytle

AUTHORS.md

@@ -28,4 +28,5 @@
 - Beverly Lytle <<[email protected]>> [@beverlylytle](https://github.com/beverlylytle>)
 - Juney Lee <<[email protected]>> [@juney-lee](https://github.com/juney-lee)
 - Xingxin He <<[email protected]>> [@XingxinHE](https://github.com/XingxinHE)
-- Robin Godwyll <<[email protected]>> [@robin-gdwl](https://github.com/robin-gdwl)
+- Robin Godwyll <<[email protected]>> [@robin-gdwl](https://github.com/robin-gdwl)
+- Mattis Koh <<[email protected]>> [@mattiskoh](https://github.com/mattiskoh)

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## Unreleased
 
 ### Added
+* Added `divide_polyline`, `divide_polyline_by_length`, `Polyline.split_at_corners` and `Polyline.tangent_at_point_on_polyline`.
 
 * Added the magic method `__str__` to `compas.geoemetry.Transformation`.
 

src/compas/geometry/primitives/polyline.py

@@ -7,6 +7,7 @@
 from compas.geometry.primitives import Primitive
 from compas.geometry.primitives import Point
 from compas.geometry.primitives import Line
+from compas.geometry.predicates import is_point_on_line
 
 from compas.utilities import pairwise
 
@@ -258,11 +259,131 @@ def transform(self, T):
             self.points[index].y = point[1]
             self.points[index].z = point[2]
 
+    def split_at_corners(self, angle_threshold):
+        """Splits a polyline at corners larger than the given angle_threshold
 
+        Parameters:
+        -----------
+        angle_threshold : float
+            In radians.
+
+        Returns
+        -------
+        list of :class:`compas.geometry.Polyline`
+
+        """
+
+        corner_ids = []
+        split_polylines = []
+        points = self.points
+        seg_ids = list(range(len(self.lines)))
+
+        if self.is_closed():
+            seg_ids.append(0)
+
+        for seg1, seg2 in pairwise(seg_ids):
+            angle = self.lines[seg1].vector.angle(self.lines[seg2].vector)
+            if angle >= angle_threshold:
+                corner_ids.append(seg1+1)
+
+        if self.is_closed() and len(corner_ids) > 0:
+            if corner_ids[-1] != len(points):
+                corner_ids = [corner_ids[-1]] + corner_ids
+        else:
+            corner_ids = [0] + corner_ids + [len(points)]
+
+        for id1, id2 in pairwise(corner_ids):
+            if id1 < id2:
+                split_polylines.append(Polyline(points[id1:id2+1]))
+            else:
+                looped_pts = [points[i] for i in range(id1, len(points))] + points[1:id2+1]
+                split_polylines.append(Polyline(looped_pts))
+
+        if self.is_closed() and not corner_ids:
+            return [Polyline(self.points)]
+
+        return split_polylines
+
+    def tangent_at_point_on_polyline(self, point):
+        """Calculates the tangent vector of a point on a polyline
+
+        Parameters:
+        -----------
+        point: :class:`compas.geometry.Point`
+
+        Returns
+        -------
+        :class:`compas.geometry.Vector`
+        """
+        for line in self.lines:
+            if is_point_on_line(point, line):
+                return line.direction
+        raise Exception('{} not found!'.format(point))
+
+    def divide_polyline(self, num_segments):
+        """Divide a polyline in equal segments.
+
+        Parameters:
+        -----------
+        num_segments : int
+
+        Returns
+        -------
+        list
+            list of :class:`compas.geometry.Point`
+        """
+        segment_length = self.length/num_segments
+
+        return self.divide_polyline_by_length(segment_length, False)
+
+    def divide_polyline_by_length(self, length, strict=True):
+        """Splits a polyline in segments of a given length
+
+        Parameters:
+        -----------
+        length : float
+
+        strict : bool
+            If set to ``False``, the remainder segment will be added even if it is smaller than the desired length
+
+        Returns
+        -------
+        list
+            list of :class:`compas.geometry.Point`
+        """
+        num_pts = int(self.length/length)
+        total_length = [0, 0]
+        division_pts = [self.points[0]]
+        new_polyline = self
+        for i in range(num_pts):
+            for i_ln, line in enumerate(new_polyline.lines):
+                total_length.append(total_length[-1] + line.length)
+                if total_length[-1] > length:
+                    amp = (length - total_length[-2]) / line.length
+                    new_pt = line.start + line.vector.scaled(amp)
+                    division_pts.append(new_pt)
+                    total_length = [0, 0]
+                    remaining_pts = new_polyline.points[i_ln+2:]
+                    new_polyline = Polyline([new_pt, line.end] + remaining_pts)
+                    break
+                elif total_length[-1] == length:
+                    total_length = [0, 0]
+                    division_pts.append(line.end)
+
+            if len(division_pts) == num_pts+1:
+                break
+
+        if strict is False and not self.is_closed() and len(division_pts) < num_pts+1:
+            division_pts.append(new_polyline.points[-1])
+        elif strict is False and division_pts[-1] != self.points[-1]:
+            division_pts.append(self.points[-1])
+
+        return division_pts
 # ==============================================================================
 # Main
 # ==============================================================================
 
+
 if __name__ == '__main__':
 
     import doctest

tests/compas/geometry/test_polyline.py

@@ -0,0 +1,54 @@
+import compas
+import pytest
+from compas.geometry import Polyline, Point
+import math
+
+
+@pytest.mark.parametrize('coords,expected', [
+    ([[0.0, 0.0, 0.0], [100.0, 0.0, 0.0]], [[0.0, 0.0, 0.0], [20.0, 0.0, 0.0], [40.0, 0.0, 0.0], [60.0, 0.0, 0.0], [80.0, 0.0, 0.0], [100.0, 0.0, 0.0]]),
+    ([[0.0, 0.0, 0.0], [100.0, 0.0, 0.0], [300.0, 0.0, 0.0]], [[0.0, 0.0, 0.0], [60.0, 0.0, 0.0], [120.0, 0.0, 0.0], [180.0, 0.0, 0.0], [240.0, 0.0, 0.0], [300.0, 0.0, 0.0]]),
+    ([[0.0, 0.0, 0.0], [200.0, 0.0, 0.0], [200.0, 200.0, 0.0], [0.0, 200.0, 0.0], [0.0, 0.0, 0.0]], [
+     [0.0, 0.0, 0.0], [160.0, 0.0, 0.0], [200.0, 120.0, 0.0], [120.0, 200.0, 0.0], [0.0, 160.0, 0.0], [0.0, 0.0, 0.0]])
+])
+def test_polyline_divide(coords, expected):
+    assert expected == Polyline(coords).divide_polyline(5)
+
+
+@pytest.mark.parametrize('coords,expected', [
+    ([[0.0, 0.0, 0.0], [100.0, 0.0, 0.0]], [[0.0, 0.0, 0.0], [100.0, 0.0, 0.0]]),
+    ([[0.0, 0.0, 0.0], [100.0, 0.0, 0.0], [300.0, 0.0, 0.0]], [[0, 0, 0], [100, 0, 0], [200, 0, 0], [300, 0, 0]]),
+    ([[0.0, 0.0, 0.0], [200.0, 0.0, 0.0], [200.0, 200.0, 0.0], [0.0, 200.0, 0.0], [0.0, 0.0, 0.0]], [[0, 0, 0], [
+     100, 0, 0], [200, 0, 0], [200, 100, 0], [200, 200, 0], [100.0, 200, 0], [0, 200, 0], [0, 100.0, 0], [0, 0, 0]])
+])
+def test_polyline_divide_length(coords, expected):
+    assert expected == Polyline(coords).divide_polyline_by_length(100)
+
+
+@pytest.mark.parametrize('coords,expected', [
+    ([[0.0, 0.0, 0.0], [100.0, 0.0, 0.0]], [[0.0, 0.0, 0.0], [80.0, 0.0, 0.0]]),
+])
+def test_polyline_divide_length_strict1(coords, expected):
+    assert expected == Polyline(coords).divide_polyline_by_length(80)
+
+
+@pytest.mark.parametrize('coords,expected', [
+    ([[0.0, 0.0, 0.0], [100.0, 0.0, 0.0]], [[0.0, 0.0, 0.0], [80.0, 0.0, 0.0], [100.0, 0.0, 0.0]]),
+])
+def test_polyline_divide_length_strict2(coords, expected):
+    assert expected == Polyline(coords).divide_polyline_by_length(80, False)
+
+
+@pytest.mark.parametrize('coords,input,expected', [
+    ([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [1.0, 1.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 0.0]], math.pi/2, [Polyline([[0.0, 0.0, 0.0], [1, 0.0, 0.0]]),
+                                                                                                        Polyline([[1, 0.0, 0.0], [1, 1, 0.0]]), Polyline([[1, 1, 0.0], [0.0, 1, 0.0]]), Polyline([[0.0, 1, 0.0], [0.0, 0.0, 0.0]])]),
+])
+def test_polyline_split_at_corners(coords, input, expected):
+    assert expected == Polyline(coords).split_at_corners(input)
+
+
+@pytest.mark.parametrize('coords,input,expected', [
+    ([[0.0, 0.0, 0.0], [100.0, 0.0, 0.0]], [50, 0, 0], [1.0, 0.0, 0.0]),
+    ([[0.0, 0.0, 0.0], [50.0, 0.0, 0.0], [100.0, 100.0, 0.0]], [50, 0, 0], [1.0, 0.0, 0.0]),
+])
+def test_polyline_tangent_at_point(coords, input, expected):
+    assert expected == Polyline(coords).tangent_at_point_on_polyline(input)