def process_param_special(self, cmd):
assert (len(cmd) == 3)
ps = [Point(p) for p in cmd[1]]
for p in ps:
self.register_pt(p)
param_method = cmd[2]
if isinstance(param_method, str):
p_method = param_method.lower()
assert (p_method
in ["triangle", "acute-tri", "equi-tri", "polygon"])
instr = Sample(ps, p_method) # No extra args here
self.instructions.append(instr)
elif isinstance(param_method, tuple):
assert (len(param_method) == 2)
head, arg = param_method
head = head.lower()
assert (head in ["right-tri", "iso-tri", "acute-iso-tri"])
assert (isinstance(arg, str) and Point(arg) in ps)
special_p = Point(arg) # Not coming in as Point
instr = Sample(ps, head, (special_p, ))
self.instructions.append(instr)
else:
raise RuntimeError("Invalid joint param method")
n_gon_color = np.random.rand(3)
for i in range(len(ps)):
self.segments.append((ps[i], ps[(i + 1) % (len(ps))]))
self.seg_colors.append(n_gon_color)
def __init__(self, x=0, y=0, amount=FOOD_AMOUNT, random=False):
self.id = uuid.uuid4()
self.body = Point(x=x, y=y, color=(0, 255, 0), random=random)
if random:
self.position = Vector(self.body.x, self.body.y)
else:
self.position = Vector(x, y)
self.amount = amount
def __init__(self, *args, **kwargs):
super(MyWindow, self).__init__(*args, **kwargs)
self.set_minimum_size(400, 300)
# pyglet.gl.glClearColor(0.2, 0.3, 0.2, 1.0)
self.line = Line()
self.triangle = Triangle(100, 100)
self.point = Point(200, 200)
self.objects = []
self.food_manager = FoodManager()
self.creature_manager = CreatureManager()
self.life_breath()
def replace_points(self, points: List[Tuple[int, int]]) -> None:
"""
This method allows updating any existing points and automatically
creating new points.
"""
idx = 0
ln = len(self.points)
for x, y in points:
if idx < ln:
p = self.points[idx]
p.x = x
p.y = y
else:
self.points.append(Point(x, y))
idx += 1
def compute(self, cmd):
assert (len(cmd) == 4)
obj_name = cmd[1]
assert (isinstance(obj_name, str))
obj_type = cmd[2].lower()
assert (obj_type in ["point", "line", "circle"])
if obj_type == "point":
p = Point(obj_name)
self.register_pt(p)
computation = self.process_point(cmd[3], unnamed=False)
assert (not isinstance(computation.val, str))
c_instr = Compute(p, computation)
self.instructions.append(c_instr)
elif obj_type == "line":
l = Line(obj_name)
self.register_line(l)
computation = self.process_line(cmd[3], unnamed=False)
assert (not isinstance(computation.val, str))
c_instr = Compute(l, computation)
self.instructions.append(c_instr)
elif obj_type == "circle":
c = Circle(obj_name)
self.register_circ(c)
computation = self.process_circle(cmd[3], unnamed=False)
assert (not isinstance(computation.val, str))
c_instr = Compute(c, computation)
self.instructions.append(c_instr)
else:
raise RuntimeError("Invalid define type")
def param(self, cmd):
assert (len(cmd) == 3 or len(cmd) == 4)
obj_type = cmd[2].lower()
assert (obj_type in ["point", "line", "circle"])
if obj_type == "line":
l = Line(cmd[1])
self.register_line(l)
param_method = "line"
if len(cmd) == 4:
param_method = cmd[3]
pred, args = self.process_param_line(param_method)
p_instr = Parameterize(l, (pred, args))
self.instructions.append(p_instr)
elif obj_type == "circle":
c = Circle(cmd[1])
self.register_circ(c)
param_method = "circle"
if len(cmd) == 4:
param_method = cmd[3]
pred, args = self.process_param_circ(param_method)
p_instr = Parameterize(c, (pred, args))
self.instructions.append(p_instr)
else:
p = Point(cmd[1])
self.register_pt(p)
param_method = "coords"
if len(cmd) == 4:
param_method = cmd[3]
pred, args = self.process_param_point(param_method)
p_instr = Parameterize(p, (pred, args))
self.instructions.append(p_instr)
def insert_point(self, idx: int, x: int, y: int) -> None:
self.points.insert(idx, Point(x, y))
def add_point(self, x: int, y: int) -> None:
self.points.append(Point(x, y))
def from_list(points: List[Tuple[int, int]]):
return PolygonHelper(*[Point(x, y) for x, y in points])
def process_point(self, p_info, unnamed=True):
if isinstance(p_info, str) and not is_number(p_info):
assert (Point(p_info) in self.points)
return Point(p_info)
if not isinstance(p_info, tuple):
raise NotImplementedError(
f"[process_point] p_info must be tuple or string")
p_pred = p_info[0].lower()
p_args = p_info[1:]
p_val = None
if p_pred == "inter-ll":
assert (len(p_args) == 2)
l1 = self.process_line(p_args[0])
l2 = self.process_line(p_args[1])
p_val = FuncInfo(p_pred, (l1, l2))
elif p_pred in ["isogonal-conj", "isotomic-conj"]:
assert (len(p_args) == 4)
ps = [self.process_point(p) for p in p_args]
p_val = FuncInfo(p_pred, tuple(ps))
elif p_pred == "harmonic-conj":
assert (len(p_args) == 3)
ps = [self.process_point(p) for p in p_args]
p_val = FuncInfo(p_pred, tuple(ps))
elif p_pred in ["incenter", "excenter", "mixtilinear-incenter"]:
assert (len(p_args) == 3)
ps = [self.process_point(p) for p in p_args]
p_val = FuncInfo(p_pred, tuple(ps))
elif p_pred == "inter-lc":
assert (len(p_args) == 3)
l = self.process_line(p_args[0])
c = self.process_circle(p_args[1])
rs = self.process_rs(p_args[2])
p_val = FuncInfo(p_pred, (l, c, rs))
elif p_pred == "inter-cc":
assert (len(p_args) == 3)
c1 = self.process_circle(p_args[0])
c2 = self.process_circle(p_args[1])
rs = self.process_rs(p_args[2])
p_val = FuncInfo(p_pred, (c1, c2, rs))
elif p_pred in ["midp", "midp-from"]:
assert (len(p_args) == 2)
ps = [self.process_point(p) for p in p_args]
p_val = FuncInfo(p_pred, tuple(ps))
elif p_pred == "foot":
assert (len(p_args) == 2)
p = self.process_point(p_args[0])
l = self.process_line(p_args[1])
p_val = FuncInfo(p_pred, (p, l))
elif p_pred == "reflect-pl":
assert (len(p_args) == 2)
p = self.process_point(p_args[0])
l = self.process_line(p_args[1])
p_val = FuncInfo(p_pred, (p, l))
elif p_pred in ["orthocenter", "circumcenter", "centroid", "incenter"]:
assert (len(p_args) == 3)
ps = [self.process_point(p) for p in p_args]
p_val = FuncInfo(p_pred, tuple(ps))
elif p_pred == "origin":
assert (len(p_args) == 1)
circ = self.process_circle(p_args[0])
p_val = FuncInfo(p_pred, (circ, ))
elif p_pred in ["amidp-opp", "amidp-same"]:
assert (len(p_args) == 3)
ps = [self.process_point(p) for p in p_args]
p_val = FuncInfo(p_pred, tuple(ps))
if p_val is not None:
P = Point(p_val)
if unnamed:
self.unnamed_points.append(P)
return P
else:
raise NotImplementedError(
f"[process_point] Unrecognized p_pred {p_pred}")