def pie(t,n,lenth):
r=lenth/math.sin(math.pi/n)/2
print r
for i in range(n):
rectangle(bob,r,360/n)
bob.lt(360/n)
bob.rt((180-360/n)/2)
pg.polygon(t,n,lenth)
def main():
win = GraphWin('line', 400, 400)
setaxis(win)
bxmin, bymin = map(int, input("enter the lower vertex").split())
bxmax, bymax = map(int, input("enter the upper vertex").split())
x1, y1 = map(int, input("Enter the first vertex").split())
x2, y2 = map(int, input("Enter the second vertex").split())
l(x1, y1, x2, y2, win, 'red')
l(*clip(bxmin, bymin, bxmax, bymax, x1, y1, x2, y2), win, 'blue')
polygon([(bxmin, bymin), (bxmax, bymin), (bxmax, bymax), (bxmin, bymax)],
win, 'green')
input("exit")
def draw(ver, win):
ver2d = []
for i in ver:
ver2d.append((i[0] - int(i[2] * (math.cos(math.pi / 4))),
i[1] - int(i[2] * (math.sin(math.pi / 4)))))
r = random.randint(0, 255)
g = random.randint(0, 255)
b = random.randint(0, 255)
polygon(ver2d[:4], win, color_rgb(r, g, b))
r = random.randint(0, 255)
g = random.randint(0, 255)
b = random.randint(0, 255)
polygon(ver2d[4:], win, color_rgb(r, g, b))
for i in range(4):
l(*ver2d[i], *ver2d[i + 4], win, "black")
def click_polygon(self):
self.check_click()
print('click polygon')
self.do_polygon += 1
if (self.do_polygon == 1):
self.click_vec = []
if (self.do_polygon == 2):
poly_id = self.graphic_id
max_id = 0
for i in self.graphics:
max_id = max(max_id, i.graphic_id)
self.graphic_id = max_id + 1
algorithm = 'DDA'
print(self.click_vec, self.R, self.G, self.B)
new_poly = polygon.polygon(self.canvas_image, poly_id,
self.canvas_width, self.canvas_height,
self.R, self.G, self.B)
xy_vec = []
for i in range(len(self.click_vec)):
xy_vec.append(self.click_vec[i][0])
xy_vec.append(self.click_vec[i][1])
new_poly.draw_poly(xy_vec, algorithm)
self.do_polygon = 0
self.graphics.append(new_poly)
self.refresh()
self.click_vec = []
self.text2.setText('绘制多边形完毕,点击的所有点为\n' + self.last_click_info)
return
self.text2.setText('开始绘制多边形')
def __init__(self ,input):
f = open(input,"r")
lines = f.readlines()
temp = lines[0].split(',')
self.M = int(temp[0])
self.N = int(temp[1])
temp =lines[1].split(',')
self.Start = point(float(temp[0]),float(temp[1]))
self.Goal = point(float(temp[2]),float(temp[3]))
self.polygons = []
self.pointsMap = []
self.pointsMap.append(self.Start)
self.pointsMap.append(self.Goal)
self.wait_point = []
n = int(lines[2])
for i in range(n):
p = polygon(lines[i+3])
self.polygons.append(p)
self.pointsMap = self.pointsMap + p.getPoints()
if len(lines) > n+3:
self.num_wait_point = int(lines[n+3])
for i in range(self.num_wait_point):
token_split = lines[n+3+i+1].split(',')
tmp = point(float(token_split[0]),float(token_split[1]))
self.pointsMap.append(tmp)
self.wait_point.append(tmp)
self.screen = pygame.display.set_mode(self.getSize())
def doScale(ver, x, y, sx, sy, win):
scal = [[sx, 0, 0], [0, sy, 0], [0, 0, 1]]
#input()
polygon(ver, win, color_rgb(240, 240, 240))
setaxis(win)
for i in range(len(ver)):
ver[i].append(1)
result = [[
int(sum(a * b for a, b in zip(A_row, B_col))) for B_col in zip(*scal)
] for A_row in ver]
#print(result)
for i in range(len(result)):
result[i] = result[i][:2]
#print(result)
polygon(result, win, 'green')
return result
def main():
win=GraphWin('line',400,400)
setaxis(win)
n=int(input("Enter the number of vertices"))
ver=[]
for i in range(n):
x,y=map(int,input().split())
ver+=[[x,y]]
pixel=polygon(ver,win,"green")
filled={}
#print(pixel)
bound={}
for i in pixel:
bound[i]=1
print("Click inside polygon")
p=win.getMouse()
stack=[(int(p.getX()),int(p.getY()))]
while len(stack)!=0:
i=stack.pop()
#print(stack)
if i not in filled and i not in bound:
win.plot(*i,"grey")
filled[i]=1
x,y=i
stack+=[(x+1,y),(x,y+1),(x-1,y),(x,y-1)]
input('exit')
def draw_poly(self,res_cmd):
poly_id=int(res_cmd[0])
n=int(res_cmd[1])
algorithm=res_cmd[2]
xy_vec=res_cmd[3:]
new_poly= polygon.polygon(self.canvas_image,poly_id,self.canvas_width,self.canvas_height,self.R,self.G,self.B)
new_poly.draw_poly(xy_vec,algorithm)
self.graphics.append(new_poly)
def test_area(self): area_polys= [[(0,0),(3,0),(3,4),(0,0)], [(0,0),(3,4),(3,6),(-1,9),(-1,0),(0,0)], [(0,0),(1,0),(1,1),(3,1),(3,0),(5,0),(5,5),(0,5),(0,0)]] area_values = [6,24,23] for na, poly in enumerate(area_polys): test_poly = polygon(poly) self.assertEqual(area_values[na],test_poly.area())
def translation(ver, x, y, win):
#input()
polygon(ver, win, color_rgb(240, 240, 240))
setaxis(win)
#print(ver)
for i in range(len(ver)):
ver[i].append(1)
#print(ver)
trans = [[1, 0, 0], [0, 1, 0], [-x, -y, 1]]
result = [[
int(sum(a * b for a, b in zip(A_row, B_col))) for B_col in zip(*trans)
] for A_row in ver]
#print(result)
for i in range(len(result)):
result[i] = result[i][:2]
#print(result)
polygon(result, win, 'green')
return result
def setVertices(self, verts): self.clear() self.vertices = verts if self.vertices[0] == self.vertices[len(self.vertices)-1]: self.polygonFinished = 1 self.poly = polygon.polygon(self.vertices) self.poly.getBeams(self.beamLines) self.poly.getH(self.hLines) self.viewport().update()
def doRotation(ver, x, y, angle, win):
angle = (math.pi * angle / 180)
rot = [[math.cos(angle), math.sin(angle), 0],
[-math.sin(angle), math.cos(angle), 0], [0, 0, 1]]
#input()
polygon(ver, win, color_rgb(240, 240, 240))
setaxis(win)
for i in range(len(ver)):
ver[i].append(1)
result = [[
int(sum(a * b for a, b in zip(A_row, B_col))) for B_col in zip(*rot)
] for A_row in ver]
#print(result)
for i in range(len(result)):
result[i] = result[i][:2]
#print(result)
polygon(result, win, 'green')
return result
def test_perimeter(self): perim_polys = [[(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)], [(0,0),(2,0),(5,4),(2,8),(-1,4),(0,4),(0,0)], [(0,0),(-4,-3),(-1,1),(0,0)]] perim_values = [4,22,10+np.sqrt(2)] for ni, poly in enumerate(perim_polys): test_poly = polygon(poly) self.assertEqual(perim_values[ni],test_poly.perimeter())
def shearY(ver, shy, win):
shry = [[1, shy, 0], [0, 1, 0], [0, 0, 1]]
#input()
polygon(ver, win, color_rgb(240, 240, 240))
setaxis(win)
#print(ver)
for i in range(len(ver)):
ver[i].append(1)
#print(ver)
result = [[
int(sum(a * b for a, b in zip(A_row, B_col))) for B_col in zip(*shry)
] for A_row in ver]
#print(result)
for i in range(len(result)):
result[i] = result[i][:2]
#print(result)
polygon(result, win, 'green')
return result
def __init__(self, pCoord=QPointF(), eCoord=QPointF(), p=polygon.polygon(vertices), b=[], h=[]): self.pursuerCoord = pCoord self.evaderCoord = eCoord self.poly = p self.beams = b self.hCuts = h self.initiateBeamGraph() self.initiateHGraph() self.setCriticalBeam()
def turnCircleIntoPoly(self, radius, center, numSides):
xOffset, yOffset = center
pts = list()
for i in range(0, numSides):
xPt = (np.sin(i / numSides * 2 * np.pi) * radius) + xOffset
yPt = (np.cos(i / numSides * 2 * np.pi) * radius) + yOffset
pts.append((xPt, yPt))
return polygon.polygon(pts)
def reflection(ver, x, y, angle, win):
ver = translation(ver, x, y, win)
ver = doRotation(ver, x, y, angle, win)
ref = [[-1, 0, 0], [0, 1, 0], [0, 0, 1]]
#input()
polygon(ver, win, color_rgb(240, 240, 240))
setaxis(win)
for i in range(len(ver)):
ver[i].append(1)
result = [[
int(sum(a * b for a, b in zip(A_row, B_col))) for B_col in zip(*ref)
] for A_row in ver]
#print(result)
for i in range(len(result)):
result[i] = result[i][:2]
#print(result)
polygon(result, win, 'green')
ver = doRotation(result, x, y, -angle, win)
ver = translation(ver, -x, -y, win)
return ver
def main():
# specify test case vertex points
pointChain_1 = [[0,0],[1,0],[1,1],[0,1],[0,0]]
pointChain_2 = [[-10.2,-6],[0,0],[1,-3],[1,-7],[0,-4],[-10.2,-6]]
pointChain_3 = [[13.5,41.5],[42.5,56.5],[39.5,69.5],[42.5,84.5],[13.5,100],[6.0,70.5],[13.5,41.5]]
# generate shape according to chain of points, display perimeter and area
shape = plg.polygon(pointChain_1)
print 'Polygon 1 perimeter:'
print shape.getPerimeter()
print
shape = plg.polygon(pointChain_2)
print 'Polygon 2 perimeter:'
print shape.getPerimeter()
print
shape = plg.polygon(pointChain_3)
print 'Polygon 3 perimeter:'
print shape.getPerimeter()
print
def main():
# specify test case vertex points
pointChain_1 = [[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]
pointChain_2 = [[-10.2, -6], [0, 0], [1, -3], [1, -7], [0, -4],
[-10.2, -6]]
pointChain_3 = [[13.5, 41.5], [42.5, 56.5], [39.5, 69.5], [42.5, 84.5],
[13.5, 100], [6.0, 70.5], [13.5, 41.5]]
# generate shape according to chain of points, display perimeter and area
shape = plg.polygon(pointChain_1)
print 'Polygon 1 perimeter:'
print shape.getPerimeter()
print
shape = plg.polygon(pointChain_2)
print 'Polygon 2 perimeter:'
print shape.getPerimeter()
print
shape = plg.polygon(pointChain_3)
print 'Polygon 3 perimeter:'
print shape.getPerimeter()
print
def clear(self): self.clickPos = QPointF() self.movePos = QPointF() self.clickEvent = 0 self.moveEvent = 0 self.initiated = 0 self.polygonFinished = 0 self.evaderSet = 0 self.pursuerSet = 0 self.evaderPos = QPointF() self.pursuerPos = QPointF() self.vertices=[] self.beamLines=[] self.hLines=[] self.poly = polygon.polygon(self.vertices) self.criticalBeam = QLineF() self.viewport().update()
def startPursuitStrategy(self, pursuerCoord, evaderCoord, p, beams, h): vertices = [] poly = polygon.polygon(vertices) pCoord = QPointF() eCoord = QPointF() pCoord = pursuerCoord/self.PIXELS_PER_UNIT_DISTANCE eCoord = evaderCoord/self.PIXELS_PER_UNIT_DISTANCE bLines = [] hLines = [] for vertex in p: vertices.append(QPointF(vertex.x()/self.PIXELS_PER_UNIT_DISTANCE, vertex.y()/self.PIXELS_PER_UNIT_DISTANCE)) poly.append(QPointF(vertex.x()/self.PIXELS_PER_UNIT_DISTANCE, vertex.y()/self.PIXELS_PER_UNIT_DISTANCE)) for beam in beams: bLines.append(QLineF(beam.p1().x()/self.PIXELS_PER_UNIT_DISTANCE, beam.p1().y()/self.PIXELS_PER_UNIT_DISTANCE, beam.p2().x()/self.PIXELS_PER_UNIT_DISTANCE, beam.p2().y()/self.PIXELS_PER_UNIT_DISTANCE)) for cut in h: hLines.append(QLineF(cut.p1().x()/self.PIXELS_PER_UNIT_DISTANCE, cut.p1().y()/self.PIXELS_PER_UNIT_DISTANCE, cut.p2().x()/self.PIXELS_PER_UNIT_DISTANCE, cut.p2().y()/self.PIXELS_PER_UNIT_DISTANCE)) self.strategy = pursuitStrategy.pursuitStrategy(pCoord, eCoord, poly, bLines, hLines)
def main():
# specify test case vertex points - should be valid
pointChain_1 = [[0,0],[1,0],[1,1],[0,1],[0,0]]
pointChain_2 = [[-10.2,-6],[0,0],[1,-3],[1,-7],[0,-4],[-10.2,-6]]
# specify test case vertex points - should not be valid
pointChain_3 = [[0,0],[1,0],[0,0]]
pointChain_4 = [[0,0],[1,0],[1,1],[0.5,1],[0.5,0],[0,0]]
pointChain_5 = [[0,0],[1,0],[1,1],[0,0],[-1,0],[0,-1],[0,0]]
pointChain_6 = [[-1,0],[1,0],[0,1],[0,-1],[-1,0]]
# generate shape according to chain of points of nested iterables
# change passed in points chain to pointChain_1, pointChain_2, and so on...
shape = plg.polygon(pointChain_1)
print 'Vertices for successfully created polygon:'
print shape.vertices
print
def triangulate(graph, enclosing_triangle):
triangles = [enclosing_triangle]
for node in graph:
#Find bad triangles
badTriangles = []
for triangle in triangles:
p, q, r = triangle
if withinCircle(node, p, q, r):
badTriangles.append(triangle)
# Find the boundaries of the polygonal hole
hole = polygon(badTriangles)
# Remove bad triangles from triangles
for triangle in badTriangles:
triangles.remove(triangle)
# Re-triangulate the polygonal hole
for edge in hole:
a, b = edge
newTriangle = {a, b, node}
triangles.append(newTriangle)
# Clean up
# If a triangle contains a vertex from the super-triangle, remove it
scaffolding = []
for triangle in triangles:
for vertex in triangle:
if vertex in enclosing_triangle:
if triangle not in scaffolding:
scaffolding.append(triangle)
for triangle in scaffolding:
triangles.remove(triangle)
return triangles
def main():
# specify test case vertex points
pointChain = [[-10.2, -6], [0, 0], [1, -3], [1, -7], [0, -4], [-10.2, -6]]
# generate shape according to chain of points
shape = plg.polygon(pointChain)
print 'Original polygon properties (vetices, perimeter, and area):'
print shape.vertices
print shape.getPerimeter()
print shape.getArea()
print
# rotate polygon about origin by 30 degrees counterclockwise
transArray1 = [[mth.cos(mth.pi / 6),
mth.sin(mth.pi / 6), 0],
[-mth.sin(mth.pi / 6),
mth.cos(mth.pi / 6), 0], [0, 0, 1]]
newShape = shape.getNewTransformedPolygon(transArray1)
print 'Transformation 1 properties (vetices, perimeter, and area):'
print newShape.vertices
print newShape.getPerimeter()
print newShape.getArea()
print
# scale polygon about origin by one half
transArray2 = [[0.5, 0, 0], [0, 0.5, 0], [0, 0, 1]]
newShape = shape.getNewTransformedPolygon(transArray2)
print 'Transformation 2 properties (vetices, perimeter, and area):'
print newShape.vertices
print newShape.getPerimeter()
print newShape.getArea()
print
# translate polygon by [3,5]
transArray3 = [[1, 0, 0], [0, 1, 0], [3, 5, 1]]
newShape = shape.getNewTransformedPolygon(transArray3)
print 'Transformation 3 properties (vetices, perimeter, and area):'
print newShape.vertices
print newShape.getPerimeter()
print newShape.getArea()
print
def cheb(points, show=False):
# preprocessing points
y = points[:, 1]
ofs_y = (np.max(y) - np.min(y)) / 2 + abs(np.min(y))
points[:, 1] = points[:, 1] - ofs_y
p = polygon(points)
c = ChebyshevCenter(p)
c._transform()
#c.showPolygon()
center = c.solve(show=show)
center[1] += ofs_y
points[:, 1] = points[:, 1] + ofs_y
return center
def main():
# specify test case vertex points
pointChain = [[-10.2,-6],[0,0],[1,-3],[1,-7],[0,-4],[-10.2,-6]]
# generate shape according to chain of points
shape = plg.polygon(pointChain)
print 'Original polygon properties (vetices, perimeter, and area):'
print shape.vertices
print shape.getPerimeter()
print shape.getArea()
print
# rotate polygon about origin by 30 degrees counterclockwise
transArray1 = [[mth.cos(mth.pi/6),mth.sin(mth.pi/6),0],[-mth.sin(mth.pi/6),mth.cos(mth.pi/6),0],[0,0,1]]
newShape = shape.getNewTransformedPolygon(transArray1)
print 'Transformation 1 properties (vetices, perimeter, and area):'
print newShape.vertices
print newShape.getPerimeter()
print newShape.getArea()
print
# scale polygon about origin by one half
transArray2 = [[0.5,0,0],[0,0.5,0],[0,0,1]]
newShape = shape.getNewTransformedPolygon(transArray2)
print 'Transformation 2 properties (vetices, perimeter, and area):'
print newShape.vertices
print newShape.getPerimeter()
print newShape.getArea()
print
# translate polygon by [3,5]
transArray3 = [[1,0,0],[0,1,0],[3,5,1]]
newShape = shape.getNewTransformedPolygon(transArray3)
print 'Transformation 3 properties (vetices, perimeter, and area):'
print newShape.vertices
print newShape.getPerimeter()
print newShape.getArea()
print
def main():
win = GraphWin('line', 400, 400)
setaxis(win)
n = int(input("Enter thr number of vertices in polygon"))
poly = []
for i in range(n):
poly.append(list(map(int, input().split())))
print(poly)
m = int(input("Enter thr number of vertices in polygon_clipper"))
clipper = []
for i in range(n):
clipper.append(list(map(int, input().split())))
clipped = polyClip(poly, clipper).copy()
polygon(poly, win, 'yellow')
polygon(clipper, win, 'red3')
polygon(clipped, win, 'black')
input("exit")
import numpy as np
import matplotlib.pyplot as plt
from polygon import polygon
from diskmap import diskmap
plt.figure(figsize=(6.4, 9.6))
r = np.arange(0.1, 1, 0.07)
theta = np.arange(0, 2 * np.pi, np.pi / 12)
p = polygon([0, 1j, -1 + 1j, -1 - 1j, 1 - 1j, 1])
m = diskmap(p, -0.5 - 0.5j)
plt.subplot(3, 2, 1)
p.plot('r')
m.plot(r, theta, 'b', lw=0.5)
plt.axis('equal')
plt.axis('off')
plt.axis([-1.02, 1.02, -1.02, 1.02])
############################################################
m = diskmap(p, 0.3 - 0.5j)
plt.subplot(3, 2, 2)
p.plot('r')
m.plot(r, theta, 'b', lw=0.5)
plt.axis('equal')
plt.axis('off')
plt.axis([-1.02, 1.02, -1.02, 1.02])
w = 0.5*(z + 1/z)
plt.plot(np.real(w), np.imag(w), 'b', lw=0.5)
s,t = np.meshgrid(np.linspace(0.01, 0.99, 100), theta)
z = s * np.exp(1j*t)
w = 0.5*(z + 1/z)
plt.plot(np.real(w.T), np.imag(w.T), 'b', lw=0.5)
plt.plot([-1,1], [0,0], 'r')
plt.axis('equal')
plt.axis('off')
plt.axis([-3,3,-3,3])
###############################################################
p = polygon([-0.5j, -2+0.5j, -0.5j, 1.5+1j])
m = extermap(p)
plt.subplot(4,2,2)
m.plot(r, theta, 'b', lw=0.5)
p.plot('r')
plt.axis('equal')
plt.axis('off')
plt.axis([-5,5,-5,5])
###############################################################
r = np.arange(0.3, 1, 0.04)
theta = 2*np.pi * np.arange(36)/36
p = polygon([1,1j,-1,-1j])
def paintEvent(self, event): radius = 3 p = QPainter(self.viewport()) p.setPen(Qt.black) for i in range(len(self.vertices)-1): p.drawLine(self.vertices[i],self.vertices[i+1]) if self.evaderSet: p.setBrush(Qt.gray) p.drawEllipse(self.evaderPos, radius, radius) if self.pursuerSet: p.setBrush(Qt.yellow) p.drawEllipse(self.pursuerPos, radius, radius) if not self.polygonFinished: if self.clickEvent: if len(self.vertices) > 1: if self.intersect(self.vertices[0], self.clickPos, radius): if not self.illegal(self.clickPos): self.vertices.append(self.vertices[0]) self.poly.append(self.vertices[0]) p.drawLine(self.vertices[len(self.vertices)-2],self.vertices[0]) self.polygonFinished = 1 self.poly = polygon.polygon(self.vertices) self.poly.getBeams(self.beamLines) self.poly.getH(self.hLines) return if not self.illegal(self.clickPos): self.vertices.append(self.clickPos) p.drawLine(self.vertices[len(self.vertices)-2],self.clickPos) else: self.clickPos = self.vertices[len(self.vertices)-1] if self.initiated: p.setBrush(QBrush(Qt.blue)) p.drawEllipse(self.vertices[0], radius, radius) p.setBrush(QBrush(Qt.red)) p.drawEllipse(self.clickPos, radius, radius) if self.illegal(self.movePos): p.setPen(Qt.red) p.drawLine(self.vertices[len(self.vertices)-1],self.movePos) else: if not self.evaderSet: p.setBrush(QBrush(Qt.gray)) p.drawEllipse(self.movePos, radius, radius) if self.clickEvent: if self.poly.containsPoint(self.clickPos, Qt.OddEvenFill): p.drawEllipse(self.clickPos, radius, radius) self.evaderPos = self.clickPos self.evaderSet = 1 return else: if not self.pursuerSet: p.setBrush(QBrush(Qt.yellow)) p.drawEllipse(self.movePos,radius,radius) if self.clickEvent: if self.poly.containsPoint(self.clickPos, Qt.OddEvenFill): p.drawEllipse(self.clickPos, radius, radius) self.pursuerPos = self.clickPos self.pursuerSet = 1 self.initiatePursuitStrategy() return if self.beams: for line in self.beamLines: p.setPen(Qt.DashLine) p.drawLine(line) if self.h: for line in self.hLines: p.setPen(Qt.DashLine) p.drawLine(line) if self.criticalBeam: p.setPen(Qt.red) p.drawLine(self.criticalBeam)
shape = 2048, 2048
#shape = 4096, 4096
print('Nb vertices: %d, image shape: %d, %d' %
(nb_vertices, shape[0], shape[1]))
row = np.random.randint(-int(shape[0]/10), int(1.1 * shape[0]), nb_vertices).astype(np.float32)
col = np.random.randint(-int(shape[0]/10), int(1.1 * shape[1]), nb_vertices).astype(np.float32)
st = time.time()
skimg_row, skimg_col = skimg_polygon(row, col, shape)
dt = time.time() - st
print('skimage: %f s' % dt)
st = time.time()
result = polygon(row, col, shape)
dt = time.time() - st
assert np.all(np.equal(skimg_row, result[0]))
assert np.all(np.equal(skimg_col, result[1]))
print('using line buffer: %f s' % dt)
st = time.time()
result = polygon_mask(row, col, shape, asmask=False)
dt = time.time() - st
assert np.all(np.equal(skimg_row, result[0]))
assert np.all(np.equal(skimg_col, result[1]))
print('using mask buffer: %f s' % dt)
st = time.time()
mask = polygon_mask(row, col, shape, asmask=True)
dt = time.time() - st
import numpy as np
import matplotlib.pyplot as plt
from polygon import polygon
from diskmap import diskmap
def plot_cmplx(z, *a, **k):
plt.plot(np.real(z), np.imag(z), *a, **k)
p = polygon([1, 1j, -1, -1j])
m = diskmap(p)
x, y = np.meshgrid(np.linspace(-0.8, 0.8, 9), np.linspace(-0.99, 0.99, 100))
z = (x + y * 1j) * (0.5 + 0.5j)
zi = z * 1j
theta = np.linspace(0, 2 * np.pi, 100)
plt.figure(figsize=(6.4, 3.2))
plt.subplot(1, 2, 1)
plt.axis('equal')
plt.axis('off')
plt.axis([-1, 1, -1, 1])
p.plot('r')
plot_cmplx(z, 'b')
plot_cmplx(zi, 'b')
plot_cmplx(p.vertex, '.y')
plt.subplot(1, 2, 2)
import numpy as np
import matplotlib.pyplot as plt
from polygon import polygon
from diskmap import diskmap
plt.figure(figsize=(6.4, 9.6))
r = np.arange(0.1, 1, 0.07)
theta = np.arange(0, 2 * np.pi, np.pi / 12)
p = polygon([1 - 0.5j, np.inf, 1j, np.inf, -1, np.inf, 1 - 1j],
[3 / 2, -1 / 4, 3 / 2, 0, 3 / 2, -1 / 4, 1])
m = diskmap(p)
plt.subplot(3, 2, 1)
m.plot(r, theta, 'b', lw=0.5)
p.plot('r')
plt.axis('equal')
plt.axis('off')
plt.axis([-2.5, 2.5, -3, 2])
############################################################
p = polygon([
1 - 1j, np.inf, 1 + 1j, np.inf, -0.3 + 1.3j, np.inf, -1 + 0.5j, np.inf,
-1 - 1j
], [1, -1 / 6, 2, -1 / 3, 2, -1 / 4, 2, -1 / 4, 1])
m = diskmap(p)
plt.subplot(3, 2, 2)
m.plot(r, theta, 'b', lw=0.5)
def setPolygon(self, vert): self.p = polygon.polygon(vert)
def main():
win = GraphWin('line', 400, 400)
win.setBackground(color_rgb(240, 240, 240))
setaxis(win)
n = int(input('no of vertices'))
ver = []
for i in range(n):
x, y = map(int, input().split())
ver += [[x, y]]
#print(ver)
polygon(ver, win, 'green')
'''print("1:translation 2: rotation 3: scale")
print("4: reflection 5:shear in X 6: shear in Y")
while(1):
flag=int(input("Enter the number"))
if(flag==1):
par=list(map(int,input("Enter Point x y").split()))
ver=translation(ver,*par,win)
elif flag==2:
par=list(map(int,input("Enter Point x y and angle").split()))
ver=rotation(ver,*par,win)
elif flag==3:
par=list(map(int,input("Enter Point x y and sx sy").split()))
ver=scale(ver,*par,win)
elif(flag==4):
par=list(map(int,input("Enter Point x y and angle of line from y").split()))
ver=reflection(ver,*par,win)
elif(flag==5):
par=list(map(int,input("Enter shx").split()))
ver=shearX(ver,*par,win)
elif(flag==6):
par=list(map(int,input("Enter shy").split()))
ver=shearY(ver,*par,win)
else:
break'''
while (1):
k = win.getKey()
#print(k)
if k == "Left":
ver = translation(ver, 5, 0, win)
elif k == "Right":
ver = translation(ver, -5, 0, win)
elif k == "Up":
ver = translation(ver, 0, -5, win)
elif k == "Down":
ver = translation(ver, 0, 5, win)
elif k == "r":
ver = doRotation(ver, 0, 0, 15, win)
elif k == "R":
ver = doRotation(ver, 0, 0, -15, win)
elif k == "s":
ver = doScale(ver, 0, 0, .5, .5, win)
elif k == "S":
ver = doScale(ver, 0, 0, 2, 2, win)
elif k == "x":
ver = shearX(ver, 1, win)
elif k == "X":
ver = shearX(ver, -1, win)
elif k == "y":
ver = shearY(ver, 1, win)
elif k == "Y":
ver = shearY(ver, -1, win)
elif k == "q":
break
input("exit")
import numpy as np
import matplotlib.pyplot as plt
from polygon import polygon
from hplmap import hplmap
plt.figure(figsize=(6, 6))
x = np.arange(-1, 4, 0.125)
y = np.arange(0.125, 2, 0.125)
p = polygon([-1, -0.5 + 0.5j, 0.5 - 0.5j, 1, np.inf], [0, 0, 0, 5 / 4, -1])
m = hplmap(p)
plt.subplot(3, 2, 1)
m.plot(x, y, 'b', lw=1)
p.plot('r')
plt.axis('equal')
plt.axis('off')
plt.axis([-1.5, 1.5, -0.53, 1.5])
####################################################
x = np.arange(-1, 4, 0.125)
y = np.arange(0.125, 2.25, 0.125)
p = polygon([0, 1j, 0.5j, 1 + 0.5j, 1, np.inf], [0, 0, 0, 0, 1 / 2, -1])
m = hplmap(p)
plt.subplot(3, 2, 2)
m.plot(x, y, 'b', lw=1)
p.plot('r')
def add_poly(self, points, mat):
poly = polygon(np.asarray(points), mat)
poly.get_normal()
self.objects.append(poly)
