"""

def __init__(self, points, suppress_errors = False):

"""

if len(points) < 3:

raise ValueError("Not enough points (need at least 3 to define a polygon, got {}".format(len(points)))

self.points = []

self.lines = []

self.normals = []

_sum = vector2.Vector2(0, 0)

for pt in points:

act_pt = pt if type(pt) == vector2.Vector2 else vector2.Vector2(pt)

if not suppress_errors:

for prev_pt in self.points:

if math.isclose(prev_pt.x, act_pt.x) and math.isclose(prev_pt.y, act_pt.y):

raise ValueError('Repeated points! points={} (repeated={})'.format(points, act_pt))

_sum += act_pt

self.points.append(act_pt)

self.center = _sum * (1 / len(self.points))

_previous = self.points[0]

for i in range(1, len(self.points) + 1):

pt = self.points[i % len(self.points)]

_line = line2.Line2(_previous, pt)

self.lines.append(_line)

norm = vector2.Vector2(_line.normal)

if norm.x < 0 or (norm.x == 0 and norm.y == -1):

norm.x *= -1

norm.y *= -1

already_contains = next((v for v in self.normals if math.isclose(v.x, norm.x) and math.isclose(v.y, norm.y)), None)

if already_contains is None:

self.normals.append(norm)

_previous = pt

self._area = None

if not suppress_errors:

# this will check counter-clockwisedness

a = self.area

# if the polygon is convex and clockwise, if you look at any point

# and take the cross product with the line from the point to the

# previous point and the line from the point to the next point

# the result will be positive

for leftpointin in range(len(self.points)):

middlepointin = (leftpointin + 1) % len(self.points)

rightpointin = (middlepointin + 1) % len(self.points)

leftpoint = self.points[leftpointin]

middlepoint = self.points[middlepointin]

rightpoint = self.points[rightpointin]

vec1 = middlepoint - leftpoint

vec2 = middlepoint - rightpoint

cross_product = vec1.cross(vec2)

if cross_product < -1e-09:

raise ValueError('Detected concavity at index {} - {} cross {} = {}\nself={}'.format(middlepointin, vec1, vec2, cross_product, str(self)))

@classmethod

def from_regular(cls, sides, length, start_rads = None, start_degs = None, center = None):

"""

if (start_rads is not None) and (start_degs is not None):

raise ValueError('One or neithter of start_rads and start_degs may be defined, but not both. (got start_rads={}, start_degs={})'.format(start_rads, start_degs))

if sides < 3 or length <= 0:

raise ValueError('Too few sides or too non-positive length (sides={}, length={})'.format(sides, length))

if start_degs is not None:

start_rads = (start_degs * math.pi) / 180

if start_rads is None:

start_rads = 0

_recenter = False

radius = length / (2 * math.sin( math.pi / sides ))

if center is None:

_recenter = True

center = vector2.Vector2(0, 0)

angle = start_rads

increment = -(math.pi * 2) / sides

pts = []

_minx = 0

_miny = 0

for i in range(sides):

x = center.x + math.cos(angle) * radius

y = center.y + math.sin(angle) * radius

pts.append(vector2.Vector2(x, y))

angle += increment

if _recenter:

_minx = min(_minx, x)

_miny = min(_miny, y)

if _recenter:

_offset = vector2.Vector2(-_minx, -_miny)

for i in range(sides):

pts[i] += _offset

return cls(pts, suppress_errors = True)

@classmethod

def from_rotated(cls, original, rotation, rotation_degrees = None):

"""

if (rotation is None) == (rotation_degrees is None):

raise ValueError("rotation must be specified exactly once (rotation={}, rotation_degrees={})".format(rotation, rotation_degrees))

if rotation_degrees is not None:

rotation = rotation_degrees * math.pi / 180

new_pts = []

for pt in original.points:

shifted = pt - original.center

new_pts.append(vector2.Vector2(original.center.x + shifted.x * math.cos(rotation) - shifted.y * math.sin(rotation),

original.center.y + shifted.y * math.cos(rotation) + shifted.x * math.sin(rotation)))

result = cls(new_pts, suppress_errors = True)

result._area = original._area

return result

@property

def area(self):

"""

if self._area is None:

_edgesum = 0

_previous = self.points[0]

for i in range(1, len(self.points) + 1):

pt = self.points[i % len(self.points)]

_edgesum += (pt.x - _previous.x) * (pt.y + _previous.y)

_previous = pt

if _edgesum < 0:

raise ValueError("Points are counter-clockwise oriented (signed square area: {})".format(_edgesum))

self._area = _edgesum / 2

return self._area

@staticmethod

def project_onto_axis(polygon, offset, axis):

"""

dot_min = None

dot_max = None

for pt in polygon.points:

dot = (pt + offset).dot(axis)

dot_min = min(dot, dot_min) if dot_min is not None else dot

dot_max = max(dot, dot_max) if dot_max is not None else dot

return axisall.AxisAlignedLine(axis, dot_min, dot_max)

@staticmethod

def contains_point(polygon, offset, point):

"""

_previous = polygon.points[0]

for i in range(1, len(polygon.points) + 1):

curr = polygon.points[i % len(polygon.points)]

vec1 = _previous + offset - point

vec2 = curr + offset - point

cross = vec1.cross(vec2)

_previous = curr

if math.isclose(cross, 0, abs_tol=1e-07):

return True, False

if cross > 0:

return False, False

return False, True

@staticmethod

def find_intersection(poly1, poly2, offset1, offset2, find_mtv = True):

"""

unique_normals = list(poly1.normals)

for n in poly2.normals:

found = False

for old_n in poly1.normals:

if math.isclose(n.x, old_n.x) and math.isclose(n.y, old_n.y):

found = True

break

if not found:

unique_normals.append(n)

not_overlapping = False

best_mtv = None

for norm in unique_normals:

proj1 = Polygon2.project_onto_axis(poly1, offset1, norm)

proj2 = Polygon2.project_onto_axis(poly2, offset2, norm)

touch, mtv = axisall.AxisAlignedLine.find_intersection(proj1, proj2)

if not touch:

return False, False, None

if mtv[0] is None:

not_overlapping = True

best_mtv = None

elif find_mtv and not not_overlapping:

if best_mtv is None or abs(mtv[0]) < abs(best_mtv[0]):

best_mtv = (mtv[0], norm)

if not_overlapping:

return True, False, None

else:

return False, True, best_mtv

@staticmethod

def _create_link(pts):

"""

param0 = "+".join(('%28{}%2C+{}%29'.format(round(v.x, 3), round(v.y, 3))) for v in pts)

xmin = pts[0].x

xmax = xmin

ymin = pts[1].y

ymax = ymin

for v in pts:

xmin = min(xmin, v.x)

xmax = max(xmax, v.x)

ymin = min(ymin, v.y)

ymax = max(ymax, v.y)

return "www.webmath.com/cgi-bin/grapher.cgi?param0={}&xmin={}&xmax={}&ymin={}&ymax={}&to_plot=points".format(param0, xmin-5, xmax+5, ymin-5, ymax+5)

def __repr__(self):

"""

return "polygon2(points={})".format(self.points)

def __str__(self):

"""