Example #1
0
def app_state(start, goal, vertices=None, edges=None):
    if vertices is None:
        vertices = [start, goal]
    if edges is None:
        edges = []
    return obj(start=start,
               goal=goal,
               vertices=vertices,
               edges=edges,
               mouse_pos=None,
               closest=None,
               origin=None,
               target=None,
               optimal_path=None,
               bidi_path=None,
               bidi_meeting_point=None,
               right_bidi_path=None,
               search_obsolete=True)
Example #2
0
if __name__ == '__main__':
    cmd = monkey.cmd()

    #debug
    appname = cmd['config'].split(os.path.sep)[-1].split('.')[0]
    #debug

    #cmd
    #appname = cmd.config.split(os.path.sep)[-1].split('.')[0]
    #cmd
    file = '%s%sconf%s%s_pageobject.yml' % (os.path.split(
        os.path.realpath(__file__))[0], os.path.sep, os.path.sep, appname)
    if os.path.exists(file):
        pageobjects = util.readyml(file)
        Obj = util.obj(pageobjects)

    Geb = GEB(cmd)
    Geb.registctrlc()
    Geb.startadbinstall()
    Geb.startserver()
    time.sleep(25)
    print(Geb.resultdir)
    if not os.path.exists(Geb.resultdir): os.makedirs(Geb.resultdir)
    file = open(Geb.resultdir + os.path.sep + 'testreport.html', 'wb')
    firstrun = 1
    secrun = 0
    tmp = sys.argv[0]
    sys.argv = []
    sys.argv.append(tmp)
    unittest.main(
Example #3
0
def parse(graph_lines, history_lines):
    """
    Parse commands and return a tuple with the following elements:
        vertices
            A ctypes array of vertices in v2f format.
        edges
            A ctypes array of vertices in v2f format, ready to pass to
            GL_LINES.
        start
            The vertex corresponding to the starting position, as an index
            into the vertices array.
        goal
            The vertex corresponting to the ending position, as an index
            into the vertices array.
        color_history
            A list of `obj`s where each of them has the attributes:
                time
                    Time in seconds from start of search.
                vertex_colors
                    A ctypes array of colors in c3B format, corresponding to
                    the vertices.
                edge_colors
                    A ctypes array of colors in c3B format, corresponding to
                    the edges.
    """
    # This function makes heavy use of iterators and itertools.
    #
    # http://docs.python.org/library/itertools.html
    vertices = None
    edges = None
    start = None
    goal = None
    color_history = [obj(time=0.0)]

    it = ifilter(None, imap(str.strip, graph_lines))

    def take_tuples_until(s):
        return imap(str.split,
                    takewhile((lambda l: l != s), it))

    # Vertices.
    assert it.next() == 'begin vertices'
    vertices = {id_: (float(x), float(y))
                for id_, x, y in take_tuples_until('end vertices')}
    vert_list = [(id_, x, y) for id_, (x, y) in vertices.iteritems()]
    vertex_index_by_id = {id_: i for i, (id_, x, y) in enumerate(vert_list)}
    vertex_buffer = (c_float * (len(vert_list) * 2))(
            *ichain((x, y) for (id_, x, y) in vert_list))

    v = obj(coords_by_id=vertices,
            flat_list=vert_list,
            index_by_id=vertex_index_by_id,
            buffer=vertex_buffer)
    len_vert_colors = len(vert_list) * 3
    color_history[0].vertex_colors = (c_ubyte * len_vert_colors)(
        *repeat(colors['default'][0], len_vert_colors))

    # Edges.
    assert it.next() == 'begin edges'
    edges = [frozenset((a, b))
             for a, b in take_tuples_until('end edges')]
    edge_index_by_vertex_ids = {pair:i
                                for i, pair in enumerate(edges)}

    edge_buffer = (c_float * (len(edges) * 4))(
                   *ichain(ichain((vertices[a], 
                                   vertices[b])
                                   for a, b in edges)))
    len_edge_colors = len(edges) * 6
    color_history[0].edge_colors = (c_ubyte * len_edge_colors)(
            *repeat(colors['default'][0], len_edge_colors))

    for rest in it:
        if rest.strip():
            print "Got unexpected line", repr(rest)

    for line in history_lines:
        line = line.strip()
        if not line:
            continue
        cmd, rest = line.split(None, 1)
        args = rest.split()
        if cmd == 'start':
            assert len(args) == 1
            start = vertices[args[0]]
        elif cmd == 'goal':
            assert len(args) == 1
            goal = vertices[args[0]]
        elif cmd == 'step':
            assert len(args) == 1
            timestamp = float(args[0])
            color_history.append(
                obj(time=timestamp,
                    vertex_colors=clone_array(color_history[-1].vertex_colors),
                    edge_colors=clone_array(color_history[-1].edge_colors)))
        elif cmd == 'vertex_color':
            id_, color_name = args
            index = vertex_index_by_id[id_]
            color_history[-1].vertex_colors[index*3:index*3+3] = \
                    colors[color_name]
        elif cmd == 'edge_color':
            a, b, color_name = args
            index = edge_index_by_vertex_ids[frozenset((a, b))]
            color_history[-1].edge_colors[index*6:index*6+6] = \
                    colors[color_name] * 2
        else:
            raise RuntimeError("Unknown command:", cmd)

    assert None not in [vertex_buffer, edge_buffer, start, goal]
    return v, edge_buffer, start, goal, color_history
Example #4
0
    def train(self,
              X,
              Y,
              max_k=100,
              nsamp=100,
              lamb=None,
              q='kl',
              mode=3,
              rerun=True,
              min_recall_per_class=0.5):
        print('##### START #####')
        Itemset.clear_db()
        prep_db(X, Y)

        # Allow specify lamb to a certain number by users
        if type(lamb) == str or lamb is None:
            samp = self.sample_from_each_label(set(Itemset.labels), 100, set(),
                                               mode)
            if lamb == 'max':
                lamb = np.max([Rule.quality([r], metric=q) for r in samp])
            elif lamb == 'mean':
                lamb = np.mean([Rule.quality([r], metric=q) for r in samp])
            else:
                lamb = 0
            print('lamb:', lamb)

        greed = GreedyDiv([], lamb)
        U_all = []
        labels_samp = set(Itemset.labels)
        while len(self) < max_k and len(labels_samp) > 0:
            if mode == 0:
                samps = []
                for label in labels_samp:
                    _, samp = sample_rn(nsamp, label)
                    samp = [Rule(s, label)
                            for s in list(samp)]  # Very time-consuming
                    samps.extend(samp)
                U = set(samps)
            else:
                covered = set([t for r in self.rules for t in r.trans()])
                U = self.sample_from_each_label(labels_samp, nsamp, covered,
                                                mode)
            print('nsamp (after):', len(U))
            if len(U) == 0:
                break
            U_all.extend(U)

            # Greedy
            greed.update_univ(U)
            r = greed.greedy_once()
            # Termination criteria. Also check zero sampling above.
            if self.enough(r):
                # Include at least one rule per class, except default class.
                labels_samp.remove(r.label)
                print('remove label:', r.label)
            else:
                # Print quality vs. dispersion
                q, d = obj(self.rules, lamb, sep=True)
                qr, dr = obj(self.rules + [r], lamb, sep=True)
                print('inc q vs. d: {}, {}'.format(qr - q, dr - d))

                self.add(r)
                if np.abs(recall(self.rules)[r.label] - 1.0) < 1e-8:
                    labels_samp.remove(r.label)
                print('#{} '.format(len(self.rules)), end='')
                printRules([r])

        # Consecutive greedy over all sampels
        if rerun:
            greed.clear()
            greed.update_univ(list(set(U_all)))
            rules = greed.greedy(len(self.rules))
            if obj(rules, lamb) > obj(self.rules, lamb):
                print('Full greedy wins: {} > {}'.format(
                    obj(rules, lamb), obj(self.rules, lamb)))
                self.reset(rules)

        default = self.set_default()
        print('default:', default)

        self.build()

        print('precision: ', precision(self).items())
        print('recall (coverage): ', recall(self.rules).items())
        print('ave disp: ', dispersion(self.rules, average=True))
        print('##### END #####')
Example #5
0
def on_key_press(k, *etc):
    ch.send(obj(type='key', key=k))
Example #6
0
def on_mouse_release(x, y, button, *etc):
    ch.send(obj(type='release', pos=vec2(x, y), button=button))
Example #7
0
def on_mouse_drag(x, y, *etc):
    aps.mouse_pos = vec2(x, y)
    ch.send(obj(type='motion', pos=vec2(x, y)))
Example #8
0
def on_mouse_press(x, y, button, *etc):
    ch.send(obj(type='press', pos=vec2(x, y), button=button))