source: mds-and-trees/tree-genealogy.py @ 625

Last change on this file since 625 was 624, checked in by konrad, 8 years ago

New, faster, more flexible and refactored version of the tree-genealogy script. Supports drawing trees as both raster graphics (bmp/png/jpg) and vector graphics (svg).

File size: 29.1 KB
Line 
1import json
2import math
3import random
4import argparse
5import bisect
6import time as timelib
7from PIL import Image, ImageDraw, ImageFont
8
9class LoadingError(Exception):
10    pass
11
12class Drawer:
13
14    def __init__(self, design, config_file, w=600, h=800, w_margin=10, h_margin=20):
15        self.design = design
16        self.width = w
17        self.height = h
18        self.w_margin = w_margin
19        self.h_margin = h_margin
20        self.w_no_margs = w - 2* w_margin
21        self.h_no_margs = h - 2* h_margin
22
23        self.colors = {
24            'black' :   {'r':0,     'g':0,      'b':0},
25            'red' :     {'r':100,   'g':0,      'b':0},
26            'green' :   {'r':0,     'g':100,    'b':0},
27            'blue' :    {'r':0,     'g':0,      'b':100},
28            'yellow' :  {'r':100,   'g':100,    'b':0},
29            'magenta' : {'r':100,   'g':0,      'b':100},
30            'cyan' :    {'r':0,     'g':100,    'b':100},
31            'orange':   {'r':100,   'g':50,     'b':0},
32            'purple':   {'r':50,    'g':0,      'b':100}
33        }
34
35        self.settings = {
36            'colors_of_kinds': ['red', 'green', 'blue', 'magenta', 'yellow', 'cyan', 'orange', 'purple'],
37            'dots': {
38                'color': {
39                    'meaning': 'depth',
40                    'start': 'purple',
41                    'end': 'green',
42                    'bias': 1
43                    },
44                'size': {
45                    'meaning': 'children',
46                    'start': 1,
47                    'end': 5,
48                    'bias': 0.5
49                    },
50                'opacity': {
51                    'meaning': 'children',
52                    'start': 0.3,
53                    'end': 0.8,
54                    'bias': 1
55                    }
56            },
57            'lines': {
58                'color': {
59                    'meaning': 'adepth',
60                    'start': 'black',
61                    'end': 'red',
62                    'bias': 3
63                    },
64                'width': {
65                    'meaning': 'adepth',
66                    'start': 1,
67                    'end': 4,
68                    'bias': 3
69                    },
70                'opacity': {
71                    'meaning': 'adepth',
72                    'start': 0.1,
73                    'end': 0.8,
74                    'bias': 5
75                    }
76            }
77        }
78
79        def merge(source, destination):
80            for key, value in source.items():
81                if isinstance(value, dict):
82                    node = destination.setdefault(key, {})
83                    merge(value, node)
84                else:
85                    destination[key] = value
86
87            return destination
88
89        if config_file != "":
90            with open(config_file) as config:
91                c = json.load(config)
92            self.settings = merge(c, self.settings)
93            #print(json.dumps(self.settings, indent=4, sort_keys=True))
94
95    def draw_dots(self, file, min_width, max_width, max_height):
96        for i in range(len(self.design.positions)):
97            node = self.design.positions[i]
98            if 'x' not in node:
99                continue
100            dot_style = self.compute_dot_style(node=i)
101            self.add_dot(file, (self.w_margin+self.w_no_margs*(node['x']-min_width)/(max_width-min_width),
102                               self.h_margin+self.h_no_margs*node['y']/max_height), dot_style)
103
104    def draw_lines(self, file, min_width, max_width, max_height):
105        for parent in range(len(self.design.positions)):
106            par_pos = self.design.positions[parent]
107            if not 'x' in par_pos:
108                continue
109            for child in self.design.tree.children[parent]:
110                chi_pos = self.design.positions[child]
111                if 'x' not in chi_pos:
112                    continue
113                line_style = self.compute_line_style(parent, child)
114                self.add_line(file, (self.w_margin+self.w_no_margs*(par_pos['x']-min_width)/(max_width-min_width),
115                                  self.h_margin+self.h_no_margs*par_pos['y']/max_height),
116                                  (self.w_margin+self.w_no_margs*(chi_pos['x']-min_width)/(max_width-min_width),
117                                  self.h_margin+self.h_no_margs*chi_pos['y']/max_height), line_style)
118
119    def draw_scale(self, file, filename):
120        self.add_text(file, "Generated from " + filename.split("\\")[-1], (5, 15), "start")
121        self.add_dashed_line(file, (self.width*0.7, self.h_margin), (self.width, self.h_margin))
122
123        start_text = ""
124        end_text = ""
125        if self.design.TIME == "BIRTHS":
126           start_text = "Birth #0"
127           end_text = "Birth #" + str(len(self.design.positions)-1)
128        if self.design.TIME == "REAL":
129           start_text = "Time " + str(min(self.design.tree.time))
130           end_text = "Time " + str(max(self.design.tree.time))
131        if self.design.TIME == "GENERATIONAL":
132           start_text = "Depth " + str(self.design.props['adepth']['min'])
133           end_text = "Depth " + str(self.design.props['adepth']['max'])
134
135        self.add_text(file, start_text, (self.width, self.h_margin + 15), "end")
136        self.add_dashed_line(file, (self.width*0.7, self.height-self.h_margin), (self.width, self.height-self.h_margin))
137        self.add_text(file, end_text, (self.width, self.height-self.h_margin + 15), "end")
138
139    def compute_property(self, part, prop, node):
140        start = self.settings[part][prop]['start']
141        end = self.settings[part][prop]['end']
142        value = (self.design.props[self.settings[part][prop]['meaning']][node]
143                 if self.settings[part][prop]['meaning'] in self.design.props else 0 )
144        bias = self.settings[part][prop]['bias']
145        if prop == "color":
146            return self.compute_color(start, end, value, bias)
147        else:
148            return self.compute_value(start, end, value, bias)
149
150    def compute_color(self, start, end, value, bias=1):
151        if isinstance(value, str):
152            value = int(value)
153            r = self.colors[self.settings['colors_of_kinds'][value]]['r']
154            g = self.colors[self.settings['colors_of_kinds'][value]]['g']
155            b = self.colors[self.settings['colors_of_kinds'][value]]['b']
156        else:
157            start_color = self.colors[start]
158            end_color = self.colors[end]
159            value = 1 - (1-value)**bias
160            r = start_color['r']*(1-value)+end_color['r']*value
161            g = start_color['g']*(1-value)+end_color['g']*value
162            b = start_color['b']*(1-value)+end_color['b']*value
163        return (r, g, b)
164
165    def compute_value(self, start, end, value, bias=1):
166        value = 1 - (1-value)**bias
167        return start*(1-value) + end*value
168
169class PngDrawer(Drawer):
170    def draw_design(self, filename, input_filename, scale="SIMPLE"):
171        print("Drawing...")
172
173        back = Image.new('RGBA', (self.width, self.height), (255,255,255,0))
174
175        min_width = min([x['x'] for x in self.design.positions if 'x' in x])
176        max_width = max([x['x'] for x in self.design.positions if 'x' in x])
177        max_height = max([x['y'] for x in self.design.positions if 'y' in x])
178
179        self.draw_lines(back, min_width, max_width, max_height)
180        self.draw_dots(back, min_width, max_width, max_height)
181
182        if scale == "SIMPLE":
183            self.draw_scale(back, input_filename)
184
185        back.show()
186        back.save(filename)
187
188    def add_dot(self, file, pos, style):
189        x, y = int(pos[0]), int(pos[1])
190        r = style['r']
191        offset = (int(x - r), int(y - r))
192        size = (2*int(r), 2*int(r))
193
194        c = style['color']
195
196        img = Image.new('RGBA', size)
197        ImageDraw.Draw(img).ellipse((1, 1, size[0]-1, size[1]-1),
198                                    (int(2.55*c[0]), int(2.55*c[1]), int(2.55*c[2]), int(255*style['opacity'])))
199        file.paste(img, offset, mask=img)
200
201    def add_line(self, file, from_pos, to_pos, style):
202        fx, fy, tx, ty = int(from_pos[0]), int(from_pos[1]), int(to_pos[0]), int(to_pos[1])
203        w = int(style['width'])
204
205        offset = (min(fx-w, tx-w), min(fy-w, ty-w))
206        size = (abs(fx-tx)+2*w, abs(fy-ty)+2*w)
207
208        c = style['color']
209
210        img = Image.new('RGBA', size)
211        ImageDraw.Draw(img).line((w, w, size[0]-w, size[1]-w) if (fx-tx)*(fy-ty)>0 else (size[0]-w, w, w, size[1]-w),
212                                  (int(2.55*c[0]), int(2.55*c[1]), int(2.55*c[2]), int(255*style['opacity'])), int(style['width']))
213        file.paste(img, offset, mask=img)
214
215    def add_dashed_line(self, file, from_pos, to_pos):
216        style = {'color': (0,0,0), 'width': 1, 'opacity': 1}
217        sublines = 50
218        # TODO could be faster: compute delta and only add delta each time (but currently we do not use it often)
219        for i in range(sublines):
220            from_pos_sub = (self.compute_value(from_pos[0], to_pos[0], 2*i/(2*sublines-1), 1),
221                            self.compute_value(from_pos[1], to_pos[1], 2*i/(2*sublines-1), 1))
222            to_pos_sub = (self.compute_value(from_pos[0], to_pos[0], (2*i+1)/(2*sublines-1), 1),
223                          self.compute_value(from_pos[1], to_pos[1], (2*i+1)/(2*sublines-1), 1))
224            self.add_line(file, from_pos_sub, to_pos_sub, style)
225
226    def add_text(self, file, text, pos, anchor, style=''):
227        font = ImageFont.truetype("Vera.ttf", 16)
228
229        img = Image.new('RGBA', (self.width, self.height))
230        draw = ImageDraw.Draw(img)
231        txtsize = draw.textsize(text, font=font)
232        pos = pos if anchor == "start" else (pos[0]-txtsize[0], pos[1]-txtsize[1])
233        draw.text(pos, text, (0,0,0), font=font)
234        file.paste(img, (0,0), mask=img)
235
236    def compute_line_style(self, parent, child):
237        return {'color': self.compute_property('lines', 'color', child),
238                'width': self.compute_property('lines', 'width', child),
239                'opacity': self.compute_property('lines', 'opacity', child)}
240
241    def compute_dot_style(self, node):
242        return {'color': self.compute_property('dots', 'color', node),
243                'r': self.compute_property('dots', 'size', node),
244                'opacity': self.compute_property('dots', 'opacity', node)}
245
246class SvgDrawer(Drawer):
247    def draw_design(self, filename, input_filename, scale="SIMPLE"):
248        print("Drawing...")
249        file = open(filename, "w")
250
251        min_width = min([x['x'] for x in self.design.positions if 'x' in x])
252        max_width = max([x['x'] for x in self.design.positions if 'x' in x])
253        max_height = max([x['y'] for x in self.design.positions if 'y' in x])
254
255        file.write('<svg xmlns:svg="http://www.w3.org/2000/svg" xmlns="http://www.w3.org/2000/svg" '
256                   'xmlns:xlink="http://www.w3.org/1999/xlink" version="1.0" '
257                   'width="' + str(self.width) + '" height="' + str(self.height) + '">')
258
259        self.draw_lines(file, min_width, max_width, max_height)
260        self.draw_dots(file, min_width, max_width, max_height)
261
262        if scale == "SIMPLE":
263            self.draw_scale(file, input_filename)
264
265        file.write("</svg>")
266        file.close()
267
268    def add_text(self, file, text, pos, anchor, style=''):
269        style = (style if style != '' else 'style="font-family: Arial; font-size: 12; fill: #000000;"')
270        file.write('<text ' + style + ' text-anchor="' + anchor + '" x="' + str(pos[0]) + '" y="' + str(pos[1]) + '" >' + text + '</text>')
271
272    def add_dot(self, file, pos, style):
273        file.write('<circle ' + style + ' cx="' + str(pos[0]) + '" cy="' + str(pos[1]) + '" />')
274
275    def add_line(self, file, from_pos, to_pos, style):
276        file.write('<line ' + style + ' x1="' + str(from_pos[0]) + '" x2="' + str(to_pos[0]) +
277                       '" y1="' + str(from_pos[1]) + '" y2="' + str(to_pos[1]) + '"  fill="none"/>')
278
279    def add_dashed_line(self, file, from_pos, to_pos):
280        style = 'stroke="black" stroke-width="0.5" stroke-opacity="1" stroke-dasharray="5, 5"'
281        self.add_line(file, from_pos, to_pos, style)
282
283    def compute_line_style(self, parent, child):
284        return self.compute_stroke_color('lines', child) + ' ' \
285               + self.compute_stroke_width('lines', child) + ' ' \
286               + self.compute_stroke_opacity(child)
287
288    def compute_dot_style(self, node):
289        return self.compute_dot_size(node) + ' ' \
290               + self.compute_fill_opacity(node) + ' ' \
291               + self.compute_dot_fill(node)
292
293    def compute_stroke_color(self, part, node):
294        color = self.compute_property(part, 'color', node)
295        return 'stroke="rgb(' + str(color[0]) + '%,' + str(color[1]) + '%,' + str(color[2]) + '%)"'
296
297    def compute_stroke_width(self, part, node):
298        return 'stroke-width="' + str(self.compute_property(part, 'width', node)) + '"'
299
300    def compute_stroke_opacity(self, node):
301        return 'stroke-opacity="' + str(self.compute_property('lines', 'opacity', node)) + '"'
302
303    def compute_fill_opacity(self, node):
304        return 'fill-opacity="' + str(self.compute_property('dots', 'opacity', node)) + '"'
305
306    def compute_dot_size(self, node):
307        return 'r="' + str(self.compute_property('dots', 'size', node)) + '"'
308
309    def compute_dot_fill(self, node):
310        color = self.compute_property('dots', 'color', node)
311        return 'fill="rgb(' + str(color[0]) + '%,' + str(color[1]) + '%,' + str(color[2]) + '%)"'
312
313class Designer:
314
315    def __init__(self, tree, jitter=False, time="GENERATIONAL", balance="DENSITY"):
316        self.props = {}
317
318        self.tree = tree
319
320        self.TIME = time
321        self.JITTER = jitter
322
323        if balance == "RANDOM":
324            self.xmin_crowd = self.xmin_crowd_random
325        elif balance == "MIN":
326            self.xmin_crowd = self.xmin_crowd_min
327        elif balance == "DENSITY":
328            self.xmin_crowd = self.xmin_crowd_density
329        else:
330            raise ValueError("Error, the value of BALANCE does not match any expected value.")
331
332    def calculate_measures(self):
333        print("Calculating measures...")
334        self.compute_adepth()
335        self.compute_depth()
336        self.compute_children()
337        self.compute_kind()
338        self.compute_time()
339        self.compute_custom()
340
341    def xmin_crowd_random(self, x1, x2, y):
342        return (x1 if random.randrange(2) == 0 else x2)
343
344    def xmin_crowd_min(self, x1, x2, y):
345        x1_closest = 999999
346        x2_closest = 999999
347        miny = y-3
348        maxy = y+3
349        i = bisect.bisect_left(self.y_sorted, miny)
350        while True:
351            if len(self.positions_sorted) <= i or self.positions_sorted[i]['y'] > maxy:
352                break
353            pos = self.positions_sorted[i]
354
355            x1_closest = min(x1_closest, abs(x1-pos['x']))
356            x2_closest = min(x2_closest, abs(x2-pos['x']))
357
358            i += 1
359        return (x1 if x1_closest > x2_closest else x2)
360
361    def xmin_crowd_density(self, x1, x2, y):
362        x1_dist = 0
363        x2_dist = 0
364        miny = y-500
365        maxy = y+500
366        i_left = bisect.bisect_left(self.y_sorted, miny)
367        i_right = bisect.bisect_right(self.y_sorted, maxy)
368        # print("i " + str(i) + " len " + str(len(self.positions)))
369        #
370        # i = bisect.bisect_left(self.y_sorted, y)
371        # i_left = max(0, i - 25)
372        # i_right = min(len(self.y_sorted), i + 25)
373
374        def include_pos(pos):
375            nonlocal x1_dist, x2_dist
376
377            dysq = (pos['y']-y)**2
378            dx1 = pos['x']-x1
379            dx2 = pos['x']-x2
380
381            x1_dist += math.sqrt(dysq + dx1**2)
382            x2_dist += math.sqrt(dysq + dx2**2)
383
384        # optimized to draw from all the nodes, if less than 10 nodes in the range
385        if len(self.positions_sorted) > i_left:
386            if i_right - i_left < 10:
387                for j in range(i_left, i_right):
388                    include_pos(self.positions_sorted[j])
389            else:
390                for j in range(10):
391                    pos = self.positions_sorted[random.randrange(i_left, i_right)]
392                    include_pos(pos)
393
394        return (x1 if x1_dist > x2_dist else x2)
395        #print(x1_dist, x2_dist)
396        #x1_dist = x1_dist**2
397        #x2_dist = x2_dist**2
398        #return x1 if x1_dist+x2_dist==0 else (x1*x1_dist + x2*x2_dist) / (x1_dist+x2_dist) + random.gauss(0, 0.01)
399        #return (x1 if random.randint(0, int(x1_dist+x2_dist)) < x1_dist else x2)
400
401    def calculate_node_positions(self, ignore_last=0):
402        print("Calculating positions...")
403
404        current_node = 0
405
406        def add_node(node):
407            nonlocal current_node
408            index = bisect.bisect_left(self.y_sorted, node['y'])
409            self.y_sorted.insert(index, node['y'])
410            self.positions_sorted.insert(index, node)
411            self.positions[node['id']] = node
412
413        self.positions_sorted = [{'x':0, 'y':0, 'id':0}]
414        self.y_sorted = [0]
415        self.positions = [{} for x in range(len(self.tree.parents))]
416        self.positions[0] = {'x':0, 'y':0, 'id':0}
417
418        nodes_to_visit = [0]
419        visited = [False] * len(self.tree.parents)
420        visited[0] = True
421
422        node_counter = 0
423        start_time = timelib.time()
424
425        while True:
426
427            node_counter += 1
428            if node_counter%1000 == 0:
429                print(str(node_counter) + " " + str(timelib.time()-start_time))
430                start_time = timelib.time()
431
432            current_node = nodes_to_visit[0]
433
434            for child in self.tree.children[current_node]:
435                if not visited[child] and self.props['adepth'][child] >= ignore_last/self.props['adepth_max']:
436                    nodes_to_visit.append(child)
437                    visited[child] = True
438
439                    ypos = 0
440                    if self.TIME == "BIRTHS":
441                        ypos = child
442                    elif self.TIME == "GENERATIONAL":
443                        ypos = self.positions[current_node]['y']+1
444                    elif self.TIME == "REAL":
445                        ypos = self.tree.time[child]
446
447                    if len(self.tree.parents[child]) == 1:
448                    # if current_node is the only parent
449                        if self.JITTER:
450                            dissimilarity = random.gauss(0, 0.5)
451                        else:
452                            dissimilarity = 1
453                        add_node({'id':child, 'y':ypos, 'x':
454                                 self.xmin_crowd(self.positions[current_node]['x']-dissimilarity,
455                                  self.positions[current_node]['x']+dissimilarity, ypos)})
456                    else:
457                        total_inheretance = sum([v for k, v in self.tree.parents[child].items()])
458                        xpos = sum([self.positions[k]['x']*v/total_inheretance
459                                   for k, v in self.tree.parents[child].items()])
460                        if self.JITTER:
461                            add_node({'id':child, 'y':ypos, 'x':xpos + random.gauss(0, 0.1)})
462                        else:
463                            add_node({'id':child, 'y':ypos, 'x':xpos})
464
465            nodes_to_visit = nodes_to_visit[1:]
466            # if none left, we can stop
467            if len(nodes_to_visit) == 0:
468                print("done")
469                break
470
471    def compute_custom(self):
472        for prop in self.tree.props:
473            self.props[prop] = [None for x in range(len(self.tree.children))]
474
475            for i in range(len(self.props[prop])):
476                self.props[prop][i] = self.tree.props[prop][i]
477
478            self.normalize_prop(prop)
479
480    def compute_time(self):
481        # simple rewrite from the tree
482        self.props["time"] = [0 for x in range(len(self.tree.children))]
483
484        for i in range(len(self.props['time'])):
485            self.props['time'][i] = self.tree.time[i]
486
487        self.normalize_prop('time')
488
489    def compute_kind(self):
490        # simple rewrite from the tree
491        self.props["kind"] = [0 for x in range(len(self.tree.children))]
492
493        for i in range (len(self.props['kind'])):
494            self.props['kind'][i] = str(self.tree.kind[i])
495
496    def compute_depth(self):
497        self.props["depth"] = [999999999 for x in range(len(self.tree.children))]
498
499        nodes_to_visit = [0]
500        self.props["depth"][0] = 0
501        while True:
502            for child in self.tree.children[nodes_to_visit[0]]:
503                nodes_to_visit.append(child)
504                self.props["depth"][child] = min([self.props["depth"][d] for d in self.tree.parents[child]])+1
505            nodes_to_visit = nodes_to_visit[1:]
506            if len(nodes_to_visit) == 0:
507                break
508
509        self.normalize_prop('depth')
510
511    def compute_adepth(self):
512        self.props["adepth"] = [0 for x in range(len(self.tree.children))]
513
514        def compute_local_adepth(node):
515            my_adepth = 0
516            for c in self.tree.children[node]:
517                my_adepth = max(my_adepth, compute_local_adepth(c)+1)
518            self.props["adepth"][node] = my_adepth
519            return my_adepth
520
521        compute_local_adepth(0)
522        self.normalize_prop('adepth')
523
524    def compute_children(self):
525        self.props["children"] = [0 for x in range(len(self.tree.children))]
526        for i in range (len(self.props['children'])):
527            self.props['children'][i] = len(self.tree.children[i])
528
529        self.normalize_prop('children')
530
531    def normalize_prop(self, prop):
532        noneless = [v for v in self.props[prop] if type(v)==int or type(v)==float]
533        if len(noneless) > 0:
534            max_val = max(noneless)
535            min_val = min(noneless)
536            self.props[prop +'_max'] = max_val
537            self.props[prop +'_min'] = min_val
538            for i in range(len(self.props[prop])):
539                if self.props[prop][i] is not None:
540                    self.props[prop][i] = (self.props[prop][i] - min_val) / max_val
541
542
543class TreeData:
544    simple_data = None
545
546    children = []
547    parents = []
548    time = []
549    kind = []
550
551    def __init__(self): #, simple_data=False):
552        #self.simple_data = simple_data
553        pass
554
555    def load(self, filename, max_nodes=0):
556        print("Loading...")
557
558        CLI_PREFIX = "Script.Message:"
559        default_props = ["Time", "FromIDs", "ID", "Operation", "Inherited"]
560
561        ids = {}
562        def get_id(id):
563            if not id in ids:
564                ids[id] = len(ids)
565            return ids[id]
566
567        file = open(filename)
568
569        # counting the number of expected nodes
570        nodes = 0
571        for line in file:
572            line_arr = line.split(' ', 1)
573            if len(line_arr) == 2:
574                if line_arr[0] == CLI_PREFIX:
575                    line_arr = line_arr[1].split(' ', 1)
576                if line_arr[0] == "[OFFSPRING]":
577                    nodes += 1
578
579        nodes = min(nodes, max_nodes if max_nodes != 0 else nodes)+1
580        self.parents = [{} for x in range(nodes)]
581        self.children = [[] for x in range(nodes)]
582        self.time = [0] * nodes
583        self.kind = [0] * nodes
584        self.props = {}
585
586        print(len(self.parents))
587
588        file.seek(0)
589        loaded_so_far = 0
590        lasttime = timelib.time()
591        for line in file:
592            line_arr = line.split(' ', 1)
593            if len(line_arr) == 2:
594                if line_arr[0] == CLI_PREFIX:
595                    line_arr = line_arr[1].split(' ', 1)
596                if line_arr[0] == "[OFFSPRING]":
597                    creature = json.loads(line_arr[1])
598                    if "FromIDs" in creature:
599
600                        # make sure that ID's of parents are lower than that of their children
601                        for i in range(0, len(creature["FromIDs"])):
602                            get_id(creature["FromIDs"][i])
603
604                        creature_id = get_id(creature["ID"])
605
606                        # debug
607                        if loaded_so_far%1000 == 0:
608                            #print(". " + str(creature_id) + " " + str(timelib.time() - lasttime))
609                            lasttime = timelib.time()
610
611                        # we assign to each parent its contribution to the genotype of the child
612                        for i in range(0, len(creature["FromIDs"])):
613                            parent_id = get_id(creature["FromIDs"][i])
614                            inherited = 1 #(creature["Inherited"][i] if 'Inherited' in creature else 1) #ONLY FOR NOW
615                            self.parents[creature_id][parent_id] = inherited
616
617                        if "Time" in creature:
618                            self.time[creature_id] = creature["Time"]
619
620                        if "Kind" in creature:
621                            self.kind[creature_id] = creature["Kind"]
622
623                        for prop in creature:
624                            if prop not in default_props:
625                                if prop not in self.props:
626                                    self.props[prop] = [None for i in range(nodes)]
627                                self.props[prop][creature_id] = creature[prop]
628
629                        loaded_so_far += 1
630                    else:
631                        raise LoadingError("[OFFSPRING] misses the 'FromIDs' field!")
632
633            if loaded_so_far >= max_nodes and max_nodes != 0:
634                break
635
636        for k in range(len(self.parents)):
637            v = self.parents[k]
638            for val in self.parents[k]:
639                self.children[val].append(k)
640
641depth = {}
642kind = {}
643
644def main():
645
646    parser = argparse.ArgumentParser(description='Draws a genealogical tree (generates a SVG file) based on parent-child relationship '
647                                                 'information from a text file. Supports files generated by Framsticks experiments.')
648    parser.add_argument('-i', '--in', dest='input', required=True, help='input file name with stuctured evolutionary data')
649    parser.add_argument('-o', '--out', dest='output', required=True, help='output file name for the evolutionary tree (SVG/PNG/JPG/BMP)')
650    parser.add_argument('-c', '--config', dest='config', default="", help='config file name ')
651
652    #TODO: better names for those parameters
653    parser.add_argument('-W', '--width', default=600, type=int, dest='width', help='width of the output image (600 by default)')
654    parser.add_argument('-H', '--height', default=800, type=int, dest='height', help='heigt of the output image (800 by default)')
655
656    parser.add_argument('-t', '--time', default='GENERATIONAL', dest='time', help='values on vertical axis (BIRTHS/GENERATIONAL(d)/REAL); '
657                                                                      'BIRTHS: time measured as the number of births since the beginning; '
658                                                                      'GENERATIONAL: time measured as number of ancestors; '
659                                                                      'REAL: real time of the simulation')
660    parser.add_argument('-b', '--balance', default='DENSITY', dest='balance', help='method of placing nodes in the tree (RANDOM/MIN/DENSITY(d))')
661    parser.add_argument('-s', '--scale', default='SIMPLE', dest='scale', help='type of timescale added to the tree (NONE(d)/SIMPLE)')
662    parser.add_argument('-j', '--jitter', dest="jitter", action='store_true', help='draw horizontal positions of children from the normal distribution')
663    parser.add_argument('-p', '--skip', dest="skip", type=int, default=0, help='skip last P levels of the tree (0 by default)')
664    parser.add_argument('-x', '--max-nodes', type=int, default=0, dest='max_nodes', help='maximum number of nodes drawn (starting from the first one)')
665    parser.add_argument('--seed', type=int, dest='seed', help='seed for the random number generator (-1 for random)')
666
667    parser.set_defaults(draw_tree=True)
668    parser.set_defaults(draw_skeleton=False)
669    parser.set_defaults(draw_spine=False)
670
671    parser.set_defaults(seed=-1)
672
673    args = parser.parse_args()
674
675    TIME = args.time.upper()
676    BALANCE = args.balance.upper()
677    SCALE = args.scale.upper()
678    JITTER = args.jitter
679    if not TIME in ['BIRTHS', 'GENERATIONAL', 'REAL']\
680        or not BALANCE in ['RANDOM', 'MIN', 'DENSITY']\
681        or not SCALE in ['NONE', 'SIMPLE']:
682        print("Incorrect value of one of the parameters! Closing the program.") #TODO don't be lazy, figure out which parameter is wrong...
683        return
684
685    dir = args.input
686    seed = args.seed
687    if seed == -1:
688        seed = random.randint(0, 10000)
689    random.seed(seed)
690    print("seed:", seed)
691
692    tree = TreeData()
693    tree.load(dir, max_nodes=args.max_nodes)
694
695    designer = Designer(tree, jitter=JITTER, time=TIME, balance=BALANCE)
696    designer.calculate_measures()
697    designer.calculate_node_positions(ignore_last=args.skip)
698
699    if args.output.endswith(".svg"):
700        drawer = SvgDrawer(designer, args.config, w=args.width, h=args.height)
701    else:
702        drawer = PngDrawer(designer, args.config, w=args.width, h=args.height)
703    drawer.draw_design(args.output, args.input, scale=SCALE)
704
705
706main()
Note: See TracBrowser for help on using the repository browser.