Data structure to represent a point (x,y) with a radius (r).
Mainly used to represent a point in an image with a vagueness around
the midpoint. The fuzzy point is then representing a rectangle area.
The radius is half of the vagueness.
| |
| (x,y) |
| r . |
|<------> |
| |
Two fuzzy points are equals if their area overlaps.
Create a sppasFuzzyPoint instance.
The given coordinates of the midpoint can be a tuple of int values
or a string representing it.
def __init__(self, coord, radius=None):
"""Create a sppasFuzzyPoint instance.
The given coordinates of the midpoint can be a tuple of int values
or a string representing it.
:param coord: (int,int) x,y coords of the midpoint value.
:param radius: (int) the radius around the midpoint.
"""
super(sppasFuzzyPoint, self).__init__()
self.__x = 0
self.__y = 0
self.__radius = None
self.set_midpoint(coord)
self.set_radius(radius)
Set self members from another sppasFuzzyPoint instance.
def set(self, other):
"""Set self members from another sppasFuzzyPoint instance.
:param other: (sppasFuzzyPoint)
"""
if isinstance(other, sppasFuzzyPoint) is False:
raise AnnDataTypeError(other, 'sppasFuzzyPoint')
self.__radius = None
self.set_midpoint(other.get_midpoint())
self.set_radius(other.get_radius())
Return a deep copy of self.
def copy(self):
"""Return a deep copy of self."""
return sppasFuzzyPoint((self.__x, self.__y), self.__radius)
Return the midpoint coords (x,y).
def get_midpoint(self):
"""Return the midpoint coords (x,y)."""
return (self.__x, self.__y)
Return a tuple (x,y) or (x,y,r).
@staticmethod
def parse(str_point):
"""Return a tuple (x,y) or (x,y,r).
:param str_point: (str) A string representing a fuzzy point.
"""
tc = str_point.lower()[1:-1]
tab = tc.split(',')
x = int(tab[0])
y = int(tab[1])
if len(tab) == 3:
return (x, y, int(tab[2]))
return (x, y, None)
Set the midpoint value.
AnnDataTypeError
def set_midpoint(self, midpoint):
"""Set the midpoint value.
:param midpoint: (tuple(int,int), str) the new midpoint coords.
:raise: AnnDataTypeError
"""
if isinstance(midpoint, str) is True:
x, y, r = sppasFuzzyPoint.parse(midpoint)
midpoint = (x, y)
self.__check_coords(midpoint)
self.__x = int(midpoint[0])
self.__y = int(midpoint[1])
Return the radius value (float or None).
def get_radius(self):
"""Return the radius value (float or None)."""
return self.__radius
Fix the radius value, ie. the vagueness of the point.
The midpoint value must be set first.
AnnDataTypeError, AnnDataNegValueError
def set_radius(self, radius=None):
"""Fix the radius value, ie. the vagueness of the point.
The midpoint value must be set first.
:param radius: (int, str, None) the radius value
:raise: AnnDataTypeError, AnnDataNegValueError
"""
if radius is not None:
if isinstance(radius, str) is True:
try:
radius = int(radius)
except ValueError:
raise AnnDataTypeError(radius, 'int')
if isinstance(radius, (int, float)) is False:
raise AnnDataTypeError(radius, 'int')
if radius is None:
self.__radius = None
else:
self.__radius = int(radius)
Check if the given midpoint is inside the vagueness of self.
def contains(self, coord):
"""Check if the given midpoint is inside the vagueness of self.
:param coord: (tuple) An (x, y) coordinates
"""
self.__check_coords(coord)
rs = self.__radius
if self.__radius is None:
rs = 0
if coord[0] < self.__x - rs:
return False
if coord[0] > self.__x + rs:
return False
if coord[1] < self.__y - rs:
return False
if coord[1] > self.__y + rs:
return False
return True
Check if given midpoint is a valid coord.
def __check_coords(self, midpoint):
"""Check if given midpoint is a valid coord.
"""
if isinstance(midpoint, tuple) is False:
raise AnnDataTypeError(midpoint, 'tuple')
if len(midpoint) != 2:
raise AnnDataTypeError(midpoint, 'tuple(int, int)')
if isinstance(midpoint[0], (int, float)) is False:
raise AnnDataTypeError(midpoint, 'tuple(int, int)')
if isinstance(midpoint[1], (int, float)) is False:
raise AnnDataTypeError(midpoint, 'tuple(int, int)')
def __format__(self, fmt):
return str(self).__format__(fmt)
def __repr__(self):
if self.__radius is None:
return 'sppasFuzzyPoint: ({:d},{:d})'.format(self.__x, self.__y)
return 'sppasFuzzyPoint: ({:d},{:d},{:d})) '.format(self.__x, self.__y, self.__radius)
def __str__(self):
if self.__radius is None:
return '({:d},{:d})'.format(self.__x, self.__y)
return '({:d},{:d},{:d})'.format(self.__x, self.__y, self.__radius)
Test equality of self with other.
Two fuzzy points are equals if the midpoint of one of them is in the
area of the other.
def __eq__(self, other):
"""Test equality of self with other.
Two fuzzy points are equals if the midpoint of one of them is in the
area of the other.
"""
point = None
if isinstance(other, str) is True:
point = sppasFuzzyPoint.parse(other)
elif isinstance(other, tuple) is True:
if len(other) in (2, 3):
point = sppasFuzzyPoint((other[0], other[1]))
if len(other) == 3:
point.set_radius(other[2])
elif isinstance(other, sppasFuzzyPoint) is True:
point = other
if point is None:
raise AnnDataTypeError('sppasFuzzyPoint', 'tuple(int,int)')
other_x, other_y = point.get_midpoint()
other_r = point.get_radius()
if other_r is None:
return self.contains((other_x, other_y))
if self.contains((other_x - other_r, other_y - other_r)) is True:
return True
if self.contains((other_x - other_r, other_y + other_r)) is True:
return True
if self.contains((other_x + other_r, other_y - other_r)) is True:
return True
if self.contains((other_x + other_r, other_y + other_r)) is True:
return True
return False
def __hash__(self):
return hash((self.__x, self.__y, self.__radius))