Skip to content

Point

Point class useful to describe any kind of points

Point

Bases: DiscreteGeometryEntity

Point class

Source code in otary/geometry/discrete/point.py 
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
class Point(DiscreteGeometryEntity):
    """Point class"""

    def __init__(self, point: NDArray, is_cast_int: bool = False) -> None:
        point = self._ensure_transform_point_array(point=point)
        super().__init__(points=point, is_cast_int=is_cast_int)

    @staticmethod
    def _ensure_transform_point_array(point: NDArray) -> NDArray:
        point = np.asarray(point)
        if point.shape == (2,):
            point = point.reshape((1, 2))
        if len(point) != 1:
            raise ValueError(f"The input point has not the expected shape {point}")
        return point

    @property
    def asarray(self):
        return self.points

    @asarray.setter
    def asarray(self, value: NDArray):
        """Setter for the asarray property

        Args:
            value (NDArray): value of the asarray to be changed
        """
        self.points = self._ensure_transform_point_array(point=value)

    @property
    def centroid(self) -> NDArray:
        """Return the point as the centroid of a point is simply the point

        Returns:
            NDArray: centroid of the point
        """
        return self.asarray[0]

    @property
    def shapely_edges(self) -> SPoint:
        """Returns the Shapely.Point representation of the point.
        See https://shapely.readthedocs.io/en/stable/reference/shapely.Point.html

        Returns:
            Point: shapely.Point object
        """
        return SPoint(self.asarray)

    @property
    def shapely_surface(self) -> SPoint:
        """Returns None since a point has no surface

        Returns:
            None: None value
        """
        return None

    @property
    def area(self) -> float:
        """Compute the area of the geometry entity

        Returns:
            float: area value
        """
        return 0

    @property
    def perimeter(self) -> float:
        """Compute the perimeter of the geometry entity

        Returns:
            float: perimeter value
        """
        return 0

    @property
    def edges(self) -> NDArray:
        """Get the edges of the point which returns empty array
        since a point has no edges

        Returns:
            NDArray: empty array of shape (0, 2, 2)
        """
        return np.empty(shape=(0, 2, 2))

    @staticmethod
    def order_idxs_points_by_dist(points: NDArray, desc: bool = False) -> NDArray:
        """Beware the method expects points to be collinear.

        Given four points [p0, p1, p2, p3], we wish to have the order in which each
        point is separated.
        The one closest to the origin is placed at the origin and relative to this
        point we are able to know at which position are the other points.

        If p0 is closest to the origin and the closest points from p0 are in order
        p2, p1 and p3. Thus the array returned by the function is [0, 2, 1, 3].

        Args:
            points (NDArray): numpy array of shape (n, 2)
            desc (bool): if True returns the indices based on distances descending
                order. Otherwise ascending order which is the default.

        Returns:
            NDArray: indices of the points
        """
        distances = np.linalg.norm(x=points, axis=1)
        idxs_order_by_dist = np.argsort(distances)
        if not desc:  # change the order if in descending order
            idxs_order_by_dist = idxs_order_by_dist[::-1]
        return idxs_order_by_dist

    def distances_vertices_to_point(self, point: NDArray) -> NDArray:
        """Compute the distances to a given point

        Args:
            point (NDArray): point to which we want to compute the distances

        Returns:
            NDArray: distance to the given point
        """
        return np.linalg.norm(self.points - point, axis=1)

    def __str__(self) -> str:
        return self.__class__.__name__ + "(" + self.asarray[0].tolist().__str__() + ")"

    def __repr__(self) -> str:
        return str(self)

area property

Compute the area of the geometry entity

Returns:

Name Type Description
float float

area value

centroid property

Return the point as the centroid of a point is simply the point

Returns:

Name Type Description
NDArray NDArray

centroid of the point

edges property

Get the edges of the point which returns empty array since a point has no edges

Returns:

Name Type Description
NDArray NDArray

empty array of shape (0, 2, 2)

perimeter property

Compute the perimeter of the geometry entity

Returns:

Name Type Description
float float

perimeter value

shapely_edges property

Returns the Shapely.Point representation of the point. See https://shapely.readthedocs.io/en/stable/reference/shapely.Point.html

Returns:

Name Type Description
Point Point

shapely.Point object

shapely_surface property

Returns None since a point has no surface

Returns:

Name Type Description
None Point

None value

distances_vertices_to_point(point)

Compute the distances to a given point

Parameters:

Name Type Description Default
point NDArray

point to which we want to compute the distances

 required

Returns:

Name Type Description
NDArray NDArray

distance to the given point
Source code in otary/geometry/discrete/point.py 
123
124
125
126
127
128
129
130
131
132
def distances_vertices_to_point(self, point: NDArray) -> NDArray:
    """Compute the distances to a given point

    Args:
        point (NDArray): point to which we want to compute the distances

    Returns:
        NDArray: distance to the given point
    """
    return np.linalg.norm(self.points - point, axis=1)

order_idxs_points_by_dist(points, desc=False) staticmethod

Beware the method expects points to be collinear.

Given four points [p0, p1, p2, p3], we wish to have the order in which each point is separated. The one closest to the origin is placed at the origin and relative to this point we are able to know at which position are the other points.

If p0 is closest to the origin and the closest points from p0 are in order p2, p1 and p3. Thus the array returned by the function is [0, 2, 1, 3].

Parameters:

Name Type Description Default
points NDArray

numpy array of shape (n, 2)

 required
desc bool

if True returns the indices based on distances descending order. Otherwise ascending order which is the default.

 False

Returns:

Name Type Description
NDArray NDArray

indices of the points
Source code in otary/geometry/discrete/point.py 
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
@staticmethod
def order_idxs_points_by_dist(points: NDArray, desc: bool = False) -> NDArray:
    """Beware the method expects points to be collinear.

    Given four points [p0, p1, p2, p3], we wish to have the order in which each
    point is separated.
    The one closest to the origin is placed at the origin and relative to this
    point we are able to know at which position are the other points.

    If p0 is closest to the origin and the closest points from p0 are in order
    p2, p1 and p3. Thus the array returned by the function is [0, 2, 1, 3].

    Args:
        points (NDArray): numpy array of shape (n, 2)
        desc (bool): if True returns the indices based on distances descending
            order. Otherwise ascending order which is the default.

    Returns:
        NDArray: indices of the points
    """
    distances = np.linalg.norm(x=points, axis=1)
    idxs_order_by_dist = np.argsort(distances)
    if not desc:  # change the order if in descending order
        idxs_order_by_dist = idxs_order_by_dist[::-1]
    return idxs_order_by_dist