def restore_poly_from_path_str(path_str):
"""
restores a list of polygons from a SVG path string
"""
contours = path_str.split('Z') # last contour may be empty
from Polygon import Polygon as Poly
poly = Poly()
for c_str in contours:
if c_str.strip() != "":
pts_str = c_str.strip()[1:].split("L")
pts = []
for pt_str in pts_str:
x, y = map(float, pt_str.split(','))
pts.append((x, y))
poly.addContour(pts, is_clockwise(pts))
return poly
def line(pos=(0,0), np=2, rotate=0.0, scale=1.0, xscale=1.0, yscale=1.0,
thickness=None, start=(0,0), end=(0,1), path=False):
v = vis.vector((end[0]-start[0]), (end[1]-start[1]))
if thickness is None:
thickness = 0.01*vis.mag(v)
dv = thickness*vis.norm(vis.vector(0,0,1).cross(v))
dx = dv.x
dy = dv.y
cp = [] # outer line
cpi = [] # inner line
vline = (vis.vector(end)-vis.vector(start)).norm()
mline = vis.mag(vis.vector(end)-vis.vector(start))
for i in range(np):
x = start[0] + (vline*i)[0]/float(np-1)*mline
y = start[1] + (vline*i)[1]/float(np-1)*mline
cp.append( (x+pos[0],y+pos[1]) )
cpi.append( (x+pos[0]+dx,y+pos[1]+dy) )
if not path:
cpi.reverse()
for p in cpi:
cp.append(p)
cp.append(cp[0])
if rotate != 0.0: cp = rotatecp(cp, pos, rotate)
if scale != 1.0: xscale = yscale = scale
pp = Polygon(cp)
if xscale != 1.0 or yscale != 1.0: pp.scale(xscale,yscale)
if not path:
return pp
else:
return [cp]
def trframe(pos=(0,0), width=2.0, height=1.0, top=None, thickness=None, rotate=0.0,
roundness=0.0, invert=False, scale=1.0, xscale=1.0, yscale=1.0):
if top == None: top = width/2.0
if thickness == Default or thickness == None: thickness = min(height,top)*0.2
else: thickness = min(height,top)*thickness*2
fsqr = trapezoid(pos=pos, width=width, height=height, top=top)
angle = atan((width-top)/2.0/height)
db = (thickness)/cos(angle)
sqr1 = trapezoid(pos=pos, width=(width-db-thickness*tan(angle)),
height=height-thickness, top=top-(db-thickness*tan(angle)))
pp = fsqr - sqr1
if rotate != 0.0: pp.rotate(rotate)
if xscale != 1.0 or yscale != 1.0: pp.scale(xscale,yscale)
if roundness > 0:
cp0 = pp.contour(0)
cp0.append(cp0[0])
cp0 = roundc(cp0, roundness=roundness, invert=invert)
cp1 = pp.contour(1)
cp1.append(cp1[0])
cp1 = roundc(cp1, roundness=roundness, invert=invert)
p1 = Polygon(cp0)
p2 = Polygon(cp1)
pp = p2-p1
return pp
else: return pp
def nframe(pos=(0,0), length=1.0, np=3, thickness=None, rotate=0.0,
roundness=0.0, invert=False, scale=1.0, xscale=1.0, yscale=1.0):
if thickness == Default or thickness == None: thickness = length*0.2
else: thickness = length*thickness*2
fsqr = ngon(pos=pos, np=np, length=length)
nga = (np-2)*pi/np
angle = (pi/2 - nga)
length2=length-thickness*cos(angle)
csa = cos(angle)
sqr1 = ngon(pos=pos, np=np, length=length-thickness/csa*2-thickness*tan(angle)*2)
pp = fsqr - sqr1
if rotate != 0.0: pp.rotate(rotate)
if xscale != 1.0 or yscale != 1.0: pp.scale(xscale,yscale)
if roundness > 0:
cp0 = pp.contour(0)
cp0.append(cp0[0])
cp0 = roundc(cp0, roundness=roundness, invert=invert)
cp1 = pp.contour(1)
cp1.append(cp1[0])
cp1 = roundc(cp1, roundness=roundness, invert=invert)
p1 = Polygon(cp0)
p2 = Polygon(cp1)
pp = p2-p1
return pp
else: return pp
def get_pyramid_polygons():
polygons = []
# front
face = get_triangle_points()
transform = get_shift_matrix(0, 0, 1).dot(get_rot_x_matrix(-math.pi / 4))
face = face.dot(transform)
face = face.dot(get_shift_matrix(0, 0, 1))
polygons.append(Polygon(face))
# back
face = get_triangle_points()
face = face.dot(get_rot_x_matrix(math.pi / 4))
face = face.dot(get_shift_matrix(0, 0, -1))
polygons.append(Polygon(face))
# left
face = get_triangle_points()
face = face.dot(get_rot_x_matrix(-math.pi / 4))
face = face.dot(get_rot_y_matrix(-math.pi / 2))
face = face.dot(get_shift_matrix(1, 0, 0))
polygons.append(Polygon(face))
# right
face = get_triangle_points()
face = face.dot(get_rot_x_matrix(-math.pi / 4))
face = face.dot(get_rot_y_matrix(math.pi / 2))
face = face.dot(get_shift_matrix(-1, 0, 0))
polygons.append(face)
return polygons
def rectangle(pos=(0,0), width=1.0, height=None, rotate=0.0, thickness=0,
roundness=0.0, invert=False, scale=1.0, xscale=1.0, yscale=1.0):
if height is None: height = width
if thickness == 0:
p0 = (pos[0]+width/2.0, pos[1]-height/2.0)
p1 = (pos[0]+width/2.0, pos[1]+height/2.0)
p2 = (pos[0]-width/2.0, pos[1]+height/2.0)
p3 = (pos[0]-width/2.0, pos[1]-height/2.0)
p4 = (pos[0]+width/2.0, pos[1]-height/2.0)
cp = [p0, p1, p2, p3, p4]
if rotate != 0.0: cp = rotatecp(cp, pos, rotate)
if scale != 1.0: xscale = yscale = scale
pp = Polygon(cp)
if xscale != 1.0 or yscale != 1.0: pp.scale(xscale,yscale)
if roundness > 0:
cp = roundc(pp.contour(0), roundness=roundness, invert=invert)
return Polygon(cp)
else: return pp
else:
pp = rframe(pos=pos, width=width, height=height, thickness=thickness,
rotate=rotate, roundness=roundness, invert=invert,
scale=scale, xscale=xscale, yscale=yscale)
return pp
def rackGear(pos=(0,0), n=30, radius=5., phi=20., addendum=0.4, dedendum=0.5,
fradius=0.1, rotate=0, scale=1.0, length=10*pi, res=1, bevel=0.05, depth=(0.4+0.6+0.1)):
tooth = RackOutline(n, res, phi, radius, addendum, dedendum,
fradius, bevel)
toothl = tooth[0][1] - tooth[-1][1]
ntooth = int(length/toothl)
flength = ntooth * toothl
gear = []
for i in range(0, ntooth):
ntooth = []
for (x, y) in tooth:
nx = x + pos[0]
ny = -i*toothl + y + pos[1]
ntooth.append((nx,ny))
gear.extend(ntooth)
gear.append((gear[-1][0]-depth,gear[-1][1]))
gear.append((gear[0][0]-depth,gear[0][1]))
gear.append(gear[0])
pp = Polygon(gear)
pp.shift(-pp.center()[0],-pp.center()[1])
if rotate != 0.0: pp.rotate(rotate)
if scale != 1.0 : pp.scale(scale,scale)
return pp
def gear(pos=(0,0), n=20, radius=5, phi=20, addendum=0.4, dedendum=0.5,
fradius=0.1, rotate=0, scale=1.0, internal=False, res=1, bevel=0):
tooth = ToothOutline(n, res, phi, radius, addendum, dedendum,
fradius, bevel=0.0)
if internal:
itooth = []
for p in tooth:
px = p[0]
py = p[1]
driro = sqrt(px*px +py*py) - radius
ir = radius - driro
ro = radius + driro
ix = (ir/ro)*px
iy = (ir/ro)*py
itooth.append((ix,iy))
tooth = itooth
gear = []
for i in range(0, n):
rotan = -i*2*pi/n
rtooth = []
for (x, y) in tooth:
rx = x*cos(rotan) - y*sin(rotan) + pos[0]
ry = x*sin(rotan) + y*cos(rotan) + pos[1]
rtooth.append((rx,ry))
gear.extend(rtooth)
#gear.append(gear[0])
pp = Polygon(gear)
if rotate != 0.0: pp.rotate(rotate)
if scale != 1.0 : pp.scale(scale,scale)
return pp
def test_circle_overlaps_poly(circle_center, circle_radius, poly_points): # Start with a cheap points-in-circle test circle_radius2 = circle_radius * circle_radius for i in range(len(poly_points)): xdiff = poly_points[i][0] - circle_center[0] ydiff = poly_points[i][1] - circle_center[1] if (xdiff*xdiff + ydiff*ydiff) <= circle_radius2: return True # Now try a bounding-rectangle test min_x = min(poly_points, key=lambda p: p[0])[0] max_x = max(poly_points, key=lambda p: p[0])[0] min_y = min(poly_points, key=lambda p: p[1])[1] max_y = max(poly_points, key=lambda p: p[1])[1] rect_pos = [min_x, min_y] rect_size = np.subtract((max_x, max_y), rect_pos) if not test_circle_overlaps_rect(circle_center, circle_radius, rect_pos, rect_size): return False # Brute-force all the possible line collsions for i in range(len(poly_points)-1): line = [poly_points[i], poly_points[i+1]]; inters = circle_line_intersection(circle_center, circle_radius, line); if inters is not None and 0 < len(inters): return True # The only other way to collide is if the circle is completely inside # the polygon polyob = Polygon(poly_points) return polyob.contains_point(circle_center)
def shape_center(shape): """ computes the center of gravity of a shapefile multi-polygon """ from Polygon import Polygon parts = shape.parts[:] parts.append(len(shape.points)) # check for countries that cross the 180° longitude far_east = False far_west = False for i in range(len(parts)-1): pts = shape.points[parts[i]:parts[i+1]] if len(pts) == 0: continue if pts[0][0] < -90: far_west = True if pts[0][0] > 90: far_east = True poly = Polygon() for i in range(len(parts)-1): pts = shape.points[parts[i]:parts[i+1]] if far_east and far_west: # correct points for j in range(len(pts)): if pts[j][0] < 0: pts[j][0] += 360 poly.addContour(pts) return poly.center()
def tile(tile_count, tile_set, radial_placement=True):
node_set = NodeSet(100)
edge_set = EdgeSet(1000, 1000, node_set)
polygon_set = PolygonSet(tile_set, node_set, edge_set)
InitPolygonType = choice(tile_set)
polygons = [Polygon.create(InitPolygonType, polygon_set)]
possibilities = [(PolygonType, i) for PolygonType in tile_set
for i in range(len(PolygonType.angles))]
for _ in range(tile_count - len(polygons)):
cur_edge = polygon_set.get_random_open_edge()
#possible to switch next line with generator function?
shuffle(possibilities)
for possibility in possibilities:
NewPolygonType, start_index = possibility
valid_new_edges = Polygon.place(NewPolygonType, cur_edge,
start_index, polygon_set)
if valid_new_edges != None:
polygons.append(
NewPolygonType(valid_new_edges, polygon_set))
break
#polygon_set.remove_polygon(edge=cur_edge)
return polygons
def __init__(self, world, chunk_pos):
self.world = world
self.pos = (chunk_pos[0] * 51.2, chunk_pos[1] * 51.2)
self.chunk_pos = (chunk_pos[0] % 32, chunk_pos[1])
self.texture = None
self.polygon = None
self.body = None
self.entities = []
self.things_to_blit = []
texture_filename = "data/world/%i_%i.tga" % self.chunk_pos
if os.path.exists(texture_filename):
self.texture = pygame.image.load(texture_filename)
self.texture.set_colorkey((255, 0, 255))
elif chunk_pos[1] <= 1:
self.texture = Chunk.underground_texture
data_filename = "data/world/%i_%i.dat" % self.chunk_pos
if os.path.exists(data_filename):
with open(data_filename) as fin:
self.polygon, self.entities = pickle.load(fin)
elif chunk_pos[1] <= 1:
self.polygon = Polygon(
((-25.6, -25.6), (-25.6, 25.6), (25.6, 25.6), (25.6, -25.6)))
self.load_body()
def __init__(self, score, time):
"Initialises resources and start level"
self.background = pygame.image.load("sprites/sky.jpg")
self.background.convert() #for blitting more faster
self.screen = Constants.SCREEN
self.score = score
self.display_items = pygame.sprite.Group()
self.timeclock = GameTime((0.05, 0.05), time)
self.display_items.add(self.timeclock, self.score)
self.time_speed = pygame.time.Clock()
self.time = 0.0
self.quit = False
self.pause = False
self.start = False
self.completed = False
self.gameover = False
self.message = None
self.polygon = Polygon(self)
self.event_manager = EventManager(self)
self.on_enter()
def test_7_distance(self):
"""Test distance after various operations"""
polygon = Polygon()
# Test initial distance
polygon.insert((0, 0), 0)
self.assertTrue(polygon[0].distance_to_next == 0)
# Test distance after adding after
polygon.insert((3, 4), 1)
self.assertTrue(polygon[0].distance_to_next == 5)
self.assertTrue(polygon[1].distance_to_next == 5)
# Test distance after adding before
polygon.insert((3, -4), 1)
self.assertTrue(polygon[0].distance_to_next == 5)
self.assertTrue(polygon[1].distance_to_next == 8)
# Test distance after []=
polygon[1] = (1, 1)
self.assertTrue(polygon[0].distance_to_next == math.sqrt(2))
self.assertTrue(polygon[1].distance_to_next == math.sqrt(13))
# Test distance after remove
polygon.remove(1)
self.assertTrue(polygon[0].distance_to_next == 5)
def __init__(self,
vertices,
color=(255, 255, 255),
velocity=(0, 0),
angular_velocity=0,
colors=None):
if isinstance(vertices, Polygon):
self.poly = vertices
else:
self.poly = Polygon(vertices)
self.colors = colors
self._color = 'primary'
if colors:
self.color = color
else:
self.colors = {'primary': color}
self.velocity = np.asarray(velocity)
self.angular_velocity = angular_velocity
# Construct vertex_list.
self._vertex_list = self._get_vertex_list()
self.enabled = True
def support(
p
): # false if not satisfies some the next conditions on the parameter spaces
[x, spline, alpha, elast] = p
if elast > 60:
return False
if len(spline) == 0:
return False
if (alpha <= 0):
return False
x_sp = spline
if (x_sp > 0.78).any() | (x_sp < 0.0).any():
return False
Q = Polygon(x_sp)
if Q.is_valid_polygon() == False:
return False
area_convex = ConvexHull(x.T).volume
if (Q.area() / area_convex) < 0.8:
return False
return is_valid_spline_JA(x_sp, h)
def ngon(pos=(0,0), np=3, length=None, radius=1.0, rotate=0.0, thickness=0,
roundness=0.0, invert=False, scale=1.0, xscale=1.0, yscale=1.0):
cp = []
if np < 3:
raise AttributeError("number of sides can not be less than 3")
return None
angle = 2*pi/np
if length != None: radius = (length/2.0)/(sin(angle/2))
else: length = radius*(sin(angle/2))*2
if thickness == 0:
seg = 2.0*pi/np
angle = rotate
for i in range(np):
x = radius*cos(angle) + pos[0]
y = radius*sin(angle) + pos[1]
cp.append((x,y))
angle += seg
cp.append(cp[0])
if scale != 1.0: xscale = yscale = scale
pp = Polygon(cp)
if xscale != 1.0 or yscale != 1.0: pp.scale(xscale,yscale)
if roundness > 0:
cp = roundc(pp.contour(0), roundness=roundness, invert=invert)
return Polygon(cp)
else: return pp
else:
pp = nframe(pos=pos, length=length, thickness=thickness, roundness=roundness,
invert=invert, rotate=rotate, np=np)
return pp
def ellipse(pos=(0,0), width=1.0, height=None, np=32, rotate=0.0, thickness=None,
scale=1.0, xscale=1.0, yscale=1.0):
if height == None: height = 0.5*width
if thickness == 0 or thickness == None:
cp = []
seg = 2.0*pi/np
angle = 0
radius=0.5
lf = width/2.0
hf = height/2.0
for i in range(np):
x = cos(angle)*lf + pos[0]
y = sin(angle)*hf + pos[1]
cp.append((x,y))
angle += seg
cp.append(cp[0])
if rotate != 0.0: cp = rotatecp(cp, pos, rotate)
if scale != 1.0: xscale = yscale = scale
pp = Polygon(cp)
if xscale != 1.0 or yscale != 1.0: pp.scale(xscale,yscale)
return pp
else:
pp = ering(pos=pos, width=width, height=height, np=np, rotate=rotate,
thickness=thickness)
return pp
def arc(pos=(0,0), radius=0.5, np=32, rotate=0.0, scale=1.0, xscale=1.0, yscale=1.0,
thickness=None, angle1=0.0, angle2=pi, path=False):
if thickness is None:
thickness = 0.01*radius
cp = [] # outer arc
cpi = [] # inner arc
seg = 2.0*pi/np
nseg = int(abs((angle2-angle1))/seg)+1
seg = (angle2-angle1)/nseg
for i in range(nseg+1):
x = cos(angle1+i*seg)
y = sin(angle1+i*seg)
cp.append( (radius*x+pos[0],radius*y+pos[1]) )
cpi.append( ((radius-thickness)*x+pos[0],(radius-thickness)*y+pos[1]) )
if not path:
cpi.reverse()
for p in cpi:
cp.append(p)
cp.append(cp[0])
if rotate != 0.0: cp = rotatecp(cp, pos, rotate)
if scale != 1.0: xscale = yscale = scale
pp = Polygon(cp)
if xscale != 1.0 or yscale != 1.0: pp.scale(xscale,yscale)
if not path:
return pp
else:
return [cp]
def test_3_address_non_existing_point(self):
"""Test addressing non existing Point."""
polygon = Polygon()
with self.assertRaises(Exception):
polygon[0] = (1, 3)
# Cannot remove an item
with self.assertRaises(Exception):
polygon.remove(0)
def reset_everything(self):
self.canvas.delete('all')
self.operation_flag = 0
self.reset_last_coord()
self.reset_first_coord()
self.main_polygon = Polygon()
self.clipping_polygon = Polygon()
self.vertex_list = None
self.clipping = None
def obliq_proj(event):
clean()
polygon = Polygon()
matrix = polygon.obliq_proj()
plot_all_faces(polygon.faces)
plot_all_vertices(polygon.vertices)
matrix_ax.table(cellText=matrix, colLabels=matrix_collabel, loc='center')
tables_fig.canvas.draw()
plt.draw()
def test_4_insert(self):
"""Test insertion"""
polygon = Polygon()
polygon.insert((1, 2), 0)
self.assertTrue(len(polygon) == 1)
self.assertTrue(polygon[0] == (1, 2))
self.assertTrue(polygon[0].distance_to_next == 0)
self.assertTrue(polygon[0].angle == 0)
self.assertTrue(polygon.get_area() == 0)
def test_5_addressing(self):
"""Test addressing"""
polygon = Polygon()
polygon.insert((1, 2), 0)
polygon[0] = (8, 9)
self.assertTrue(polygon[-1] == (8, 9))
self.assertTrue(polygon[0] == (8, 9))
self.assertTrue(polygon[0].distance_to_next == 0)
self.assertTrue(polygon[0].angle == 0)
self.assertTrue(polygon.get_area() == 0)
def pointlist(pos=[], rotate=0.0, roundness=0.0, invert=False,
scale=1.0, xscale=1.0, yscale=1.0, path=False):
# pos may be either a list of points or a Polygon object
try:
points = pos.contour(0)
if len(pos) > 1:
raise AttributeError("pointlist can deal with only a single contour.")
except:
points = pos[:]
closed = (points[-1] == points[0])
if not closed:
points.append(points[0])
pp = Polygon(points)
if len(pp) and rotate != 0.0: pp.rotate(rotate)
if scale != 1.0: xscale = yscale = scale
if xscale != 1.0 or yscale != 1.0: pp.scale(xscale,yscale)
if roundness > 0:
cp = roundc(pp.contour(0), roundness=roundness, invert=invert)
pp = Polygon(cp)
if path:
if closed:
return list(pp)
else:
return list(pp)[:-1]
else:
return pp
def find_inside_point(p: Polygon.Polygon, i: int):
# random search
xmin, xmax, ymin, ymax = p.boundingBox(i)
for _ in range(1000):
x = random.random() * (xmax - xmin) + xmin
y = random.random() * (ymax - ymin) + ymin
if p.isInside(x, y, i):
return x, y
raise Exception("Couldn't find interior point")
def center(self):
ret = [0, 0]
if self.type() == 'MultiPolygon':
p = Polygon(self.coordinates()[0][0])
ret = list(p.center())
else:
ret = self.coordinates()
c = transform_to_4326(self.crs_code(), ret[0], ret[1])
return [c[0], c[1]]
def common_area(x0, y0, x1, y1):
nb, _ = x0.shape
cost = empty((nb))
for i in range(nb):
x0_, x1_ = x0[i], x1[i]
if abs(x0_[0] - x1_[0]) > 180:
x1_ = (x1[i] - (x0_[0] - 180)) % 360 + x0_[0] - 180
p0 = Polygon(create_vertice(x0_, y0[i]))
p1 = Polygon(create_vertice(x1_, y1[i]))
cost[i] = (p0 & p1).area() / (p0 + p1).area()
return cost
def polygon_center(polygon): """ computes the center of gravity of a gisutils.Polygon """ from Polygon import Polygon as Poly pts = [] for pt in polygon.points: pts.append((pt.x, pt.y)) poly = Poly(pts) c = poly.center() return Point(c[0], c[1])
def overlaps_segment(self, other):
"""
Determines whether the query segment overlaps with this
:py:class:`TriSegment`
:param other: query :py:class:`TriSegment`
:return: ``True`` iff the query segment overlaps with this segment
"""
p_self = Polygon(np.dot(self.xyz_points, self.projection_plane.T))
p_other = Polygon(np.dot(other.xyz_points, self.projection_plane.T))
return ((p_self & p_other).area() > 0)
def addTestPolygons(self):
from Polygon import Polygon
self.robot = Polygon([(-1, 0), (0, -1), (1, 0), (0, 1)])
#self.robot = Polygon(generateCircle(100, (-4, -4)))
self.polygons = [
#Polygon(generateCircle(100, (4, 4))),
#Polygon([(2, 1), (5, 1), (5, 4), (2, 4)]),
#Polygon([(-1, 3), (1, 0), (4, 2), (2, 4)]),
#Polygon([(3, -4), (7, -3), (5.5, -2)]),
#Polygon([(3, 4), (6, 3), (5, 2)]),
]
self.buildVisibilityMap()
def calcQueryBBox(self, bbox):
print("new bbox")
ymin = bbox[1] - self.getRoutingBBoxMargin()
xmin = bbox[0] - self.getRoutingBBoxMargin()
ymax = bbox[3] + self.getRoutingBBoxMargin()
xmax = bbox[2] + self.getRoutingBBoxMargin()
bboxNew = [xmin, ymin, xmax, ymax]
self.lastBBoxCPolygon = Polygon([(bboxNew[0], bboxNew[3]),
(bboxNew[2], bboxNew[3]),
(bboxNew[2], bboxNew[1]),
(bboxNew[0], bboxNew[1])])
self.lastBBox = bboxNew
def _maxeffpolygon(c):
max_ratio = 0
radius = 5
for i in range(3, c + 1):
pol = Polygon(i, radius)
#print(pol.area())
r = pol.area() / pol.perimeter()
#print(r)
if r > max_ratio:
max_ratio = r
side_len = i
return f'Polygon having max efficiency is having side:{side_len} and the ratio is:{max_ratio:0.3f}\n'
def test_2_point_is_valid(self):
"""Test point's validation. Point MUST be a 2 dimensional tuple (x,y)"""
polygon = Polygon()
with self.assertRaises(Exception):
polygon.insert((1, ), 0)
with self.assertRaises(Exception):
polygon.insert(1, 0)
with self.assertRaises(Exception):
polygon.insert((1, "2"), 0)
with self.assertRaises(Exception):
polygon.insert(("1", 2), 0)
def __init__(self, world, chunk_pos):
self.world = world
self.pos = (chunk_pos[0] * 51.2, chunk_pos[1] * 51.2)
self.chunk_pos = (chunk_pos[0] % 32, chunk_pos[1])
self.texture = None
self.polygon = None
self.body = None
self.entities = []
self.things_to_blit = []
texture_filename = "data/world/%i_%i.tga" % self.chunk_pos
if os.path.exists(texture_filename):
self.texture = pygame.image.load(texture_filename)
self.texture.set_colorkey((255, 0, 255))
elif chunk_pos[1] <= 1:
self.texture = Chunk.underground_texture
data_filename = "data/world/%i_%i.dat" % self.chunk_pos
if os.path.exists(data_filename):
with open(data_filename) as fin:
self.polygon, self.entities = pickle.load(fin)
elif chunk_pos[1] <= 1:
self.polygon = Polygon((
(-25.6, -25.6),
(-25.6, 25.6),
(25.6, 25.6),
(25.6, -25.6)
))
self.load_body()
def build_polygons(cell_indices, A0): polys = [] for i,indices in enumerate(cell_indices): theta = rand_angle() poly = Polygon(i, indices, A0, theta) polys.append(poly) return polys
def restore_poly_from_path_str(path_str):
"""
restores a list of polygons from a SVG path string
"""
contours = path_str.split('Z') # last contour may be empty
from Polygon import Polygon as Poly
poly = Poly()
for c_str in contours:
if c_str.strip() != "":
pts_str = c_str.strip()[1:].split("L")
pts = []
for pt_str in pts_str:
x, y = map(float, pt_str.split(','))
pts.append((x, y))
poly.addContour(pts, is_clockwise(pts))
return poly
def __init__(self,score,time):
"Initialises resources and start level"
self.background=pygame.image.load("sprites/sky.jpg")
self.background.convert() #for blitting more faster
self.screen=Constants.SCREEN
self.score = score
self.display_items = pygame.sprite.Group()
self.timeclock = GameTime((0.05,0.05),time)
self.display_items.add(self.timeclock,self.score)
self.time_speed=pygame.time.Clock()
self.time=0.0
self.quit = False
self.pause = False
self.start = False
self.completed = False
self.gameover = False
self.message = None
self.polygon=Polygon(self)
self.event_manager = EventManager(self)
self.on_enter()
def _create_map_1(env):
#obs_movement = MovementPattern.StaticMovement((0,0))
#obs = DynamicObstacle(obs_movement)
#obs.fillcolor = (0x55, 0x55, 0x55)
#obs.shape = 4
#obs.polygon = Polygon([
# (640, 80),
# (640, 480),
# (445, 450),
# (408, 300),
# (408, 165),
# (460, 108),
# (490, 104),
# (490, 91),
# (640, 80),
#]);
with open('obs2.json') as f:
obslist = json.load(f)
for obs in obslist:
obs_movement = MovementPattern.StaticMovement((0, 0))
if obs['type'] == 'circle':
obs_movement = MovementPattern.StaticMovement(obs['center'])
obs2 = DynamicObstacle(obs_movement)
obs2.shape = 1
obs2.radius = obs['radius']
obs2.fillcolor = (0x55, 0x55, 0x55)
env.static_obstacles.append(obs2)
continue
polygon = Polygon(np.array(obs['points']))
obs2 = DynamicObstacle(obs_movement)
obs2.shape = 4
obs2.polygon = polygon
obs2.fillcolor = (0x55, 0x55, 0x55)
env.static_obstacles.append(obs2)
def __init__( self , polygons = None ):
if polygons is None:
self._polygons = [ Polygon.rand_triangle( IMG_WIDTH , IMG_HEIGHT ) for _ in range( 0 , P ) ]
else:
self._polygons = polygons
self._fitness = -1
self._pixelArray = None
pass
def updateLocation(self, newLocation):
self.previousLocation = self.location
self.location = newLocation
self.bbox = BoundingBox(self.location.x-self.width/2, self.location.y-self.height/2,
self.location.x+self.width/2, self.location.y+self.height/2)
self.polygon = Polygon.createBoundingBoxPolygon(Vector(self.location.x-self.width/2, self.location.y-self.height/2),
Vector(self.location.x+self.width/2, self.location.y+self.height/2))
self.polygon.convex = True
def fetch_grid((i, j)):
"""on demand generation of empty grid squares."""
(i, j) = unwrap((i, j))
if (i, j) not in grid:
xloc = i * grid_spacing
yloc = j * grid_spacing
r = Polygon(
[
(xloc, yloc),
(xloc + grid_spacing, yloc),
(xloc + grid_spacing, yloc + grid_spacing),
(xloc, yloc + grid_spacing),
]
)
p = sample.sample(r)
t = random.expovariate(r.area())
grid[i, j] = (p, t, r)
return grid[(i, j)]
def apply_contours(self, contours):
"""
constructs a Polygon from contours
"""
self.contours = contours
from Polygon import Polygon as GPCPoly
poly = GPCPoly()
skip = 0
for pts_ in contours:
pts = []
for pt in pts_:
if 'deleted' in pt and pt.deleted is True:
skip += 1
continue
pts.append((pt[0], pt[1]))
ishole = utils.is_clockwise(pts)
if len(pts) > 2:
poly.addContour(pts, ishole)
self.poly = poly
def circle(pos=(0,0), radius=0.5, np=32, scale=1.0, xscale=1.0, yscale=1.0,
thickness=0):
if thickness == 0:
cp = []
seg = 2.0*pi/np
for i in range(np):
angle = i*seg
x = radius*cos(angle) + pos[0]
y = radius*sin(angle) + pos[1]
cp.append((x,y))
cp.append(cp[0])
if scale != 1.0: xscale = yscale = scale
pp = Polygon(cp)
if xscale != 1.0 or yscale != 1.0: pp.scale(xscale,yscale)
return pp
else:
if thickness == Default: thickness = radius*0.2
pp = ring(pos=pos, radius=radius, np=np, scale=scale,
iradius=(radius-thickness), xscale=xscale, yscale=yscale)
return pp
def star(pos=(0,0), radius=1.0, n=5, iradius=None, rotate=0.0, thickness=0.0,
roundness=0.0, invert=False, scale=1.0, xscale=1.0, yscale=1.0):
if iradius == None: iradius = radius*0.5
if thickness == 0.0:
pstar = Star(radius=radius, center=pos, beams=n, iradius=iradius)
cp = pstar[0]
cp.append(cp[0])
cp.reverse() # Polygon Star goes around clockwise, so reverse to go CCW
cp = rotatecp(cp, pos, rotate)
if scale != 1.0: xscale = yscale = scale
pp = Polygon(cp)
if xscale != 1.0 or yscale != 1.0: pp.scale(xscale,yscale)
if roundness > 0:
cp = roundc(pp.contour(0), roundness=roundness, invert=invert)
return Polygon(cp)
else: return pp
else:
pp = sframe(pos=pos, radius=radius, iradius=iradius, rotate=rotate,
thickness=thickness, roundness=roundness, invert=invert,
scale=scale, xscale=xscale, yscale=yscale, n=n)
return pp
def cross(pos=(0,0), width=1.0, thickness=0.2, rotate=0.0,
roundness=0.0, invert=False, scale=1.0, xscale=1.0, yscale=1.0):
fsqr = rectangle(pos=pos, width=width)
sqr1 = rectangle(pos=(pos[0]-(width+thickness)/4.0,
pos[1]+(width+thickness)/4.0), width=(width-thickness)/2.0)
sqr2 = rectangle(pos=(pos[0]+(width+thickness)/4.0,
pos[1]+(width+thickness)/4.0), width=(width-thickness)/2.0)
sqr3 = rectangle(pos=(pos[0]+(width+thickness)/4.0,
pos[1]-(width+thickness)/4.0), width=(width-thickness)/2.0)
sqr4 = rectangle(pos=(pos[0]-(width+thickness)/4.0,
pos[1]-(width+thickness)/4.0), width=(width-thickness)/2.0)
poly = fsqr - sqr1 -sqr2 -sqr3 -sqr4
cp = poly.contour(0)
cp.append(cp[0])
if rotate != 0.0: cp = rotatecp(cp, pos, rotate)
pp = Polygon(cp)
if xscale != 1.0 or yscale != 1.0: pp.scale(xscale,yscale)
if roundness > 0:
cp = roundc(pp.contour(0), roundness=roundness, invert=invert)
return Polygon(cp)
else: return pp
def generate_polygon(coords, scale):
"""
Generate a polygon that encompasses a set of grid coordinates.
:param coords: List of coordinates to draw polygon around
:param scale: Area around each grid square (1/scale in degrees is area of each point)
:return: Polygon of area representing the set of points
:return: Polygon of area representing the set of points
"""
out_poly = Polygon()
h_step = 0.51/scale
for pos in coords:
# sum up each polygon
out_poly.addContour([
(pos[0] - h_step, pos[1] - h_step),
(pos[0] + h_step, pos[1] - h_step),
(pos[0] + h_step, pos[1] + h_step),
(pos[0] - h_step, pos[1] + h_step)
])
out_poly.simplify()
return out_poly
def main(filein, fileout, width, height, gap):
d = dxfgrabber.read(filein)
def flipxy(p):
return (p[1], p[0])
layers = {}
for r in d.entities:
if not r.layer in layers:
layers[r.layer] = []
layers[r.layer].append(map(flipxy, r.points))
polys_to_cut = []
for (_, ps) in layers.iteritems():
polys_to_cut += map(lambda p: geo.extend_poly(gap, p, False), ps)
h = height / 2.0
w = width / 2.0
gndplane = Polygon([(h, w), (-h, w), (-h, -w), (h, -w)])
for p in polys_to_cut:
gndplane = gndplane - Polygon(p)
# Polygon.triStrip() returns a list of tristrips which need to be
# turned into quads, and the list needs to be flattened.
layers["GROUND"] = [
quad for quads in map(
geo.tristrip_to_quads,
gndplane.triStrip())
for quad in quads]
drawing = DXFEngine.drawing(fileout)
for (l, qs) in layers.iteritems():
for q in qs:
drawing.add(DXFEngine.face3d(map(flipxy, q), layer=l))
drawing.save()
def __init__(self,minDist=100,maxDist=1000,minPoints=3,maxPoints=1000,startY=33.230073,startX=-97.143826):
self.minDist = minDist
self.maxDist = maxDist
self.minPoints = minPoints
self.maxPoints = maxPoints
self.randPoints = random.randrange(self.minPoints,self.maxPoints)
self.startX = startX
self.startY = startY
self.currIteration = 0.0
self.maxIteration = self.maxPoints
self.polygon = Polygon()
self.points = []
self.generatePolygon()
def __init__(self, vertices, color=(255, 255, 255), velocity=(0, 0), angular_velocity=0, colors=None):
if isinstance(vertices, Polygon):
self.poly = vertices
else:
self.poly = Polygon(vertices)
self.colors = colors
self._color = "primary"
if colors:
self.color = color
else:
self.colors = {"primary": color}
self.velocity = np.asarray(velocity)
self.angular_velocity = angular_velocity
# Construct vertex_list.
self._vertex_list = self._get_vertex_list()
self.enabled = True
class MPolygon:
"""
this class will eventually stop the mess with Polygon classes
"""
def __init__(self, id, points, mode='tuple', data=None):
from Polygon import Polygon as Poly
self.poly = Poly()
def __str__(self):
return '<M;Polygon ('+str(len(self.points))+' points)>'
def svgPathString(self, useInt=True):
"""
returns the path string representation of this polygon
"""
ps = ''
pts = self.points[:]
if self.closed:
pts.append(pts[0])
for pt in pts:
if pt.deleted: continue #ignore deleted points
if ps == '': ps = 'M'
else: ps += 'L'
if useInt:
ps += '%d,%d' % (round(pt.x), round(pt.y))
else:
ps += '%.3f,%.3f' % (pt.x, pt.y)
if self.closed:
ps += 'Z' # close path
return ps
def area(self):
return self.poly.area()
def on_key_press(symbol, modifiers):
global actor
if symbol == key.LEFT:
actor.controls.pressedLeft = True
if symbol == key.RIGHT:
actor.controls.pressedRight = True
if symbol == key.UP:
actor.controls.pressedUp = True
if symbol == key.DOWN:
actor.controls.pressedDown = True
if symbol == key.SPACE:
actor.controls.pressedJump = True
global polygon2
global debug
if symbol == key.A:
polygon2 = Polygon.createBoundingBoxPolygon(Vector(-20, -20), Vector(40, 0))
polygon2.midpointDisplacement(8)
polygon2.midpointDisplacement(6)
polygon2.triangulate()
if symbol == key.Z:
debug = (debug + 1)%4
def get_cube_polygons():
# a cube consist of six faces
# left
polygons = []
rec = Polygon(get_rectangle_points())
t = get_shift_matrix(-1, 0, 0).dot(get_rot_y_matrix(math.pi/2))
polygons.append(rec.transform(t))
# right
t = get_shift_matrix(1, 0, 0).dot(get_rot_y_matrix(math.pi/2))
polygons.append(rec.transform(t))
# bottom
t = get_shift_matrix(0, -1, 0).dot(get_rot_x_matrix(math.pi/2))
polygons.append(rec.transform(t))
# top
t = get_shift_matrix(0, 1, 0).dot(get_rot_x_matrix(math.pi/2))
polygons.append(rec.transform(t))
# front
t = get_shift_matrix(0, 0, -1)
polygons.append(rec.transform(t))
# back
t = get_shift_matrix(0, 0, 1)
polygons.append(rec.transform(t))
return polygons
def main():
size = True
n = 0
#pointt = [Point(0, 0), Point(1, 3), Point(1, 2), Point(2, 3), Point(4, 1), Point(5, 1), Point(5, 0)]
pointt = [Point(0, -4), Point(0, 2), Point(-3, -1), Point(3, -1), Point(-1, 0), Point(1, -2), Point(1, 0) , Point(-1, -2)]
point = [Point(0, 5), Point(5, 0), Point(0, -5), Point(-5, 0)]
points = []
counter = 0
control_point = 0
with open('data.txt') as f:
for line in f:
int_list = [float(i) for i in line.split()]
counter += 1
if counter == 1:
n = int_list[0]
control_point = Point(int_list[1],int_list[2])
else:
if counter <= n+1:
points.append(Point(int_list[0],int_list[1]))
#print int_list
# for i in points:
# print(i._x )
# print( i._y)
control_point = Point(2,2)
poly = Polygon(pointt, False)
print(poly.get_area())
print(poly.is_point_belongs(control_point))
print(poly.is_point_belongs_another(control_point))
poly.write_to_file()
return
def __mutate5__( code ):
idxToChange = randint( 0 , len( code._polygons )-1 )
polygon = code._polygons[ idxToChange ]
newVertex = Polygon.rand_xy( IMG_WIDTH , IMG_HEIGHT )
polygon._vertices.append( newVertex )
