Exemple #1
0
    def __init__(self, start, end, size, gap, angle=None, align='center', layer=None, datatype=None):

        self.start=np.array(start)
        self.end=np.array(end)
        self.size=np.array(size)
        self.gap=gap
        self.align=align

        pts=np.array([[0,0], [0, size[1]], size, [size[0], 0]])
        if angle is not None:
            pts=rotate(pts, angle, 'com')
            
        if align.lower()=='bottom':
            pass
        elif align.lower()=='top':
            pts=translate(pts, (0, -self.size[1]))
        elif align.lower()=='center':
            pts=translate(pts, (0, -self.size[1]/2))        
        else:
            raise ValueError('Align parameter must be one of bottom/top/center')

        strip_width=size[0]+gap
        
        v=self.end-self.start
        l=np.sqrt(np.dot(v,v))        
        N=int(np.floor(l/strip_width))
        spacing=v/N
        rotation=math.atan2(v[1], v[0])*180/np.pi
        pts=rotate(pts, rotation)

        origin = start + 0.5* v* (l-(N*strip_width - gap))/l

        polys=[translate(pts, origin + i*spacing) for i in range(N)]

        Elements.__init__(self, polys, layer, datatype)
Exemple #2
0
def vicreb_rot(deltas, seed, dim, nA, nB, t_max, v, R_v, L, D_rot, out=None):
    n = nA + nB

    np.random.seed(seed)

    r = np.random.uniform(-L / 2.0, L / 2.0, [n, dim])
    u = utils.sphere_pick(n=n, d=dim)

    As = np.zeros([n], dtype=np.bool)
    As[:nA] = True
    Bs = np.logical_not(As)
    r0 = r.copy()
    wraps = np.zeros_like(r, dtype=np.int)

    if out is not None:
        np.savez(os.path.join(out, 'static.npz'), L=L, As=As, r0=r0, v=v)
    ums, ums_A, ums_B = [], [], []
    for t in range(t_max):
        abssep = np.abs(r[:, np.newaxis] - r[np.newaxis, :])
        seps = np.minimum(abssep, L - abssep)
        withins = utils.vector_mag_sq(seps) < R_v ** 2.0

        u_o = u.copy()
        u[...] = 0.0
        for i_n in range(n):
            delta_A, delta_B = deltas[not As[i_n]]

            w_As = np.logical_and(withins[i_n], As)
            w_Bs = np.logical_and(withins[i_n], Bs)

            u_net_A = np.sum(u_o[w_As], axis=0)
            u_net_B = np.sum(u_o[w_Bs], axis=0)
            u[i_n] += utils.rotate(u_net_A, delta_A)[0]
            u[i_n] += utils.rotate(u_net_B, delta_B)[0]

            if np.all(u[i_n] == 0.0):
                u[i_n] = u_o[i_n]

        u = utils.vector_unit_nonull(u)
        u = utils.rot_diff(u, D_rot, 1.0)

        r += v * u

        wraps_cur = ((r > L / 2.0).astype(np.int) -
                     (r < -L / 2.0).astype(np.int))
        wraps += wraps_cur
        r -= wraps_cur * L

        if out is not None:
            np.savez(os.path.join(out, 'dyn_{:010d}'.format(t)),
                     t=t, r=r, u=u, w=wraps)
        ums_A.append(utils.vector_mag(np.mean(u[As], axis=0)))
        ums_B.append(utils.vector_mag(np.mean(u[Bs], axis=0)))
        ums.append(utils.vector_mag(np.mean(u, axis=0)))
    return (np.mean(ums_A), scipy.stats.sem(ums_A),
            np.mean(ums_B), scipy.stats.sem(ums_B),
            np.mean(ums), scipy.stats.sem(ums),
            )
 def random_full_rotation(img):
     # rotate either 0, 90, 180 or 270 degrees
     rot = np.random.randint(0, 4)
     if rot == 0:
         return img
     elif rot == 1:
         img, _ = utils.rotate(img, 90)
     elif rot == 2:
         img, _ = utils.rotate(img, 180)
     elif rot == 3:
         img, _ = utils.rotate(img, 270)
     return img
Exemple #4
0
    def process_frame(self, thresholded_frame):
        if self.area and self.area.is_complete:
            thresholded_frame = thresholded_frame[self.area.y1:self.area.y2, self.area.x1:self.area.x2]

        processed_frame = Frame()
        points = numpy.transpose(thresholded_frame.nonzero())

        if not len(points):
            return

        # Precalculations
        tan_half_fov_x = math.tan(self.fov_x/2)
        tan_half_fov_y = math.tan(self.fov_y/2)

        # m is the vector from the camera position to the origin
        m = self.camera_position * -1
        w = self.width/2
        h = self.height/2

        for point in points:
            img_y, img_x = point

            if self.area and self.area.is_complete:
                img_y += self.area.y1
                img_x += self.area.x1

            # Horizontal angle between platform middle (in image) and point
            delta_x = float(img_x - self.platform_middle[0])/2
            tau = math.atan(delta_x/w*tan_half_fov_x)

            # Vertical angle
            delta_y = float(img_y - self.platform_middle[1])/2
            rho = math.atan(delta_y/h*tan_half_fov_y)

            # Rotate vector m around tau and rho to point towards 'point'
            v = m
            v = rotate('z', v, tau) # Rotate around z axis for horizontal angle
            v = rotate('x', v, rho) # Rotate around x axis for vertical angle

            v = self.get_laser_plane_intersection(v)

            # Ignore any vertices that have negative z coordinates (pre scaling)
            if v[2] < 0:
                continue

            x,y,z = v*self.scale
            x,y,z = rotate('z', v, self.rotation_angle)

            vertex = Vertex(x, y, z)
            processed_frame.append(vertex)

        self.processed_frames.append(processed_frame)
 def physicsStep_(self):
     gravity = utils.rotate(self.original_gravity, self.world_angle.get())
     self.world.SetGravity(gravity)
     self.world.Step(
             self.settings.time_step,
             self.settings.vel_iters,
             self.settings.pos_iters)
Exemple #6
0
def findAngle2(data, lat_spacing_guess_px, rot_angle_scan_range_deg=(-10, -5)):
    """
    Find the angle phi (degrees) in scan_range for each lattice axis, under
    which the image "data" is rotated with respect to the imaging coordinates.
    
    Returns [[xphi, xamp, xrchisq, yphi, yamp, yrchisq], [x, xamps, yamps]]
    """
    xamps = []
    yamps = []
    dx = 0.1
    x = numpy.arange(rot_angle_scan_range_deg[0], rot_angle_scan_range_deg[1], dx)

    for phi in x:
        temp = data.copy()
        temp = utils.rotate(temp, phi)

        xlinescan = temp.sum(axis=0)
        ylinescan = temp.sum(axis=1)
        xamps.append(analyzeAutocorrelation(xlinescan, lat_spacing_guess_px)[1])
        yamps.append(analyzeAutocorrelation(ylinescan, lat_spacing_guess_px)[1])

    xfit, xpars = gauss1d(xamps)
    yfit, ypars = gauss1d(yamps)

    xchisq = ((xamps - xfit) ** 2).sum() / 0.003 ** 2
    ychisq = ((yamps - yfit) ** 2).sum() / 0.003 ** 2
    xrchisq = xchisq / (len(xamps) - 4)
    yrchisq = ychisq / (len(yamps) - 4)

    xphi = x[0] + xpars[1] * dx
    yphi = x[0] + ypars[1] * dx
    return [[xphi, xpars[0], xrchisq, yphi, ypars[0], yrchisq], [x, xamps, yamps]]
    def apply(self, wrench, dt):
        if self.drag_model.enabled:
            self.drag_model.u[0] = (self.state.twist.linear[0] - self.wind[0])
            self.drag_model.u[1] = -(self.state.twist.linear[1] - self.wind[1])
            self.drag_model.u[2] = -(self.state.twist.linear[2] - self.wind[2])
            self.drag_model.u[3] = self.state.twist.angular[0]
            self.drag_model.u[4] = -self.state.twist.angular[1]
            self.drag_model.u[5] = -self.state.twist.angular[2]

            self.drag_model.u[0:3] = utils.rotate(self.drag_model.u[0:3], self.state.quaternion)
            self.drag_model.u[3:6] = utils.rotate(self.drag_model.u[3:6], self.state.quaternion)

            self.drag_model.limit(-100.0, 100.0)

            if self.verbose:
                print
                utils.pv('self.__class__.__name__')

            self.f(self.drag_model.u, dt, self.drag_model.y)

            if self.verbose:
                utils.pv('self.drag_model')

            if self.verbose:
                utils.pv('wrench')

            if len(wrench):
                wrench.force.x += -self.drag_model.y[0]
                wrench.force.y += self.drag_model.y[1]
                wrench.force.z += self.drag_model.y[2]
                wrench.torque.x += -self.drag_model.y[3]
                wrench.torque.y += self.drag_model.y[4]
                wrench.torque.z += self.drag_model.y[5]
            else:
                wrench.force.x = -self.drag_model.y[0]
                wrench.force.y = self.drag_model.y[1]
                wrench.force.z = self.drag_model.y[2]
                wrench.torque.x = -self.drag_model.y[3]
                wrench.torque.y = self.drag_model.y[4]
                wrench.torque.z = self.drag_model.y[5]

        if self.verbose:
            utils.pv('wrench')

        return wrench
    def resize(self, vec1, vec2):
        level = self.level
        self.destroy()

        w,h = self.size

        vec1 = utils.rotate(vec1 - self.position, -self.angle)
        vec2 = utils.rotate(vec2 - self.position, -self.angle)
        try:
            w *= 1. * vec2[0] / vec1[0]
            h *= 1. * vec2[1] / vec1[1]
        except ZeroDivisionError:
            pass #whatever

        w = max(w, 0.1)
        h = max(h, 0.1)
        self.size = (w,h)

        self.create(level)
Exemple #9
0
    def actonK(self,k,ig):
        '''
        Get the k' vector after group action on k specified by ig

        k:
            the input k-vector.
        ig:
            specify the group element to act on k.
        '''
        #get the transformation to k: G^-1(ig)*k
        k1=rotate(k,ig*pi*2/self.n)
        return k1
    def stopGrab(self):
        if self.grabJoint:
            self.level.world.DestroyJoint(self.grabJoint)
            self.grabJoint = None

            offs = b2d.b2Vec2(self.radius*1.5, self.radius*1.5)
            offs = utils.rotate(offs, self.level.world_angle.get())
            saypos = self.body.position + offs
            self.level.putStaticActor(SaySomething(saypos), removeAfter = 1)

            self.candy.release()
            self.candy = None
Exemple #11
0
 def ai(self, themap, engine):
     if self.hp > 0:
         lx,ly = self.lp[0]
         rx,ry = self.rp[0]
         pcoords = tuple(themap.player.coords)
         if pcoords in self.los:
             self.playermemory = pcoords
             if pcoords in self.loe:
                 engine.attack(self,themap.player)
                 
             else:
                 self.move(themap)
                 
         elif pcoords in self.lp and themap.passable(lx,ly):
             rotate(self,"snwe"[self.facing])
             
         elif pcoords in self.rp and themap.passable(rx,ry):
             rotate(self,"nswe"[self.facing])
             
         else:
             self.move(themap)
    def straighten(self, stepsize=3, low_angle=-5, high_angle=5):
        # width is shape[1], height is shape[0]
        #cv2.imwrite("tmp//before.jpg", self.img)
        origWidth = self.img.shape[1]
        if low_angle < -20 or high_angle > 20:
            raise Exception("Photo is too skewed. Please straighten photo before trying to process it")


        img = resize(self.img, width=600)         # for some reason, straightening works better at this width :-??

        # straighten out images
        # using histograms: rotate +-5 in .3 steps, get max of each histogram
        #                   and ideal rotation is argmax of those maxes

        simg = img
        hists = []
        rng = list(range(low_angle*stepsize, high_angle*stepsize))
        bincount = 600 if img.shape[0] > 600 else img.shape[0]
        for ang in rng:
            pimg = rotate(simg, ang/float(stepsize), fixed=True) # was true, but doesn't make sense and doens't work
            # pimg = rotate(simg, ang/float(stepsize))
            # cv2.imwrite("tmp//rotate %d.jpg" % ang, pimg)
            hist, _ = np.histogram(pimg.sum(axis=1), bincount)
            #plt.plot(hist)
            #plt.savefig('tmp//hist %d.png' % ang, bbox_inches='tight')
            #plt.close()
            hists.append(max(hist))
        rot = np.argmax(hists)

        # if the best rotation angle is the one on the edge of our threshold, try to rotate again with an extended
        # threshold in that direction
        if rot == 0:
            self.straighten(low_angle=low_angle-5, high_angle=high_angle-5)
        elif rot == len(rng) - 1:
            self.straighten(low_angle=low_angle+5, high_angle=high_angle+5)
        img = rotate(self.img, rng[rot]/float(stepsize), fixed=False)   # otsu's method removes
                                                                          # background noise better

        # self.img = img.resize(w=origWidth//2)        # so that all letters are small enough
        self.img = resize(img, width=600)              # maybe I should look at average size of a blob ?
Exemple #13
0
def stupid_user(usernum, rotate_tested = 10, rotate_module=10, accepted_results=15, test=False):
    results = dict.fromkeys(range(0,150), 0)
    reached_leafs = [1000] * 150
    train_set = complete_train_set(usernum)
    all_sets = parted_all_for_user(usernum)
    for jj in range(0, rotate_module):
        pztree = PZFTree(rotate(train_set, randint(0,5000)))
        print "Avg tree depth = {0}".format(pztree.avg_tree_depth)
        # for i, run_set in enumerate(all_sets[50:], start=50):
        for i, run_set in enumerate(all_sets, start=0):
            for j in range(0,3):
                run_set= rotate(run_set,randint(0,len(run_set)))
                res_p, leafs_run = pztree.run_seq_weigted(run_set, factor=25)
                if res_p > results[i]:
                    results[i] = res_p
                if leafs_run < reached_leafs[i]:
                    reached_leafs[i] = leafs_run
    lst_leafs = pick_best_leafs(reached_leafs, accepted_results)
    lst_prob = pick_best(results, test_data[usernum], reached_leafs, rotate_module, accepted_results)
    # lst_prob = []
    to_csv = [0]*150

    hits_leafs = 0
    hits_prob = 0
    # compare_results(lst_leafs,lst_prob, test_data[usernum])
    for loc in lst_leafs:
        to_csv[loc] = 1
        if test:
            if test_data[usernum][loc]==1:
                print "Hit Leafs: " + str(loc)
                hits_leafs += 1

    for loc in lst_prob:
        # to_csv[loc] = 1
        if test:
            if test_data[usernum][loc]==1:
                print "Hit prob: " + str(loc)
                hits_prob += 1
    return hits_leafs, hits_prob, len(lst_leafs), len(lst_prob), to_csv
Exemple #14
0
    def actonK(self,k,ig):
        '''
        Get the k' vector after group action on k specified by ig

        k:
            the input k-vector.
        ig:
            specify the group element to act on k.
        '''
        #get the transformation to k: G^-1(ig)*k
        k1=rotate(k,ig*pi*2/self.n)
        if ig>=self.ng/2:
            #image about the y axis
            k1=sv(k1,n=array([1.0,0.0]))
        return k1
    def drawHand(self, graphics):
        if not self.grabJoint: return

        a = self.grabJoint.GetAnchor1()
        b = self.grabJoint.GetAnchor2()
        pos = (a+b)/2.
        h = (a-b).Length()/2.
        w = h/4.
        right = utils.rotate(b2d.b2Vec2(-10,0), self.level.world_angle.get())
        angle = utils.angle_between(right, b-a)*180/math.pi-90

        graphics.putSprite(
                pos,
                self.grab_spr_name,
                (w,h),
                angle=angle)
Exemple #16
0
def findAngle(data, length_guess, scan_range=(-12, -4)):
    """
   Finds the angle phi in scan_range, under which the image in "data" is rotated with
   respect to the imaging coordinates.
   The image must contain at least one lattice structure in one direction for this to work.
   """
    breiten_neu = []
    breiten_alt = []
    x = numpy.arange(scan_range[0], scan_range[1], 0.1)

    for phi in x:
        temp = data.copy()
        temp = utils.rotate(temp, phi)

        linescan_neu = temp.sum(axis=0)
        linescan_alt = temp.sum(axis=1)
        breiten_neu.append(analyzeAutocorrelation(linescan_neu, length_guess)[1])
        breiten_alt.append(analyzeAutocorrelation(linescan_alt, length_guess)[1])

    def fitfunction(p, xachse):
        return p[0] * numpy.exp(-((xachse - p[1]) / p[2]) ** 2) + p[3]

    def errorfunction(p, xachse, data):
        return data - fitfunction(p, xachse)

    (pars_neu, success_neu) = optimize.leastsq(
        errorfunction, [0.15, scan_range[len(scan_range) // 2], 5, 0], args=(x, breiten_neu)
    )
    (pars_alt, success_alt) = optimize.leastsq(
        errorfunction, [0.15, scan_range[len(scan_range) // 2], 5, 0], args=(x, breiten_alt)
    )

    (neu, alt) = (True, True)
    if pars_neu[0] < 0.12:
        neu = False
    if pars_alt[0] < 0.12:
        alt = False
    if not alt and not neu:
        raise Exception, "No lattice structure found"

    phi = (pars_neu[1] * neu + pars_alt[1] * alt) / (alt + neu)

    return phi
    def draw(self, graphics):
        #super(Gorilla, self).draw(graphics)
        right = utils.rotate(b2d.b2Vec2(-10,0), self.level.world_angle.get())
        if self.body.linearVelocity.Length()<1:
            angle = 0.
        else:
            angle = utils.angle_between(right, self.body.linearVelocity-right)
            angle = int(angle * 180 / math.pi)

        if self.hasCandy(): sprite = self.happy_spr_name
        else: sprite = self.spr_name
        graphics.putSprite(
                self.body.position,
                sprite,
                (self.radius, self.radius),
                angle=angle,
                flipX = True,
                flipY = abs(angle)>90)

        self.drawHand(graphics)
Exemple #18
0
def vicrot(delta, n, seed, dim, t_max, v, R_v, L, D_rot, out=None):
    np.random.seed(seed)

    r = np.random.uniform(-L / 2.0, L / 2.0, [n, dim])
    u = utils.sphere_pick(n=n, d=dim)

    r0 = r.copy()
    wraps = np.zeros_like(r, dtype=np.int)

    if out is not None:
        np.savez(os.path.join(out, 'static.npz'), L=L, r0=r0, v=v)
    ums = []
    for t in range(t_max):
        abssep = np.abs(r[:, np.newaxis] - r[np.newaxis, :])
        seps = np.minimum(abssep, L - abssep)
        withins = utils.vector_mag_sq(seps) < R_v ** 2.0

        u_o = u.copy()
        u[...] = 0.0
        for i_n in range(n):
            u_net = np.sum(u_o[withins[i_n]], axis=0)
            u[i_n] = utils.rotate(u_net, delta)

        u = utils.vector_unit_nonull(u)
        u = utils.rot_diff(u, D_rot, 1.0)

        r += v * u

        wraps_cur = ((r > L / 2.0).astype(np.int) -
                     (r < -L / 2.0).astype(np.int))
        wraps += wraps_cur
        r -= wraps_cur * L

        if out is not None:
            np.savez(os.path.join(out, 'dyn_{:010d}'.format(t)),
                     t=t, r=r, u=u, w=wraps)
        ums.append(utils.vector_mag(np.mean(u, axis=0)))
    return np.mean(ums), scipy.stats.sem(ums)
Exemple #19
0
def key_expand(key, nr, nk):
    expanded = [k for k in key]
    tmp = [0]*4
    rcon_iter = 1

    # size is either 16, 24 or 42 byte
    size = nk*4

    # length of the expended keysize is either
    # 176, 208 or 240, depending on the keysize
    expanded_keysize = (nr+1)*16
    currentsize = size

    while currentsize < expanded_keysize:

        for i in range(4):
            tmp[i] = expanded[(currentsize-4)+i]

        if currentsize%size == 0:
            tmp = rotate(tmp)
            for i in range(4):
                tmp[i] = S[tmp[i]]

            tmp[0] = tmp[0]^RCON[rcon_iter]
            rcon_iter += 1

        # Add an extra s-box for 256 bit keys
        if currentsize%size == 16 and size==32:
            for i in range(4):
                tmp[i] = S[tmp[i]]

        for i in range(4):
            expanded.append(expanded[currentsize-size]^tmp[i])
            currentsize += 1

    return expanded
Exemple #20
0
 def to_body(self, v):
     """
     Convert vel/accel from world frame to body frame
     """
     return utils.rotate(v, self.inverse_quaternion)
Exemple #21
0
def admin_inner(client, nick, crawler):
    if nick not in client.mod_conf['admin']['admins']:
        return 'You do not have administrator privileges!'
    
    try:
        cmd = crawler.normal().lower()
        text = crawler.chain
    except IndexError:
        cmd = 'help'
    
    ### Position #############
    
    if cmd == 'sit':
        client.sit()
    
    elif cmd == 'stand':
        client.stand()
    
    elif cmd == 'face':
        client.face(crawler.chain[0])
    
    ### Joke moves ###########
    
    elif cmd == 'spin':
        args = ['l', 's', '4'] if not text else text.split()
        
        rot = ['n', 'e', 's', 'w']
        rot = rotate(rot, rot.index(args[1][0].lower()))
        if args[0][0].lower() == 'l':
            rot.reverse()
        
        rot *= int(args[2])
        client.emote(10)
        client.sleep(600)
        for d in rot:
            client.face(d)
            client.sleep(300)
        client.sleep(300)
        client.emote(115)
    
    
    elif cmd == 'juke':
        # 2 args or no args
        if len(crawler) not in (0, 2):
            return 'Bad args! See the help sub-command.'
        args = ['u', 's'] if not text else text.lower().split()
        e_up = args[0][0] == 'u'
        s_dir = args[1][0]
        f2 = 'n' if s_dir in 'ew' else 'w'
        f3 = 's' if s_dir in 'ew' else 'e'
        
        main = ['d', s_dir, '.500', ':122', '.500']
        
        routine = ['u', 'd', 'u', 'd', 'u', f2, s_dir, f2, s_dir, 
                   f3, s_dir, f3, s_dir, 'd', 'u', 'd', ':127']
        routine += ['u'] if e_up else []
        for p in routine:
            main.append(p)
            main.append('.500')
        
        for p in main:
            if p[0] == '.':
                client.sleep(int(p[1:]))
            elif p[0] == ':':
                client.emote(int(p[1:]))
            elif p == 'u':
                client.stand()
            elif p == 'd':
                client.sit()
            else:
                client.face(p)
    
    ### Communications #######
    
    elif cmd == 'emote':
        client.emote(crawler.chain)
    
    elif cmd == 'say':
        client.msg(crawler.chain)
    
    elif cmd == 'whisper':
        # Need the last arg first :-/
        crawler.flip()
        to = crawler.quoted()
        crawler.flip()
        client.whisper(to, crawler.chain)
    
    ### Interaction ##########
    
    elif cmd == 'attack':
        whom = crawler.quoted()
        being_id = client.mod_whois_nmap.get(whom)
        if not being_id:
            if whom.isdigit():
                being_id = int(whom)
            else:
                return 'Sorry, I don\'t know that name.'
        
        name = client.mod_whois_imap.get(being_id)
        if name:
           more = ' (%s)' % name
        else:
            more = ''
            client.whois(being_id)
        
        text = crawler.chain
        keep = not text or text[0].lower() in 'yt'
        client.attack(being_id, keep)
        return 'Attacking %s%s!' % (being_id, more)
    
    
    elif cmd == 'goto':
        x, y = text.split()
        client.goto(int(x), int(y))
    
    ### Information ##########
    
    elif cmd == 'names':
        return ',\n'.join(
          ', '.join('%s=%s' % pair for pair in ten) 
          for ten in isection(client.mod_whois_imap.items(), 10)
        )
    
    elif cmd == 'pos':
        return 'x=%s, y=%s' % tuple(client.pos)
    
    ### Resetters ############
    
    elif cmd == 'quit':
        client.done = True
    
    elif cmd == 'respawn':
        client.respawn()
    
    elif cmd == 'refresh':
        if rebuild_prices.rebuild():
            return 'Successfully rebuilt TMW price DB!'
        else:
            return 'Rebuilding the TMW price DB failed!'
    
    elif cmd == 'reload':
        for mod in client.installed_mods.values():
            reload(mod)
        commands.setup_commands(client)
        
        return 'Successfully reloaded all mods installed on this bot.'
    
    ### Help #################
    
    elif cmd == 'help':
        return '\n'.join([
          '`sit` to sit; `stand` to stand; '
          '`face n|s|e|w` to face a particular direction;',
          
          '`spin [l|r] [n|s|e|w] [num]` to make the bot spin rapidly; '
          '`juke [u|d] [n|s|e|w]` to execute a lame move sequence;',
          
          '`emote <number>` to display an emote; '
          '`say <some message>` to say something; '
          '`whisper <some thing> to <player>` to whisper to a player;',
          
          '`goto <x> <y>` to move the bot;',
          
          '`names` to see all the names that the bot recognizes;',
          
          '`respawn` to respawn; '
          '`refresh` to update the db of TMW prices (long!); '
          '`reload` to reload all mods installed on this bot.'
        ])
    
    else:
        return 'Unknown command `%s`; see the `help` sub-command.' % cmd
Exemple #22
0
 def from_body(self, v):
     """
     Conver vel/accel from body frame to world frame
     """
     return utils.rotate(v, self.quaternion)
 def getOriginalVec(self, *args):
     vec = b2d.b2Vec2(*args)
     return utils.rotate(vec, self.world_angle.get())
Exemple #24
0
def generate_hdf5(ftxt, output, fname, argument=False):

    data = getDataFromTxt(ftxt)
    F_imgs = []
    F_landmarks = []
    EN_imgs = []
    EN_landmarks = []
    NM_imgs = []
    NM_landmarks = []

    for (imgPath, bbox, landmarkGt) in data:
        img = cv2.imread(imgPath, cv2.CV_LOAD_IMAGE_GRAYSCALE)
        assert(img is not None)
        logger("process %s" % imgPath)
        # F
        f_bbox = bbox.subBBox(-0.05, 1.05, -0.05, 1.05)
        f_face = img[f_bbox.top:f_bbox.bottom+1,f_bbox.left:f_bbox.right+1]

        ## data argument
        if argument and np.random.rand() > -1:
            ### flip
            face_flipped, landmark_flipped = flip(f_face, landmarkGt)
            face_flipped = cv2.resize(face_flipped, (39, 39))
            F_imgs.append(face_flipped.reshape((1, 39, 39)))
            F_landmarks.append(landmark_flipped.reshape(10))
            ### rotation
            if np.random.rand() > 0.5:
                face_rotated_by_alpha, landmark_rotated = rotate(img, f_bbox, \
                    bbox.reprojectLandmark(landmarkGt), 5)
                landmark_rotated = bbox.projectLandmark(landmark_rotated)
                face_rotated_by_alpha = cv2.resize(face_rotated_by_alpha, (39, 39))
                F_imgs.append(face_rotated_by_alpha.reshape((1, 39, 39)))
                F_landmarks.append(landmark_rotated.reshape(10))
                ### flip with rotation
                face_flipped, landmark_flipped = flip(face_rotated_by_alpha, landmark_rotated)
                face_flipped = cv2.resize(face_flipped, (39, 39))
                F_imgs.append(face_flipped.reshape((1, 39, 39)))
                F_landmarks.append(landmark_flipped.reshape(10))
            ### rotation
            if np.random.rand() > 0.5:
                face_rotated_by_alpha, landmark_rotated = rotate(img, f_bbox, \
                    bbox.reprojectLandmark(landmarkGt), -5)
                landmark_rotated = bbox.projectLandmark(landmark_rotated)
                face_rotated_by_alpha = cv2.resize(face_rotated_by_alpha, (39, 39))
                F_imgs.append(face_rotated_by_alpha.reshape((1, 39, 39)))
                F_landmarks.append(landmark_rotated.reshape(10))
                ### flip with rotation
                face_flipped, landmark_flipped = flip(face_rotated_by_alpha, landmark_rotated)
                face_flipped = cv2.resize(face_flipped, (39, 39))
                F_imgs.append(face_flipped.reshape((1, 39, 39)))
                F_landmarks.append(landmark_flipped.reshape(10))

        f_face = cv2.resize(f_face, (39, 39))
        en_face = f_face[:31, :]
        nm_face = f_face[8:, :]

        f_face = f_face.reshape((1, 39, 39))
        f_landmark = landmarkGt.reshape((10))
        F_imgs.append(f_face)
        F_landmarks.append(f_landmark)

        # EN
        # en_bbox = bbox.subBBox(-0.05, 1.05, -0.04, 0.84)
        # en_face = img[en_bbox.top:en_bbox.bottom+1,en_bbox.left:en_bbox.right+1]

        ## data argument
        if argument and np.random.rand() > 0.5:
            ### flip
            face_flipped, landmark_flipped = flip(en_face, landmarkGt)
            face_flipped = cv2.resize(face_flipped, (31, 39)).reshape((1, 31, 39))
            landmark_flipped = landmark_flipped[:3, :].reshape((6))
            EN_imgs.append(face_flipped)
            EN_landmarks.append(landmark_flipped)

        en_face = cv2.resize(en_face, (31, 39)).reshape((1, 31, 39))
        en_landmark = landmarkGt[:3, :].reshape((6))
        EN_imgs.append(en_face)
        EN_landmarks.append(en_landmark)

        # NM
        # nm_bbox = bbox.subBBox(-0.05, 1.05, 0.18, 1.05)
        # nm_face = img[nm_bbox.top:nm_bbox.bottom+1,nm_bbox.left:nm_bbox.right+1]

        ## data argument
        if argument and np.random.rand() > 0.5:
            ### flip
            face_flipped, landmark_flipped = flip(nm_face, landmarkGt)
            face_flipped = cv2.resize(face_flipped, (31, 39)).reshape((1, 31, 39))
            landmark_flipped = landmark_flipped[2:, :].reshape((6))
            NM_imgs.append(face_flipped)
            NM_landmarks.append(landmark_flipped)

        nm_face = cv2.resize(nm_face, (31, 39)).reshape((1, 31, 39))
        nm_landmark = landmarkGt[2:, :].reshape((6))
        NM_imgs.append(nm_face)
        NM_landmarks.append(nm_landmark)

    #imgs, landmarks = process_images(ftxt, output)

    F_imgs, F_landmarks = np.asarray(F_imgs), np.asarray(F_landmarks)
    EN_imgs, EN_landmarks = np.asarray(EN_imgs), np.asarray(EN_landmarks)
    NM_imgs, NM_landmarks = np.asarray(NM_imgs),np.asarray(NM_landmarks)

    F_imgs = processImage(F_imgs)
    shuffle_in_unison_scary(F_imgs, F_landmarks)
    EN_imgs = processImage(EN_imgs)
    shuffle_in_unison_scary(EN_imgs, EN_landmarks)
    NM_imgs = processImage(NM_imgs)
    shuffle_in_unison_scary(NM_imgs, NM_landmarks)

    # full face
    base = join(OUTPUT, '1_F')
    createDir(base)
    output = join(base, fname)
    logger("generate %s" % output)
    with h5py.File(output, 'w') as h5:
        h5['data'] = F_imgs.astype(np.float32)
        h5['landmark'] = F_landmarks.astype(np.float32)

    # eye and nose
    base = join(OUTPUT, '1_EN')
    createDir(base)
    output = join(base, fname)
    logger("generate %s" % output)
    with h5py.File(output, 'w') as h5:
        h5['data'] = EN_imgs.astype(np.float32)
        h5['landmark'] = EN_landmarks.astype(np.float32)

    # nose and mouth
    base = join(OUTPUT, '1_NM')
    createDir(base)
    output = join(base, fname)
    logger("generate %s" % output)
    with h5py.File(output, 'w') as h5:
        h5['data'] = NM_imgs.astype(np.float32)
        h5['landmark'] = NM_landmarks.astype(np.float32)
        print 'regenerating '+pair[0]+' with label '+pair[1]
        image = skimage.io.imread(Image_Path+filename)
        transformed_img = random_crop(image)
        skimage.io.imsave(Image_Path+str(next_image_num)+'.png',transformed_img)
        rep_image_label_file.write(str(next_image_num)+'.png '+pair[1].split('\n')[0]+'\n')
        next_image_num += 1

    # do random rotate
    # int(augment_fraction*train_image_num)
    aug_idxs = np.random.choice(train_image_num, int(augment_fraction*train_image_num), replace=False)+1
    for augidx in aug_idxs:
        filename = str(augidx)+'.png'
        pair = train_image_labels[augidx-1].split(' ')
        print 'regenerating '+pair[0]+' with label '+pair[1]
        image = skimage.io.imread(Image_Path+filename)
        transformed_img = rotate(image)
        skimage.io.imsave(Image_Path+str(next_image_num)+'.png',transformed_img)
        rep_image_label_file.write(str(next_image_num)+'.png '+pair[1].split('\n')[0]+'\n')
        next_image_num += 1


# for augidx in aug_idxs:
#     filename = str(augidx)+'.png'
#     image = skimage.io.imread(Image_Path+filename)
#     # do some transform here
#     print image.shape
#
#     skimage.io.imshow(image)
#     skimage.io.show()
#
#     test_img = random_crop(image)
Exemple #26
0
modo = [TONO, TONO, SEMITONO, TONO, TONO, TONO, SEMITONO]
inicio = 0

# Existen 8 modos, se obtienen rotando los intervalos de la escala
for i in range(8):
    actual = inicio
    frecuencias_modo = [frecuencias[actual]]

    for intervalo in modo:
        actual += intervalo
        frecuencias_modo.append(frecuencias[actual])

    notas += frecuencias_modo
    inicio += modo[0]

    modo = rotate(modo)


muestras_por_segundo = 44100
duracion = 0.5

muestras_totales = duracion * muestras_por_segundo

muestras = []

for frecuencia in notas:
    ciclos_por_muestra = frecuencia / muestras_por_segundo
    incremento = 2 * math.pi * ciclos_por_muestra
    fase = 0

    for i in range(int(muestras_totales)):
 def set_state(self, state):
     self.tf = utils.rotate(state[0])
     for line in self.lines:
         line.set_tf(self.tf)
Exemple #28
0
escala = [TONO, TONO, SEMITONO, TONO, TONO, TONO, SEMITONO]


# Pueden obtenerse 7 acordes por cada escala
inicio = 0
for x in range(8):
    actual = inicio
    notas = [frecuencias[actual]]
    for grupo in grouper(escala, 2, 0):
        actual += sum(grupo)
        notas.append(frecuencias[actual])

    acordes.append(notas)
    inicio += escala[0]

    escala = rotate(escala)


muestras_por_segundo = 44100
duracion = 2

muestras_totales = duracion * muestras_por_segundo

muestras = []

for indice, acorde in enumerate(acordes):
    inicio_acorde = indice * duracion * muestras_por_segundo

    for frecuencia in acorde:
        ciclos_por_muestra = frecuencia / muestras_por_segundo
        incremento = 2 * math.pi * ciclos_por_muestra