def test_point_rotate(self): # Rotate point about origin p = Point(1.0, 3.0) p.rotate(angle=0.5) # Correct answer determined using AutoCAD software self.assertAlmostEqual(p.x, -0.56069405, places=3) self.assertAlmostEqual(p.y, 3.11217322, places=3)
def on_key_press(self, symbol, modifiers): # выход из приложения if symbol == key.ESCAPE: self.close() # удаление точки elif symbol == key.DELETE: self.boundary.delete() # уменьшение точек elif symbol == key.DOWN: Point.set_radius(Point.radius - 1) # увеличение точек elif symbol == key.UP: Point.set_radius(Point.radius + 1) # очищение boundary elif symbol == key.C: self.boundary.clear() self.container3D.clear() elif symbol == key.A: self.container3D.rotate(-180, 0) elif symbol == key.W: self.container3D.rotate(0, 180) elif symbol == key.D: self.container3D.rotate(180, 0) elif symbol == key.S: self.container3D.rotate(0, -180) elif symbol == key.Q: self.container3D.clear() elif symbol == key.P: print(datetime.now())
def combine_chains(chain1: EpicycleChain1D, chain2: EpicycleChain1D, tag_name, color='black'): assert chain1.canvas == chain2.canvas assert chain1.num_vectors == chain2.num_vectors rotation = (chain1.rotation + chain2.rotation) / 2 result_chain = EpicycleChain1D(chain1.canvas, chain1.origin_point, rotation, tag_name=tag_name) N = chain1.num_vectors c = result_chain.canvas result_chain.vectors = [Vector(Point(0, 0), Point(0, 0)) for i in range(N)] result_chain.epicycles = [ ( c.create_line(0, 0, 0, 0, tag=tag_name, fill=color), # , arrow=tk.LAST), c.create_oval(0, 0, 0, 0, tag=tag_name, outline=color)) for i in range(N) ] for i in range(N): result_chain.vectors[i] = chain1.vectors[i] + chain2.vectors[i] result_chain.num_vectors = N return result_chain
def test_point_constructors(self): pt1 = (4.5, -5.4) pt2 = Point.from_tuple(pt1) pt3 = Point(x=4.5, y=-5.4) pt4 = Point.from_point(pt3) self.assertAlmostEqual(pt1[0], pt2.x, places=6) self.assertAlmostEqual(pt1[1], pt2.y, places=6) self.assertAlmostEqual(pt1[0], pt3.x, places=6) self.assertAlmostEqual(pt1[1], pt3.y, places=6) self.assertAlmostEqual(pt1[0], pt4.x, places=6) self.assertAlmostEqual(pt1[1], pt4.y, places=6)
def find_layout(c, start): NORTH = 1 SOUTH = 2 WEST = 3 EAST = 4 direc_order = [NORTH, EAST, SOUTH, WEST] direc_step = { NORTH: Point(0, 1), EAST: Point(1, 0), SOUTH: Point(0, -1), WEST: Point(-1, 0) } BLOCKED = 0 OK = 1 END = 2 move = NORTH loc = start direc = 0 # Empirically determined size layout = np.full((43, 43), 3, dtype=np.int8) layout[tuple(start)] = 2 move_count = 0 while c.running: c.run([move]) status = c.output.pop() step = direc_step[move] next_loc = loc + step if next_loc == start: break layout[tuple(next_loc)] = status if status == BLOCKED: # Turn left direc = (direc - 1) % 4 move = direc_order[direc] elif status in (OK, END): # Turn right--essentially constantly tests wall on right move_count += 1 loc = next_loc direc = (direc + 1) % 4 move = direc_order[direc] if status == END: goal = next_loc # fig, ax = plt.subplots(figsize=(10, 10)) # ax.imshow(layout.T, origin='lower') return layout, goal
def __init__(self): self.floor = 0 self.pos = Point(0, 0) # overwritten by game state initialization self.level = 1 self.xp = 0 self.next_lvl = XP_LEVELS[1] self.hp = 10 self.max_hp = 10 self.dmg = "1d6" self.vis_range = 15 self.gp = 0 self.potions = 1 self.name = random.choice(NAMES) self.race = random.choice(RACES) self.pclass = random.choice(CLASSES)
def merge_vectors(vectors1, vectors2): assert vectors1[0].p_from == vectors2[0].p_from assert len(vectors1) == len(vectors2) vectors = [] x_prev, y_prev = list(vectors1[0].p_from.get_iter()) for i in range(len(vectors1)): rel_vec1 = (vectors1[i].p_to[0] - vectors1[i].p_from[0], vectors1[i].p_to[1] - vectors1[i].p_from[1]) rel_vec2 = (vectors2[i].p_to[0] - vectors2[i].p_from[0], vectors2[i].p_to[1] - vectors2[i].p_from[1]) rel_vec = rel_vec1[0] + rel_vec2[0], rel_vec1[1] + rel_vec2[1] x_cur, y_cur = x_prev + rel_vec[0], y_prev + rel_vec[1] vectors.append(Vector(Point(x_prev, y_prev), Point(x_cur, y_cur))) x_prev, y_prev = x_cur, y_cur return vectors
def __init__(self, id, description, lat, lon): """ Save the passed-in data. @param id: id of the point of interest @type id: C{string} @param description: description of the point of interest @type description: C{string} @param lat: latitude of point of interest @type lat: C{float} @param lon: longitude of point of interest @type lon: C{float} """ Point.__init__(self, lat, lon, id=id) self.description = description
def on_mouse_press(self, x, y, buttons, modifiers): # левая для создания точек if buttons & mouse.LEFT: if self.container2D.isin(x, y): x, y = self.container2D.recount_xy(x, y) z = randint(0, self.container2D.height_w) self.boundary.mouse_press(Point(x, y, z))
def points_inside_triangle(a: Point, b: Point, c: Point): xs = [x.x() for x in (a, b, c)] ys = [x.y() for x in (a, b, c)] xs = np.array(xs, dtype=float) ys = np.array(ys, dtype=float) # The possible range of coordinates that can be returned x_range = np.arange(np.min(xs), np.max(xs) + 1) y_range = np.arange(np.min(ys), np.max(ys) + 1) # Set the grid of coordinates on which the triangle lies. The centre of the # triangle serves as a criterion for what is inside or outside the triangle. X, Y = np.meshgrid(x_range, y_range) xc = np.mean(xs) yc = np.mean(ys) # From the array 'triangle', points that lie outside the triangle will be # set to 'False'. triangle = np.ones(X.shape, dtype=bool) for i in range(3): ii = (i + 1) % 3 if xs[i] == xs[ii]: include = X * (xc - xs[i]) / abs(xc - xs[i]) > xs[i] * (xc - xs[i]) / abs(xc - xs[i]) else: poly = np.poly1d([(ys[ii] - ys[i]) / (xs[ii] - xs[i]), ys[i] - xs[i] * (ys[ii] - ys[i]) / (xs[ii] - xs[i])]) include = Y * (yc - poly(xc)) / abs(yc - poly(xc)) > poly(X) * (yc - poly(xc)) / abs(yc - poly(xc)) triangle *= include xs = X[triangle] ys = Y[triangle] return [Point(x, y) for x, y in zip(xs, ys)]
def __init__(self, id, fromto, cue, comments): """ Save the passed-in data. @param id: id of the turn @type id: C{string} @param fromto: from segment to segment @type fromto: C{string} @param cue: instructions for executing the turn @type cue: C{string} @param comments: additional info about the turn @type comments: C{string} """ Point.__init__(self, id=id) self.fromto = fromto self.cue = cue self.comments = comments
def Txt2PntList(txt): """ Convert a string to list of points e.g. "1 2 4 6 -1 2" -> [Point(1,2), Point(4, 6), Point(-1, 2)] """ # change string to list of floats fl = [float(item) for item in txt.strip().split()] # generate easting, northing list return [Point(*i) for i in zip(fl[::2], fl[1::2])]
def _init_epicycles(self, color): c = self.canvas self.epicycles = [ ( c.create_line(0, 0, 0, 0, tag=self.tag_name, fill=color), # , activefill=color, arrow=tk.LAST, arrowshape="10 20 10" c.create_oval(0, 0, 0, 0, tag=self.tag_name, outline=color, width=2)) for i in range(self.num_vectors) ] self.vectors = [ Vector(Point(0, 0), Point(0, 0)) for i in range(self.num_vectors) ]
def shortest_path(x, y, val): """Shortest path using A*.""" goal = Point(x, y) start = Point(1, 1) frontier = [Node(0, start)] min_dist = {start: 0} # came_from = {} while frontier: current = heapq.heappop(frontier).point if current == goal: break for pt in current.neighbors: if is_wall(*pt, val): continue if (dist := min_dist.get(current, 0) + 1) < min_dist.get(pt, 2**32): # came_from[pt] = current min_dist[pt] = dist heapq.heappush(frontier, Node(dist + pt.manhattan_distance(goal), pt))
def set_multi_board(self): # Update board with new start: if self.multi: return start = Point(*self.get_location('@')) self.layout[start.y - 1] = self.layout[start.y - 1][:start.x - 1] + '@#@' + self.layout[start.y - 1][start.x + 2:] self.layout[start.y] = self.layout[start.y][:start.x - 1] + '###' + self.layout[start.y][start.x + 2:] self.layout[start.y + 1] = self.layout[start.y + 1][:start.x - 1] + '@#@' + self.layout[start.y + 1][start.x + 2:] self.multi = True
def run(data): c = Computer.fromstring(data) # arbitrary starting point really, just denotes a location in the grid start = Point(22, 20) layout, goal = find_layout(c, start) path = astar(start, goal, layout) return path.cost, fill(goal, layout)
def __init__(self, id, type, description, lat, lon): """ Save the passed-in data. @param id: id of the stop @type id: C{string} @param type: type of stop (convenience store, restaurant, etc...) @type type: C{string} @param description: description of the stop @type description: C{string} @param lat: latitude of the stop @type lat: C{float} @param lon: longitude of the stop @type lon: C{float} """ Point.__init__(self, lat, lon, id=id) self.type = type self.description = description
def update_vectors_by_time(self, time): x_prev, y_prev = self.x0, self.y0 j = 0 self.fourier_vectors = sorted(self.fourier_vectors, key=lambda i: i.amp, reverse=True) for f_vec in self.fourier_vectors: # for f_vec in self.fourier_vectors: rad = f_vec.amp x_cur = x_prev + rad * math.cos(time * f_vec.freq + f_vec.phase + self.rotation) y_cur = y_prev + rad * math.sin(time * f_vec.freq + f_vec.phase + self.rotation) self.vectors[j] = Vector(Point(x_prev, y_prev), Point(x_cur, y_cur)) x_prev, y_prev = x_cur, y_cur j += 1 return Point(x_cur, y_cur) # last point of chain
def getMinVolEllipse(self, P=None, tolerance=0.0001): """ Find the minimum volume ellipsoid which holds all the points Based on work by Nima Moshtagh http://www.mathworks.com/matlabcentral/fileexchange/9542 and also by looking at: http://cctbx.sourceforge.net/current/python/scitbx.math.minimum_covering_ellipsoid.html Which is based on the first reference anyway! Here, P is a numpy array of N dimensional points like this: P = [[x,y,z,...], <-- one point per line [x,y,z,...], [x,y,z,...]] Returns: (center, radii, rotation) """ (N, d) = np.shape(P) d = float(d) # Q will be our working array Q = np.vstack([np.copy(P.T), np.ones(N)]) QT = Q.T # initializations err = 1.0 + tolerance u = (1.0 / N) * np.ones(N) # Khachiyan Algorithm while err > tolerance: V = np.dot(Q, np.dot(np.diag(u), QT)) M = np.diag(np.dot(QT, np.dot( linalg.inv(V), Q))) # M the diagonal vector of an NxN matrix j = np.argmax(M) maximum = M[j] step_size = (maximum - d - 1.0) / ((d + 1.0) * (maximum - 1.0)) new_u = (1.0 - step_size) * u new_u[j] += step_size err = np.linalg.norm(new_u - u) u = new_u # center of the ellipse center = np.dot(P.T, u) # the A matrix for the ellipse A = linalg.inv( np.dot(P.T, np.dot(np.diag(u), P)) - np.array([[a * b for b in center] for a in center])) / d # Get the values we'd like to return U, s, rotation = linalg.svd(A) radii = 1.0 / np.sqrt(s) V1 = Vector2(rotation[0][0], rotation[0][1]) V2 = Vector2(rotation[1][0], rotation[1][1]) return Ellipse(Point(center), radii, [V1, V2])
def mouse_drag(self, x, y, dx, dy): if self.mouse_press_index is None: self.mouse_press_index = self.get_point_index(Point(x - dx, y - dy)) if self.mouse_press_index is None: return self.control_points[self.mouse_press_index].x = x self.control_points[self.mouse_press_index].y = y for line in self.lines: line.recount_points() self.changed = True
def to_image(panels): min_row = min(panels.keys(), key=lambda i: i.y).y max_row = max(panels.keys(), key=lambda i: i.y).y min_col = min(panels.keys(), key=lambda i: i.x).x max_col = max(panels.keys(), key=lambda i: i.x).x return '\n'.join(''.join( '#' if panels.get(Point(col, row), 0) == 1 else ' ' for col in range(min_col, max_col + 1)) for row in range(max_row, min_row - 1, -1))
def walk(steps): loc = Point(0, 0) direc = Vector(0, 1, 0) for turn, dist in moves(steps): if turn == 'R': direc = -Vector.k().cross(direc) else: direc = direc.cross(-Vector.k()) loc += dist * direc return loc
def import_data(filename): lines = open(filename, 'r').read() solids = re.split("--- SOLID \[\d*\]---", lines) return [ Solid([ Face(*[ Point(*[float(p) for p in point.split(";")]) for point in face.split("\n") if len(point) != 0 ]) for face in solid.split("\n\n") if face != "" ]) for solid in solids if solid != "" ]
def __init__(self, *args, **kwargs): super(App, self).__init__(caption='Kirchhoff-Plateau Surfaces', resizable=True, width=950, height=480, *args, **kwargs) self.set_minimum_size(950, 480) # инициализируются в on_resize self.container2D, self.container3D = None, None # создаём Boundary self.boundary = Boundary() # для рисования Point.set_radius(5) glEnable(GL_POINT_SMOOTH) glEnable(GL_LINE_SMOOTH) glEnable(GL_DEPTH_TEST) # чёрный фон glClearColor(0., 0., 0., 1)
def walk_scaffold(layout, robot): direcs = { '>': Vector(1, 0, 0), '<': Vector(-1, 0, 0), '^': Vector(0, -1, 0), 'V': Vector(0, 1, 0) } scaffold = '#' cur_loc = Point(*robot[:2]) cur_dir = direcs[robot[-1]] cur_run = 0 moves = [] while True: #print(cur_loc, cur_dir) next_loc = cur_loc + cur_dir if valid_index( layout, next_loc) and layout[next_loc.y][next_loc.x] == scaffold: cur_loc = next_loc cur_run += 1 else: if cur_run: moves.append(cur_run) cur_run = 0 # All of the directions are kinda flipped from expected because we're in a coordinate system # where +y is down. if cur_dir.x == 1: left = cur_loc.down right = cur_loc.up elif cur_dir.x == -1: left = cur_loc.up right = cur_loc.down elif cur_dir.y == 1: left = cur_loc.right right = cur_loc.left elif cur_dir.y == -1: left = cur_loc.left right = cur_loc.right if valid_index(layout, left) and layout[left.y][left.x] == scaffold: moves.append('L') cur_dir = cur_dir.cross(Vector.k()) elif valid_index(layout, right) and layout[right.y][right.x] == scaffold: moves.append('R') cur_dir = Vector.k().cross(cur_dir) else: break return ','.join(str(i) for i in moves)
def fit(self, data): x_m = np.mean(data[0]) y_m = np.mean(data[1]) center_estimate = x_m, y_m center, ier = optimize.leastsq(self._f, center_estimate, args=(data[0], data[1])) xc, yc = center Ri = self._calc_R(data[0], data[1], *center) R = Ri.mean() residu = np.sum((Ri - R)**2) return Circle(Point(xc, yc), R)
def draw(self): for i in range(self.num_vectors): vector = self.vectors[i] epi = self.epicycles[i] from_x, from_y, to_x, to_y = list(vector.get_iter()) rad = vector.norm() self.canvas.coords(epi[0], from_x, from_y, to_x, to_y) # line self.canvas.coords(epi[1], from_x - rad, from_y - rad, from_x + rad, from_y + rad) # circle # return last point of chain return Point(to_x, to_y)
def total_visited(x, y, val): """Flood fill with A*-style distance tracking.""" start = Point(1, 1) frontier = deque([start]) min_dist = {start: 0} while frontier: current = frontier.pop() for pt in current.neighbors: if is_wall(*pt, val): continue if (dist := min_dist.get(current, 0) + 1) <= min(min_dist.get(pt, 2**32), 50): min_dist[pt] = dist frontier.appendleft(pt)
def distance(e: Edge, p: Point) -> float: # http://geomalgorithms.com/a02-_lines.html#Distance-to-Ray-or-Segment v = Vector(e.p1, e.p2) w = Vector(e.p1, p) c1 = dot(w, v) c2 = dot(v, v) b = c1 / c2 pb = Point(e.p1.x + b * v.x, e.p1.y + b * v.y, e.p1.z + b * v.z) if c1 <= 0: return distance(p, e.p1) if c2 <= c1: return distance(p, e.p2) return distance(p, pb)
def __init__(self, id, stop, poi, lat, lon, ele, usgs): """ Save the passed-in data. @param id: id of the C{Waypoint} @type id: C{string} @param stop: space-delimited list of stop id's for this waypoint @type stop: C{string} @param poi: space-delimited list of poi id's for this waypoint @type poi: C{string} @param lat: latitude of the waypoint @type lat: C{float} @param lon: longitude of the waypoint @type lon: C{float} @param ele: observed elevation for this waypoint (meters above sea level) @type ele: C{float} @param usgs: USGS elevation for this waypoint (meters above sea level) @type usgs: C{float} """ Point.__init__(self, lat, lon, ele, usgs, id) self.stop = stop self.poi = poi
def walk2(steps): loc = Point(0, 0) visited = {loc} direc = Vector(0, 1, 0) for turn, dist in cycle(moves(steps)): if turn == 'R': direc = -Vector.k().cross(direc) else: direc = direc.cross(-Vector.k()) for _ in range(dist): loc += direc if loc in visited: return loc else: visited.add(loc)
def polypath(*polys, **kwargs): d = '' for poly in polys: poly = [Point(p[0], p[1]) for p in poly] pts = [(towards(poly[i], poly[i - 1], 1e-2), poly[i], towards(poly[i], poly[(i + 1) % len(poly)], 1e-2)) for i in range(len(poly))] started = False for p0, p1, p2 in pts: d += '%s%f,%f Q%f,%f %f,%f' % ('L' if started else 'M', p0.x, p0.y, p1.x, p1.y, p2.x, p2.y) started = True d += 'z' return Path(d=d, **kwargs)
def find_location(cp): right = Vector(1, 0, 0) down = Vector(0, 1, 0) loc = Point(0, 0) size = 100 right_edge = Vector(size - 1, 0, 0) bottom_edge = Vector(0, size - 1, 0) while not (cp(loc + right_edge) and cp(loc + bottom_edge)): while not cp(loc + bottom_edge): loc += right while not cp(loc + right_edge): loc += down return loc
def find_path(self): bfs = BreadthFirstSearch(self.start) for loc in bfs: if loc == self.end: break if loc in self.portals: bfs.add(self.portals[loc]) for candidate in Point(*loc).neighbors: if self.maze[candidate.y][candidate.x] == self.PATH: bfs.add(tuple(candidate)) else: raise RuntimeError('Failed to find end!') return bfs.order()