# HG changeset patch # User Eugen Sawin # Date 1276381089 -7200 # Node ID a99535269d6062ee521589fd21c09425042c2b15 Initial. diff -r 000000000000 -r a99535269d60 algorithm.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/algorithm.py Sun Jun 13 00:18:09 2010 +0200 @@ -0,0 +1,39 @@ +def isDivergent(f): + if f == float("inf") or f == float("-inf"): + return True + return False + +class Cell(object): + def __init__(self, c, value, iterations): + self.c = c + self.value = value + self.iterations = iterations + +class Mandelbrot(object): + def __init__(self, range, resolution): + self.range = range + self.resolution = resolution + def iterate(self, z, c): + return z * z + c + def test(self, c, max_iter): + z = [0] + for i in xrange(max_iter): + z.append(self.iterate(z[-1], c)) + if isDivergent(z[-1].real) or isDivergent(z[-1].imag): + break + return z + + def resolve(self, max_iter): + cells = {} + x_diff = (self.range[1].real - self.range[0].real) / self.resolution[0] + y_diff = (self.range[1].imag - self.range[0].imag) / self.resolution[1] + c_diff = complex(x_diff, y_diff) + + for y in xrange(self.resolution[1]): + for x in xrange(self.resolution[0]): + c = self.range[0] + c_diff * complex(x, y) + print c + print self.test(c, max_iter) + + + diff -r 000000000000 -r a99535269d60 com.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/com.py Sun Jun 13 00:18:09 2010 +0200 @@ -0,0 +1,72 @@ +import model +import pickle + +commands = {} + +def help(socket, client): + socket.sendto("\n".join([key + ": " + value[1] + for key, value in commands.iteritems()]) + "\n", client) + +def createModel(socket, client, (name,)): + model.createModel(name) + socket.sendto("model %s created\n" % name, client) + +def deleteModel(socket, client, (name,)): + if model.deleteModel(name): + socket.sendto("model %s deleted\n" % name, client) + +def saveModel(socket, client, (name,)): + model = lookupModel(socket, client, name) + if model: + pickle.dump(model, open(name, "w")) + socket.sendto("model %s saved\n" % name, client) + +def loadModel(socket, client, (name,)): + model.addModel(pickle.load(open(name, "r"))) + socket.sendto("model %s loaded\n" % name, client) + + +def lookupModel(socket, client, name): + if name not in model.models: + socket.sendto("model %s not found\n" % name, client) + return None + else: + return model.models[name] + +def addObserver(socket, client, (modelName, eventType)): + model = lookupModel(socket, client, modelName) + if model: + model.register(socket, client, eventType) + socket.sendto("observer for event type %s added: " % eventType + + str(client) + "\n", client) + +def setResolution(socket, client, (modelName, x, y)): + model = lookupModel(socket, client, modelName) + if model: + model.setResolution(int(x), int(y)) + socket.sendto("model %s resolution set to %s, %s\n" % + (modelName, x, y), client) + +def setRange(socket, client, (modelName, begin, end)): + model = lookupModel(socket, client, modelName) + if model: + model.setRange(complex(begin), complex(end)) + socket.sendto("model %s range set to %s, %s\n" % + (modelName, begin, end), client) + +def update(socket, client, (modelName, iterations)): + model = lookupModel(socket, client, modelName) + if model: + model.update(int(iterations)) + socket.sendto("model %s updated with max %s iterations\n" + % (modelName, iterations), client) + +commands = {"help": (help, "help"), + "create model": (createModel, "creates a new model"), + "delete model": (deleteModel, "deletes a model"), + "save model": (saveModel, "makes a persistent copy of the model"), + "load model": (loadModel, "loads a persistent model"), + "set resolution": (setResolution, "sets the model resolution"), + "set range": (setRange, "sets the model range"), + "update": (update, "updates the model data"), + "add observer": (addObserver, "adds an observer to a model's events")} diff -r 000000000000 -r a99535269d60 model.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/model.py Sun Jun 13 00:18:09 2010 +0200 @@ -0,0 +1,42 @@ +import algorithm + +models = {} + +def createModel(name): + models[name] = Model(name) + +def addModel(model): + models[model.name] = model + +def deleteModel(name): + if name in models: + del models[name] + return True + return False + +# event = (type,value) +eventTypes = ("view", "model", "server") + +class Model(object): + def __init__(self, name): + self.name = name + self.cells = {} + self.observers = {} + for t in eventTypes: + self.observers[t] = [] + self.resolution = (0,0) + self.range = (complex(0,0), complex(0,0)) + def dispatch(self, event): + for o in self.observers: + o[0].sendto("%s" % (event), o[1]) + def register(self, socket, observer, eventType): + self.observers[eventType].append((socket, observer)) + def setResolution(self, x, y): + self.resolution = (x,y) + def setRange(self, begin, end): + self.range = (begin, end) + def update(self, max_iter): + m = algorithm.Mandelbrot(self.range, self.resolution) + self.cells = m.resolve(max_iter) + + diff -r 000000000000 -r a99535269d60 server.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/server.py Sun Jun 13 00:18:09 2010 +0200 @@ -0,0 +1,45 @@ +#!/usr/bin/python + +import com +import optparse +import SocketServer + +option_list = [ + optparse.make_option("-q", "--quiet", action="store_true", dest="quiet", + help="quiet mode", default=False)] + +class Handler(SocketServer.BaseRequestHandler): + """ + """ + def handle(self): + data = self.request[0].strip() + socket = self.request[1] + print "%s wrote:" % self.client_address[0] + print data + for key, value in com.commands.iteritems(): + if key in data: + args = data.partition(key)[2].split() + if args: + value[0](socket, self.client_address, args) + else: + value[0](socket, self.client_address) + +class Server(SocketServer.UDPServer): + def __init__(self, host, port, handler, options): + SocketServer.UDPServer.__init__(self, (host, port), handler) + self.host = host + self.port = port + self.handler = handler + self.options = options + def run(self): + self.serve_forever() + +if __name__ == "__main__": + parser = optparse.OptionParser(usage="usage: %prog [options] port", + option_list=option_list) + options, args = parser.parse_args() + + if len(args) > 0: + port = int(args[0]) + server = Server("localhost", port, Handler, options) + server.run()