predator-prey simulations

Transcription

1 predator-prey simulations 1 Hopping Frogs an object oriented model of a frog animating frogs with threads 2 Frogs on Canvas a GUI for hopping frogs stopping and restarting threads 3 Flying Birds an object oriented model of a bird defining a pond of frogs giving birds access to the swamp MCS 260 Lecture 36 Introduction to Computer Science Jan Verschelde, 11 April 2016 Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

2 predator-prey simulations 1 Hopping Frogs an object oriented model of a frog animating frogs with threads 2 Frogs on Canvas a GUI for hopping frogs stopping and restarting threads 3 Flying Birds an object oriented model of a bird defining a pond of frogs giving birds access to the swamp Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

3 Modeling Frogs in object oriented fashion Imagine frogs happily hopping around in a pond... Functional attributes in the class Frog: hop : wait a bit and hop to next spot, run : do some fixed number of hops. Data attributes in the class Frog: position : coordinates (x, y) for its location, hop limit : number of hops done by the frog, step size : largest step size a frog can do, rest time : time while frog rests between steps. Adding some randomness makes it more interesting. Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

4 The Class Diagram In the Unified Modeling Language (UML), we draw Frog position hop limit step size rest time hop run Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

5 script class_frog.py from time import sleep from random import randint class Frog(object): Object oriented model of a frog. def init (self, n, x, y, h, d, m): A frog with name n at (x,y) makes m hops of size at most h, resting at most d seconds. self.name = n self.position = (x, y) self.hop_limit = m self.step_size = h self.rest_time = d Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

6 functional attributes def hop(self): The frog waits a bit before hopping. name = self.name pos = self.position rnd = randint(0, self.rest_time) print(name + at + str(pos) \ + waits + str(rnd) + seconds ) sleep(rnd) hopstep = self.step_size (xps, yps) = self.position nxp = xps + randint(-1, +1)*hopstep nyp = yps + randint(-1, +1)*hopstep self.position = (nxp, nyp) print(name + hops to + str((nxp, nyp))) Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

7 functions run and main def run(self): The frog does as many hops as the value set by self.hop_limit. while self.hop_limit > 0: self.hop() self.hop_limit = self.hop_limit - 1 def main(): Kermit our hero hops around! print( Kermit the frog is born... ) k = Frog( Kermit, +10, +10, 5, 2, 4) print( Kermit starts hopping... ) k.run() Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

8 predator-prey simulations 1 Hopping Frogs an object oriented model of a frog animating frogs with threads 2 Frogs on Canvas a GUI for hopping frogs stopping and restarting threads 3 Flying Birds an object oriented model of a bird defining a pond of frogs giving birds access to the swamp Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

9 multithreading in Python many frogs hop independently Most processors have multiple cores, allowing for parallel execution in real time, speeding up calculations. Even on one core, the operating system runs many threads. Python provides the Thread class in the threading module. In addition to the init we override the definition of run when defining a class, inheriting from Thread. For t, an instance of the inherited Thread class: t.start() executes the defined run method. multiple threads run simultaneously Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

10 script class_threadfrog.py from threading import Thread from class_frog import Frog class ThreadFrog(Thread, Frog): Exports hopping frogs as threads. def init (self, n, x, y, h, d, m): A frog with name n at (x,y) makes m hops of size at most h, resting at most d seconds. Thread. init (self, name=n) Frog. init (self, n, x, y, h, d, m) We inherit from Thread and Frog. Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

11 script class_threadfrog.py continued... def run(self): The frog does as many moves as the value set by self.moves. while self.hop_limit > 0: self.hop() self.hop_limit = self.hop_limit - 1 The hop() method is defined in class_frog.py, as a method of the class Frog. Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

12 the main() in class_script def main(): Runs a simple test on hopping frogs. print( creating two frogs: a and b ) ann = ThreadFrog( a, +10, +10, 5, 2, 4) bob = ThreadFrog( b, -10, -10, 15, 5, 3) print( starting the hopping... ) ann.start() bob.start() print( waiting for frogs to finish... ) ann.join() bob.join() if name == " main ": main() Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

13 predator-prey simulations 1 Hopping Frogs an object oriented model of a frog animating frogs with threads 2 Frogs on Canvas a GUI for hopping frogs stopping and restarting threads 3 Flying Birds an object oriented model of a bird defining a pond of frogs giving birds access to the swamp Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

14 Frogs on Canvas a GUI for hopping frogs In our GUI, the canvas will be the pond. The user can place frogs in the pond with the mouse. Three buttons: start : to start animating the hopping of frogs, stop : to stop the animation for adding frogs, clear : to clear the canvas after killing frogs. The names of the frogs are letters a, b, c,... used as text to mark the frogs on canvas. Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

15 running the GUI Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

16 data attributes from tkinter import Tk, StringVar, Label, Canvas from tkinter import Button, W, E, ALL from class_threadfrog import ThreadFrog class DrawFrogs(object): GUI to hopping frogs on canvas def init (self, wdw, d): Defines a square canvas of d pixels, label, start, stop, and clear buttons. wdw.title("drawing hopping frogs") self.frogs = [] self.gohop = False self.dim = d self.msg = StringVar() Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

17 label, canvas, bindings, buttons self.msg.set("put mouse inside box to place frogs") self.lab = Label(wdw, textvariable=self.msg) self.lab.grid(row=0, column=0, columnspan=3) self.cnv = Canvas(wdw, width=d, height=d, bg= white ) self.cnv.grid(row=1, columnspan=3) self.cnv.bind("<button-1>", self.button_pressed) self.cnv.bind("<buttonrelease-1>", self.button_released) self.bt0 = Button(wdw, text= start, command=self.start) self.bt0.grid(row=2, column=0, sticky=w+e) self.bt1 = Button(wdw, text= stop, command=self.stop) self.bt1.grid(row=2, column=1, sticky=w+e) self.bt2 = Button(wdw, text= clear, command=self.clear) self.bt2.grid(row=2, column=2, sticky=w+e) Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

18 defining mouse bindings def button_pressed(self, event): Displays coordinates of button pressed. self.msg.set("currently at [ " + \ str(event.x) + ", " + str(event.y) + " ]" +\ " release to place frog") def button_released(self, event): At release of button, a frog is created at the current location of the mouse pointer. self.msg.set("placed frog at [ " + \ str(event.x) + ", " + str(event.y) + " ]") self.new_frog(event.x, event.y) self.draw_frogs() Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

19 anewfrog def new_frog(self, xps, yps): Defines a new frog with coordinates given in (xps, yps) via the mouse. nbr = len(self.frogs) name = chr(ord( a )+nbr) frog = ThreadFrog(name, xps, yps, 20, 5, 100) self.frogs.append(frog) Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

20 drawing frogs def draw_frogs(self): Draws frogs on canvas, eventually after fixing their coordinates. dim = self.dim for frog in self.frogs: (xps, yps) = frog.position name = frog.getname() self.cnv.delete(name) if xps < 0: xps = dim - xps if yps < 0: yps = dim - yps if xps > dim: xps = xps - dim if yps > dim: yps = yps - dim frog.position = (xps, yps) self.cnv.create_text(xps, yps, text=name, tags=name) Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

21 starting the animation def start(self): Starts all frogs and the animation. self.gohop = True for frog in self.frogs: frog.start() while self.gohop: self.draw_frogs() self.cnv.after(10) self.cnv.update() Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

22 predator-prey simulations 1 Hopping Frogs an object oriented model of a frog animating frogs with threads 2 Frogs on Canvas a GUI for hopping frogs stopping and restarting threads 3 Flying Birds an object oriented model of a bird defining a pond of frogs giving birds access to the swamp Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

23 stopping an animation We cannot halt threads, but we kill frogs by setting their hop_limit to zero. Setting hop_limit stops the loop in run and then we create a new frog with the same data. def clear(self): Deletes all frogs from canvas. print( killing all frogs... ) for frog in self.frogs: frog.hop_limit = 0 while len(self.frogs) > 0: self.frogs.pop(0) self.cnv.delete(all) # cleaning canvas Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

24 stopping and restarting def stop(self): Sets hop limits of frogs to zero. self.gohop = False print( setting moves of frogs to zero... ) for frog in self.frogs: frog.hop_limit = 0 print( resetting all frogs... ) newfrogs = [] while len(self.frogs) > 0: frog = self.frogs.pop(0) pos = frog.position step = frog.step_size rest = frog.rest_time newf = ThreadFrog(frog.getName(), pos[0], pos[1], \ step, rest, 100) newfrogs.append(newf) self.frogs = newfrogs Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

25 predator-prey simulations 1 Hopping Frogs an object oriented model of a frog animating frogs with threads 2 Frogs on Canvas a GUI for hopping frogs stopping and restarting threads 3 Flying Birds an object oriented model of a bird defining a pond of frogs giving birds access to the swamp Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

26 Modeling Birds in object oriented fashion Birds fly over the pond, preying on frogs. Functional attributes for an object of the class Bird: fly : fly in some direction and then land, eat : eat closest frog within a certain radius, run :dofly() and eat() a fixed number of times. Data attributes in the class Bird: position : coordinates (x, y) for its location, direction : tuple (d x, d y ) defines flying direction, fly range : how many times a bird flies and lands, land time : time spent on land between air trips, eat radius : distance for closest frog to be eaten. Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

27 The Class Diagram In the Unified Modeling Language (UML), we draw Bird position direction fly range land time eat radius fly eat run Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

28 script flying_birds.py class Bird(Thread): Exports flying birds as threads. def init (self, n, p, d, m, s, r): A bird with name n at position p flies m times in the direction d, spending at most s seconds on land, eating frogs within radius r. Thread. init (self, name=n) self.position = p self.direction = d self.fly_range = m self.land_time = s self.eat_radius = r Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

29 birds fly def fly(self): The bird waits a bit before flying. name = self.getname() pos = self.position tsec = randint(0, self.land_time) print(name + at + str(pos) \ + lands + str(tsec) + seconds ) sleep(tsec/2) self.eat() sleep(tsec/2) (xps, yps) = self.position nxps = xps + self.direction[0] nyps = yps + self.direction[1] self.position = (nxps, nyps) print(name + flies to + str((nxps, nyps))) Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

30 predator-prey simulations 1 Hopping Frogs an object oriented model of a frog animating frogs with threads 2 Frogs on Canvas a GUI for hopping frogs stopping and restarting threads 3 Flying Birds an object oriented model of a bird defining a pond of frogs giving birds access to the swamp Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

31 finding the closest frog To define the eat() method of the class Bird, we need to compute the closest frog. FrogPond frogs nearest_frog Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

32 script frog_pond.py from math import sqrt from class_threadfrog import ThreadFrog class FrogPond(object): A pond keeps the frogs and allows to locate the frogs for predators. def init (self, F): F is a list of frogs, which may be empty at first. self.frogs = F Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

33 computing the distance we indicate a method without def distance(pnt, qnt): Returns the distance between points pnt and qnt. sqrdif = (pnt[0] - qnt[0])**2 + (pnt[1] - qnt[1])**2 return sqrt(sqrdif) The method is then called as FrogPond.distance(). A static method is similar to a class wide data attribute. Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

34 computing the nearest frog def nearest_frog(self, pos): On input in pos is a tuple (x, y) with numerical coordinates in the plane. Returns (-1, None, -1) for an empty pond, or the tuple (d, f, i) where d is the distance of pos to the nearest frog at position i in the list of frogs. if len(self.frogs) == 0: return (-1, None, -1) else: k = 0 mindis = FrogPond.distance(self.frogs[k].position, pos) for i in range(1, len(self.frogs)): dis = FrogPond.distance(self.frogs[i].position, pos) if dis < mindis: (k, mindis) = (i, dis) return (mindis, self.frogs[k], k) Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

35 testing the class def main(): Runs a test on the FrogPond class. print( swamp with two frogs: a and b ) ann = ThreadFrog( a, +10, +10, 5, 2, 4) bob = ThreadFrog( b, -10, -10, 15, 5, 3) swamp = FrogPond([ann, bob]) while True: posraw = input("give a tuple of coordinates : ") pos = eval(posraw) near = swamp.nearest_frog(pos) if near[0]!= -1: print( nearest frog to, pos, is, \ near[1].getname(), at distance, \ near[0], at position, near[2]) ans = input("more locations? (y/n) ") if ans!= y : break Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

36 predator-prey simulations 1 Hopping Frogs an object oriented model of a frog animating frogs with threads 2 Frogs on Canvas a GUI for hopping frogs stopping and restarting threads 3 Flying Birds an object oriented model of a bird defining a pond of frogs giving birds access to the swamp Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

37 at start of flying_birds.py from class_threadfrog import ThreadFrog from frog_pond import FrogPond print( swamp with four frogs ) ANN = ThreadFrog( ann, +10, +10, 2, 5, 20) BOB = ThreadFrog( bob, +10, -10, 2, 5, 20) CINDY = ThreadFrog( cindy, -10, +10, 2, 5, 20) DAVE = ThreadFrog( dave, -10, -10, 2, 5, 20) SWAMP = FrogPond([ANN, BOB, CINDY, DAVE]) class Bird(Thread): Exports flying birds as threads. Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

38 method eat() def eat(self): Finds closest frog to the bird and eats it if within its radius. name = self.getname() prey = SWAMP.nearest_frog(self.position) if prey[0]!= -1: prn = prey[1].getname() spr = nearest frog to + name \ + is + prn \ + at distance + ( %.2f % prey[0]) if prey[0] > self.eat_radius: print(spr) else: print(spr + => + prn + gobbled up ) prey[1].hop_limit = 0 del SWAMP.frogs[prey[2]] Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

39 overriding the run def run(self): The bird flies as many times as the value set by self.fly_range. while self.fly_range > 0: self.fly() self.fly_range = self.fly_range - 1 Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

40 testing the simulation We have a swamp with four frogs, initially placed as below: c a d b and two birds flying into the pond, with directions drawn by arrows above. As they lie straight in the path of the birds, frogs b and d are easy preys, while a and c may hop away, escaping the birds. Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

41 themainprogram def main(): Runs a simple test on flying birds. print( creating two birds: A and B ) (apos, adir) = ((-15, -15), (+1, +1)) (bpos, bdir) = ((+15, -15), (-1, +1)) apred = Bird( A, apos, adir, 30, 4, 5) bpred = Bird( B, bpos, bdir, 30, 4, 5) print( frogs start life in swamp... ) for frog in SWAMP.frogs: frog.start() print( birds start to fly... ) apred.start() bpred.start() apred.join() bpred.join() Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

42 Three Classes ThreadFrog position hop limit step size rest time hop run FrogPond frogs nearest_frog Bird position direction fly range land time eat radius fly eat run The class FrogPond depends on the class ThreadFrog. The eat() method in Bird depends on ThreadFrog and on an instance of FrogPond. Intro to Computer Science (MCS 260) predator-prey simulations L April / 43

43 Summary and Assignments Read chapter 11 of Python Programming. Assignments: 1 Extend the Frog class with a method breed(). When two frogs are within a certain distance from each other, new frogs are born. 2 Adjust the direction of the bird in the eat() method so that the bird flies towards the closest frog. 3 Change the class Bird so the simulation runs from a script not in the same file as the definition of the class. 4 Add flying birds to the GUI to place frogs. Represent the birds by circles with radius equal to their eat radius so the user can observe when a frog is gobbled up. Intro to Computer Science (MCS 260) predator-prey simulations L April / 43