Esempio n. 1
0
    def uniform_frechet_distance(
        polyline1: Sequence[Sequence[float]],
        polyline2: Sequence[Sequence[float]],
    ) -> float:
        """Compute the maximum distance between two curves if walk on a constant speed on a curve.

        Arguments:
            polyline1: The first polyline consists of multiple points.
            polyline2: The second polyline consists of multiple points.

        Returns:
            The computed distance between the two polylines.

        Examples:
            >>> polyline_1 = [[1, 1], [1, 2], [2, 2]]
            >>> polyline_2 = [[4, 5], [2, 1], [3, 3]]
            >>> Polyline2D.uniform_frechet_distance(polyline_1, polyline_2)
            3.605551275463989

        """
        # forward:
        line1 = Polyline2D(polyline1)
        line2 = Polyline2D(polyline2)

        polyline_info1 = Polyline2D._get_polyline_info(line1)
        polyline_info2 = Polyline2D._get_polyline_info(line2)

        insert_args1, insert_args2 = Polyline2D._get_insert_args(
            polyline_info1, polyline_info2)

        for arg in reversed(insert_args1):
            line1.insert(*arg)
        for arg in reversed(insert_args2):
            line2.insert(*arg)
        distance_forward = max(_dist(*args) for args in zip(line1, line2))

        # backward:
        line1 = Polyline2D(polyline1)
        line2_reverse = Polyline2D(reversed(polyline2))

        polyline_info2_reverse = Polyline2D._get_polyline_info(line2_reverse)

        insert_args1, insert_args2 = Polyline2D._get_insert_args(
            polyline_info1, polyline_info2_reverse)

        for arg in reversed(insert_args1):
            line1.insert(*arg)
        for arg in reversed(insert_args2):
            line2_reverse.insert(*arg)
        distance_reverse = max(
            _dist(*args) for args in zip(line1, line2_reverse))

        return min(distance_forward, distance_reverse)
Esempio n. 2
0
    def similarity(
        polyline1: Sequence[Sequence[float]],
        polyline2: Sequence[Sequence[float]],
    ) -> float:
        """Calculate the similarity between two polylines, range from 0 to 1.

        Arguments:
            polyline1: The first polyline consists of multiple points.
            polyline2: The second polyline consisting of multiple points.

        Returns:
            The similarity between the two polylines.
            The larger the value, the higher the similarity.

        Examples:
            >>> polyline_1 = [[1, 1], [1, 2], [2, 2]]
            >>> polyline_2 = [[4, 5], [2, 1], [3, 3]]
            >>> Polyline2D.similarity(polyline_1, polyline_2)
            0.2788897449072022

        """
        min_distance = Polyline2D.uniform_frechet_distance(
            polyline1, polyline2)
        max_distance = max(
            _dist(*args) for args in product(polyline1, polyline2))
        return 1 - min_distance / max_distance